@artel/artc 0.6.25270 → 0.6.25272

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';

package/build/types/entities/intrinsic/IntrinsicConstructorEntity.d.ts

@@ -0,0 +1,56 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Analyzer } from '../../analysis/index.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import type { PackageEntity, TypeEntityWithMembers, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { ConstructorEntity, ConstructorEntityDefinition, DefaultConstructorEntityInfo, EntityHidingLevel, EntityKind, FieldEntity, ParameterEntity } from '../index.js';
+export declare class IntrinsicConstructorEntity implements ConstructorEntity {
+    private readonly parameters;
+    private readonly containingEntity;
+    private readonly isDefault_;
+    private readonly isHidden_;
+    private readonly markedAbstract_;
+    readonly kind = EntityKind.Constructor;
+    constructor(parameters: readonly ParameterEntity[], containingEntity: TypeWithMembersOrExtensionEntity, isDefault_: DefaultConstructorEntityInfo | undefined, isHidden_: EntityHidingLevel | undefined, markedAbstract_: boolean);
+    getParameters(): readonly ParameterEntity[];
+    getDefinition(): ConstructorEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isDefault(): DefaultConstructorEntityInfo | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): ConstructorEntity;
+}
+export declare class DefaultConstructorEntity implements ConstructorEntity {
+    private readonly analyzer;
+    private readonly containingType;
+    private readonly variablesToInitialize;
+    private readonly baseConstructor;
+    readonly kind = EntityKind.Constructor;
+    private readonly parametersInfo;
+    constructor(analyzer: Analyzer, containingType: TypeEntityWithMembers, variablesToInitialize: readonly VariableToInitialize[], baseConstructor: types.Constructor | undefined);
+    getParameters(): readonly ParameterEntity[];
+    getDefinition(): ConstructorEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isDefault(): DefaultConstructorEntityInfo | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): ConstructorEntity;
+    private getParametersInfo;
+    private createOrderedParametersForBaseConstructor;
+}
+export declare class VariableToInitialize {
+    readonly entity: FieldEntity;
+    readonly hasInitializer: boolean;
+    constructor(entity: FieldEntity, hasInitializer: boolean);
+}

package/build/types/entities/intrinsic/IntrinsicFunctionEntity.d.ts

