@artel/artc 0.6.26039 → 0.9.26001

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

@@ -0,0 +1,447 @@
+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 { BaseFieldEntity, EntityContainingParameter, EntityHidingLevel, EntityKind, FieldEntity, FieldEntityWithImplicitAccessors, IndexerEntity, LocalVariableEntity, LocalVariableKind, MethodEntity, PackageEntity, PackageFunctionEntity, PackageVariableEntity, ParameterEntity, PreservedReducedTypeEntityMemberInfo, SpecialVariableEntityInfo, Tag, Translation, TypeWithMembersOrExtensionEntity, VariableEntityDefinition } from '../../index.js';
+export declare class PackageVariableDeclarationEntity implements PackageVariableEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "package";
+    private readonly name;
+    private readonly typeInferrer;
+    private readonly hiding;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.PackageVariableDeclaration);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): PackageFunctionEntity | undefined;
+    getSetter(): PackageFunctionEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    ensureAllDiagnosticsReported(): void;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageVariableEntity;
+}
+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;
+    private readonly name;
+    private readonly hiding;
+    private hasReportedAllDiagnostics;
+    constructor(analyzer: Analyzer, getterDeclaration: tree.PackageVariableGetterDeclaration | undefined, setterDeclaration: tree.PackageVariableSetterDeclaration | undefined);
+    getName(): Name;
+    getType(): types.Type;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    isConstant(): boolean;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): PackageFunctionEntity | undefined;
+    getSetter(): PackageFunctionEntity | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageVariableEntity;
+    ensureAllDiagnosticsReported(): void;
+}
+export declare class FieldDeclarationEntity extends FieldEntityWithImplicitAccessors {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly name;
+    private readonly typeInferrer;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.FieldDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Field> | undefined;
+    isVariant(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): FieldEntity;
+    ensureAllDiagnosticsReported(): void;
+    protected getExplicitGetter(): MethodEntity | undefined;
+    protected getExplicitSetter(): MethodEntity | undefined;
+}
+export declare class ComputedFieldDeclarationEntity extends BaseFieldEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly getterDeclaration;
+    private readonly setterDeclaration;
+    private readonly getterOrSetterDeclaration;
+    private readonly name;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private hasReportedAllDiagnostics;
+    constructor(analyzer: Analyzer, getterDeclaration: tree.FieldGetterDeclaration | undefined, setterDeclaration: tree.FieldSetterDeclaration | undefined);
+    getName(): Name;
+    getType(): types.Type;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    isConstant(): boolean;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): MethodEntity | undefined;
+    getSetter(): MethodEntity | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Field> | undefined;
+    isVariant(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): FieldEntity;
+    ensureAllDiagnosticsReported(): void;
+}
+export declare class VariantValueDeclarationEntity extends BaseFieldEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly containingDeclaration;
+    private readonly name;
+    private readonly type;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    constructor(analyzer: Analyzer, node: tree.VariantValueDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): MethodEntity | undefined;
+    getSetter(): MethodEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Field> | undefined;
+    isVariant(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): FieldEntity;
+}
+export declare class LocalVariableDeclarationEntity implements LocalVariableEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    private readonly name;
+    private readonly typeInferrer;
+    private hasReportedAllDiagnostics;
+    constructor(analyzer: Analyzer, node: tree.LocalVariableDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): undefined;
+    getSetter(): 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;
+    ensureAllDiagnosticsReported(): void;
+}
+export declare class ForStatementElementVariableDeclarationEntity implements LocalVariableEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    private readonly name;
+    private readonly typeInferrer;
+    private hasReportedAllDiagnostics;
+    constructor(analyzer: Analyzer, node: tree.ForStatementVariableDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): undefined;
+    getSetter(): 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;
+    ensureAllDiagnosticsReported(): void;
+}
+export declare class ForStatementIndexVariableDeclarationEntity implements LocalVariableEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    private readonly name;
+    constructor(analyzer: Analyzer, node: tree.ForStatementVariableDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): undefined;
+    getSetter(): 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;
+}
+export declare class ErrorVariableDeclarationEntity implements LocalVariableEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "local";
+    private readonly name;
+    private readonly type;
+    constructor(analyzer: Analyzer, node: tree.ErrorVariableDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): undefined;
+    getSetter(): 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;
+}
+export declare class ParameterDeclarationEntity implements ParameterEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    private readonly name;
+    private readonly typeInferrer;
+    private hasReportedAllDiagnostics;
+    constructor(analyzer: Analyzer, node: tree.ParameterDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): undefined;
+    getSetter(): 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;
+    isObjectParameter(): boolean;
+    getOriginalEntity(): ParameterEntity;
+    ensureAllDiagnosticsReported(): void;
+}
+export declare class IndexParameterDeclarationEntity implements ParameterEntity {
+    private readonly analyzer;
+    private readonly getterParameterDeclaration;
+    private readonly setterParameterDeclaration;
+    private readonly indexerEntity;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    private readonly getterOrSetterParameterDeclaration;
+    private readonly name;
+    private readonly typeInferrer;
+    private hasReportedAllDiagnostics;
+    constructor(analyzer: Analyzer, getterParameterDeclaration: tree.ParameterDeclaration | undefined, setterParameterDeclaration: tree.ParameterDeclaration | undefined, indexerEntity: IndexerEntity);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): undefined;
+    getSetter(): 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;
+    isObjectParameter(): boolean;
+    getOriginalEntity(): ParameterEntity;
+    ensureAllDiagnosticsReported(): void;
+}
+export declare class FunctionLiteralParameterDeclarationEntity implements ParameterEntity {
+    private readonly analyzer;
+    private readonly node;
+    private readonly functionLiteral;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    private readonly parameterIndex;
+    private readonly name;
+    private type;
+    constructor(analyzer: Analyzer, node: tree.ParameterDeclaration, functionLiteral: tree.FunctionLiteral);
+    setTypeIfHasNoTypeSpecifier(type: types.Type): void;
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): undefined;
+    getSetter(): 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;
+    isObjectParameter(): boolean;
+    private getContainingFunctionLiteralEntity;
+}
+export declare class TranslationTextTemplateParameterEntity implements ParameterEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    private readonly name;
+    constructor(analyzer: Analyzer, node: tree.TranslationTextTemplateParameter);
+    getContainingEntity(): EntityContainingParameter;
+    getName(): Name;
+    getContainer(): PackageEntity;
+    getContainingPackage(): PackageEntity;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): undefined;
+    getSetter(): undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    isOptional(): boolean;
+    isVariadic(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    isObjectParameter(): boolean;
+    getOriginalEntity(): ParameterEntity;
+}
+export declare class StaticFieldDeclarationEntity extends FieldEntityWithImplicitAccessors {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly name;
+    private readonly typeInferrer;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private modifierFlags_;
+    private hasReportedAllDiagnostics;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.StaticFieldDeclaration);
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Field> | undefined;
+    isVariant(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): FieldEntity;
+    ensureAllDiagnosticsReported(): void;
+    protected getExplicitGetter(): MethodEntity | undefined;
+    protected getExplicitSetter(): MethodEntity | undefined;
+}
+export declare class ComputedStaticFieldDeclarationEntity extends BaseFieldEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly getterDeclaration;
+    private readonly setterDeclaration;
+    private readonly getterOrSetterDeclaration;
+    private readonly name;
+    private readonly hiding;
+    private readonly isPreservedReducedTypeMember_;
+    private containingEntity;
+    private hasReportedAllDiagnostics;
+    constructor(analyzer: Analyzer, getterDeclaration: tree.StaticFieldGetterDeclaration | undefined, setterDeclaration: tree.StaticFieldSetterDeclaration | undefined);
+    getName(): Name;
+    getType(): types.Type;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    isConstant(): boolean;
+    isStatic(): boolean;
+    markedBasic(): boolean;
+    isOverride(): boolean;
+    markedAbstract(): boolean;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): MethodEntity | undefined;
+    getSetter(): MethodEntity | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    isPreservedReducedTypeMember(): PreservedReducedTypeEntityMemberInfo<types.Field> | undefined;
+    isVariant(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): FieldEntity;
+    ensureAllDiagnosticsReported(): void;
+}

