@artel/artc 0.6.25271 → 0.6.25273

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

@@ -0,0 +1,77 @@
+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 { AnonymousFunctionTypeDeclaration, PackageFunctionTypeDeclaration } 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 type { AnonymousFunctionTypeEntity, FunctionTypeEntityDefinition, PackageEntity, PackageFunctionTypeEntity } from '../index.js';
+import { EntityContext, EntityHidingLevel, EntityKind, ParameterEntity, SubstitutionApplicationMode, TypeEntityKind, TypeParameterEntity } from '../index.js';
+export declare class PackageFunctionTypeDeclarationEntity implements PackageFunctionTypeEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Function;
+    readonly subkind = "package";
+    private readonly name;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly hiding;
+    private modifierFlags_;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: PackageFunctionTypeDeclaration);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    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;
+    getBaseObjectType(): BaseObjectType;
+    getContext(): EntityContext;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageFunctionTypeEntity;
+}
+export declare class AnonymousFunctionTypeDeclarationEntity 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: AnonymousFunctionTypeDeclaration);
+    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;
+    getContext(): EntityContext;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AnonymousFunctionTypeEntity;
+}

package/build/types/entities/{GetterEntity.d.ts → source/SourceGetterEntity.d.ts}

@@ -1,32 +1,10 @@
-import { Analyzer } from '../analysis/index.js';
-import { GetterDeclaration } from '../analysis/NodeTypeUtils.js';
-import { Tag } from '../analysis/Tag.js';
-import { Translation } from '../analysis/Translation.js';
-import { PackageDialect, PackageLocale } from '../common/index.js';
-import { DereferencedVariableGetterDeclaration, FieldGetterDeclaration, IndexedElementGetterDeclaration, PackageVariableGetterDeclaration } from '../tree/index.js';
-import * as types from '../types/index.js';
-import { IEntity } from './IEntity.js';
-import { DefinitionKind, DereferenceOperatorEntity, EntityHidingLevel, EntityKind, FieldEntity, IndexerEntity, PackageEntity, PackageVariableEntity } from './index.js';
-export interface GetterEntity extends IEntity {
-    readonly kind: EntityKind.Getter;
-    getReturnType(): types.Type;
-    getDefinition(): GetterEntityDefinition;
-    isModifyingOwningPlainObject(): boolean;
-    getOwningEntity(): EntityOwningGetter;
-    isHidden(): EntityHidingLevel | undefined;
-    getTags(): readonly Tag[];
-    getTranslation(): Translation | undefined;
-    getOriginalEntity(): GetterEntity;
-}
-export type GetterEntityDefinition = {
-    kind: DefinitionKind.Source;
-    node: GetterDeclaration;
-} | {
-    kind: DefinitionKind.Intrinsic;
-} | {
-    kind: DefinitionKind.TypeScript;
-};
-export type EntityOwningGetter = PackageVariableEntity | FieldEntity | IndexerEntity | DereferenceOperatorEntity;
+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, FieldGetterDeclaration, IndexedElementGetterDeclaration, PackageVariableGetterDeclaration } from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { EntityHidingLevel, EntityKind, EntityOwningGetter, GetterEntity, GetterEntityDefinition, PackageEntity } from '../index.js';
 export declare class PackageVariableGetterDeclarationEntity implements GetterEntity {
     private readonly analyzer;
     private readonly node;
@@ -107,22 +85,3 @@ export declare class DereferencedVariableGetterDeclarationEntity implements Gett
     getDialect(): PackageDialect;
     getOriginalEntity(): GetterEntity;
 }
-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/source/SourceIndexerEntity.d.ts

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

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

@@ -0,0 +1,38 @@
+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 * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { EntityHidingLevel, EntityKind, OperatorEntity, OperatorEntityDefinition, OperatorKind, PackageEntity, ParameterEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+export declare class OperatorDeclarationEntity implements OperatorEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Operator;
+    private readonly operatorKind;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly hiding;
+    private containingEntity;
+    private modifierFlags_;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.OperatorDeclaration);
+    getOperatorKind(): OperatorKind;
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): OperatorEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getOverriddenMembers(): readonly types.Operator[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): OperatorEntity;
+    private convertSyntaxOperatorKind;
+}

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