@@ -0,0 +1,77 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import type { FunctionEntityDefinition, MethodEntity, PackageEntity, PackageFunctionEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { EntityHidingLevel, EntityKind, ParameterEntity, SubstitutionApplicationMode, TypeParameterEntity } from '../index.js';
+export declare class IntrinsicPackageFunctionEntity implements PackageFunctionEntity {
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly isAsync_;
+    private readonly isHidden_;
+    private readonly tags;
+    private readonly containingPackage;
+    readonly kind = EntityKind.Function;
+    readonly subkind = "package";
+    constructor(name: Name, typeParameters: readonly TypeParameterEntity[], parameters: readonly ParameterEntity[], returnType: types.Type, isAsync_: boolean, isHidden_: EntityHidingLevel | undefined, tags: readonly Tag[], containingPackage: PackageEntity);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageFunctionEntity;
+}
+export declare class IntrinsicMethodEntity implements MethodEntity {
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly isAsync_;
+    private readonly isHidden_;
+    private readonly tags;
+    private readonly isFunctionTypeInvokeMethod_;
+    private readonly containingEntity;
+    private readonly isStatic_;
+    private readonly isBasic_;
+    private readonly isOverride_;
+    private readonly isAbstract_;
+    private readonly isModifyingOwningPlainObject_;
+    private readonly overriddenMembers;
+    readonly kind = EntityKind.Function;
+    readonly subkind = "method";
+    constructor(name: Name, typeParameters: readonly TypeParameterEntity[], parameters: readonly ParameterEntity[], returnType: types.Type, isAsync_: boolean, isHidden_: EntityHidingLevel | undefined, tags: readonly Tag[], isFunctionTypeInvokeMethod_: boolean, containingEntity: TypeWithMembersOrExtensionEntity, isStatic_: boolean, isBasic_: boolean, isOverride_: boolean, isAbstract_: boolean, isModifyingOwningPlainObject_: boolean, overriddenMembers: readonly types.Method[]);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    isFunctionTypeInvokeMethod(): boolean;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    isModifyingOwningPlainObject(): boolean;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getOverriddenMembers(): readonly types.Method[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+}

package/build/types/entities/intrinsic/IntrinsicFunctionTypeEntity.d.ts

@@ -0,0 +1,17 @@
+import { Analyzer } from '../../analysis/index.js';
+import { Name } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import type { AnonymousFunctionTypeEntity, PackageEntity, PackageFunctionTypeEntity } from '../index.js';
+import { EntityContext, EntityHidingLevel, ParameterEntity, SubstitutionApplicationMode, TypeParameterEntity } from '../index.js';
+export declare class UnfinishedIntrinsicAnonymousFunctionTypeEntity {
+    private readonly unfinishedValue_;
+    get unfinishedValue(): AnonymousFunctionTypeEntity;
+    constructor(analyzer: Analyzer, returnType: types.Type, isAsync: boolean, containingPackage: PackageEntity, isHidden: EntityHidingLevel | undefined, context: EntityContext | undefined);
+    finish(typeParameters: readonly TypeParameterEntity[], parameters: readonly ParameterEntity[]): AnonymousFunctionTypeEntity;
+}
+export declare class UnfinishedIntrinsicPackageFunctionTypeEntity {
+    private readonly unfinishedValue_;
+    get unfinishedValue(): PackageFunctionTypeEntity;
+    constructor(analyzer: Analyzer, name: Name, returnType: types.Type, isAsync: boolean, substitutionApplicationMode: SubstitutionApplicationMode, containingPackage: PackageEntity, isHidden: EntityHidingLevel | undefined, context: EntityContext | undefined);
+    finish(typeParameters: readonly TypeParameterEntity[], parameters: readonly ParameterEntity[]): PackageFunctionTypeEntity;
+}

package/build/types/entities/intrinsic/IntrinsicGetterEntity.d.ts

@@ -0,0 +1,25 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import type { EntityOwningGetter } from '../index.js';
+import { EntityHidingLevel, EntityKind, GetterEntity, GetterEntityDefinition, PackageEntity } from '../index.js';
+export declare class IntrinsicGetterEntity implements GetterEntity {
+    private readonly returnType;
+    private readonly owningEntity;
+    private readonly isHidden_;
+    private readonly isModifyingOwningPlainObject_;
+    readonly kind = EntityKind.Getter;
+    constructor(returnType: types.Type, owningEntity: EntityOwningGetter, isHidden_: EntityHidingLevel | undefined, isModifyingOwningPlainObject_: boolean);
+    getReturnType(): types.Type;
+    getDefinition(): GetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningGetter;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): GetterEntity;
+}

package/build/types/entities/intrinsic/IntrinsicStructuredTypeEntity.d.ts

@@ -0,0 +1,17 @@
+import { Analyzer } from '../../analysis/index.js';
+import { Name } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import type { AnonymousStructuredTypeEntity, PackageEntity, PackageStructuredTypeEntity, StructuredTypeKind } from '../index.js';
+import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, EntityContext, EntityHidingLevel, IndexerEntity, NamedTypeMemberEntity, OperatorEntity, SubstitutionApplicationMode, TypeParameterEntity } from '../index.js';
+export declare class UnfinishedIntrinsicPackageStructuredTypeEntity {
+    private readonly unfinishedValue_;
+    get unfinishedValue(): PackageStructuredTypeEntity;
+    constructor(analyzer: Analyzer, name: Name, containingPackage: PackageEntity, typeParameters: readonly TypeParameterEntity[], isBasic: boolean, isAbstract: boolean, structuredTypeKind: StructuredTypeKind, baseObjectType: types.StructuredType | undefined, baseAspectTypes: readonly types.StructuredType[], isHidden: EntityHidingLevel | undefined, substitutionApplicationMode: SubstitutionApplicationMode, context: EntityContext | undefined);
+    finish(ownNamedMembers: readonly NamedTypeMemberEntity[], ownOperators: readonly OperatorEntity[], ownConstructors: readonly ConstructorEntity[], ownDestructors: readonly DestructorEntity[], ownIndexers: readonly IndexerEntity[], ownDereferenceOperators: readonly DereferenceOperatorEntity[]): PackageStructuredTypeEntity;
+}
+export declare class UnfinishedIntrinsicAnonymousStructuredTypeEntity {
+    private readonly unfinishedValue_;
+    get unfinishedValue(): AnonymousStructuredTypeEntity;
+    constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], structuredTypeKind: StructuredTypeKind, baseObjectType: types.StructuredType | undefined, baseAspectTypes: readonly types.StructuredType[], isHidden: EntityHidingLevel | undefined, substitutionApplicationMode: SubstitutionApplicationMode, containingPackage: PackageEntity, context: EntityContext | undefined);
+    finish(ownNamedMembers: readonly NamedTypeMemberEntity[], ownOperators: readonly OperatorEntity[], ownConstructors: readonly ConstructorEntity[], ownDestructors: readonly DestructorEntity[], ownIndexers: readonly IndexerEntity[], ownDereferenceOperators: readonly DereferenceOperatorEntity[]): AnonymousStructuredTypeEntity;
+}