package/build/types/entities/source/m/SourceVariantTypeEntity.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 { BaseObjectType } from '../../BaseObjectType.js';
+import { EntityHidingLevel, EntityKind, EntityNaming, PackageEntity, PackageVariantTypeEntity, SubstitutionApplicationMode, Tag, Translation, TypeEntityKind, TypeEntityMembers, TypeParameterEntity, VariantTypeEntityDefinition } from '../../index.js';
+export declare class PackageVariantDeclarationEntity implements PackageVariantTypeEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Variant;
+    readonly subkind = "package";
+    private readonly name;
+    private readonly typeParameters;
+    private readonly members;
+    private readonly underlyingType;
+    private readonly baseObjectType;
+    private readonly hiding;
+    private modifierFlags_;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.PackageTypeDeclaration);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getMembers(): TypeEntityMembers;
+    getUnderlyingType(): types.Type;
+    getDefinition(): VariantTypeEntityDefinition;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getBaseObjectType(): BaseObjectType;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageVariantTypeEntity;
+}

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

@@ -0,0 +1,15 @@
+export * from './SourceAliasTypeEntity.js';
+export * from './SourceConstructorEntity.js';
+export * from './SourceDestructorEntity.js';
+export * from './SourceFunctionEntity.js';
+export * from './SourceFunctionTypeEntity.js';
+export * from './SourceGetterEntity.js';
+export * from './SourceIndexerEntity.js';
+export * from './SourcePackageAliasEntity.js';
+export * from './SourcePackageEntity.js';
+export * from './SourceSetterEntity.js';
+export * from './SourceStructuredTypeEntity.js';
+export * from './SourceTextTranslationEntity.js';
+export * from './SourceTypeParameterEntity.js';
+export * from './SourceVariableEntity.js';
+export * from './SourceVariantTypeEntity.js';

