@artel/artc 0.6.26039 → 0.9.26001

package/build/types/entities/interfaces/m/ConstructorEntityM.d.ts

@@ -0,0 +1,10 @@
+import * as types from '../../../types/index.js';
+import { BaseConstructorEntity } from '../BaseConstructorEntity.js';
+export declare abstract class ConstructorEntityM extends BaseConstructorEntity {
+    constructor();
+    getReturnType(): types.Type;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    isAsync(): boolean;
+}

package/build/types/entities/interfaces/m/DestructorEntityM.d.ts

@@ -0,0 +1,8 @@
+import { BaseDestructorEntity } from '../BaseDestructorEntity.js';
+export declare abstract class DestructorEntityM extends BaseDestructorEntity {
+    constructor();
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    isAsync(): boolean;
+}

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

@@ -0,0 +1,2 @@
+export * from './ConstructorEntityM.js';
+export * from './DestructorEntityM.js';

package/build/types/entities/source/a/SourceFunctionEntity.d.ts

@@ -83,7 +83,7 @@ export declare class OperatorDeclarationEntity extends BaseOperatorEntity {
     private modifierFlags_;
     private hasReportedAllDiagnostics;
     private get modifierFlags();
-    constructor(analyzer: Analyzer, node: tree.MethodDeclaration, syntacticOperatorKind: tree.OperatorKind);
+    constructor(analyzer: Analyzer, node: tree.MethodDeclaration);
     getName(): Name;
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly ParameterEntity[];

package/build/types/entities/source/a/SourcePackageEntity.d.ts

@@ -2,7 +2,7 @@ import { Analyzer } from '../../../analysis/a/Analyzer.js';
 import { ResolvedTranslationPackage } from '../../../analysis/a/ResolvedTranslationPackage.js';
 import { PackageDialect, PackageLocale } from '../../../common/index.js';
 import { PackageName, PlatformKind, ProgramPackageA, SourcePackageA, TextTranslationPackageA, TranslationPackageA } from '../../../project/index.js';
-import { AnonymousTypeEntity, EntityKind, EntityLocalizationContext, InterfacePackageEntityInfo, IPackageEntity, LocalizablePackageMemberEntity, NameTranslationPackageEntity, PackageEntity, PackageEntityDefinition, PackageEntityMembers, ProgramPackageEntity, Tag, TextTranslationPackageEntity, TextTranslationPackageEntityInfo, Translation, TypeMemberEntity } from '../../index.js';
+import { AnonymousTypeEntity, EntityKind, EntityLocalizationContext, InterfacePackageEntityInfo, IPackageEntity, LocalizablePackageMemberEntity, NameTranslationPackageEntity, PackageEntity, PackageEntityDefinition, PackageEntityMembers, ProgramPackageEntity, Tag, TextTranslationPackageEntity, TextTranslationPackageEntityInfo, Translation, TypeMemberEntity, LocalTypeEntity } from '../../index.js';
 export declare abstract class SourcePackageEntity implements IPackageEntity {
     readonly kind = EntityKind.Package;
     protected readonly analyzer: Analyzer;
@@ -55,6 +55,7 @@ export declare class SourceNameTranslationPackageEntity extends SourcePackageEnt
     getTranslatedPackageMember(entity: LocalizablePackageMemberEntity): LocalizablePackageMemberEntity;
     getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
     getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
+    getTranslatedLocalTypeEntity(entity: LocalTypeEntity): LocalTypeEntity;
 }
 export declare class SourceTextTranslationPackageEntity extends SourcePackageEntity implements TextTranslationPackageEntity {
     readonly subkind = "text-translation";

package/build/types/entities/source/a/SourceStructuredTypeEntity.d.ts

@@ -6,7 +6,6 @@ export declare class PackageStructuredTypeDeclarationEntity implements PackageSt
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Structured;
     readonly subkind = "package";
-    private readonly analyzer;
     private readonly node;
     private readonly data;
     constructor(analyzer: Analyzer, node: tree.PackageStructuredTypeDeclaration);
@@ -31,11 +30,10 @@ export declare class PackageStructuredTypeDeclarationEntity implements PackageSt
     getOriginalEntity(): PackageStructuredTypeEntity;
 }
 export declare class AnonymousStructuredTypeDeclarationEntity implements AnonymousStructuredTypeEntity {
-    private readonly analyzer;
-    private readonly node;
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Structured;
     readonly subkind = "anonymous";
+    private readonly node;
     private readonly data;
     constructor(analyzer: Analyzer, node: tree.AnonymousStructuredTypeDeclaration);
     getNaming(): EntityNaming;
@@ -59,11 +57,11 @@ export declare class AnonymousStructuredTypeDeclarationEntity implements Anonymo
 }
 export declare abstract class SourceStructuredTypeDeclarationData {
     protected readonly analyzer: Analyzer;
+    private readonly baseTypes;
+    private readonly members;
     protected abstract get memberBlock(): tree.TypeMemberDeclarationBlock;
     protected abstract get extendsClause(): tree.ExtendsClause | undefined;
     protected abstract get entity(): StructuredTypeEntity;
-    private readonly baseTypes;
-    private readonly members;
     constructor(analyzer: Analyzer);
     abstract getStructuredTypeKind(): StructuredTypeKind;
     getContainingPackage(): PackageEntity;

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

@@ -0,0 +1,32 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { Name, PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import { AliasedType, AliasTypeEntity, AliasTypeEntityDefinition, EntityHidingLevel, EntityKind, PackageEntity, SubstitutionApplicationMode, Tag, Translation, TypeEntityKind, TypeEntityMembers, 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: tree.PackageAliasTypeDeclaration);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getAliasedType(): AliasedType;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): AliasTypeEntityDefinition;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AliasTypeEntity;
+}

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

@@ -0,0 +1,40 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { Name, PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { DefaultConstructorEntityInfo, EntityHidingLevel, FunctionEntityDefinition, MethodEntity, PackageEntity, ParameterEntity, PreservedReducedTypeEntityMemberInfo, Tag, Translation, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../index.js';
+import { ConstructorEntityM } from '../../interfaces/m/ConstructorEntityM.js';
+export declare class ConstructorDeclarationEntity extends ConstructorEntityM {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.MethodDeclaration);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    getDefinition(): FunctionEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isDefault(): DefaultConstructorEntityInfo | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Method> | undefined;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    isDefaultConstructor(): DefaultConstructorEntityInfo | undefined;
+    getOriginalEntity(): MethodEntity;
+    ensureAllDiagnosticsReported(): void;
+    getOverriddenMembers(): readonly types.Method[];
+    getShadowedMembers(): readonly types.NamedTypeMember[];
+}

package/build/types/entities/source/m/SourceDestructorEntity.d.ts

@@ -0,0 +1,38 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { Name, PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { EntityHidingLevel, FunctionEntityDefinition, MethodEntity, PackageEntity, ParameterEntity, PreservedReducedTypeEntityMemberInfo, Tag, Translation, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../index.js';
+import { DestructorEntityM } from '../../interfaces/m/DestructorEntityM.js';
+export declare class DestructorDeclarationEntity extends DestructorEntityM {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.MethodDeclaration);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    getDefinition(): FunctionEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Method> | undefined;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+    ensureAllDiagnosticsReported(): void;
+    getOverriddenMembers(): readonly types.Method[];
+    getShadowedMembers(): readonly types.NamedTypeMember[];
+}

package/build/types/entities/source/m/SourceFunctionEntity.d.ts

@@ -0,0 +1,252 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { Name, PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { AnonymousFunctionEntity, BaseOrdinaryPackageFunctionEntity, EntityHidingLevel, EntityKind, EntityNaming, FunctionEntityDefinition, MethodEntity, NestedFunctionEntity, OperatorKind, PackageEntity, PackageFunctionEntity, ParameterEntity, PreservedReducedTypeEntityMemberInfo, SubstitutionApplicationMode, Tag, Translation, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../index.js';
+import { BaseOperatorEntity } from '../../interfaces/BaseOperatorEntity.js';
+import { BaseOrdinaryMethodEntity } from '../../interfaces/BaseOrdinaryMethodEntity.js';
+import { FunctionLiteralParameterDeclarationEntity } from './SourceVariableEntity.js';
+export declare class PackageFunctionDeclarationEntity extends BaseOrdinaryPackageFunctionEntity {
+    private readonly analyzer;
+    private readonly node;
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly hiding;
+    private modifierFlags_;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.PackageFunctionDeclaration);
+    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;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageFunctionEntity;
+}
+export declare class OrdinaryMethodDeclarationEntity extends BaseOrdinaryMethodEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.MethodDeclaration);
+    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;
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Method> | undefined;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+    ensureAllDiagnosticsReported(): void;
+}
+export declare class OperatorDeclarationEntity extends BaseOperatorEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly name;
+    private readonly operatorKind;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.MethodDeclaration);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Method> | undefined;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOperatorKind(): OperatorKind;
+    getOriginalEntity(): MethodEntity;
+    ensureAllDiagnosticsReported(): void;
+    private convertSyntacticOperatorKind;
+}
+export declare class NestedFunctionDeclarationEntity implements NestedFunctionEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Function;
+    readonly subkind = "nested";
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    constructor(analyzer: Analyzer, node: tree.NestedFunctionDeclaration);
+    getName(): Name;
+    getNaming(): EntityNaming;
+    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(): NestedFunctionEntity;
+}
+export declare class FunctionLiteralEntity implements AnonymousFunctionEntity, RegularOrBlockFunctionLiteralEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Function;
+    readonly subkind = "anonymous";
+    get isInferringReturnType(): boolean;
+    get isInferringIsAsync(): boolean;
+    private isTargetTypeSet;
+    private targetType;
+    private areParameterTypesSet;
+    private readonly parameters;
+    private returnType;
+    private isInferringReturnType_;
+    constructor(analyzer: Analyzer, node: tree.FunctionLiteral);
+    setTargetFunctionType(type: types.FunctionType | undefined): void;
+    dependsOnTargetType(): boolean;
+    getNaming(): EntityNaming;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly FunctionLiteralParameterDeclarationEntity[];
+    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(): AnonymousFunctionEntity;
+    ensureParameterTypesAreSet(): void;
+    private ensureTargetTypeIsSet;
+    private setParameterTypes;
+}
+export declare class FunctionBlockLiteralEntity implements AnonymousFunctionEntity, RegularOrBlockFunctionLiteralEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Function;
+    readonly subkind = "anonymous";
+    get isInferringReturnType(): boolean;
+    get isInferringIsAsync(): boolean;
+    private parameters;
+    private isTargetTypeSet;
+    private targetType;
+    private returnType;
+    private isAsync_;
+    private isInferringReturnType_;
+    private isInferringIsAsync_;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlockLiteral);
+    setTargetFunctionType(type: types.FunctionType | undefined): void;
+    dependsOnTargetType(): boolean;
+    getNaming(): EntityNaming;
+    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(): AnonymousFunctionEntity;
+    private ensureParametersAreCreated;
+    private ensureTargetTypeIsSet;
+    private createParameters;
+}
+export declare class OrdinaryStaticMethodDeclarationEntity extends BaseOrdinaryMethodEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.StaticMethodDeclaration);
+    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;
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Method> | undefined;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+    ensureAllDiagnosticsReported(): void;
+}
+interface RegularOrBlockFunctionLiteralEntity {
+    readonly isInferringReturnType: boolean;
+    readonly isInferringIsAsync: boolean;
+    setTargetFunctionType(type: types.FunctionType | undefined): void;
+    dependsOnTargetType(): boolean;
+}
+export {};