package/build/types/entities/intrinsic/IntrinsicTypeParameterEntity.d.ts

@@ -0,0 +1,32 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import type { EntityContainingTypeParameter } from '../index.js';
+import { EntityContext, EntityHidingLevel, EntityKind, PackageEntity, TypeEntityKind, TypeParameterConstraint, TypeParameterEntity, TypeParameterEntityDefinition } from '../index.js';
+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/intrinsic/IntrinsicVariableEntity.d.ts

@@ -0,0 +1,123 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Lazy, Name, PackageDialect, PackageLocale } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import type { EntityContainingParameter, PackageEntity } from '../index.js';
+import { EntityHidingLevel, EntityKind, FieldEntity, GetterEntity, LocalVariableEntity, LocalVariableKind, PackageVariableEntity, ParameterEntity, SetterEntity, SpecialVariableEntityInfo, TypeWithMembersOrExtensionEntity, VariableEntityDefinition } from '../index.js';
+export declare class IntrinsicPackageVariableEntity implements PackageVariableEntity {
+    private readonly name;
+    private readonly type;
+    private readonly containingPackage;
+    private readonly isSpecial_;
+    private readonly isHidden_;
+    private readonly getter;
+    private readonly setter;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "package";
+    constructor(name: Name, type: types.Type | Lazy<types.Type>, containingPackage: PackageEntity, isSpecial_: SpecialVariableEntityInfo | undefined, isHidden_: EntityHidingLevel | undefined, getter: GetterEntity | undefined, setter: SetterEntity | undefined);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageVariableEntity;
+}
+export declare class IntrinsicFieldEntity implements FieldEntity {
+    private readonly name;
+    private readonly type;
+    private readonly containingEntity;
+    private readonly isStatic_;
+    private readonly markedBasic_;
+    private readonly isOverride_;
+    private readonly markedAbstract_;
+    private readonly isSpecial_;
+    private readonly isHidden_;
+    private readonly getter;
+    private readonly setter;
+    private readonly overriddenMembers;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "field";
+    constructor(name: Name, type: types.Type, containingEntity: TypeWithMembersOrExtensionEntity, isStatic_: boolean, markedBasic_: boolean, isOverride_: boolean, markedAbstract_: boolean, isSpecial_: SpecialVariableEntityInfo | undefined, isHidden_: EntityHidingLevel | undefined, getter: GetterEntity | undefined, setter: SetterEntity | undefined, overriddenMembers: readonly types.Field[]);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    getOverriddenMembers(): readonly types.Field[];
+    isVariant(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): FieldEntity;
+}
+export declare class IntrinsicParameterEntity implements ParameterEntity {
+    private readonly name;
+    private readonly type;
+    private readonly containingEntity;
+    private readonly isOptional_;
+    private readonly isVariadic_;
+    private readonly isSpecial_;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    constructor(name: Name, type: types.Type, containingEntity: EntityContainingParameter, isOptional_: boolean, isVariadic_: boolean, isSpecial_: SpecialVariableEntityInfo | undefined);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainingEntity(): EntityContainingParameter;
+    getContainingPackage(): PackageEntity;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): ParameterEntity;
+}
+export declare class IntrinsicLocalVariableEntity implements LocalVariableEntity {
+    private readonly name;
+    private readonly type;
+    private readonly isConstant_;
+    private readonly containingPackage;
+    private readonly isSpecial_;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    constructor(name: Name, type: types.Type, isConstant_: boolean, containingPackage: PackageEntity, isSpecial_: SpecialVariableEntityInfo | undefined);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getLocalVariableKind(): LocalVariableKind;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): LocalVariableEntity;
+}

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