package/build/types/entities/translated/TranslatedPackageEntity.d.ts

@@ -1,6 +1,6 @@
 import { PackageDialect, PackageLocale } from '../../common/index.js';
 import { PackageName, PlatformKind } from '../../project/index.js';
-import { AnonymousTypeEntity, EntityKind, EntityLocalizationContext, LocalizablePackageMemberEntity, Tag, Translation, TypeMemberEntity } from '../index.js';
+import { AnonymousTypeEntity, EntityKind, EntityLocalizationContext, LocalizablePackageMemberEntity, Tag, Translation, TypeMemberEntity, LocalTypeEntity } from '../index.js';
 import { InterfacePackageEntityInfo, PackageEntityDefinition } from '../interfaces/index.js';
 import { IPackageEntity, NameTranslationPackageEntity, PackageEntity, ProgramPackageEntity, TextTranslationPackageEntity, TextTranslationPackageEntityInfo } from '../interfaces/PackageEntity.js';
 import { PackageEntityMembers } from '../PackageEntityMembers.js';
@@ -44,6 +44,7 @@ export declare abstract class TranslatedNameTranslationPackageEntity extends Tra
     getTranslatedPackageMember(entity: LocalizablePackageMemberEntity): LocalizablePackageMemberEntity;
     getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
     getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
+    getTranslatedLocalTypeEntity(entity: LocalTypeEntity): LocalTypeEntity;
 }
 export declare abstract class TranslatedTextTranslationPackageEntity extends TranslatedPackageEntity implements TextTranslationPackageEntity {
     readonly subkind = "text-translation";

package/build/types/entities/translated/TranslatedStructuredTypeEntity.d.ts

@@ -5,7 +5,7 @@ import { BaseObjectType, CycleFreeBaseObjectTypeResolutionResult } from '../Base
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
 import { EntityHidingLevel, EntityKind, EntityNaming, Tag, Translation, TypeEntityMembers } from '../index.js';
 import { PackageEntity } from '../interfaces/PackageEntity.js';
-import { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, StructuredTypeEntityDefinition, StructuredTypeKind } from '../interfaces/StructuredTypeEntity.js';
+import { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, StructuredTypeEntityDefinition, StructuredTypeKind, LocalStructuredTypeEntity } from '../interfaces/StructuredTypeEntity.js';
 import { TypeParameterEntity } from '../interfaces/TypeParameterEntity.js';
 import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
 import { TypeEntityKind } from '../TypeEntity.js';
@@ -71,6 +71,38 @@ export declare abstract class TranslatedAnonymousStructuredTypeEntity implements
     getTags(): readonly Tag[];
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
 }