@@ -0,0 +1,24 @@
+import { Analyzer } from '../../analysis/index.js';
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import { PackageImport } from '../../tree/index.js';
+import { EntityHidingLevel, EntityKind, PackageAliasEntity, PackageAliasEntityDefinition, PackageEntity } from '../index.js';
+export declare class AliasedPackageImportEntity implements PackageAliasEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.PackageAlias;
+    private readonly name;
+    constructor(analyzer: Analyzer, node: PackageImport, alias: tree.Identifier);
+    getName(): Name;
+    getDefinition(): PackageAliasEntityDefinition;
+    getPackage(): PackageEntity | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageAliasEntity;
+    getTags(): readonly Tag[];
+}

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

@@ -0,0 +1,34 @@
+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 type { SourcePackage } from '../../project/index.js';
+import { PackageName, PlatformKind } from '../../project/index.js';
+import { EntityKind, InterfacePackageEntityInfo, PackageEntity, PackageEntityDefinition, TextTranslationPackageEntityInfo } from '../index.js';
+import { PackageEntityMembers } from '../PackageMembers.js';
+export declare class SourcePackageEntity implements PackageEntity {
+    private readonly analyzer;
+    private readonly package_;
+    readonly kind = EntityKind.Package;
+    private readonly members;
+    private readonly interfaceInfo;
+    private readonly implementedInterfacePackage;
+    private readonly textTranslationInfo;
+    constructor(analyzer: Analyzer, package_: SourcePackage);
+    getName(): PackageName;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getMembers(): PackageEntityMembers;
+    getInterfacePackageInfo(): InterfacePackageEntityInfo | undefined;
+    getImplementedInterfacePackage(): PackageEntity | undefined;
+    getSupportedPlatforms(): readonly PlatformKind[];
+    getContainingPackage(): PackageEntity;
+    getDefinition(): PackageEntityDefinition;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): PackageEntity;
+    getTags(): readonly Tag[];
+    getTextTranslationPackageInfo(): TextTranslationPackageEntityInfo | undefined;
+    private createPackageMembers;
+    private createInterfacePackageInfo;
+    private createTextTranslationInfo;
+}

package/build/types/entities/{SetterEntity.d.ts → source/SourceSetterEntity.d.ts}

@@ -1,30 +1,9 @@
-import { Analyzer } from '../analysis/index.js';
-import { SetterDeclaration } from '../analysis/NodeTypeUtils.js';
-import { Tag } from '../analysis/Tag.js';
-import { Translation } from '../analysis/Translation.js';
-import { PackageDialect, PackageLocale } from '../common/index.js';
-import { DereferencedVariableSetterDeclaration, FieldSetterDeclaration, IndexedElementSetterDeclaration, PackageVariableSetterDeclaration } from '../tree/index.js';
-import { IEntity } from './IEntity.js';
-import { DefinitionKind, DereferenceOperatorEntity, EntityHidingLevel, EntityKind, FieldEntity, IndexerEntity, PackageEntity, PackageVariableEntity } from './index.js';
-export interface SetterEntity extends IEntity {
-    readonly kind: EntityKind.Setter;
-    getDefinition(): SetterEntityDefinition;
-    isModifyingOwningPlainObject(): boolean;
-    getOwningEntity(): EntityOwningSetter;
-    isHidden(): EntityHidingLevel | undefined;
-    getTags(): readonly Tag[];
-    getTranslation(): Translation | undefined;
-    getOriginalEntity(): SetterEntity;
-}
-export type SetterEntityDefinition = {
-    kind: DefinitionKind.Source;
-    node: SetterDeclaration;
-} | {
-    kind: DefinitionKind.Intrinsic;
-} | {
-    kind: DefinitionKind.TypeScript;
-};
-export type EntityOwningSetter = PackageVariableEntity | FieldEntity | IndexerEntity | DereferenceOperatorEntity;
+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 { DereferencedVariableSetterDeclaration, FieldSetterDeclaration, IndexedElementSetterDeclaration, PackageVariableSetterDeclaration } from '../../tree/index.js';
+import { EntityHidingLevel, EntityKind, EntityOwningSetter, PackageEntity, SetterEntity, SetterEntityDefinition } from '../index.js';
 export declare class PackageVariableSetterDeclarationEntity implements SetterEntity {
     private readonly analyzer;
     private readonly node;

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

@@ -0,0 +1,114 @@
+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 * as tree from '../../tree/index.js';
+import { BaseAspectTypes } from '../BaseAspectTypes.js';
+import { BaseObjectType } from '../BaseObjectType.js';
+import { EntityNaming } from '../EntityNaming.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import { AnonymousStructuredTypeEntity, EntityContext, EntityHidingLevel, EntityKind, PackageEntity, PackageStructuredTypeEntity, StructuredTypeEntity, StructuredTypeEntityDefinition, StructuredTypeKind, SubstitutionApplicationMode, TypeEntityKind, TypeParameterEntity } from '../index.js';
+export declare class PackageStructuredTypeDeclarationEntity implements PackageStructuredTypeEntity {
+    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);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContext(): EntityContext;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    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 data;
+    constructor(analyzer: Analyzer, node: tree.AnonymousStructuredTypeDeclaration);
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContainingPackage(): PackageEntity;
+    getContext(): EntityContext;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AnonymousStructuredTypeEntity;
+}
+export declare abstract class SourceStructuredTypeDeclarationData {
+    protected readonly analyzer: Analyzer;
+    protected abstract get body(): tree.StructuredTypeDeclarationBody;
+    protected abstract get entity(): StructuredTypeEntity;
+    private readonly baseTypes;
+    private readonly members;
+    constructor(analyzer: Analyzer);
+    getContainingPackage(): PackageEntity;
+    getMembers(): TypeEntityMembers;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    private getBaseTypes;
+    private validateBaseTypeListAndCreateBaseTypes;
+}
+export declare class SourcePackageStructuredTypeDeclarationData extends SourceStructuredTypeDeclarationData {
+    protected readonly entity: PackageStructuredTypeEntity;
+    private readonly node;
+    private readonly name;
+    private readonly typeParameters;
+    private readonly hiding;
+    private modifierFlags_;
+    protected get body(): tree.StructuredTypeDeclarationBody;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.PackageStructuredTypeDeclaration, entity: PackageStructuredTypeEntity);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class SourceAnonymousStructuredTypeDeclarationData extends SourceStructuredTypeDeclarationData {
+    protected readonly entity: AnonymousStructuredTypeEntity;
+    private readonly node;
+    protected get body(): tree.StructuredTypeDeclarationBody;
+    constructor(analyzer: Analyzer, node: tree.AnonymousStructuredTypeDeclaration, entity: AnonymousStructuredTypeEntity);
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    getDefinition(): StructuredTypeEntityDefinition;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}

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

