@artel/artc 0.6.25243 → 0.6.25245

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

@@ -1,25 +1,30 @@
+import { Localization } from '../analysis/Localization.js';
 import { Tag } from '../analysis/Tags.js';
 import { Analyzer } from '../analysis/index.js';
 import { Name } from '../common/index.js';
 import { AnonymousVariantTypeDeclaration, PackageVariantTypeDeclaration } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { EntityNaming } from './EntityNaming.js';
-import { OriginalTypeEntityMembers } from './TypeEntityMembers.js';
+import { TypeEntityMembers } from './TypeEntityMembers.js';
 import { BaseObjectType, 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;
+    getOriginalEntity(): PackageVariantTypeEntity;
 }
 export interface AnonymousVariantTypeEntity extends IVariantTypeEntity {
     readonly subkind: 'anonymous';
     getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): AnonymousVariantTypeEntity;
 }
 interface IVariantTypeEntity extends ITypeEntity {
     readonly kind: EntityKind.Type;
     readonly typeEntityKind: TypeEntityKind.Variant;
-    getMembers(): OriginalTypeEntityMembers;
+    getMembers(): TypeEntityMembers;
     getUnderlyingType(): types.Type;
     getDefinition(): VariantTypeEntityDefinition;
     getNaming(): EntityNaming;
@@ -55,7 +60,7 @@ export declare class PackageVariantTypeDeclarationEntity implements PackageVaria
     getNaming(): EntityNaming;
     getName(): Name;
     getContainingPackage(): PackageEntity;
-    getMembers(): OriginalTypeEntityMembers;
+    getMembers(): TypeEntityMembers;
     getUnderlyingType(): types.Type;
     getDefinition(): VariantTypeEntityDefinition;
     getArity(): number;
@@ -65,6 +70,8 @@ export declare class PackageVariantTypeDeclarationEntity implements PackageVaria
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
     getBaseObjectType(): BaseObjectType;
     getContext(): EntityContext;
+    getLocalization(): Localization;
+    getOriginalEntity(): PackageVariantTypeEntity;
 }
 export declare class AnonymousVariantTypeDeclarationEntity implements AnonymousVariantTypeEntity {
     private readonly _analyzer;
@@ -76,7 +83,7 @@ export declare class AnonymousVariantTypeDeclarationEntity implements AnonymousV
     private readonly _members;
     private readonly _baseObjectType;
     constructor(_analyzer: Analyzer, _node: AnonymousVariantTypeDeclaration);
-    getMembers(): OriginalTypeEntityMembers;
+    getMembers(): TypeEntityMembers;
     getUnderlyingType(): types.Type;
     getDefinition(): VariantTypeEntityDefinition;
     getNaming(): EntityNaming;
@@ -88,5 +95,7 @@ export declare class AnonymousVariantTypeDeclarationEntity implements AnonymousV
     getContainingPackage(): PackageEntity;
     getBaseObjectType(): BaseObjectType;
     getContext(): EntityContext;
+    getLocalization(): Localization;
+    getOriginalEntity(): AnonymousVariantTypeEntity;
 }
 export {};

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

@@ -1,5 +1,4 @@
 import { Analyzer } from '../analysis/Analyzer.js';
-import { LocalizationContext } from '../analysis/LocalizationContext.js';
 import { SemanticContext } from '../analysis/semantic-context/SemanticContext.js';
 import { PackageDialect, PackageLocale } from '../common/index.js';
 import * as types from '../types/index.js';
@@ -22,6 +21,7 @@ import { TypeExtensionEntity } from './TypeExtensionEntity.js';
 import { TypeParameterEntity } from './TypeParameterEntity.js';
 import { FieldEntity, PackageVariableEntity, VariableEntity } from './VariableEntity.js';
 import { PackageVariantTypeEntity, VariantTypeEntity } from './VariantTypeEntity.js';
+export * from './AliasedType.js';
 export * from './AliasTypeEntity.js';
 export * from './ConstructorEntity.js';
 export * from './DereferenceOperatorEntity.js';
@@ -106,14 +106,15 @@ export declare namespace TypeMemberEntity {
     function getOverriddenMembers(entity: TypeMemberEntity): readonly types.TypeMember[];
     function instantiate(analyzer: Analyzer, entity: TypeMemberEntity, substitutions: types.Substitutions): types.TypeMember;
 }
