@artel/artc 0.6.25258 → 0.6.25260

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

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { Analyzer, WellKnownDeclarations } from '../analysis/index.js';
-import { Localization } from '../analysis/Localization.js';
 import { Tag } from '../analysis/Tags.js';
+import { Translation } from '../analysis/Translation.js';
 import { Name, PackageDialect, PackageLocale } from '../common/index.js';
 import { EntityContext, EntityHidingLevel, EntityKind, InterfacePackageEntityInfo, TypeEntity, TypeEntityWithMembers } from '../entities/index.js';
 import { PackageEntity, PackageEntityDefinition } from '../entities/PackageEntity.js';
@@ -18,11 +18,11 @@ export declare class TsInteropContext {
     readonly tsProgramState: TsProgramState;
     readonly type: TypeContext;
     readonly packageForSymbolsWithUnknownOrigin: TsPackageEntityForSymbolsWithUnknownOrigin;
-    private readonly _config;
-    private readonly _packagesCreationResult;
-    private readonly _defaultExportTag;
-    private _wellKnownDeclarations;
-    private _standardTypes;
+    private readonly config;
+    private readonly packagesCreationResult;
+    private readonly defaultExportTag;
+    private wellKnownDeclarations_;
+    private standardTypes_;
     get tsProgram(): ts.Program;
     get tsChecker(): ts.TypeChecker;
     get packageContentsByEntity(): ReadonlyMap<PackageEntity, TsPackageContents>;
@@ -39,11 +39,11 @@ export declare class TsInteropContext {
     getEntityOfSourcePackageLoadedFromDts(sourcePackage: ProgramPackage): SourcePackageLoadedFromDtsEntity | undefined;
     isSignatureAsync(node: ts.SignatureDeclaration): boolean;
     getSignatureReturnType(node: ts.SignatureDeclaration, replaceWithPromisedTypeIfPromise: boolean): types.Type;
-    getTypeMemberHiding(node: ts.Declaration | undefined, containingType: TypeEntity): EntityHidingLevel | undefined;
+    createTypeMemberHiding(node: ts.Declaration | undefined, containingType: TypeEntity): EntityHidingLevel | undefined;
     onPackageMembersCreated(pkg: PackageEntity, creationResult: TsPackageMembersCreationResult): void;
     onTypeMembersCreated(type: TypeEntityWithMembers, creationResult: TsTypeMembersCreationResult): void;
     ifTypeCanBeExpressedByFunctionTypeThenCallSignature(symbol: ts.Symbol): ts.Symbol | undefined;
-    getName(original: string, ownerKind: 'type' | 'variable' | 'method'): Name;
+    createName(original: string, ownerKind: 'type' | 'variable' | 'method'): Name;
     createDefaultExportTag(): Tag;
     createTypeEntityContext(entity: TypeEntity): EntityContext;
     private getPackagesCreationResult;
@@ -95,10 +95,10 @@ export declare namespace ResolvedJavaScriptImplementation {
  * родительский символ. Поэтому параметры создаются не лениво, а в момент создания содержащий их сущностей.
  */
 declare class TypeContext {
-    private readonly _tsctx;
-    private readonly _typeEntities;
-    private readonly _packagesWithCreatedMembers;
-    private readonly _esSymbolType;
+    private readonly tsctx;
+    private readonly typeEntities;
+    private readonly packagesWithCreatedMembers;
+    private readonly esSymbolType_;
     private get checker();
     private get refObjectOrNull();
     private get esSymbolType();
@@ -158,7 +158,7 @@ export declare class TsProgramState {
     readonly setSymbol: ts.Symbol | undefined;
     readonly readonlySetSymbol: ts.Symbol | undefined;
     readonly esSymbolSymbol: ts.Symbol | undefined;
-    private readonly _referencedFilesByFileWithReference;
+    private readonly referencedFilesByFileWithReference_;
     get referencedFilesByFileWithReference(): ReadonlyMap<ts.Path, readonly TsFileReferenceInfo[]>;
     constructor(program: ts.Program);
     private createReferencedFilesByFileWithReference;
@@ -188,7 +188,9 @@ declare class TsPackageEntityForSymbolsWithUnknownOrigin implements PackageEntit
     getImplementedInterfacePackage(): PackageEntity | undefined;
     getSupportedPlatforms(): readonly PlatformKind[];
     getDefinition(): PackageEntityDefinition;
-    getLocalization(): Localization;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
     getOriginalEntity(): PackageEntity;
+    getTags(): readonly Tag[];
 }
 export {};

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

@@ -5,14 +5,14 @@ import { ProgramPackage } from '../project/SourcePackage.js';
 import { TsInteropContext } from './TsInteropContext.js';
 import { TsPackageMembersCreationResult } from './TsPackageMembersCreator.js';
 export declare class TsPackageContents {
-    private readonly _tsctx;
-    private readonly _symbols;
-    private readonly _packageEntity;
-    private readonly _sourcePackageToMergeWith;
+    private readonly tsctx;
+    private readonly symbols;
+    private readonly packageEntity;
+    private readonly sourcePackageToMergeWith;
     readonly kind = "module";
-    private readonly _membersCreationResult;
-    private readonly _tsSymbols;
-    constructor(_tsctx: TsInteropContext, _symbols: TsPackageSymbols, _packageEntity: PackageEntity, _sourcePackageToMergeWith: ProgramPackage | undefined);
+    private readonly membersCreationResult;
+    private readonly tsSymbols;
+    constructor(tsctx: TsInteropContext, symbols: TsPackageSymbols, packageEntity: PackageEntity, sourcePackageToMergeWith: ProgramPackage | undefined);
     getMembers(): PackageEntityMembers;
     containsGlobalSymbol(symbol: ts.Symbol): boolean;
     getMembersCreationResult(): TsPackageMembersCreationResult;
@@ -24,18 +24,18 @@ export declare namespace TsPackageSymbols {
      * https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html#modular-libraries
      */
     export class Module implements ITsPackageSymbols {
-        private readonly _tsctx;
+        private readonly tsctx;
         /**
          * (symbol.flags & ts.SymbolFlags.ValueModule) !== 0
          */
-        private readonly _symbol;
+        private readonly symbol;
         readonly kind = "module";
-        private readonly _items;
-        constructor(_tsctx: TsInteropContext, 
+        private readonly items;
+        constructor(tsctx: TsInteropContext, 
         /**
          * (symbol.flags & ts.SymbolFlags.ValueModule) !== 0
          */
-        _symbol: ts.Symbol);
+        symbol: ts.Symbol);
         getItems(): readonly SymbolFromTs[];
     }
     /**
@@ -45,11 +45,11 @@ export declare namespace TsPackageSymbols {
      * https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html#global-libraries
      */
     export class GlobalLibrary implements ITsPackageSymbols {
-        private readonly _tsctx;
-        private readonly _sourceFiles;
+        private readonly tsctx;
+        private readonly sourceFiles;
         readonly kind = "global-library";
-        private readonly _items;
-        constructor(_tsctx: TsInteropContext, _sourceFiles: readonly ts.SourceFile[]);
+        private readonly items;
+        constructor(tsctx: TsInteropContext, sourceFiles: readonly ts.SourceFile[]);
         getItems(): readonly SymbolFromTs[];
     }
     interface ITsPackageSymbols {

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

@@ -6,16 +6,16 @@ import * as tree from '../tree/index.js';
 import { TsInteropContext } from './TsInteropContext.js';
 import { SymbolFromTs } from './TsPackageContents.js';
 export declare class TsPackageMembersCreator {
-    private readonly _tsctx;
-    private readonly _symbols;
-    private readonly _packageEntity;
-    private readonly _sourcePackageToMergeWith;
-    private readonly _forceMembersAreHiddenInPackage;
-    private readonly _typeEntityBySymbol;
-    private readonly _owningNamedSymbolByTypeLiteralSymbol;
-    private readonly _namedDeclarationsByName;
-    private readonly _packageMemberEntityByNode;
-    constructor(_tsctx: TsInteropContext, _symbols: Iterable<SymbolFromTs>, _packageEntity: PackageEntity, _sourcePackageToMergeWith: SourcePackage | undefined, _forceMembersAreHiddenInPackage?: boolean);
+    private readonly tsctx;
+    private readonly symbols;
+    private readonly packageEntity;
+    private readonly sourcePackageToMergeWith;
+    private readonly forceMembersAreHiddenInPackage;
+    private readonly typeEntityBySymbol;
+    private readonly owningNamedSymbolByTypeLiteralSymbol;
+    private readonly namedDeclarationsByName;
+    private readonly packageMemberEntityByNode;
+    constructor(tsctx: TsInteropContext, symbols: Iterable<SymbolFromTs>, packageEntity: PackageEntity, sourcePackageToMergeWith: SourcePackage | undefined, forceMembersAreHiddenInPackage?: boolean);
     create(): TsPackageMembersCreationResult;
     private createAndRegisterPackageMemberEntity;
     /**

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

@@ -2,13 +2,13 @@ import ts from 'typescript';
 import { Uri } from '../common/index.js';
 import { TypeScriptLibrariesProvider } from './TsLibrariesProvider.js';
 export declare class TsProgramLoader {
-    private readonly _librariesProvider;
-    private readonly _rootDirectoryUri;
-    private readonly _standardLibraryFileNames;
-    private readonly _npmPackageNames;
-    private readonly _moduleNames;
-    private readonly _oldProgram?;
-    constructor(_librariesProvider: TypeScriptLibrariesProvider, _rootDirectoryUri: Uri, _standardLibraryFileNames: readonly string[], _npmPackageNames: readonly string[], _moduleNames: readonly string[], _oldProgram?: ts.Program | undefined);
+    private readonly librariesProvider;
+    private readonly rootDirectoryUri;
+    private readonly standardLibraryFileNames;
+    private readonly npmPackageNames;
+    private readonly moduleNames;
+    private readonly oldProgram?;
+    constructor(librariesProvider: TypeScriptLibrariesProvider, rootDirectoryUri: Uri, standardLibraryFileNames: readonly string[], npmPackageNames: readonly string[], moduleNames: readonly string[], oldProgram?: ts.Program | undefined);
     load(): TsProgramLoadResult;
     private createFileWithLibraryImportsText;
     private createCompilerHost;

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

@@ -3,15 +3,15 @@ import { TypeEntityWithMembers, TypeParameterEntity } from '../entities/index.js
 import { TypeEntityMembers } from '../entities/TypeEntityMembers.js';
 import { TsInteropContext } from './TsInteropContext.js';
 export declare class TsTypeMembersCreator {
-    private readonly _tsctx;
-    private readonly _symbols;
-    private readonly _symbolsToForceStatic;
-    private readonly _typeSymbolDeclarations;
-    private readonly _typeEntity;
-    private readonly _symbolToTakeDefaultClassConstructorsFrom;
-    private readonly _membersOfTypeToMergeWith;
-    private readonly _typeParameterBySymbol;
-    constructor(_tsctx: TsInteropContext, _symbols: Iterable<ts.Symbol>, _symbolsToForceStatic: Iterable<ts.Symbol> | undefined, _typeSymbolDeclarations: readonly ts.Declaration[] | undefined, _typeEntity: TypeEntityWithMembers, _symbolToTakeDefaultClassConstructorsFrom: ts.Symbol | undefined, _membersOfTypeToMergeWith: TypeEntityMembers | undefined);
+    private readonly tsctx;
+    private readonly symbols;
+    private readonly symbolsToForceStatic;
+    private readonly typeSymbolDeclarations;
+    private readonly typeEntity;
+    private readonly symbolToTakeDefaultClassConstructorsFrom;
+    private readonly membersOfTypeToMergeWith;
+    private readonly typeParameterBySymbol;
+    constructor(tsctx: TsInteropContext, symbols: Iterable<ts.Symbol>, symbolsToForceStatic: Iterable<ts.Symbol> | undefined, typeSymbolDeclarations: readonly ts.Declaration[] | undefined, typeEntity: TypeEntityWithMembers, symbolToTakeDefaultClassConstructorsFrom: ts.Symbol | undefined, membersOfTypeToMergeWith: TypeEntityMembers | undefined);
     create(): TsTypeMembersCreationResult;
     private createTypeMemberEntity;
     /**

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

@@ -2,13 +2,14 @@ import { Analyzer } from '../analysis/index.js';
 import { AliasTypeEntity, TypeParameterEntity } from '../entities/index.js';
 import { IType, Substitutions, Type } from './index.js';
 export declare class AliasType implements IType {
-    private readonly _analyzer;
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly analyzer;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "alias";
-    private readonly _aliasedType;
+    private readonly aliasedType;
+    get isNullType(): boolean;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer, _entity: AliasTypeEntity, _substitutions: Substitutions);
+    constructor(analyzer: Analyzer, entity: AliasTypeEntity, substitutions: Substitutions);
     getAliasedType(): Type;
     getTypeParameters(): readonly TypeParameterEntity[];
     getSubstitutions(): Substitutions;

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

@@ -1,14 +1,15 @@
 import { Analyzer } from '../analysis/index.js';
 import { FunctionTypeEntity, TypeParameterEntity } from '../entities/index.js';
-import { IType, Substitutions, Type, ValueParameter } from './index.js';
+import { IType, Substitutions, Type, Parameter } from './index.js';
 export declare class FunctionType implements IType {
-    private readonly _analyzer;
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly analyzer;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "function";
-    private readonly _valueParameters;
+    private readonly parameters;
+    get isNullType(): boolean;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer, _entity: FunctionTypeEntity, _substitutions: Substitutions);
+    constructor(analyzer: Analyzer, entity: FunctionTypeEntity, substitutions: Substitutions);
     getTypeParameters(): readonly TypeParameterEntity[];
     getSubstitutions(): Substitutions;
     applySubstitutions(substitutions: Substitutions): FunctionType;
@@ -16,7 +17,7 @@ export declare class FunctionType implements IType {
     getEntity(): FunctionTypeEntity;
     isAsync(): boolean;
     getReturnType(): Type;
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
     getBaseType(): Type | undefined;
     getBaseObjectTypeOrAliasedType(): Type | undefined;
     toString(): string;

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

@@ -5,8 +5,9 @@ import { IType, Type } from './index.js';
 export declare class IntersectionType implements IType {
     readonly kind = "intersection";
     readonly originalTypes: readonly Type[];
-    private readonly _analyzer;
-    private readonly _unaliasedFlattenedTypes;
+    private readonly analyzer;
+    private readonly unaliasedFlattenedTypes_;
+    get isNullType(): boolean;
     get unaliasedFlattenedTypes(): readonly Type[];
     get debuggerDisplay(): string;
     constructor(analyzer: Analyzer, originalTypes: readonly Type[]);

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

@@ -2,17 +2,18 @@ import { Analyzer } from '../analysis/index.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;
+    private readonly analyzer;
+    private readonly entity;
     readonly isNullExcluded: boolean;
     readonly kind = "parameter";
-    private readonly _constraint;
+    private readonly constraint_;
+    get isNullType(): boolean;
     /**
      * Ограничение параметра типа с учётом флага {@link isNullExcluded}.
      */
     get constraint(): Type | undefined;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer, _entity: TypeParameterEntity, isNullExcluded: boolean);
+    constructor(analyzer: Analyzer, entity: TypeParameterEntity, isNullExcluded: boolean);
     getSubstitutions(): Substitutions;
     getEntity(): TypeParameterEntity;
     applySubstitutions(substitutions: Substitutions): Type;

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

@@ -1,27 +1,27 @@
 import { Analyzer, WellKnownDeclarations } from '../analysis/index.js';
 import { StructuredType, UnresolvedType } from './index.js';
 export declare class StandardTypes {
-    private readonly _analyzer;
-    private readonly _wellKnownDeclarations;
-    private _refObject;
-    private _plainObject;
-    private _number;
-    private _integer;
-    private _text;
-    private _textTemplate;
-    private _char;
-    private _unresolved;
-    private _yesNo;
-    private _null;
-    private _measure;
-    private _enumerator;
-    private _enumerable;
-    private _array;
-    private _reference;
-    private _task;
-    private _error;
-    private _func;
-    constructor(_analyzer: Analyzer, _wellKnownDeclarations: WellKnownDeclarations);
+    private readonly analyzer;
+    private readonly wellKnownDeclarations;
+    private refObject_;
+    private plainObject_;
+    private number_;
+    private integer_;
+    private text_;
+    private textTemplate_;
+    private char_;
+    private unresolved_;
+    private yesNo_;
+    private null_;
+    private measure_;
+    private enumerator_;
+    private enumerable_;
+    private array_;
+    private reference_;
+    private task_;
+    private error_;
+    private func_;
+    constructor(analyzer: Analyzer, wellKnownDeclarations: WellKnownDeclarations);
     get refObject(): StructuredType;
     get plainObject(): StructuredType;
     get number(): StructuredType;

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

@@ -1,21 +1,20 @@
 import { Analyzer } from '../analysis/index.js';
-import { StructuredTypeEntity, TypeParameterEntity } from '../entities/index.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;
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly analyzer;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "structured";
-    private readonly _baseObjectType;
-    private readonly _baseAspectTypes;
+    private readonly baseObjectType;
+    private readonly baseAspectTypes;
+    get isNullType(): boolean;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer, _entity: StructuredTypeEntity, _substitutions: Substitutions);
+    constructor(analyzer: Analyzer, entity: StructuredTypeEntity, substitutions: Substitutions);
     getSubstitutions(): Substitutions;
     getTypeParameters(): readonly TypeParameterEntity[];
     applySubstitutions(substitutions: Substitutions): StructuredType;
-    isAspect(): boolean;
-    isRefObject(): boolean;
-    isPlainObject(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
     markedBasic(): boolean;
     isAbstract(): boolean;
     equals(other: Type): boolean;

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

@@ -2,7 +2,7 @@ import { Analyzer } from '../analysis/index.js';
 import { TypeParameterEntity } from '../entities/index.js';
 import { Type } from './index.js';
 export declare class Substitutions {
-    private static _empty;
+    private static empty_;
     /**
      * Ключом `SubstitutionMap` всегда является параметр на языке оригинала.
      */

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

@@ -9,6 +9,7 @@ import { VariantType } from './VariantType.js';
 import { Substitutions, UnionType } from './index.js';
 export type Type = StructuredType | VariantType | FunctionType | AliasType | UnresolvedType | ParameterType | UnionType | IntersectionType;
 export interface IType {
+    readonly isNullType: boolean;
     getSubstitutions(): Substitutions;
     applySubstitutions(substitutions: Substitutions): Type;
     /**

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

@@ -1,6 +1,6 @@
 import { Analyzer } from '../analysis/index.js';
 import { Name } from '../common/index.js';
-import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, EntityHidingLevel, FieldEntity, IndexerEntity, MethodEntity, OperatorEntity, OperatorKind, ParameterVariableEntity, TypeParameterEntity } from '../entities/index.js';
+import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, EntityHidingLevel, FieldEntity, IndexerEntity, MethodEntity, OperatorEntity, OperatorKind, ParameterEntity, TypeParameterEntity } from '../entities/index.js';
 import { FunctionType } from './FunctionType.js';
 import { Substitutions } from './Substitutions.js';
 import { Type } from './Type.js';
@@ -9,17 +9,17 @@ export type NamedTypeMember = Field | Method;
 export declare function isNamedTypeMember(member: TypeMember): member is NamedTypeMember;
 export type AnonymousTypeMember = Exclude<TypeMember, NamedTypeMember>;
 export declare class Method implements ITypeMember {
-    private readonly _analyzer;
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly analyzer;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "method";
-    private readonly _valueParameters;
-    private readonly _signatureType;
+    private readonly parameters;
+    private readonly signatureType;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer, _entity: MethodEntity, _substitutions: Substitutions);
+    constructor(analyzer: Analyzer, entity: MethodEntity, substitutions: Substitutions);
     getName(): Name;
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
     getReturnType(): Type;
     getEntity(): MethodEntity;
     getSubstitutions(): Substitutions;
@@ -33,23 +33,23 @@ export declare class Method implements ITypeMember {
     equals(other: TypeMember): boolean;
     toString(): string;
 }
-export declare class ValueParameter {
-    private readonly _entity;
-    private readonly _substitutions;
-    constructor(_entity: ParameterVariableEntity, _substitutions: Substitutions);
+export declare class Parameter {
+    private readonly entity;
+    private readonly substitutions;
+    constructor(entity: ParameterEntity, substitutions: Substitutions);
     getName(): Name;
     getType(): Type;
-    getEntity(): ParameterVariableEntity;
+    getEntity(): ParameterEntity;
     getSubstitutions(): Substitutions;
     isOptional(): boolean;
     isVariadic(): boolean;
 }
 export declare class Field implements ITypeMember {
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "field";
     get debuggerDisplay(): string;
-    constructor(_entity: FieldEntity, _substitutions: Substitutions);
+    constructor(entity: FieldEntity, substitutions: Substitutions);
     getName(): Name;
     getType(): Type;
     getEntity(): FieldEntity;
@@ -64,16 +64,16 @@ export declare class Field implements ITypeMember {
     toString(): string;
 }
 export declare class Operator implements ITypeMember {
-    private readonly _analyzer;
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly analyzer;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "operator";
-    private readonly _valueParameters;
-    private readonly _signatureEntity;
+    private readonly parameters;
+    private readonly signatureEntity;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer, _entity: OperatorEntity, _substitutions: Substitutions);
+    constructor(analyzer: Analyzer, entity: OperatorEntity, substitutions: Substitutions);
     getOperatorKind(): OperatorKind;
-    getValueParameters(): readonly ValueParameter[];
+    getParameters(): readonly Parameter[];
     getReturnType(): Type;
     getEntity(): OperatorEntity;
     getSubstitutions(): Substitutions;
@@ -86,14 +86,14 @@ export declare class Operator implements ITypeMember {
     toString(): string;
 }
 export declare class Constructor implements ITypeMember {
-    private readonly _analyzer;
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly analyzer;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "constructor";
-    private readonly _valueParameters;
+    private readonly parameters;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer, _entity: ConstructorEntity, _substitutions: Substitutions);
-    getValueParameters(): readonly ValueParameter[];
+    constructor(analyzer: Analyzer, entity: ConstructorEntity, substitutions: Substitutions);
+    getParameters(): readonly Parameter[];
     getEntity(): ConstructorEntity;
     getSubstitutions(): Substitutions;
     isHidden(): EntityHidingLevel | undefined;
@@ -104,13 +104,13 @@ export declare class Constructor implements ITypeMember {
     toString(): string;
 }
 export declare class Destructor implements ITypeMember {
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "destructor";
-    private readonly _valueParameters;
+    private readonly parameters;
     get debuggerDisplay(): string;
-    constructor(_entity: DestructorEntity, _substitutions: Substitutions);
-    getValueParameters(): readonly ValueParameter[];
+    constructor(entity: DestructorEntity, substitutions: Substitutions);
+    getParameters(): readonly Parameter[];
     getEntity(): DestructorEntity;
     getSubstitutions(): Substitutions;
     isHidden(): EntityHidingLevel | undefined;
@@ -120,13 +120,13 @@ export declare class Destructor implements ITypeMember {
     toString(): string;
 }
 export declare class Indexer implements ITypeMember {
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "indexer";
-    private readonly _valueParameters;
+    private readonly parameters;
     get debuggerDisplay(): string;
-    constructor(_entity: IndexerEntity, _substitutions: Substitutions);
-    getValueParameters(): readonly ValueParameter[];
+    constructor(entity: IndexerEntity, substitutions: Substitutions);
+    getParameters(): readonly Parameter[];
     getType(): Type;
     getEntity(): IndexerEntity;
     getSubstitutions(): Substitutions;
@@ -138,11 +138,11 @@ export declare class Indexer implements ITypeMember {
     toString(): string;
 }
 export declare class DereferenceOperator implements ITypeMember {
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "dereference-operator";
     get debuggerDisplay(): string;
-    constructor(_entity: DereferenceOperatorEntity, _substitutions: Substitutions);
+    constructor(entity: DereferenceOperatorEntity, substitutions: Substitutions);
     getType(): Type;
     getEntity(): DereferenceOperatorEntity;
     getSubstitutions(): Substitutions;

package/build/types/types/UnionType.d.ts

@@ -5,8 +5,9 @@ import { IType, Type } from './index.js';
 export declare class UnionType implements IType {
     readonly kind = "union";
     readonly originalTypes: readonly Type[];
-    private readonly _analyzer;
-    private readonly _unaliasedFlattenedTypes;
+    private readonly analyzer;
+    private readonly unaliasedFlattenedTypes_;
+    get isNullType(): boolean;
     get unaliasedFlattenedTypes(): readonly Type[];
     get debuggerDisplay(): string;
     constructor(analyzer: Analyzer, originalTypes: readonly Type[]);

package/build/types/types/UnresolvedType.d.ts

@@ -3,10 +3,11 @@ import { TypeEntity } from '../entities/index.js';
 import { Substitutions } from './Substitutions.js';
 import { IType, Type } from './Type.js';
 export declare class UnresolvedType implements IType {
-    private readonly _analyzer;
+    private readonly analyzer;
     readonly kind = "unresolved";
+    get isNullType(): boolean;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer);
+    constructor(analyzer: Analyzer);
     equals(other: Type): boolean;
     getSubstitutions(): Substitutions;
     applySubstitutions(_substitutions: Substitutions): Type;

package/build/types/types/VariantType.d.ts

@@ -2,12 +2,13 @@ import { Analyzer } from '../analysis/index.js';
 import { VariantTypeEntity } from '../entities/index.js';
 import { IType, Substitutions, Type } from './index.js';
 export declare class VariantType implements IType {
-    private readonly _analyzer;
-    private readonly _entity;
-    private readonly _substitutions;
+    private readonly analyzer;
+    private readonly entity;
+    private readonly substitutions;
     readonly kind = "variant";
+    get isNullType(): boolean;
     get debuggerDisplay(): string;
-    constructor(_analyzer: Analyzer, _entity: VariantTypeEntity, _substitutions: Substitutions);
+    constructor(analyzer: Analyzer, entity: VariantTypeEntity, substitutions: Substitutions);
     getSubstitutions(): Substitutions;
     applySubstitutions(substitutions: Substitutions): Type;
     getEntity(): VariantTypeEntity;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artel/artc",
-  "version": "0.6.25258",
+  "version": "0.6.25260",
   "description": "Артель Компилятор | Artel Compiler",
   "author": "Nezaboodka Team <contact@nezaboodka.com>",
   "license": "LGPL-3.0-or-later",