@artel/artc 0.6.25259 → 0.6.25261

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

@@ -1,24 +1,25 @@
-import { Localization } from '../analysis/Localization.js';
 import { Tag } from '../analysis/Tags.js';
+import { Translation } from '../analysis/Translation.js';
 import { Analyzer } from '../analysis/index.js';
-import { Name } from '../common/index.js';
+import { Name, PackageDialect, PackageLocale } from '../common/index.js';
 import { AnonymousVariantTypeDeclaration, PackageVariantTypeDeclaration } 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 { BaseObjectType, DefinitionKind, EntityContext, EntityHidingLevel, EntityKind, ITypeEntity, PackageEntity, SubstitutionApplicationMode, TypeEntityKind, TypeParameterEntity } from './index.js';
+import { DefinitionKind, EntityContext, EntityHidingLevel, EntityKind, ITypeEntity, PackageEntity, SubstitutionApplicationMode, TypeEntityKind, TypeParameterEntity } from './index.js';
 export type VariantTypeEntity = PackageVariantTypeEntity | AnonymousVariantTypeEntity;
 export interface PackageVariantTypeEntity extends IVariantTypeEntity {
     readonly subkind: 'package';
     getName(): Name;
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
     getOriginalEntity(): PackageVariantTypeEntity;
 }
 export interface AnonymousVariantTypeEntity extends IVariantTypeEntity {
     readonly subkind: 'anonymous';
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
     getOriginalEntity(): AnonymousVariantTypeEntity;
 }
 interface IVariantTypeEntity extends ITypeEntity {
@@ -45,19 +46,20 @@ export type VariantTypeEntityDefinition = {
     kind: DefinitionKind.TypeScript;
 };
 export declare class PackageVariantTypeDeclarationEntity implements PackageVariantTypeEntity {
-    private readonly _analyzer;
-    private readonly _node;
+    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 _modifierFlags;
+    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: PackageVariantTypeDeclaration);
+    constructor(analyzer: Analyzer, node: PackageVariantTypeDeclaration);
     getNaming(): EntityNaming;
     getName(): Name;
     getContainingPackage(): PackageEntity;
@@ -71,19 +73,21 @@ export declare class PackageVariantTypeDeclarationEntity implements PackageVaria
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
     getBaseObjectType(): BaseObjectType;
     getContext(): EntityContext;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): PackageVariantTypeEntity;
 }
 export declare class AnonymousVariantTypeDeclarationEntity implements AnonymousVariantTypeEntity {
-    private readonly _analyzer;
-    private readonly _node;
+    private readonly analyzer;
+    private readonly node;
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Variant;
     readonly subkind = "anonymous";
-    private readonly _underlyingType;
-    private readonly _members;
-    private readonly _baseObjectType;
-    constructor(_analyzer: Analyzer, _node: AnonymousVariantTypeDeclaration);
+    private readonly underlyingType;
+    private readonly members;
+    private readonly baseObjectType;
+    constructor(analyzer: Analyzer, node: AnonymousVariantTypeDeclaration);
     getMembers(): TypeEntityMembers;
     getUnderlyingType(): types.Type;
     getDefinition(): VariantTypeEntityDefinition;
@@ -96,7 +100,9 @@ export declare class AnonymousVariantTypeDeclarationEntity implements AnonymousV
     getContainingPackage(): PackageEntity;
     getBaseObjectType(): BaseObjectType;
     getContext(): EntityContext;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): AnonymousVariantTypeEntity;
 }
 export {};

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

@@ -24,6 +24,8 @@ import { FieldEntity, PackageVariableEntity, VariableEntity } from './VariableEn
 import { PackageVariantTypeEntity, VariantTypeEntity } from './VariantTypeEntity.js';
 export * from './AliasedType.js';
 export * from './AliasTypeEntity.js';
+export * from './BaseAspectTypes.js';
+export * from './BaseObjectType.js';
 export * from './ConstructorEntity.js';
 export * from './DereferenceOperatorEntity.js';
 export * from './DestructorEntity.js';
@@ -43,7 +45,6 @@ export * from './StructuredTypeEntity.js';
 export * from './SubstitutionApplicationMode.js';
 export * from './TypeEntity.js';
 export * from './TypeExtensionEntity.js';
-export * from './TypeMemberContainer.js';
 export * from './TypeParameterEntity.js';
 export * from './VariableEntity.js';
 export * from './VariantTypeEntity.js';
@@ -76,6 +77,9 @@ export type TypeEntityWithMembers = FunctionTypeEntity | StructuredTypeEntity |
 export declare function isTypeEntityWithMembers(entity: TypeEntity): entity is TypeEntityWithMembers;
 export type TypeOrExtensionEntity = TypeEntity | TypeExtensionEntity;
 export type TypeWithMembersOrExtensionEntity = TypeEntityWithMembers | TypeExtensionEntity;
