@artel/artc 0.6.26039 → 0.8.26001

package/build/types/entities/source/m/SourcePackageEntity.d.ts

@@ -0,0 +1,68 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { ResolvedTranslationPackage } from '../../../analysis/m/ResolvedTranslationPackage.js';
+import { PackageDialect, PackageLocale } from '../../../common/index.js';
+import { PackageName, PlatformKind, ProgramPackageM, SourcePackageM, TextTranslationPackageM, TranslationPackageM } from '../../../project/index.js';
+import { AnonymousTypeEntity, EntityKind, EntityLocalizationContext, InterfacePackageEntityInfo, IPackageEntity, LocalizablePackageMemberEntity, NameTranslationPackageEntity, PackageEntity, PackageEntityDefinition, PackageEntityMembers, ProgramPackageEntity, Tag, TextTranslationPackageEntity, TextTranslationPackageEntityInfo, Translation, TypeMemberEntity, LocalTypeEntity } from '../../index.js';
+export declare abstract class SourcePackageEntity implements IPackageEntity {
+    readonly kind = EntityKind.Package;
+    protected readonly analyzer: Analyzer;
+    protected abstract package_: SourcePackageM;
+    protected abstract asPackageEntity: PackageEntity;
+    private readonly members;
+    private readonly interfaceInfo;
+    private readonly implementedInterfacePackage;
+    private readonly textTranslationInfo;
+    constructor(analyzer: Analyzer);
+    getName(): PackageName;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getMembers(): PackageEntityMembers;
+    getInterfacePackageInfo(): InterfacePackageEntityInfo | undefined;
+    getImplementedInterfacePackage(): PackageEntity | undefined;
+    getSupportedPlatforms(): readonly PlatformKind[];
+    getContainingPackage(): PackageEntity;
+    getDefinition(): PackageEntityDefinition;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): PackageEntity;
+    getTags(): readonly Tag[];
+    getTextTranslationPackageInfo(): TextTranslationPackageEntityInfo | undefined;
+    private createPackageMembers;
+    private createInterfacePackageInfo;
+    private createTextTranslationInfo;
+}
+export declare class SourceProgramPackageEntity extends SourcePackageEntity implements ProgramPackageEntity {
+    readonly subkind = "program";
+    protected readonly package_: ProgramPackageM;
+    protected get asPackageEntity(): PackageEntity;
+    constructor(analyzer: Analyzer, package_: ProgramPackageM);
+}
+export declare class SourceNameTranslationPackageEntity extends SourcePackageEntity implements NameTranslationPackageEntity {
+    readonly subkind = "name-translation";
+    protected readonly package_: TranslationPackageM;
+    private readonly targetPackage;
+    private readonly translatedTargetPackage;
+    private readonly localizedReferencedPackagesMap;
+    private readonly localizationContext;
+    private readonly resolvedTranslationPackage_;
+    protected get asPackageEntity(): PackageEntity;
+    constructor(analyzer: Analyzer, package_: TranslationPackageM);
+    getTranslationLocale(): PackageLocale;
+    getTargetPackage(): PackageEntity | undefined;
+    getTranslatedTargetPackage(): PackageEntity | undefined;
+    getResolvedTranslationPackage(): ResolvedTranslationPackage | undefined;
+    getLocalizationContext(): EntityLocalizationContext;
+    getLocalizedReferencedPackagesMap(): ReadonlyMap<PackageEntity, PackageEntity>;
+    getTranslatedPackageMember(entity: LocalizablePackageMemberEntity): LocalizablePackageMemberEntity;
+    getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
+    getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
+    getTranslatedLocalTypeEntity(entity: LocalTypeEntity): LocalTypeEntity;
+}
+export declare class SourceTextTranslationPackageEntity extends SourcePackageEntity implements TextTranslationPackageEntity {
+    readonly subkind = "text-translation";
+    protected readonly package_: TextTranslationPackageM;
+    private readonly targetPackage;
+    protected get asPackageEntity(): PackageEntity;
+    constructor(analyzer: Analyzer, package_: TextTranslationPackageM);
+    getTargetPackage(): PackageEntity | undefined;
+    isPrimary(): boolean;
+}

