@artel/artc 0.6.25191

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

@@ -0,0 +1,423 @@
+import { Tag } from '../analysis/Tags.js';
+import { Analyzer } from '../analysis/index.js';
+import { Lazy, Name } from '../common/index.js';
+import { EnumerationVariableDeclaration, ErrorVariableDeclaration, LocalVariableDeclaration, MethodLiteral, PackageVariableDeclaration, PackageVariableGetterDeclaration, PackageVariableSetterDeclaration, ParameterDeclaration, SetterParameterDeclaration, TypeVariableDeclaration, TypeVariableGetterDeclaration, TypeVariableSetterDeclaration } from '../tree/index.js';
+import * as types from '../types/index.js';
+import type { Entity, IndexerEntity, PackageEntity } from './index.js';
+import { Entity as ActualEntity, ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, GetterEntity, MethodEntity, MethodTypeEntity, SetterEntity, TypeMemberEntityContainer } from './index.js';
+export type VariableEntity = PackageVariableEntity | TypeVariableEntity | ParameterVariableEntity | LocalVariableEntity;
+export interface PackageVariableEntity extends IVariableEntity {
+    readonly subkind: 'package';
+    getContainingPackage(): PackageEntity;
+}
+export interface TypeVariableEntity extends IVariableEntity {
+    readonly subkind: 'type';
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isConsistent(): boolean;
+    isObservable(): boolean;
+}
+export interface ParameterVariableEntity extends IVariableEntity {
+    readonly subkind: 'parameter';
+    getContainer(): ParameterVariableEntityContainer;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+}
+export interface LocalVariableEntity extends IVariableEntity {
+    readonly subkind: 'local';
+    getContainingEntity(): Entity;
+}
+interface IVariableEntity {
+    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[];
+}
+export type ParameterVariableEntityContainer = ParameterVariableEntityContainer.Entity | ParameterVariableEntityContainer.MethodLiteral;
+export declare namespace ParameterVariableEntityContainer {
+    class Entity {
+        readonly entity: EntityContainingValueParameter;
+        readonly kind = "entity";
+        constructor(entity: EntityContainingValueParameter);
+    }
+    class MethodLiteral {
+        readonly entityContainingMethod: ActualEntity;
+        readonly kind = "method-literal";
+        constructor(entityContainingMethod: ActualEntity);
+    }
+}
+export type EntityContainingValueParameter = MethodEntity | IndexerEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | SetterEntity;
+export declare function isEntityContainingValueParameter(entity: Entity): entity is EntityContainingValueParameter;
+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: PackageVariableDeclaration | TypeVariableDeclaration | LocalVariableDeclaration | EnumerationVariableDeclaration | ErrorVariableDeclaration | ParameterDeclaration | SetterParameterDeclaration;
+};
+export type MultiSourceVariableEntityDefinition = {
+    kind: 'multi';
+    nodes: ReadonlyArray<PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | TypeVariableGetterDeclaration | TypeVariableSetterDeclaration | ParameterDeclaration>;
+};
+export declare class ImplicitMethodBlockParameterSpecialVariableEntityInfo {
+    readonly targetTypeParameter: types.ValueParameter;
+    readonly kind = "implicit-method-block-parameter";
+    constructor(targetTypeParameter: types.ValueParameter);
+}
+export type SpecialVariableEntityInfo = ResultSpecialVariableEntityInfo | ParamSpecialVariableEntityInfo | ValueSpecialVariableEntityInfo | BackingSpecialVariableEntityInfo | ParamObjectMemberSpecialVariableEntityInfo | ImplicitMethodBlockParameterSpecialVariableEntityInfo;
+export declare class ResultSpecialVariableEntityInfo {
+    readonly kind = "result";
+}
+export declare class ParamSpecialVariableEntityInfo {
+    readonly kind = "param";
+}
+export declare class ValueSpecialVariableEntityInfo {
+    readonly kind = "value";
+}
+export declare class BackingSpecialVariableEntityInfo {
+    readonly computedVariable: PackageVariableEntity | TypeVariableEntity;
+    readonly kind = "backing";
+    constructor(computedVariable: PackageVariableEntity | TypeVariableEntity);
+}
+export declare class ParamObjectMemberSpecialVariableEntityInfo {
+    readonly correspondingParameter: VariableEntity;
+    readonly kind = "param-object-member";
+    constructor(correspondingParameter: VariableEntity);
+}
+export declare class PackageVariableDeclarationEntity implements PackageVariableEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "package";
+    private readonly _typeInferrer;
+    constructor(_analyzer: Analyzer, _node: PackageVariableDeclaration);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+}
+export declare class ComputedPackageVariableDeclarationEntity implements PackageVariableEntity {
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "package";
+    private readonly _analyzer;
+    private readonly _getterDeclaration;
+    private readonly _setterDeclaration;
+    private readonly _getterOrSetterDeclaration;
+    constructor(analyzer: Analyzer, getterDeclaration: PackageVariableGetterDeclaration | undefined, setterDeclaration: PackageVariableSetterDeclaration | undefined);
+    getName(): Name;
+    getType(): types.Type;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    isConstant(): boolean;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+}
+export declare class TypeVariableDeclarationEntity implements TypeVariableEntity {
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "type";
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _typeInferrer;
+    constructor(analyzer: Analyzer, node: TypeVariableDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isConsistent(): boolean;
+    isObservable(): boolean;
+}
+export declare class ComputedTypeVariableDeclarationEntity implements TypeVariableEntity {
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "type";
+    private readonly _analyzer;
+    private readonly _getterDeclaration;
+    private readonly _setterDeclaration;
+    private readonly _getterOrSetterDeclaration;
+    constructor(analyzer: Analyzer, getterDeclaration: TypeVariableGetterDeclaration | undefined, setterDeclaration: TypeVariableSetterDeclaration | undefined);
+    getName(): Name;
+    getType(): types.Type;
+    getContainer(): TypeMemberEntityContainer;
+    isHidden(): EntityHidingLevel | undefined;
+    isConstant(): boolean;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isConsistent(): boolean;
+    isObservable(): boolean;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+}
+export declare class LocalVariableDeclarationEntity implements LocalVariableEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    private readonly _typeInferrer;
+    constructor(_analyzer: Analyzer, _node: LocalVariableDeclaration);
+    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(): Entity;
+}
+export declare class EnumerationVariableDeclarationEntity implements LocalVariableEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    private readonly _typeInferrer;
+    constructor(_analyzer: Analyzer, _node: EnumerationVariableDeclaration);
+    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(): Entity;
+}
+export declare class ErrorVariableDeclarationEntity implements LocalVariableEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    constructor(_analyzer: Analyzer, _node: ErrorVariableDeclaration);
+    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(): Entity;
+}
+export declare class ParameterDeclarationEntity implements ParameterVariableEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    private readonly _typeInferrer;
+    constructor(_analyzer: Analyzer, _node: ParameterDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainer(): ParameterVariableEntityContainer;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+}
+export declare class TypeIndexerParameterDeclarationEntity implements ParameterVariableEntity {
+    private readonly _analyzer;
+    private readonly _getterParameterDeclaration;
+    private readonly _setterParameterDeclaration;
+    private readonly _indexerEntity;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    private readonly _getterOrSetterParameterDeclaration;
+    private readonly _typeInferrer;
+    constructor(_analyzer: Analyzer, _getterParameterDeclaration: ParameterDeclaration | undefined, _setterParameterDeclaration: ParameterDeclaration | undefined, _indexerEntity: IndexerEntity);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainer(): ParameterVariableEntityContainer;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+}
+export declare class MethodLiteralParameterDeclarationEntity implements ParameterVariableEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _methodLiteral;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    private readonly _parameterIndex;
+    constructor(_analyzer: Analyzer, _node: ParameterDeclaration, _methodLiteral: MethodLiteral);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainer(): ParameterVariableEntityContainer;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+}
+export declare class SetterParameterDeclarationEntity implements ParameterVariableEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    constructor(_analyzer: Analyzer, _node: SetterParameterDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainer(): ParameterVariableEntityContainer;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+}
+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;
+}
+export declare class IntrinsicTypeVariableEntity implements TypeVariableEntity {
+    private readonly _name;
+    private readonly _type;
+    private readonly _container;
+    private readonly _isStatic;
+    private readonly _isRedefinable;
+    private readonly _isRedefined;
+    private readonly _isAbstract;
+    private readonly _isConsistent;
+    private readonly _isObservable;
+    private readonly _isSpecial;
+    private readonly _isHidden;
+    private readonly _getter;
+    private readonly _setter;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "type";
+    constructor(_name: Name, _type: types.Type, _container: TypeMemberEntityContainer, _isStatic: boolean, _isRedefinable: boolean, _isRedefined: boolean, _isAbstract: boolean, _isConsistent: boolean, _isObservable: boolean, _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[];
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isConsistent(): boolean;
+    isObservable(): boolean;
+}
+export declare class IntrinsicParameterVariableEntity implements ParameterVariableEntity {
+    private readonly _name;
+    private readonly _type;
+    private readonly _container;
+    private readonly _isOptional;
+    private readonly _isVariadic;
+    private readonly _isSpecial;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    constructor(_name: Name, _type: types.Type, _container: ParameterVariableEntityContainer, _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[];
+    getContainer(): ParameterVariableEntityContainer;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+}
+export declare class IntrinsicLocalVariableEntity implements LocalVariableEntity {
+    private readonly _name;
+    private readonly _type;
+    private readonly _isConstant;
+    private readonly _containingEntity;
+    private readonly _isSpecial;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    constructor(_name: Name, _type: types.Type, _isConstant: boolean, _containingEntity: Entity, _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(): Entity;
+}
+export {};

package/build/types/entities/VariantEntity.d.ts

@@ -0,0 +1,31 @@
+import { Tag } from '../analysis/Tags.js';
+import { Analyzer } from '../analysis/index.js';
+import { Name } from '../common/index.js';
+import { VariantDeclaration } from '../tree/index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, VariantTypeEntity } from './index.js';
+export interface VariantEntity {
+    readonly kind: EntityKind.Variant;
+    getName(): Name;
+    getDefinition(): VariantEntityDefinition;
+    getContainingEntity(): VariantTypeEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}
+export type VariantEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: VariantDeclaration;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export declare class VariantDeclarationEntity implements VariantEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Variant;
+    private readonly _variantTypeDeclaration;
+    constructor(_analyzer: Analyzer, _node: VariantDeclaration);
+    getName(): Name;
+    getDefinition(): VariantEntityDefinition;
+    getContainingEntity(): VariantTypeEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}

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

@@ -0,0 +1,83 @@
+import { Tag } from '../analysis/Tags.js';
+import { Analyzer } from '../analysis/index.js';
+import { Name } from '../common/index.js';
+import { AnonymousVariantTypeDeclaration, PackageVariantTypeDeclaration } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { EntityNaming } from './EntityNaming.js';
+import { OriginalTypeEntityMembers } from './TypeEntityMembers.js';
+import { OriginalVariants } from './Variants.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, PackageEntity, SubstitutionApplicationMode, TypeParameterEntity } from './index.js';
+export type VariantTypeEntity = PackageVariantTypeEntity | AnonymousVariantTypeEntity;
+export interface PackageVariantTypeEntity extends IVariantTypeEntity {
+    readonly subkind: 'package';
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+}
+export interface AnonymousVariantTypeEntity extends IVariantTypeEntity {
+    readonly subkind: 'anonymous';
+    getContainingPackage(): PackageEntity;
+}
+interface IVariantTypeEntity {
+    readonly kind: EntityKind.VariantType;
+    getVariants(): OriginalVariants;
+    getMembers(): OriginalTypeEntityMembers;
+    getUnderlyingType(): types.Type;
+    getDefinition(): VariantTypeEntityDefinition;
+    getNaming(): EntityNaming;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export type VariantTypeEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: PackageVariantTypeDeclaration | AnonymousVariantTypeDeclaration;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export declare class PackageVariantTypeDeclarationEntity implements PackageVariantTypeEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.VariantType;
+    readonly subkind = "package";
+    private readonly _typeParameters;
+    private readonly _variants;
+    private readonly _members;
+    private readonly _underlyingType;
+    constructor(_analyzer: Analyzer, _node: PackageVariantTypeDeclaration);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getVariants(): OriginalVariants;
+    getMembers(): OriginalTypeEntityMembers;
+    getUnderlyingType(): types.Type;
+    getDefinition(): VariantTypeEntityDefinition;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class AnonymousVariantTypeDeclarationEntity implements AnonymousVariantTypeEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.VariantType;
+    readonly subkind = "anonymous";
+    private readonly _variants;
+    private readonly _underlyingType;
+    private readonly _members;
+    constructor(_analyzer: Analyzer, _node: AnonymousVariantTypeDeclaration);
+    getVariants(): OriginalVariants;
+    getMembers(): OriginalTypeEntityMembers;
+    getUnderlyingType(): types.Type;
+    getDefinition(): VariantTypeEntityDefinition;
+    getNaming(): EntityNaming;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContainingPackage(): PackageEntity;
+}
+export {};

package/build/types/entities/Variants.d.ts

@@ -0,0 +1,10 @@
+import { Name } from '../common/index.js';
+import { VariantEntity } from './VariantEntity.js';
+export declare class OriginalVariants {
+    private readonly _variants;
+    private readonly _variantsByUniversalName;
+    private get variantsByUniversalName();
+    constructor(_variants: readonly VariantEntity[]);
+    get(): readonly VariantEntity[];
+    getByName(name: Name): readonly VariantEntity[];
+}

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

@@ -0,0 +1,87 @@
+import { AliasTypeEntity } from './AliasTypeEntity.js';
+import { ConstructorEntity } from './ConstructorEntity.js';
+import { DestructorEntity } from './DestructorEntity.js';
+import { GetterEntity } from './GetterEntity.js';
+import { IndexerEntity } from './IndexerEntity.js';
+import { DereferenceOperatorEntity } from './DereferenceOperatorEntity.js';
+import { MethodEntity, PackageMethodEntity, TypeMethodEntity } from './MethodEntity.js';
+import { AnonymousMethodTypeEntity, MethodTypeEntity, PackageMethodTypeEntity } from './MethodTypeEntity.js';
+import { PackageAliasEntity } from './PackageAliasEntity.js';
+import { PackageEntity } from './PackageEntity.js';
+import { SetterEntity } from './SetterEntity.js';
+import { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, StructuredTypeEntity } from './StructuredTypeEntity.js';
+import { TypeExtensionEntity } from './TypeExtensionEntity.js';
+import { TypeParameterEntity } from './TypeParameterEntity.js';
+import { UnaryOperatorEntity } from './UnaryOperatorEntity.js';
+import { PackageVariableEntity, TypeVariableEntity, VariableEntity } from './VariableEntity.js';
+import { VariantEntity } from './VariantEntity.js';
+import { AnonymousVariantTypeEntity, PackageVariantTypeEntity, VariantTypeEntity } from './VariantTypeEntity.js';
+import { BinaryOperatorEntity } from './index.js';
+export * from './AliasTypeEntity.js';
+export * from './BinaryOperatorEntity.js';
+export * from './ConstructorEntity.js';
+export * from './DestructorEntity.js';
+export * from './EntityHiding.js';
+export * from './EntityNaming.js';
+export * from './GetterEntity.js';
+export * from './IndexerEntity.js';
+export * from './DereferenceOperatorEntity.js';
+export * from './MethodEntity.js';
+export * from './MethodTypeEntity.js';
+export * from './PackageAliasEntity.js';
+export * from './PackageEntity.js';
+export * from './SetterEntity.js';
+export * from './StructuredTypeEntity.js';
+export * from './SubstitutionApplicationMode.js';
+export * from './TypeExtensionEntity.js';
+export * from './TypeMemberContainer.js';
+export * from './TypeParameterEntity.js';
+export * from './UnaryOperatorEntity.js';
+export * from './VariableEntity.js';
+export * from './VariantEntity.js';
+export * from './VariantTypeEntity.js';
+export declare const enum DefinitionKind {
+    Source = 0,
+    Intrinsic = 1,
+    TypeScript = 2
+}
+export declare const enum EntityKind {
+    Variable = 0,
+    Variant = 1,
+    VariantType = 2,
+    Getter = 3,
+    Setter = 4,
+    Method = 5,
+    TypeParameter = 6,
+    Indexer = 7,
+    DereferenceOperator = 8,
+    Constructor = 9,
+    Destructor = 10,
+    MethodType = 11,
+    StructuredType = 12,
+    PackageAlias = 13,
+    AliasType = 14,
+    UnaryOperator = 15,
+    BinaryOperator = 16,
+    Package = 17,
+    TypeExtension = 18
+}
+export type Entity = PackageEntity | VariableEntity | VariantEntity | VariantTypeEntity | GetterEntity | SetterEntity | MethodEntity | TypeParameterEntity | IndexerEntity | DereferenceOperatorEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity | TypeExtensionEntity | UnaryOperatorEntity | BinaryOperatorEntity;
+export type TypeEntity = MethodTypeEntity | StructuredTypeEntity | TypeParameterEntity | VariantTypeEntity | AliasTypeEntity;
+export type PackageTypeEntity = PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageVariantTypeEntity | AliasTypeEntity;
+export declare function isPackageTypeEntity(entity: TypeEntity): entity is PackageTypeEntity;
+export type NamedTypeEntity = PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageVariantTypeEntity | AliasTypeEntity | TypeParameterEntity;
+export type TypeEntityWithMembers = MethodTypeEntity | StructuredTypeEntity | VariantTypeEntity | AliasTypeEntity;
+export declare function isTypeEntityWithMembers(entity: TypeEntity): entity is TypeEntityWithMembers;
+export declare function isTypeEntity(entity: Entity): entity is TypeEntity;
+export declare function isNamedTypeEntity(entity: TypeEntity): entity is NamedTypeEntity;
+export type PackageMemberEntity = PackageVariableEntity | PackageMethodEntity | PackageTypeEntity;
+export type EntityWithTags = AliasTypeEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | MethodEntity | MethodTypeEntity | StructuredTypeEntity | VariableEntity | VariantEntity | VariantTypeEntity;
+export declare function isEntityWithTags(entity: Entity): entity is EntityWithTags;
+export type TypeMemberEntity = TypeVariableEntity | TypeMethodEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | UnaryOperatorEntity | BinaryOperatorEntity;
+export declare function isTypeMemberEntity(entity: Entity): entity is TypeMemberEntity;
+export type AnonymousTypeEntity = AnonymousStructuredTypeEntity | AnonymousMethodTypeEntity | AnonymousVariantTypeEntity;
+export declare function isAnonymousTypeEntity(entity: Entity): entity is AnonymousTypeEntity;
+export declare function entityToStringDecorator<T extends {
+    new (...args: any[]): Entity;
+}>(constructor: T): void;

package/build/types/executor/CommandLineCompiler.d.ts

@@ -0,0 +1,8 @@
+export declare class CommandLineCompiler {
+    static readonly successExitCode = 0;
+    static readonly errorExitCode = 1;
+    static run(args: readonly string[]): Promise<number>;
+    private static displayUsageMessage;
+    private static displayPerformanceMeasurementResults;
+    private static execute;
+}

package/build/types/executor/Compiler.d.ts

@@ -0,0 +1,15 @@
+import { Analyzer } from '../analysis/Analyzer.js';
+import { CancellationToken, Uri } from '../common/index.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { EmitOptions, OutputAcceptor } from '../emitter/index.js';
+import { Compilation } from '../project/Compilation.js';
+import { SourcesProvider } from '../project/CompilationLoader.js';
+import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
+export type LaunchUri = Uri;
+export declare class Compiler {
+    static loadCompilation(projectUri: Uri, sourcesProvider: SourcesProvider, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, workspaceUri?: Uri, standardPackagesUri?: Uri, cancellationToken?: CancellationToken): Promise<Compilation | undefined>;
+    static createAnalyzer(compilation: Compilation, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, _cancellationToken?: CancellationToken): Promise<Analyzer | undefined>;
+    static analyze(analyzer: Analyzer, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<boolean>;
+    static emit(analyzer: Analyzer, outputUri: Uri, outputAcceptor: OutputAcceptor, _diagnostics: DiagnosticAcceptor | undefined, emitOptions?: EmitOptions, cancellationToken?: CancellationToken): Promise<LaunchUri | undefined>;
+    static emitToString(analyzer: Analyzer, _diagnostics: DiagnosticAcceptor | undefined, emitOptions?: EmitOptions, cancellationToken?: CancellationToken): Promise<string>;
+}

package/build/types/executor/FileSystemUri.d.ts

@@ -0,0 +1,5 @@
+import { Uri } from '../common/index.js';
+export declare class FileSystemUri {
+    static pathToUri(path: string): Uri;
+    static toPath(uri: Uri): string;
+}