@artel/artc 0.6.25244 → 0.6.25246

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;
+}

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

@@ -0,0 +1,107 @@
+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 { EntityNaming } from '../EntityNaming.js';
+import { EntityContext, EntityKind } from '../index.js';
+import { PackageEntity } from '../PackageEntity.js';
+import type { AnonymousStructuredTypeEntity, PackageStructuredTypeEntity } from '../StructuredTypeEntity.js';
+import { BaseAspectTypes, BaseObjectType, CycleFreeBaseAspectTypesResolutionResult, CycleFreeBaseObjectTypeResolutionResult, StructuredTypeEntityDefinition } from '../StructuredTypeEntity.js';
+import { SubstitutionApplicationMode } from '../SubstitutionApplicationMode.js';
+import { TypeEntityKind } from '../TypeEntity.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import { TypeParameterEntity } from '../TypeParameterEntity.js';
+export declare 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 _localizationContext;
+    private readonly _containingPackage;
+    private readonly _typeParameters;
+    private readonly _members;
+    private readonly _baseObjectType;
+    private readonly _baseAspectTypes;
+    private readonly _context;
+    constructor(originalEntity: PackageStructuredTypeEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): PackageStructuredTypeEntity;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    isAspect(): boolean;
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContext(): EntityContext;
+}
+export declare class TranslatedAnonymousStructuredTypeEntity implements AnonymousStructuredTypeEntity {
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "anonymous";
+    private readonly _originalEntity;
+    private readonly _translation;
+    private readonly _localizationContext;
+    private readonly _containingPackage;
+    private readonly _typeParameters;
+    private readonly _members;
+    private readonly _baseObjectType;
+    private readonly _baseAspectTypes;
+    private readonly _context;
+    constructor(originalEntity: AnonymousStructuredTypeEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): AnonymousStructuredTypeEntity;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    isAspect(): boolean;
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContext(): EntityContext;
+}
+export declare class LocalizedBaseObjectType extends BaseObjectType {
+    private readonly _original;
+    private readonly _localizationContext;
+    private readonly _declared;
+    private readonly _cycleFree;
+    get declared(): types.Type | undefined;
+    get cycleFree(): types.Type | undefined;
+    get causesCycle(): boolean;
+    constructor(original: BaseObjectType, localizationContext: EntityLocalizationContext);
+    resolveBaseObjectType(circularityTrackingStack: boolean[]): CycleFreeBaseObjectTypeResolutionResult;
+}
+export declare class LocalizedBaseAspectTypes extends BaseAspectTypes {
+    private readonly _original;
+    private readonly _localizationContext;
+    private readonly _declared;
+    private readonly _cycleFree;
+    get declared(): readonly types.Type[];
+    get cycleFree(): readonly types.Type[];
+    get causesCycle(): boolean;
+    constructor(original: BaseAspectTypes, localizationContext: EntityLocalizationContext);
+    resolveBaseAspectTypes(circularityTrackingStack: boolean[]): CycleFreeBaseAspectTypesResolutionResult;
+}

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

@@ -0,0 +1,28 @@
+import { Localization, Translation } from '../../analysis/Localization.js';
+import { Tag } from '../../analysis/Tags.js';
+import { EntityHidingLevel } from '../EntityHiding.js';
+import { EntityLocalizationContext } from '../EntityLocalizationContext.js';
+import { EntityContext, EntityKind, NamedTypeEntity } from '../index.js';
+import { PackageEntity } from '../PackageEntity.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import type { TypeExtensionEntity, TypeExtensionEntityDefinition } from '../TypeExtensionEntity.js';
+export declare class TranslatedTypeExtensionEntity implements TypeExtensionEntity {
+    readonly kind = EntityKind.TypeExtension;
+    private readonly _originalEntity;
+    private readonly _translation;
+    private readonly _localizationContext;
+    private readonly _containingPackage;
+    private readonly _members;
+    private readonly _extendedTypeEntity;
+    private readonly _context;
+    constructor(originalEntity: TypeExtensionEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getMembers(): TypeEntityMembers;
+    getContainingPackage(): PackageEntity;
+    getExtendedTypeEntity(): NamedTypeEntity | undefined;
+    getDefinition(): TypeExtensionEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getContext(): EntityContext;
+    getLocalization(): Localization;
+    getOriginalEntity(): TypeExtensionEntity;
+}

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

@@ -0,0 +1,46 @@
+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 { EntityContext, EntityKind } from '../index.js';
+import { TypeEntityKind } from '../TypeEntity.js';
+import type { TypeParameterEntity } from '../TypeParameterEntity.js';
+import { CycleFreeConstraintResolutionResult, EntityContainingTypeParameter, TypeParameterConstraint, TypeParameterEntityDefinition } from '../TypeParameterEntity.js';
+export declare class TranslatedTypeParameterEntity implements TypeParameterEntity {
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Parameter;
+    private readonly _originalEntity;
+    private readonly _translation;
+    private readonly _name;
+    private readonly _localizationContext;
+    private readonly _defaultType;
+    private readonly _constraint;
+    private readonly _context;
+    private readonly _containingEntity;
+    constructor(originalEntity: TypeParameterEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getName(): Name;
+    getConstraint(): TypeParameterConstraint;
+    getDefaultType(): types.Type | undefined;
+    getDefinition(): TypeParameterEntityDefinition;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getContainingEntity(): EntityContainingTypeParameter;
+    isHidden(): EntityHidingLevel | undefined;
+    getLocalization(): Localization;
+    getOriginalEntity(): TypeParameterEntity;
+    getContext(): EntityContext;
+    getTags(): readonly Tag[];
+}
+export declare class LocalizedTypeParameterConstraint extends TypeParameterConstraint {
+    private readonly _original;
+    private readonly _localizationContext;
+    private readonly _declared;
+    private readonly _cycleFree;
+    get declared(): types.Type | undefined;
+    get cycleFree(): types.Type | undefined;
+    get causesCycle(): boolean;
+    constructor(original: TypeParameterConstraint, localizationContext: EntityLocalizationContext);
+    resolveConstraint(circularityTrackingStack: boolean[]): CycleFreeConstraintResolutionResult;
+}