package/build/types/entities/source/m/SourceSetterEntity.d.ts

@@ -0,0 +1,122 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { BasePackageMemberAccessorEntity, BaseTypeMemberAccessorEntity, EntityHidingLevel, EntityOwningPackageMemberAccessor, EntityOwningTypeMemberAccessor, FunctionEntityDefinition, MethodEntity, PackageEntity, PackageFunctionEntity, PackageMemberAccessorKind, ParameterEntity, Tag, Translation, TypeMemberAccessorKind, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../index.js';
+export declare class PackageVariableSetterDeclarationEntity extends BasePackageMemberAccessorEntity {
+    private readonly analyzer;
+    private readonly node;
+    private modifierFlags_;
+    private readonly hiding;
+    private readonly parameters;
+    get accessorKind(): PackageMemberAccessorKind;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.PackageVariableSetterDeclaration);
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getAccessorOwner(): EntityOwningPackageMemberAccessor;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    isAsync(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageFunctionEntity;
+}
+export declare class FieldSetterDeclarationEntity extends BaseTypeMemberAccessorEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly hiding;
+    private readonly parameters;
+    private containingEntity;
+    private modifierFlags_;
+    get accessorKind(): TypeMemberAccessorKind;
+    get isImplicitAccessor(): boolean;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.FieldSetterDeclaration);
+    getDefinition(): FunctionEntityDefinition;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getAccessorOwner(): EntityOwningTypeMemberAccessor;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+}
+export declare class IndexedElementSetterDeclarationEntity extends BaseTypeMemberAccessorEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly hiding;
+    private readonly parameters;
+    private containingEntity;
+    private modifierFlags_;
+    get accessorKind(): TypeMemberAccessorKind;
+    get isImplicitAccessor(): boolean;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.IndexedElementSetterDeclaration);
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getAccessorOwner(): EntityOwningTypeMemberAccessor;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    isAsync(): boolean;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+}
+export declare class StaticFieldSetterDeclarationEntity extends BaseTypeMemberAccessorEntity {
+    protected readonly analyzer: Analyzer;
+    private readonly node;
+    private readonly hiding;
+    private readonly parameters;
+    private containingEntity;
+    private modifierFlags_;
+    get accessorKind(): TypeMemberAccessorKind;
+    get isImplicitAccessor(): boolean;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.StaticFieldSetterDeclaration);
+    getDefinition(): FunctionEntityDefinition;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getAccessorOwner(): EntityOwningTypeMemberAccessor;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getTypeParametersArity(): number;
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): MethodEntity;
+}

package/build/types/entities/source/m/SourceStructuredTypeEntity.d.ts

