@artel/artc 0.6.25244 → 0.6.25245

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

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

@@ -0,0 +1,97 @@
+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 { GetterEntity } from '../GetterEntity.js';
+import { EntityKind, TypeMemberEntityContainer } from '../index.js';
+import { PackageEntity } from '../PackageEntity.js';
+import { SetterEntity } from '../SetterEntity.js';
+import type { FieldEntity, PackageVariableEntity, ParameterVariableEntity } from '../VariableEntity.js';
+import { ParameterVariableEntityContainer, SpecialVariableEntityInfo, VariableEntityDefinition } from '../VariableEntity.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 _localizationContext;
+    private readonly _containingPackage;
+    private readonly _type;
+    private readonly _getter;
+    private readonly _setter;
+    constructor(originalEntity: PackageVariableEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): PackageVariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    ensureAllDiagnosticsReported?(): void;
+}
+export declare class TranslatedFieldEntity implements FieldEntity {
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "field";
+    private readonly _originalEntity;
+    private readonly _translation;
+    private readonly _name;
+    private readonly _localizationContext;
+    private readonly _container;
+    private readonly _type;
+    private readonly _getter;
+    private readonly _setter;
+    private readonly _overriddenMembers;
+    constructor(originalEntity: FieldEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getContainer(): TypeMemberEntityContainer;
+    getLocalization(): Localization;
+    getOriginalEntity(): FieldEntity;
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getOverriddenMembers(): readonly types.Field[];
+    isVariant(): boolean;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    ensureAllDiagnosticsReported?(): void;
+}
+export declare class TranslatedParameterVariableEntity implements ParameterVariableEntity {
+    readonly kind = EntityKind.Variable;
+    readonly subkind = "parameter";
+    private readonly _originalEntity;
+    private readonly _translation;
+    private readonly _name;
+    private readonly _localizationContext;
+    private readonly _container;
+    private readonly _type;
+    constructor(originalEntity: ParameterVariableEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getContainer(): ParameterVariableEntityContainer;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+    getLocalization(): Localization;
+    getOriginalEntity(): ParameterVariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    ensureAllDiagnosticsReported?(): void;
+}

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

@@ -0,0 +1,76 @@
+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 { 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 type { AnonymousVariantTypeEntity, PackageVariantTypeEntity } from '../VariantTypeEntity.js';
+import { VariantTypeEntityDefinition } from '../VariantTypeEntity.js';
+export declare 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 _localizationContext;
+    private readonly _containingPackage;
+    private readonly _typeParameters;
+    private readonly _underlyingType;
+    private readonly _members;
+    private readonly _baseObjectType;
+    private readonly _context;
+    constructor(originalEntity: PackageVariantTypeEntity, translation: Translation, name: Name, localizationContext: EntityLocalizationContext);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): PackageVariantTypeEntity;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getUnderlyingType(): types.Type;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): VariantTypeEntityDefinition;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getBaseObjectType(): BaseObjectType;
+    getContext(): EntityContext;
+}
+export declare class TranslatedAnonymousVariantTypeEntity implements AnonymousVariantTypeEntity {
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Variant;
+    readonly subkind = "anonymous";
+    private readonly _originalEntity;
+    private readonly _translation;
+    private readonly _localizationContext;
+    private readonly _containingPackage;
+    private readonly _typeParameters;
+    private readonly _underlyingType;
+    private readonly _members;
+    private readonly _baseObjectType;
+    private readonly _context;
+    constructor(originalEntity: AnonymousVariantTypeEntity, translation: Translation, localizationContext: EntityLocalizationContext);
+    getContainingPackage(): PackageEntity;
+    getLocalization(): Localization;
+    getOriginalEntity(): AnonymousVariantTypeEntity;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getUnderlyingType(): types.Type;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): VariantTypeEntityDefinition;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getBaseObjectType(): BaseObjectType;
+    getContext(): EntityContext;
+}

package/build/types/project/SourcePackage.d.ts

@@ -75,6 +75,7 @@ export declare class ProgramPackageConfiguration {
 }
 export declare class PackageName {
     readonly segments: ReadonlyNonEmptyArray<Name>;
+    get key(): string;
     constructor(segments: ReadonlyNonEmptyArray<Name>);
     static parse(name: string): PackageName;
     considerEqual(name: PackageName): boolean;

package/build/types/services/DefinitionService.d.ts

@@ -10,7 +10,6 @@ export declare class DefinitionService {
     private getDefinitionOfReference;
     private getReferenceTargetSourceLocation;
     private getReferenceTargetEntity;
-    private createLocalizationContextForSourceGeneration;
     private getSourceLocationsOfVariableEntity;
     private getSourceLocationsOfSpecialVariable;
     private getSourceLocationOfSubprogramNode;