+export declare namespace TypeWithMembersOrExtensionEntity {
+    function getContextualTypeEntity(entity: TypeWithMembersOrExtensionEntity): TypeEntity | undefined;
+}
 export declare function isTypeWithMembersOrExtensionEntity(entity: Entity): entity is TypeWithMembersOrExtensionEntity;
 export declare function isTypeEntity(entity: Entity): entity is TypeEntity;
 export declare function isNamedTypeEntity(entity: TypeEntity): entity is NamedTypeEntity;

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

@@ -1,6 +1,6 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
-import { Name } from '../../common/index.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/index.js';
 import { AliasedType, CycleFreeAliasedTypeResolutionResult } from '../AliasedType.js';
 import type { AliasTypeEntity } from '../AliasTypeEntity.js';
@@ -17,19 +17,21 @@ export declare class TranslatedAliasTypeEntity implements AliasTypeEntity {
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Alias;
     readonly subkind = "package";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _typeParameters;
-    private readonly _aliasedType;
-    private readonly _members;
-    private readonly _context;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly typeParameters;
+    private readonly aliasedType;
+    private readonly members;
+    private readonly context;
     constructor(originalEntity: AliasTypeEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
     getName(): Name;
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): AliasTypeEntity;
     getTypeParameters(): readonly TypeParameterEntity[];
     getAliasedType(): AliasedType;
@@ -42,10 +44,10 @@ export declare class TranslatedAliasTypeEntity implements AliasTypeEntity {
     getContext(): EntityContext;
 }
 export declare class LocalizedAliasedType extends AliasedType {
-    private readonly _original;
-    private readonly _localizationContext;
-    private readonly _declared;
-    private readonly _cycleFree;
+    private readonly original;
+    private readonly localizationContext;
+    private readonly declared_;
+    private readonly cycleFree_;
     get declared(): types.Type;
     get cycleFree(): types.Type;
     get causesCycle(): boolean;

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

@@ -1,22 +1,26 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
 import type { ConstructorEntity, ConstructorEntityDefinition, DefaultConstructorEntityInfo } from '../ConstructorEntity.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
-import { EntityKind, TypeMemberEntityContainer } from '../index.js';
-import { ParameterVariableEntity } from '../VariableEntity.js';
+import { EntityKind, PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { ParameterEntity } from '../VariableEntity.js';
 export declare class TranslatedConstructorEntity implements ConstructorEntity {
     readonly kind = EntityKind.Constructor;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _container;
-    private readonly _valueParameters;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingEntity;
+    private readonly parameters;
     constructor(originalEntity: ConstructorEntity, translation: Translation, localizationContext: EntityLocalizationContext);
-    getContainer(): TypeMemberEntityContainer;
-    getLocalization(): Localization;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): ConstructorEntity;
-    getValueParameters(): readonly ParameterVariableEntity[];
+    getParameters(): readonly ParameterEntity[];
     getDefinition(): ConstructorEntityDefinition;
     isDefault(): DefaultConstructorEntityInfo | undefined;
     isHidden(): EntityHidingLevel | undefined;

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

@@ -1,23 +1,27 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/index.js';
 import type { DereferenceOperatorEntity, DereferenceOperatorEntityDefinition } from '../DereferenceOperatorEntity.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
-import { EntityKind, GetterEntity, SetterEntity, TypeMemberEntityContainer } from '../index.js';
+import { EntityKind, GetterEntity, PackageEntity, SetterEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 export declare class TranslatedDereferenceOperatorEntity implements DereferenceOperatorEntity {
     readonly kind = EntityKind.DereferenceOperator;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _container;
-    private readonly _type;
-    private readonly _getter;
-    private readonly _setter;
-    private readonly _overriddenMembers;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingEntity;
+    private readonly type;
+    private readonly getter;
+    private readonly setter;
+    private readonly overriddenMembers;
     constructor(originalEntity: DereferenceOperatorEntity, translation: Translation, localizationContext: EntityLocalizationContext);
-    getContainer(): TypeMemberEntityContainer;
-    getLocalization(): Localization;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): DereferenceOperatorEntity;
     getDefinition(): DereferenceOperatorEntityDefinition;
     isHidden(): EntityHidingLevel | undefined;

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

@@ -1,22 +1,26 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
 import type { DestructorEntity, DestructorEntityDefinition } from '../DestructorEntity.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
-import { EntityKind, TypeMemberEntityContainer } from '../index.js';
-import { ParameterVariableEntity } from '../VariableEntity.js';
+import { EntityKind, PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { ParameterEntity } from '../VariableEntity.js';
 export declare class TranslatedDestructorEntity implements DestructorEntity {
     readonly kind = EntityKind.Destructor;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _container;
-    private readonly _valueParameters;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingEntity;
+    private readonly parameters;
     constructor(originalEntity: DestructorEntity, translation: Translation, localizationContext: EntityLocalizationContext);
-    getContainer(): TypeMemberEntityContainer;
-    getLocalization(): Localization;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): DestructorEntity;
-    getValueParameters(): readonly ParameterVariableEntity[];
+    getParameters(): readonly ParameterEntity[];
     getDefinition(): DestructorEntityDefinition;
     isHidden(): EntityHidingLevel | undefined;
     markedAbstract(): boolean;

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

@@ -1,35 +1,37 @@
 import { Analyzer } from '../../analysis/Analyzer.js';
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
-import { Name } from '../../common/index.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 type { MethodEntity, PackageFunctionEntity } from '../FunctionEntity.js';
 import { FunctionEntityDefinition } from '../FunctionEntity.js';
-import { EntityKind, TypeMemberEntityContainer } from '../index.js';
+import { EntityKind, TypeWithMembersOrExtensionEntity } from '../index.js';
 import { PackageEntity } from '../PackageEntity.js';
 import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
 import { TypeParameterEntity } from '../TypeParameterEntity.js';
-import { ParameterVariableEntity } from '../VariableEntity.js';
+import { ParameterEntity } from '../VariableEntity.js';
 export declare class TranslatedPackageFunctionEntity implements PackageFunctionEntity {
     readonly kind = EntityKind.Function;
     readonly subkind = "package";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _typeParameters;
-    private readonly _valueParameters;
-    private readonly _returnType;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
     constructor(originalEntity: PackageFunctionEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): PackageFunctionEntity;
     getName(): Name;
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly ParameterVariableEntity[];
+    getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
     getDefinition(): FunctionEntityDefinition;
     isAsync(): boolean;
@@ -41,23 +43,26 @@ export declare class TranslatedPackageFunctionEntity implements PackageFunctionE
 export declare class TranslatedMethodEntity implements MethodEntity {
     readonly kind = EntityKind.Function;
     readonly subkind = "method";
-    private readonly _analyzer;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _container;
-    private readonly _typeParameters;
-    private readonly _valueParameters;
-    private readonly _returnType;
-    private readonly _overriddenMembers;
+    private readonly analyzer;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingEntity;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly overriddenMembers;
     constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
-    getContainer(): TypeMemberEntityContainer;
-    getLocalization(): Localization;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): MethodEntity;
     getName(): Name;
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly ParameterVariableEntity[];
+    getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
     getDefinition(): FunctionEntityDefinition;
     isStatic(): boolean;

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

@@ -1,7 +1,8 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
-import { Name } from '../../common/index.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/Type.js';
+import { BaseObjectType } from '../BaseObjectType.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
 import { EntityNaming } from '../EntityNaming.js';
@@ -9,35 +10,36 @@ import type { AnonymousFunctionTypeEntity, PackageFunctionTypeEntity } from '../
 import { FunctionTypeEntityDefinition } from '../FunctionTypeEntity.js';
 import { EntityContext, EntityKind } from '../index.js';
 import { PackageEntity } from '../PackageEntity.js';
-import { BaseObjectType } from '../StructuredTypeEntity.js';
 import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
 import { TypeEntityKind } from '../TypeEntity.js';
 import { TypeEntityMembers } from '../TypeEntityMembers.js';
 import { TypeParameterEntity } from '../TypeParameterEntity.js';
-import { ParameterVariableEntity } from '../VariableEntity.js';
+import { ParameterEntity } from '../VariableEntity.js';
 export declare class TranslatedPackageFunctionTypeEntity implements PackageFunctionTypeEntity {
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Function;
     readonly subkind = "package";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _name;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _typeParameters;
-    private readonly _valueParameters;
-    private readonly _returnType;
-    private readonly _members;
-    private readonly _baseObjectType;
-    private readonly _context;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly name;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly context;
     constructor(originalEntity: PackageFunctionTypeEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
     getName(): Name;
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): PackageFunctionTypeEntity;
     getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly ParameterVariableEntity[];
+    getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
     getMembers(): TypeEntityMembers;
     getDefinition(): FunctionTypeEntityDefinition;
@@ -53,23 +55,25 @@ export declare class TranslatedAnonymousFunctionTypeEntity implements AnonymousF
     readonly kind = EntityKind.Type;
     readonly typeEntityKind = TypeEntityKind.Function;
     readonly subkind = "anonymous";
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _containingPackage;
-    private readonly _typeParameters;
-    private readonly _valueParameters;
-    private readonly _returnType;
-    private readonly _members;
-    private readonly _baseObjectType;
-    private readonly _context;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingPackage;
+    private readonly typeParameters;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly context;
     constructor(originalEntity: AnonymousFunctionTypeEntity, translation: Translation, localizationContext: EntityLocalizationContext);
     getContainingPackage(): PackageEntity;
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): AnonymousFunctionTypeEntity;
     getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
-    getValueParameters(): readonly ParameterVariableEntity[];
+    getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
     getMembers(): TypeEntityMembers;
     getDefinition(): FunctionTypeEntityDefinition;

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

@@ -1,25 +1,29 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
 import { Type } from '../../types/Type.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
 import type { GetterEntity } from '../GetterEntity.js';
 import { EntityOwningGetter, GetterEntityDefinition } from '../GetterEntity.js';
-import { EntityKind } from '../index.js';
+import { EntityKind, PackageEntity } from '../index.js';
 export declare class TranslatedGetterEntity implements GetterEntity {
     readonly kind = EntityKind.Getter;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _returnType;
-    private readonly _owningEntity;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly returnType;
+    private readonly owningEntity;
     constructor(originalEntity: GetterEntity, translation: Translation, localizationContext: EntityLocalizationContext);
     getReturnType(): Type;
     getDefinition(): GetterEntityDefinition;
     isModifyingOwningPlainObject(): boolean;
     getOwningEntity(): EntityOwningGetter;
+    getContainingPackage(): PackageEntity;
     isHidden(): EntityHidingLevel | undefined;
     getTags(): readonly Tag[];
-    getLocalization(): Localization;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): GetterEntity;
 }

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

@@ -1,27 +1,31 @@
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
+import { 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, GetterEntity, SetterEntity, TypeMemberEntityContainer } from '../index.js';
+import { EntityKind, GetterEntity, PackageEntity, SetterEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 import type { IndexerEntity, IndexerEntityDefinition } from '../IndexerEntity.js';
-import { ParameterVariableEntity } from '../VariableEntity.js';
+import { ParameterEntity } from '../VariableEntity.js';
 export declare class TranslatedIndexerEntity implements IndexerEntity {
     readonly kind = EntityKind.Indexer;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _container;
-    private readonly _valueParameters;
-    private readonly _type;
-    private readonly _getter;
-    private readonly _setter;
-    private readonly _overriddenMembers;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingEntity;
+    private readonly parameters;
+    private readonly type;
+    private readonly getter;
+    private readonly setter;
+    private readonly overriddenMembers;
     constructor(originalEntity: IndexerEntity, translation: Translation, localizationContext: EntityLocalizationContext);
-    getContainer(): TypeMemberEntityContainer;
-    getLocalization(): Localization;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): IndexerEntity;
-    getValueParameters(): readonly ParameterVariableEntity[];
+    getParameters(): readonly ParameterEntity[];
     getDefinition(): IndexerEntityDefinition;
     isHidden(): EntityHidingLevel | undefined;
     markedAbstract(): boolean;

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

@@ -1,28 +1,32 @@
 import { Analyzer } from '../../analysis/Analyzer.js';
-import { Localization, Translation } from '../../analysis/Localization.js';
 import { Tag } from '../../analysis/Tags.js';
+import { Translation } from '../../analysis/Translation.js';
+import { 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, OperatorKind, TypeMemberEntityContainer } from '../index.js';
+import { EntityKind, OperatorKind, PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 import type { OperatorEntity, OperatorEntityDefinition } from '../OperatorEntity.js';
-import { ParameterVariableEntity } from '../VariableEntity.js';
+import { ParameterEntity } from '../VariableEntity.js';
 export declare class TranslatedOperatorEntity implements OperatorEntity {
     readonly kind = EntityKind.Operator;
-    private readonly _analyzer;
-    private readonly _originalEntity;
-    private readonly _translation;
-    private readonly _localizationContext;
-    private readonly _container;
-    private readonly _valueParameters;
-    private readonly _returnType;
-    private readonly _overriddenMembers;
+    private readonly analyzer;
+    private readonly originalEntity;
+    private readonly translation;
+    private readonly localizationContext;
+    private readonly containingEntity;
+    private readonly parameters;
+    private readonly returnType;
+    private readonly overriddenMembers;
     constructor(analyzer: Analyzer, originalEntity: OperatorEntity, translation: Translation, localizationContext: EntityLocalizationContext);
-    getContainer(): TypeMemberEntityContainer;
-    getLocalization(): Localization;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
     getOriginalEntity(): OperatorEntity;
     getOperatorKind(): OperatorKind;
-    getValueParameters(): readonly ParameterVariableEntity[];
+    getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
     getDefinition(): OperatorEntityDefinition;
     isStatic(): boolean;