@@ -0,0 +1,7 @@
+export * from './IntrinsicConstructorEntity.js';
+export * from './IntrinsicFunctionEntity.js';
+export * from './IntrinsicFunctionTypeEntity.js';
+export * from './IntrinsicGetterEntity.js';
+export * from './IntrinsicStructuredTypeEntity.js';
+export * from './IntrinsicTypeParameterEntity.js';
+export * from './IntrinsicVariableEntity.js';

package/build/types/entities/source/SourceAliasTypeEntity.d.ts

@@ -0,0 +1,36 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Analyzer } from '../../analysis/index.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
+import { PackageAliasTypeDeclaration } from '../../tree/index.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import { AliasedType, AliasTypeEntity, AliasTypeEntityDefinition, EntityContext, EntityHidingLevel, EntityKind, PackageEntity, SubstitutionApplicationMode, TypeEntityKind, TypeParameterEntity } from '../index.js';
+export declare class PackageAliasTypeDeclarationEntity implements AliasTypeEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Alias;
+    private readonly name;
+    private readonly aliasedType;
+    private readonly typeParameters;
+    private readonly members;
+    private readonly hiding;
+    private modifierFlags_;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: PackageAliasTypeDeclaration);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getAliasedType(): AliasedType;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): AliasTypeEntityDefinition;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContext(): EntityContext;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AliasTypeEntity;
+}

package/build/types/entities/source/SourceConstructorEntity.d.ts

@@ -0,0 +1,30 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Analyzer } from '../../analysis/index.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
+import { ConstructorDeclaration } from '../../tree/index.js';
+import type { ConstructorEntity, ConstructorEntityDefinition, DefaultConstructorEntityInfo, PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { EntityHidingLevel, EntityKind, ParameterEntity } from '../index.js';
+export declare class ConstructorDeclarationEntity implements ConstructorEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Constructor;
+    private readonly parameters;
+    private readonly hiding;
+    private containingEntity;
+    private modifierFlags_;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: ConstructorDeclaration);
+    getParameters(): readonly ParameterEntity[];
+    getDefinition(): ConstructorEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isDefault(): DefaultConstructorEntityInfo | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): ConstructorEntity;
+}

package/build/types/entities/source/SourceDereferenceOperatorEntity.d.ts

@@ -0,0 +1,37 @@
+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 { DereferencedVariableGetterDeclaration, DereferencedVariableSetterDeclaration } from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { DereferenceOperatorEntity, DereferenceOperatorEntityDefinition, EntityHidingLevel, EntityKind, GetterEntity, PackageEntity, SetterEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+export declare class DereferenceOperatorDeclarationEntity implements DereferenceOperatorEntity {
+    readonly kind = EntityKind.DereferenceOperator;
+    private readonly analyzer;
+    private readonly getterDeclaration;
+    private readonly setterDeclaration;
+    private readonly getterOrSetterDeclaration;
+    private containingEntity;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, getterDeclaration: DereferencedVariableGetterDeclaration | undefined, setterDeclaration: DereferencedVariableSetterDeclaration | undefined);
+    getType(): types.Type;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    getDefinition(): DereferenceOperatorEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    getOverriddenMembers(): readonly types.DereferenceOperator[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): DereferenceOperatorEntity;
+    ensureAllDiagnosticsReported(): void;
+}