@artel/artc 0.6.26017 → 0.6.26019

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

@@ -1,25 +1,21 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.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 } from '../EntityHiding.js';
-import { EntityKind, GetterEntity, PackageEntity, PreservedReducedTypeEntityMemberInfo, SetterEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
-import type { IndexerEntity, IndexerEntityDefinition } from '../interfaces/IndexerEntity.js';
+import { EntityHidingLevel, EntityKind, GetterEntity, PackageEntity, PreservedReducedTypeEntityMemberInfo, SetterEntity, Tag, Translation, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { IndexerEntity, IndexerEntityDefinition } from '../interfaces/IndexerEntity.js';
 import { ParameterEntity } from '../interfaces/VariableEntity.js';
 export declare abstract class TranslatedIndexerEntity implements IndexerEntity {
     readonly kind = EntityKind.Indexer;
     protected readonly originalEntity: IndexerEntity;
     protected readonly translation: Translation;
-    protected readonly translationPackage: AnalyzedTranslationPackage;
     protected readonly containingEntity: TypeWithMembersOrExtensionEntity;
+    private readonly containingPackage;
     private readonly type;
     private readonly getter;
     private readonly setter;
     private readonly overriddenMembers;
     private readonly isPreservedReducedTypeMember_;
-    constructor(originalEntity: IndexerEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    private get localizationContext();
+    constructor(originalEntity: IndexerEntity, translation: Translation, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
     abstract getParameters(): readonly ParameterEntity[];
     getContainingEntity(): TypeWithMembersOrExtensionEntity;
     getContainingPackage(): PackageEntity;
@@ -41,15 +37,9 @@ export declare abstract class TranslatedIndexerEntity implements IndexerEntity {
     ensureAllDiagnosticsReported?(): void;
     getTags(): readonly Tag[];
 }
-export declare class SourceTranslatedIndexerEntity extends TranslatedIndexerEntity {
-    private readonly node;
-    private readonly parameters;
-    constructor(originalEntity: IndexerEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.IndexerTranslation | undefined);
-    getParameters(): readonly ParameterEntity[];
-}
 export declare class UnfinishedIntrinsicTranslatedIndexerEntity {
     private readonly unfinishedValue_;
     get unfinishedValue(): IndexerEntity;
-    constructor(originalEntity: IndexerEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    constructor(originalEntity: IndexerEntity, translation: Translation, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
     finish(parameters: readonly ParameterEntity[]): IndexerEntity;
 }

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

@@ -1,23 +1,20 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.js';
-import { Tag } from '../../analysis/Tag.js';
-import { Translation } from '../../analysis/Translation.js';
 import { PackageDialect, PackageLocale } from '../../common/index.js';
-import { PackageName, PlatformKind } from '../../project/SourcePackage.js';
-import { EntityKind } from '../index.js';
-import type { PackageEntity, TextTranslationPackageEntityInfo } from '../interfaces/PackageEntity.js';
-import { InterfacePackageEntityInfo, PackageEntityDefinition } from '../interfaces/PackageEntity.js';
+import { PackageName, PlatformKind } from '../../project/index.js';
+import { AnonymousTypeEntity, EntityKind, EntityLocalizationContext, LocalizablePackageMemberEntity, Tag, Translation, TypeMemberEntity } 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';
-export declare class TranslatedPackageEntity implements PackageEntity {
+export declare abstract class TranslatedPackageEntity implements IPackageEntity {
     readonly kind = EntityKind.Package;
-    private readonly originalEntity;
+    protected abstract readonly originalEntity: PackageEntity;
+    protected abstract asPackageEntity: PackageEntity;
     private readonly translation;
     private readonly name;
-    private readonly translationPackage;
-    constructor(originalEntity: PackageEntity, translation: Translation, name: PackageName, translationPackage: AnalyzedTranslationPackage);
+    constructor(translation: Translation, name: PackageName);
+    abstract getMembers(): PackageEntityMembers;
     getName(): PackageName;
     getLocale(): PackageLocale;
     getDialect(): PackageDialect;
-    getMembers(): PackageEntityMembers;
     getInterfacePackageInfo(): InterfacePackageEntityInfo | undefined;
     getImplementedInterfacePackage(): PackageEntity | undefined;
     getSupportedPlatforms(): readonly PlatformKind[];
@@ -28,3 +25,31 @@ export declare class TranslatedPackageEntity implements PackageEntity {
     getTags(): readonly Tag[];
     getTextTranslationPackageInfo(): TextTranslationPackageEntityInfo | undefined;
 }
+export declare abstract class TranslatedProgramPackageEntity extends TranslatedPackageEntity implements ProgramPackageEntity {
+    readonly subkind = "program";
+    protected readonly originalEntity: ProgramPackageEntity;
+    protected get asPackageEntity(): PackageEntity;
+    constructor(originalEntity: ProgramPackageEntity, translation: Translation, name: PackageName);
+}
+export declare abstract class TranslatedNameTranslationPackageEntity extends TranslatedPackageEntity implements NameTranslationPackageEntity {
+    readonly subkind = "name-translation";
+    protected readonly originalEntity: NameTranslationPackageEntity;
+    protected get asPackageEntity(): PackageEntity;
+    constructor(originalEntity: NameTranslationPackageEntity, translation: Translation, name: PackageName);
+    getTranslationLocale(): PackageLocale;
+    getTargetPackage(): PackageEntity | undefined;
+    getTranslatedTargetPackage(): PackageEntity | undefined;
+    getLocalizedReferencedPackagesMap(): ReadonlyMap<PackageEntity, PackageEntity>;
+    getLocalizationContext(): EntityLocalizationContext;
+    getTranslatedPackageMember(entity: LocalizablePackageMemberEntity): LocalizablePackageMemberEntity;
+    getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
+    getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
+}
+export declare abstract class TranslatedTextTranslationPackageEntity extends TranslatedPackageEntity implements TextTranslationPackageEntity {
+    readonly subkind = "text-translation";
+    protected readonly originalEntity: TextTranslationPackageEntity;
+    protected get asPackageEntity(): PackageEntity;
+    constructor(originalEntity: TextTranslationPackageEntity, translation: Translation, name: PackageName);
+    getTargetPackage(): PackageEntity | undefined;
+    isPrimary(): boolean;
+}

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

@@ -1,34 +1,27 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.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 * as types from '../../types/index.js';
 import { BaseAspectTypes } from '../BaseAspectTypes.js';
 import { BaseObjectType } from '../BaseObjectType.js';
-import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
-import type { ReducedTypeEntity, ReducedTypeEntityDefinition } from '../index.js';
-import { CycleFreeReductionSourceResolutionResult, EntityKind, ReductionSource } from '../index.js';
+import { CycleFreeReductionSourceResolutionResult, EntityHidingLevel, EntityKind, ReducedTypeEntity, ReducedTypeEntityDefinition, ReductionSource, Tag, Translation, TypeEntityMembers } from '../index.js';
 import { PackageEntity, TypeParameterEntity } from '../interfaces/index.js';
 import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
 import { TypeEntityKind } from '../TypeEntity.js';
-import { TypeEntityMembers } from '../TypeEntityMembers.js';
-export declare class TranslatedReducedTypeEntity implements ReducedTypeEntity {
+export declare abstract class TranslatedReducedTypeEntity implements ReducedTypeEntity {
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Reduced;
     readonly subkind = "package";
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly name;
-    private readonly translationPackage;
-    private readonly node;
-    private readonly typeParameters;
-    private readonly members;
+    protected readonly originalEntity: ReducedTypeEntity;
+    protected readonly translation: Translation;
+    protected readonly name: Name;
+    private readonly containingPackage;
     private readonly reductionSource;
     private readonly baseObjectType;
     private readonly baseAspectTypes;
-    constructor(originalEntity: ReducedTypeEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    private get localizationContext();
+    constructor(originalEntity: ReducedTypeEntity, translation: Translation, name: Name);
+    abstract getTypeParameters(): readonly TypeParameterEntity[];
+    abstract getMembers(): TypeEntityMembers;
     getName(): Name;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
@@ -36,8 +29,6 @@ export declare class TranslatedReducedTypeEntity implements ReducedTypeEntity {
     getDialect(): PackageDialect;
     getOriginalEntity(): ReducedTypeEntity;
     getReductionSource(): ReductionSource;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getMembers(): TypeEntityMembers;
     getDefinition(): ReducedTypeEntityDefinition;
     getArity(): number;
     getBaseObjectType(): BaseObjectType;

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

@@ -1,18 +1,14 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.js';
-import { Tag } from '../../analysis/Tag.js';
-import { Translation } from '../../analysis/Translation.js';
 import { PackageDialect, PackageLocale } from '../../common/index.js';
-import { EntityHidingLevel } from '../EntityHiding.js';
-import { EntityKind, PackageEntity } from '../index.js';
-import type { EntityOwningSetter, SetterEntity } from '../interfaces/SetterEntity.js';
-import { SetterEntityDefinition } from '../interfaces/SetterEntity.js';
+import { EntityHidingLevel, EntityKind, PackageEntity, Tag, Translation } from '../index.js';
+import { EntityOwningSetter, SetterEntity, SetterEntityDefinition } from '../interfaces/SetterEntity.js';
 export declare class TranslatedSetterEntity implements SetterEntity {
     readonly kind = EntityKind.Setter;
     private readonly originalEntity;
     private readonly translation;
-    private readonly translationPackage;
     private readonly owningEntity;
-    constructor(originalEntity: SetterEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedOwningEntity: EntityOwningSetter);
+    private readonly containingPackage;
+    private get localizationContext();
+    constructor(originalEntity: SetterEntity, translation: Translation, translatedOwningEntity: EntityOwningSetter);
     getDefinition(): SetterEntityDefinition;
     getOwningEntity(): EntityOwningSetter;
     getContainingPackage(): PackageEntity;

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

@@ -1,35 +1,28 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.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 * as types from '../../types/index.js';
 import { BaseAspectTypes, CycleFreeBaseAspectTypesResolutionResult } from '../BaseAspectTypes.js';
 import { BaseObjectType, CycleFreeBaseObjectTypeResolutionResult } from '../BaseObjectType.js';
-import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
-import { EntityNaming } from '../EntityNaming.js';
-import { EntityKind } from '../index.js';
+import { EntityHidingLevel, EntityKind, EntityNaming, Tag, Translation, TypeEntityMembers } from '../index.js';
 import { PackageEntity } from '../interfaces/PackageEntity.js';
-import type { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, StructuredTypeEntityDefinition, StructuredTypeKind } from '../interfaces/StructuredTypeEntity.js';
+import { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity, StructuredTypeEntityDefinition, StructuredTypeKind } from '../interfaces/StructuredTypeEntity.js';
 import { TypeParameterEntity } from '../interfaces/TypeParameterEntity.js';
 import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
 import { TypeEntityKind } from '../TypeEntity.js';
-import { TypeEntityMembers } from '../TypeEntityMembers.js';
-export declare class TranslatedPackageStructuredTypeEntity implements PackageStructuredTypeEntity {
+export declare abstract class TranslatedPackageStructuredTypeEntity implements PackageStructuredTypeEntity {
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Structured;
     readonly subkind = "package";
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly name;
-    private readonly translationPackage;
-    private readonly node;
-    private readonly typeParameters;
-    private readonly members;
+    protected readonly originalEntity: PackageStructuredTypeEntity;
+    protected readonly translation: Translation;
+    protected readonly name: Name;
+    private readonly containingPackage;
     private readonly baseObjectType;
     private readonly baseAspectTypes;
-    constructor(originalEntity: PackageStructuredTypeEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    private get localizationContext();
+    constructor(originalEntity: PackageStructuredTypeEntity, translation: Translation, name: Name);
+    abstract getTypeParameters(): readonly TypeParameterEntity[];
+    abstract getMembers(): TypeEntityMembers;
     getName(): Name;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
@@ -37,8 +30,6 @@ export declare class TranslatedPackageStructuredTypeEntity implements PackageStr
     getDialect(): PackageDialect;
     getOriginalEntity(): PackageStructuredTypeEntity;
     getNaming(): EntityNaming;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getMembers(): TypeEntityMembers;
     getDefinition(): StructuredTypeEntityDefinition;
     markedBasic(): boolean;
     isAbstract(): boolean;
@@ -50,17 +41,18 @@ export declare class TranslatedPackageStructuredTypeEntity implements PackageStr
     getTags(): readonly Tag[];
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
 }
-export declare class TranslatedAnonymousStructuredTypeEntity implements AnonymousStructuredTypeEntity {
+export declare abstract class TranslatedAnonymousStructuredTypeEntity implements AnonymousStructuredTypeEntity {
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Structured;
     readonly subkind = "anonymous";
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly translationPackage;
-    private readonly members;
+    protected readonly originalEntity: AnonymousStructuredTypeEntity;
+    protected readonly translation: Translation;
+    private readonly containingPackage;
     private readonly baseObjectType;
     private readonly baseAspectTypes;
-    constructor(originalEntity: AnonymousStructuredTypeEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage);
+    private get localizationContext();
+    constructor(originalEntity: AnonymousStructuredTypeEntity, translation: Translation);
+    abstract getMembers(): TypeEntityMembers;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
     getLocale(): PackageLocale;
@@ -68,7 +60,6 @@ export declare class TranslatedAnonymousStructuredTypeEntity implements Anonymou
     getOriginalEntity(): AnonymousStructuredTypeEntity;
     getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
-    getMembers(): TypeEntityMembers;
     getDefinition(): StructuredTypeEntityDefinition;
     markedBasic(): boolean;
     isAbstract(): boolean;

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

@@ -1,21 +1,14 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.js';
-import { Tag } from '../../analysis/Tag.js';
-import { Translation } from '../../analysis/Translation.js';
 import { PackageDialect, PackageLocale } from '../../common/index.js';
-import { EntityHidingLevel } from '../EntityHiding.js';
-import { EntityKind, NamedTypeEntity } from '../index.js';
-import { PackageEntity } from '../interfaces/PackageEntity.js';
-import type { TypeExtensionEntity, TypeExtensionEntityDefinition } from '../interfaces/TypeExtensionEntity.js';
-import { TypeEntityMembers } from '../TypeEntityMembers.js';
-export declare class TranslatedTypeExtensionEntity implements TypeExtensionEntity {
+import { EntityHidingLevel, EntityKind, NamedTypeEntity, PackageEntity, Tag, Translation, TypeEntityMembers, TypeExtensionEntity, TypeExtensionEntityDefinition } from '../index.js';
+export declare abstract class TranslatedTypeExtensionEntity implements TypeExtensionEntity {
     readonly kind = EntityKind.TypeExtension;
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly translationPackage;
-    private readonly members;
+    protected readonly originalEntity: TypeExtensionEntity;
+    protected readonly translation: Translation;
+    private readonly containingPackage;
     private readonly extendedTypeEntity;
-    constructor(originalEntity: TypeExtensionEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage);
-    getMembers(): TypeEntityMembers;
+    private get localizationContext();
+    constructor(originalEntity: TypeExtensionEntity, translation: Translation);
+    abstract getMembers(): TypeEntityMembers;
     getContainingPackage(): PackageEntity;
     getExtendedTypeEntity(): NamedTypeEntity | undefined;
     getDefinition(): TypeExtensionEntityDefinition;

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

@@ -1,13 +1,8 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.js';
-import { Tag } from '../../analysis/Tag.js';
-import { Translation } from '../../analysis/Translation.js';
 import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/index.js';
-import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
-import { EntityKind, PackageEntity } from '../index.js';
-import type { EntityContainingTypeParameter, TypeParameterEntity } from '../interfaces/TypeParameterEntity.js';
-import { CycleFreeConstraintResolutionResult, TypeParameterConstraint, TypeParameterEntityDefinition } from '../interfaces/TypeParameterEntity.js';
+import { EntityHidingLevel, EntityKind, PackageEntity, Tag, Translation } from '../index.js';
+import { CycleFreeConstraintResolutionResult, EntityContainingTypeParameter, TypeParameterConstraint, TypeParameterEntity, TypeParameterEntityDefinition } from '../interfaces/TypeParameterEntity.js';
 import { TypeEntityKind } from '../TypeEntity.js';
 export declare class TranslatedTypeParameterEntity implements TypeParameterEntity {
     readonly kind = EntityKind.Type;
@@ -15,11 +10,12 @@ export declare class TranslatedTypeParameterEntity implements TypeParameterEntit
     private readonly originalEntity;
     private readonly translation;
     private readonly name;
-    private readonly translationPackage;
     private readonly containingEntity;
+    private readonly containingPackage;
     private readonly defaultType;
     private readonly constraint;
-    constructor(originalEntity: TypeParameterEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: EntityContainingTypeParameter);
+    private get localizationContext();
+    constructor(originalEntity: TypeParameterEntity, translation: Translation, name: Name, translatedContainingEntity: EntityContainingTypeParameter);
     getName(): Name;
     getConstraint(): TypeParameterConstraint;
     getDefaultType(): types.Type | undefined;

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

@@ -1,26 +1,18 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.js';
-import { Tag } from '../../analysis/Tag.js';
-import { Translation } from '../../analysis/Translation.js';
 import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/index.js';
-import { EntityHidingLevel } from '../EntityHiding.js';
-import { EntityKind, PreservedReducedTypeEntityMemberInfo, TypeWithMembersOrExtensionEntity } from '../index.js';
-import { GetterEntity } from '../interfaces/GetterEntity.js';
-import { PackageEntity } from '../interfaces/PackageEntity.js';
-import { SetterEntity } from '../interfaces/SetterEntity.js';
-import type { EntityContainingParameter, FieldEntity, PackageVariableEntity, ParameterEntity } from '../interfaces/VariableEntity.js';
-import { SpecialVariableEntityInfo, VariableEntityDefinition } from '../interfaces/VariableEntity.js';
+import { EntityContainingParameter, EntityHidingLevel, EntityKind, FieldEntity, GetterEntity, PackageEntity, PackageVariableEntity, ParameterEntity, PreservedReducedTypeEntityMemberInfo, SetterEntity, SpecialVariableEntityInfo, Tag, Translation, TypeWithMembersOrExtensionEntity, VariableEntityDefinition } from '../index.js';
 export declare class TranslatedPackageVariableEntity implements PackageVariableEntity {
     readonly kind = EntityKind.Variable;
     readonly subkind = "package";
     private readonly originalEntity;
     private readonly translation;
     private readonly name;
-    private readonly translationPackage;
+    private readonly containingPackage;
     private readonly type;
     private readonly getter;
     private readonly setter;
-    constructor(originalEntity: PackageVariableEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage);
+    private get localizationContext();
+    constructor(originalEntity: PackageVariableEntity, translation: Translation, name: Name);
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
     getLocale(): PackageLocale;
@@ -43,14 +35,15 @@ export declare class TranslatedFieldEntity implements FieldEntity {
     private readonly originalEntity;
     private readonly translation;
     private readonly name;
-    private readonly translationPackage;
     private readonly containingEntity;
+    private readonly containingPackage;
     private readonly type;
     private readonly getter;
     private readonly setter;
     private readonly overriddenMembers;
     private readonly isPreservedReducedTypeMember_;
-    constructor(originalEntity: FieldEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    private get localizationContext();
+    constructor(originalEntity: FieldEntity, translation: Translation, name: Name, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
     getContainingEntity(): TypeWithMembersOrExtensionEntity;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
@@ -81,10 +74,11 @@ export declare class TranslatedParameterEntity implements ParameterEntity {
     private readonly originalEntity;
     private readonly translation;
     private readonly name;
-    private readonly translationPackage;
     private readonly containingEntity;
+    private readonly containingPackage;
     private readonly type;
-    constructor(originalEntity: ParameterEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: EntityContainingParameter);
+    private get localizationContext();
+    constructor(originalEntity: ParameterEntity, translation: Translation, name: Name, translatedContainingEntity: EntityContainingParameter);
     getContainingEntity(): EntityContainingParameter;
     getContainingPackage(): PackageEntity;
     isOptional(): boolean;

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

@@ -1,34 +1,21 @@
-import { AnalyzedTranslationPackage } from '../../analysis/AnalyzedTranslationPackage.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 * as types from '../../types/Type.js';
 import { BaseObjectType } from '../BaseObjectType.js';
-import { EntityHidingLevel } from '../EntityHiding.js';
-import { EntityNaming } from '../EntityNaming.js';
-import { EntityKind } from '../index.js';
-import { PackageEntity } from '../interfaces/PackageEntity.js';
-import { TypeParameterEntity } from '../interfaces/TypeParameterEntity.js';
-import type { PackageVariantTypeEntity } from '../interfaces/VariantTypeEntity.js';
-import { VariantTypeEntityDefinition } from '../interfaces/VariantTypeEntity.js';
-import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
-import { TypeEntityKind } from '../TypeEntity.js';
-import { TypeEntityMembers } from '../TypeEntityMembers.js';
-export declare class TranslatedPackageVariantTypeEntity implements PackageVariantTypeEntity {
+import { EntityHidingLevel, EntityKind, EntityNaming, PackageEntity, PackageVariantTypeEntity, SubstitutionApplicationMode, Tag, Translation, TypeEntityKind, TypeEntityMembers, TypeParameterEntity, VariantTypeEntityDefinition } from '../index.js';
+export declare abstract class TranslatedPackageVariantTypeEntity implements PackageVariantTypeEntity {
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Variant;
     readonly subkind = "package";
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly name;
-    private readonly translationPackage;
-    private readonly node;
-    private readonly typeParameters;
+    protected readonly originalEntity: PackageVariantTypeEntity;
+    protected readonly translation: Translation;
+    protected readonly name: Name;
+    private readonly containingPackage;
     private readonly underlyingType;
-    private readonly members;
     private readonly baseObjectType;
-    constructor(originalEntity: PackageVariantTypeEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    private get localizationContext();
+    constructor(originalEntity: PackageVariantTypeEntity, translation: Translation, name: Name);
+    abstract getTypeParameters(): readonly TypeParameterEntity[];
+    abstract getMembers(): TypeEntityMembers;
     getName(): Name;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
@@ -36,9 +23,7 @@ export declare class TranslatedPackageVariantTypeEntity implements PackageVarian
     getDialect(): PackageDialect;
     getOriginalEntity(): PackageVariantTypeEntity;
     getNaming(): EntityNaming;
-    getTypeParameters(): readonly TypeParameterEntity[];
     getUnderlyingType(): types.Type;
-    getMembers(): TypeEntityMembers;
     getDefinition(): VariantTypeEntityDefinition;
     getArity(): number;
     isHidden(): EntityHidingLevel | undefined;

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

@@ -0,0 +1,14 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/a/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/a/SourceTranslatedConstructorEntity.d.ts

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

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

@@ -0,0 +1,9 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { DestructorEntity, ParameterEntity, Translation, TypeWithMembersOrExtensionEntity } from '../../../index.js';
+import { TranslatedDestructorEntity } from '../../TranslatedDestructorEntity.js';
+export declare class SourceTranslatedDestructorEntity extends TranslatedDestructorEntity {
+    private readonly translationPackage;
+    private readonly parameters;
+    constructor(originalEntity: DestructorEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    getParameters(): readonly ParameterEntity[];
+}

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

@@ -0,0 +1,24 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Analyzer } from '../../../../analysis/Analyzer.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/a/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 SourceTranslatedMethodEntity 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/a/SourceTranslatedFunctionTypeEntity.d.ts

@@ -0,0 +1,13 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import * as tree from '../../../../tree/a/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/a/SourceTranslatedIndexerEntity.d.ts

@@ -0,0 +1,11 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import * as tree from '../../../../tree/a/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(originalEntity: IndexerEntity, translation: Translation, translationPackage: ResolvedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.IndexerTranslation | undefined);
+    getParameters(): readonly ParameterEntity[];
+}

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

@@ -0,0 +1,19 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { PackageName } from '../../../../project/SourcePackage.js';
+import { NameTranslationPackageEntity, PackageEntityMembers, ProgramPackageEntity, TextTranslationPackageEntity, Translation } from '../../../index.js';
+import { TranslatedNameTranslationPackageEntity, TranslatedProgramPackageEntity, TranslatedTextTranslationPackageEntity } from '../../index.js';
+export declare class SourceTranslatedProgramPackageEntity extends TranslatedProgramPackageEntity {
+    private readonly translationPackage;
+    constructor(originalEntity: ProgramPackageEntity, translation: Translation, name: PackageName, translationPackage: ResolvedTranslationPackage);
+    getMembers(): PackageEntityMembers;
+}
+export declare class SourceTranslatedNameTranslationPackageEntity extends TranslatedNameTranslationPackageEntity {
+    private readonly translationPackage;
+    constructor(originalEntity: NameTranslationPackageEntity, translation: Translation, name: PackageName, translationPackage: ResolvedTranslationPackage);
+    getMembers(): PackageEntityMembers;
+}
+export declare class SourceTranslatedTextTranslationPackageEntity extends TranslatedTextTranslationPackageEntity {
+    private readonly translationPackage;
+    constructor(originalEntity: TextTranslationPackageEntity, translation: Translation, name: PackageName, translationPackage: ResolvedTranslationPackage);
+    getMembers(): PackageEntityMembers;
+}

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

@@ -0,0 +1,20 @@
+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';
+export declare class SourceTranslatedPackageStructuredTypeEntity extends TranslatedPackageStructuredTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly members;
+    constructor(originalEntity: PackageStructuredTypeEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}
+export declare class SourceTranslatedAnonymousStructuredTypeEntity extends TranslatedAnonymousStructuredTypeEntity {
+    private readonly translationPackage;
+    private readonly members;
+    constructor(originalEntity: AnonymousStructuredTypeEntity, translation: Translation, translationPackage: ResolvedTranslationPackage);
+    getMembers(): TypeEntityMembers;
+}

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

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