@@ -0,0 +1,111 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { Name, PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import { BaseAspectTypes } from '../../BaseAspectTypes.js';
+import { BaseObjectType } from '../../BaseObjectType.js';
+import { EntityHidingLevel, EntityKind, EntityNaming, LocalStructuredTypeEntity, PackageEntity, PackageStructuredTypeEntity, StructuredTypeEntity, StructuredTypeEntityDefinition, StructuredTypeKind, SubstitutionApplicationMode, Tag, Translation, TypeEntityKind, TypeEntityMembers, TypeParameterEntity } from '../../index.js';
+export declare class PackageStructuredTypeDeclarationEntity implements PackageStructuredTypeEntity {
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "package";
+    private readonly node;
+    private readonly data;
+    constructor(analyzer: Analyzer, node: tree.PackageTypeDeclaration);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageStructuredTypeEntity;
+}
+export declare class LocalStructuredTypeDeclarationEntity implements LocalStructuredTypeEntity {
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "local";
+    private readonly node;
+    private readonly data;
+    constructor(analyzer: Analyzer, node: tree.LocalStructuredTypeDeclaration);
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): LocalStructuredTypeEntity;
+    getName(): Name;
+}
+export declare abstract class SourceStructuredTypeDeclarationData {
+    protected readonly analyzer: Analyzer;
+    private readonly baseTypes;
+    private readonly members;
+    protected abstract get typeNode(): tree.PackageTypeDeclaration | tree.LocalStructuredTypeDeclaration;
+    protected abstract get entity(): StructuredTypeEntity;
+    constructor(analyzer: Analyzer);
+    getContainingPackage(): PackageEntity;
+    getMembers(): TypeEntityMembers;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    private getBaseTypes;
+    private validateBaseTypeListAndCreateBaseTypes;
+    abstract getStructuredTypeKind(): StructuredTypeKind;
+}
+export declare class SourcePackageStructuredTypeDeclarationData extends SourceStructuredTypeDeclarationData {
+    protected readonly entity: PackageStructuredTypeEntity;
+    private readonly node;
+    private readonly name;
+    private readonly typeParameters;
+    private readonly structuredTypeKind;
+    private readonly hiding;
+    private modifierFlags_;
+    protected get typeNode(): tree.PackageTypeDeclaration;
+    private get modifierFlags();
+    constructor(analyzer: Analyzer, node: tree.PackageTypeDeclaration, entity: PackageStructuredTypeEntity);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getDefinition(): StructuredTypeEntityDefinition;
+    isAbstract(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getStructuredTypeKind(): StructuredTypeKind;
+}
+export declare class SourceLocalStructuredTypeDeclarationData extends SourceStructuredTypeDeclarationData {
+    protected readonly entity: LocalStructuredTypeEntity;
+    private readonly node;
+    private readonly name;
+    protected get typeNode(): tree.LocalStructuredTypeDeclaration;
+    constructor(analyzer: Analyzer, node: tree.LocalStructuredTypeDeclaration, entity: LocalStructuredTypeEntity);
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getArity(): number;
+    getDefinition(): StructuredTypeEntityDefinition;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getName(): Name;
+}

package/build/types/entities/source/m/SourceTextTranslationEntity.d.ts

@@ -0,0 +1,29 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import { EntityHidingLevel, EntityKind, PackageEntity, ParameterEntity, Tag, TextTranslationEntity, TextTranslationEntityDefinition, Translation } from '../../index.js';
+export declare class TextTranslationDeclarationEntity implements TextTranslationEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.TextTranslation;
+    private readonly key;
+    private readonly text;
+    private readonly textFragments;
+    private readonly parameters;
+    private readonly comment;
+    constructor(analyzer: Analyzer, node: tree.TextTranslationSource);
+    isTextTemplate(): boolean;
+    getKey(): string;
+    getText(): string;
+    getTextFragments(): readonly string[];
+    getParameters(): readonly ParameterEntity[];
+    getComment(): string | undefined;
+    getContainingPackage(): PackageEntity;
+    getDefinition(): TextTranslationEntityDefinition;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    isHidden(): EntityHidingLevel | undefined;
+    getOriginalEntity(): TextTranslationDeclarationEntity;
+}

package/build/types/entities/source/m/SourceTypeParameterEntity.d.ts

@@ -0,0 +1,30 @@
+import { Analyzer } from '../../../analysis/m/Analyzer.js';
+import { Name, PackageDialect, PackageLocale } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import * as types from '../../../types/index.js';
+import { EntityContainingTypeParameter, EntityHidingLevel, EntityKind, PackageEntity, Tag, Translation, TypeEntityKind, TypeParameterConstraint, TypeParameterEntity, TypeParameterEntityDefinition } from '../../index.js';
+export declare class SourceTypeParameterEntity implements TypeParameterEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Parameter;
+    private readonly name;
+    private readonly definition;
+    private readonly constraint;
+    private readonly default;
+    constructor(analyzer: Analyzer, node: tree.TypeParameterDeclaration);
+    getName(): Name;
+    getConstraint(): TypeParameterConstraint;
+    getDefaultType(): types.Type | undefined;
+    getDefinition(): TypeParameterEntityDefinition;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getContainingEntity(): EntityContainingTypeParameter;
+    getContainingPackage(): PackageEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): TypeParameterEntity;
+}