package/build/types/entities/source/m/SourceFunctionTypeEntity.d.ts

@@ -0,0 +1,35 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { BaseObjectType } from '../../BaseObjectType.js';
+import { AnonymousFunctionTypeEntity, EntityHidingLevel, EntityKind, EntityNaming, FunctionTypeEntityDefinition, PackageEntity, ParameterEntity, SubstitutionApplicationMode, Tag, Translation, TypeEntityKind, TypeEntityMembers, TypeParameterEntity } from '../../index.js';
+export declare class LocalFunctionTypeDeclarationEntity implements AnonymousFunctionTypeEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Function;
+    readonly subkind = "anonymous";
+    private readonly parameters;
+    private readonly returnType;
+    private readonly members;
+    private readonly baseObjectType;
+    constructor(analyzer: Analyzer, node: tree.LocalFunctionTypeDeclaration);
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): FunctionTypeEntityDefinition;
+    isAsync(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContainingPackage(): PackageEntity;
+    getBaseObjectType(): BaseObjectType;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AnonymousFunctionTypeEntity;
+}

package/build/types/entities/source/m/SourceGetterEntity.d.ts

@@ -0,0 +1,122 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { BasePackageMemberAccessorEntity, BaseTypeMemberAccessorEntity, EntityHidingLevel, EntityOwningPackageMemberAccessor, EntityOwningTypeMemberAccessor, FunctionEntityDefinition, MethodEntity, PackageEntity, PackageFunctionEntity, PackageMemberAccessorKind, ParameterEntity, Tag, Translation, TypeMemberAccessorKind, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../index.js';
+export declare class PackageVariableGetterDeclarationEntity extends BasePackageMemberAccessorEntity {
+    private readonly analyzer;
+    private readonly node;
+    private modifierFlags_;
+    private readonly hiding;
+    private readonly parameters;
+    get accessorKind(): PackageMemberAccessorKind;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.PackageVariableGetterDeclaration);
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getAccessorOwner(): EntityOwningPackageMemberAccessor;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    isAsync(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageFunctionEntity;
+}
+export declare class FieldGetterDeclarationEntity extends BaseTypeMemberAccessorEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly hiding;
+    private readonly parameters;
+    private containingEntity;
+    private modifierFlags_;
+    get accessorKind(): TypeMemberAccessorKind;
+    get isImplicitAccessor(): boolean;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.FieldGetterDeclaration);
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getAccessorOwner(): EntityOwningTypeMemberAccessor;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    isAsync(): boolean;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+}
+export declare class IndexedElementGetterDeclarationEntity extends BaseTypeMemberAccessorEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly hiding;
+    private readonly parameters;
+    private containingEntity;
+    private modifierFlags_;
+    get accessorKind(): TypeMemberAccessorKind;
+    get isImplicitAccessor(): boolean;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.IndexedElementGetterDeclaration);
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getAccessorOwner(): EntityOwningTypeMemberAccessor;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    isAsync(): boolean;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+}
+export declare class StaticFieldGetterDeclarationEntity extends BaseTypeMemberAccessorEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly hiding;
+    private readonly parameters;
+    private containingEntity;
+    private modifierFlags_;
+    get accessorKind(): TypeMemberAccessorKind;
+    get isImplicitAccessor(): boolean;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.StaticFieldGetterDeclaration);
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getAccessorOwner(): EntityOwningTypeMemberAccessor;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    isAsync(): boolean;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+}

package/build/types/entities/source/m/SourceIndexerEntity.d.ts

@@ -0,0 +1,36 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { BaseIndexerEntity, EntityHidingLevel, IndexerEntity, IndexerEntityDefinition, MethodEntity, PackageEntity, ParameterEntity, PreservedReducedTypeEntityMemberInfo, Tag, Translation, TypeWithMembersOrExtensionEntity } from '../../index.js';
+export declare class IndexerDeclarationEntity extends BaseIndexerEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly getterDeclaration;
+    private readonly setterDeclaration;
+    private readonly getterOrSetterDeclaration;
+    private readonly hiding;
+    private readonly parameters;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private hasReportedAllDiagnostics;
+    constructor(analyzer: Analyzer, getterDeclaration: tree.IndexedElementGetterDeclaration | undefined, setterDeclaration: tree.IndexedElementSetterDeclaration | undefined);
+    getParameters(): readonly ParameterEntity[];
+    getType(): types.Type;
+    getGetter(): MethodEntity | undefined;
+    getSetter(): MethodEntity | undefined;
+    getDefinition(): IndexerEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Indexer> | undefined;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): IndexerEntity;
+    ensureAllDiagnosticsReported(): void;
+}