+export type NamedTypeMemberEntity = FieldEntity | MethodEntity;
+export type NamedEntity = VariableEntity | PackageVariantTypeEntity | FunctionEntity | TypeParameterEntity | PackageFunctionTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
 export declare class EntityContext {
     readonly containingPackage: PackageEntity;
     readonly hidingMatcher: IEntityHidingMatcher;
-    readonly localizationContext: LocalizationContext | undefined;
     readonly typeExtensionLookup: SemanticContext | undefined;
-    get lctxOrLocale(): LocalizationContext | PackageLocale;
+    get locale(): PackageLocale;
     get packageDialect(): PackageDialect;
-    constructor(containingPackage: PackageEntity, hidingMatcher: IEntityHidingMatcher, localizationContext: LocalizationContext | undefined, typeExtensionLookup: SemanticContext | undefined);
+    constructor(containingPackage: PackageEntity, hidingMatcher: IEntityHidingMatcher, typeExtensionLookup: SemanticContext | undefined);
     static fromSemanticContext(semanticContext: SemanticContext): EntityContext;
 }
 export declare function entityToStringDecorator<T extends {

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

@@ -0,0 +1,54 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.js';
+import { Name } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import { AliasedType, CycleFreeAliasedTypeResolutionResult } from '../AliasedType.js';
+import type { AliasTypeEntity } from '../AliasTypeEntity.js';
+import { AliasTypeEntityDefinition } from '../AliasTypeEntity.js';
+import { EntityHidingLevel } from '../EntityHiding.js';
+import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
+import { EntityContext, EntityKind } from '../index.js';
+import { PackageEntity } from '../PackageEntity.js';
+import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
+import { TypeEntityKind } from '../TypeEntity.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import { TypeParameterEntity } from '../TypeParameterEntity.js';
+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;
+    constructor(originalEntity: AliasTypeEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): AliasTypeEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getAliasedType(): AliasedType;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): AliasTypeEntityDefinition;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContext(): EntityContext;
+}
+export declare class LocalizedAliasedType extends AliasedType {
+    private readonly _original;
+    private readonly _localizationContext;
+    private readonly _declared;
+    private readonly _cycleFree;
+    get declared(): types.Type;
+    get cycleFree(): types.Type;
+    get causesCycle(): boolean;
+    constructor(original: AliasedType, localizationContext: EntityLocalizationContext);
+    resolveAliasedType(circularityTrackingStack: boolean[]): CycleFreeAliasedTypeResolutionResult;
+}

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

@@ -0,0 +1,25 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.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';
+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;
+    constructor(originalEntity: ConstructorEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getContainer(): TypeMemberEntityContainer;
+    getLocalization(): Localization;
+    getOriginalEntity(): ConstructorEntity;
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getDefinition(): ConstructorEntityDefinition;
+    isDefault(): DefaultConstructorEntityInfo | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+}

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

@@ -0,0 +1,34 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.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';
+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;
+    constructor(originalEntity: DereferenceOperatorEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getContainer(): TypeMemberEntityContainer;
+    getLocalization(): Localization;
+    getOriginalEntity(): DereferenceOperatorEntity;
+    getDefinition(): DereferenceOperatorEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getType(): types.Type;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    getOverriddenMembers(): readonly types.DereferenceOperator[];
+    ensureAllDiagnosticsReported?(): void;
+    getTags(): readonly Tag[];
+}

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

@@ -0,0 +1,24 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.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';
+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;
+    constructor(originalEntity: DestructorEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getContainer(): TypeMemberEntityContainer;
+    getLocalization(): Localization;
+    getOriginalEntity(): DestructorEntity;
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getDefinition(): DestructorEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+}

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

@@ -0,0 +1,75 @@
+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 * 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 { PackageEntity } from '../PackageEntity.js';
+import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
+import { TypeParameterEntity } from '../TypeParameterEntity.js';
+import { ParameterVariableEntity } 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;
+    constructor(originalEntity: PackageFunctionEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): PackageFunctionEntity;
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+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;
+    constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getContainer(): TypeMemberEntityContainer;
+    getLocalization(): Localization;
+    getOriginalEntity(): MethodEntity;
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    isModifyingOwningPlainObject(): boolean;
+    isFunctionTypeInvokeMethod(): boolean;
+    getOverriddenMembers(): readonly types.Method[];
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}

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