+export declare abstract class TranslatedLocalStructuredTypeEntity implements LocalStructuredTypeEntity {
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "local";
+    protected readonly originalEntity: LocalStructuredTypeEntity;
+    protected readonly translation: Translation;
+    protected readonly name: Name;
+    private readonly containingPackage;
+    private readonly baseObjectType;
+    private readonly baseAspectTypes;
+    private get localizationContext();
+    getName(): Name;
+    constructor(originalEntity: LocalStructuredTypeEntity, translation: Translation, name: Name);
+    abstract getMembers(): TypeEntityMembers;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): LocalStructuredTypeEntity;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
 export declare class LocalizedBaseObjectType extends BaseObjectType {
     private readonly original;
     private readonly localizationContext;

package/build/types/entities/translated/source/a/SourceTranslatedPackageStructuredTypeEntity.d.ts

@@ -1,8 +1,8 @@
 import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
 import { Name } from '../../../../common/index.js';
 import * as tree from '../../../../tree/a/index.js';
-import { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, Translation, TypeEntityMembers, TypeParameterEntity } from '../../../index.js';
-import { TranslatedAnonymousStructuredTypeEntity, TranslatedPackageStructuredTypeEntity } from '../../TranslatedStructuredTypeEntity.js';
+import { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, Translation, TypeEntityMembers, TypeParameterEntity, LocalStructuredTypeEntity } from '../../../index.js';
+import { TranslatedAnonymousStructuredTypeEntity, TranslatedPackageStructuredTypeEntity, TranslatedLocalStructuredTypeEntity } from '../../TranslatedStructuredTypeEntity.js';
 export declare class SourceTranslatedPackageStructuredTypeEntity extends TranslatedPackageStructuredTypeEntity {
     private readonly translationPackage;
     private readonly node;
@@ -18,3 +18,9 @@ export declare class SourceTranslatedAnonymousStructuredTypeEntity extends Trans
     constructor(originalEntity: AnonymousStructuredTypeEntity, translation: Translation, translationPackage: ResolvedTranslationPackage);
     getMembers(): TypeEntityMembers;
 }
+export declare class SourceTranslatedLocalStructuredTypeEntity extends TranslatedLocalStructuredTypeEntity {
+    private readonly translationPackage;
+    private readonly members;
+    constructor(originalEntity: LocalStructuredTypeEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage);
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/m/SourceTranslatedAliasTypeEntity.d.ts

@@ -0,0 +1,14 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/m/ResolvedTranslationPackage.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/m/index.js';
+import { AliasTypeEntity, Translation, TypeEntityMembers, TypeParameterEntity } from '../../../index.js';
+import { TranslatedAliasTypeEntity } from '../../index.js';
+export declare class SourceTranslatedAliasTypeEntity extends TranslatedAliasTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly members;
+    constructor(originalEntity: AliasTypeEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.TypeTranslationDeclaration | tree.FunctionTypeTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/m/SourceTranslatedDestructorEntity.d.ts

@@ -0,0 +1,12 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/m/ResolvedTranslationPackage.js';
+import { Analyzer } from '../../../../analysis/Analyzer.js';
+import { MethodEntity, ParameterEntity, Translation, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../../index.js';
+import { TranslatedMethodEntity } from '../../TranslatedFunctionEntity.js';
+export declare class SourceTranslatedDestructorEntity extends TranslatedMethodEntity {
+    private readonly translationPackage;
+    private readonly parameters;
+    private readonly typeParameters;
+    constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    getParameters(): readonly ParameterEntity[];
+    getTypeParameters(): readonly TypeParameterEntity[];
+}

package/build/types/entities/translated/source/m/SourceTranslatedFunctionEntity.d.ts

@@ -0,0 +1,24 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/m/ResolvedTranslationPackage.js';
+import { Analyzer } from '../../../../analysis/Analyzer.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/m/index.js';
+import { MethodEntity, PackageFunctionEntity, ParameterEntity, Translation, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../../index.js';
+import { TranslatedMethodEntity, TranslatedPackageFunctionEntity } from '../../index.js';
+export declare class SourceTranslatedPackageFunctionEntity extends TranslatedPackageFunctionEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly parameters;
+    constructor(originalEntity: PackageFunctionEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.PackageFunctionTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+}
+export declare class SourceTranslatedOrdinaryOrOperatorMethodEntity extends TranslatedMethodEntity {
+    private readonly node;
+    private readonly translationPackage;
+    private readonly typeParameters;
+    private readonly parameters;
+    constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.MethodTranslation | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+}

package/build/types/entities/translated/source/m/SourceTranslatedFunctionTypeEntity.d.ts

@@ -0,0 +1,13 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/m/ResolvedTranslationPackage.js';
+import * as tree from '../../../../tree/m/index.js';
+import { AnonymousFunctionTypeEntity, ParameterEntity, Translation, TypeEntityMembers } from '../../../index.js';
+import { TranslatedAnonymousFunctionTypeEntity } from '../../TranslatedFunctionTypeEntity.js';
+export declare class SourceTranslatedAnonymousFunctionTypeEntity extends TranslatedAnonymousFunctionTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly parameters;
+    private readonly members;
+    constructor(originalEntity: AnonymousFunctionTypeEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, node: tree.FunctionTypeTranslationDeclaration | undefined);
+    getParameters(): readonly ParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/m/SourceTranslatedIndexerEntity.d.ts

@@ -0,0 +1,12 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/m/ResolvedTranslationPackage.js';
+import { Analyzer } from '../../../../analysis/Analyzer.js';
+import * as tree from '../../../../tree/m/index.js';
+import { IndexerEntity, ParameterEntity, Translation, TypeWithMembersOrExtensionEntity } from '../../../index.js';
+import { TranslatedIndexerEntity } from '../../TranslatedIndexerEntity.js';
+export declare class SourceTranslatedIndexerEntity extends TranslatedIndexerEntity {
+    readonly translationPackage: ResolvedTranslationPackage;
+    private readonly node;
+    private readonly parameters;
+    constructor(analyzer: Analyzer, originalEntity: IndexerEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.IndexerTranslation | undefined);
+    getParameters(): readonly ParameterEntity[];
+}