@@ -0,0 +1,30 @@
+import { Analyzer } from '../../analysis/index.js';
+import { Tag } from '../../analysis/Tag.js';
+import { TextKey } from '../../analysis/TextIdentity.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import { EntityKind, PackageEntity, ParameterEntity, TextTranslationEntity, TextTranslationEntityDefinition } from '../index.js';
+export declare class TextTranslationDeclarationEntity implements TextTranslationEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.TextTranslation;
+    private readonly key;
+    private readonly text;
+    private readonly textFragments;
+    private readonly parameters;
+    private readonly comment;
+    constructor(analyzer: Analyzer, node: tree.TextTranslationSource);
+    isTextTemplate(): boolean;
+    getKey(): TextKey;
+    getText(): string;
+    getTextFragments(): readonly string[];
+    getParameters(): readonly ParameterEntity[];
+    getComment(): string | undefined;
+    getContainingPackage(): PackageEntity;
+    getDefinition(): TextTranslationEntityDefinition;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+}

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

@@ -0,0 +1,28 @@
+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 { TypeExtensionDeclaration } from '../../tree/index.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import { EntityContext, EntityHidingLevel, EntityKind, NamedTypeEntity, PackageEntity, TypeExtensionEntity, TypeExtensionEntityDefinition } from '../index.js';
+export declare class SourceTypeExtensionEntity implements TypeExtensionEntity {
+    readonly kind = EntityKind.TypeExtension;
+    private readonly analyzer;
+    private readonly node;
+    private readonly members;
+    private readonly hiding;
+    private modifierFlags_;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: TypeExtensionDeclaration);
+    getMembers(): TypeEntityMembers;
+    getContainingPackage(): PackageEntity;
+    getExtendedTypeEntity(): NamedTypeEntity | undefined;
+    getDefinition(): TypeExtensionEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getContext(): EntityContext;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): TypeExtensionEntity;
+}

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

@@ -0,0 +1,34 @@
+import { Analyzer } from '../../analysis/index.js';
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
+import { TypeParameterDeclaration } from '../../tree/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 SourceTypeParameterEntity implements TypeParameterEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Parameter;
+    private readonly name;
+    private readonly definition;
+    private readonly constraint;
+    private readonly default;
+    constructor(analyzer: Analyzer, node: TypeParameterDeclaration);
+    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;
+}