@@ -0,0 +1,83 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.js';
+import { Name } from '../../common/index.js';
+import * as types from '../../types/Type.js';
+import { EntityHidingLevel } from '../EntityHiding.js';
+import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
+import { EntityNaming } from '../EntityNaming.js';
+import type { AnonymousFunctionTypeEntity, PackageFunctionTypeEntity } from '../FunctionTypeEntity.js';
+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';
+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;
+    constructor(originalEntity: PackageFunctionTypeEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): PackageFunctionTypeEntity;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): FunctionTypeEntityDefinition;
+    isAsync(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getBaseObjectType(): BaseObjectType;
+    getContext(): EntityContext;
+}
+export declare class TranslatedAnonymousFunctionTypeEntity implements AnonymousFunctionTypeEntity {
+    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;
+    constructor(originalEntity: AnonymousFunctionTypeEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): AnonymousFunctionTypeEntity;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): FunctionTypeEntityDefinition;
+    isAsync(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getBaseObjectType(): BaseObjectType;
+    getContext(): EntityContext;
+}

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

@@ -0,0 +1,25 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.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';
+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;
+    constructor(originalEntity: GetterEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getReturnType(): Type;
+    getDefinition(): GetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningGetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getLocalization(): Localization;
+    getOriginalEntity(): GetterEntity;
+}

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

@@ -0,0 +1,37 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.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 type { IndexerEntity, IndexerEntityDefinition } from '../IndexerEntity.js';
+import { ParameterVariableEntity } 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;
+    constructor(originalEntity: IndexerEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getContainer(): TypeMemberEntityContainer;
+    getLocalization(): Localization;
+    getOriginalEntity(): IndexerEntity;
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getDefinition(): IndexerEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    markedAbstract(): boolean;
+    getType(): types.Type;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    getOverriddenMembers(): readonly types.Indexer[];
+    ensureAllDiagnosticsReported?(): void;
+    getTags(): readonly Tag[];
+}

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

@@ -0,0 +1,35 @@
+import { Analyzer } from '../../analysis/Analyzer.js';
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.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 type { OperatorEntity, OperatorEntityDefinition } from '../OperatorEntity.js';
+import { ParameterVariableEntity } 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;
+    constructor(analyzer: Analyzer, originalEntity: OperatorEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getContainer(): TypeMemberEntityContainer;
+    getLocalization(): Localization;
+    getOriginalEntity(): OperatorEntity;
+    getOperatorKind(): OperatorKind;
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): OperatorEntityDefinition;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getOverriddenMembers(): readonly types.Operator[];
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}

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

@@ -0,0 +1,28 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { PackageDialect } from '../../common/PackageDialect.js';
+import { PackageLocale } from '../../common/PackageLocale.js';
+import { PackageName, PlatformKind } from '../../project/SourcePackage.js';
+import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
+import { EntityKind } from '../index.js';
+import type { PackageEntity } from '../PackageEntity.js';
+import { InterfacePackageEntityInfo, PackageEntityDefinition } from '../PackageEntity.js';
+import { PackageEntityMembers } from '../PackageMembers.js';
+export declare class TranslatedPackageEntity implements PackageEntity {
+    readonly kind = EntityKind.Package;
+    private readonly _originalEntity;
+    private readonly _translation;
+    private readonly _name;
+    private readonly _localizationContext;
+    private readonly _members;
+    constructor(originalEntity: PackageEntity, translation: Translation, name: PackageName, localizationContext: EntityLocalizationContext);
+    getName(): PackageName;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getMembers(): PackageEntityMembers;
+    isInterface(): InterfacePackageEntityInfo | undefined;
+    getImplementedInterfacePackage(): PackageEntity | undefined;
+    getSupportedPlatforms(): readonly PlatformKind[];
+    getDefinition(): PackageEntityDefinition;
+    getLocalization(): Localization;
+    getOriginalEntity(): PackageEntity;
+}

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

@@ -0,0 +1,22 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.js';
+import { EntityHidingLevel } from '../EntityHiding.js';
+import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
+import { EntityKind } from '../index.js';
+import type { SetterEntity } from '../SetterEntity.js';
+import { EntityOwningSetter, SetterEntityDefinition } from '../SetterEntity.js';
+export declare class TranslatedSetterEntity implements SetterEntity {
+    readonly kind = EntityKind.Setter;
+    private readonly _originalEntity;
+    private readonly _translation;
+    private readonly _localizationContext;
+    private readonly _owningEntity;
+    constructor(originalEntity: SetterEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getLocalization(): Localization;
+    getOriginalEntity(): SetterEntity;
+}