@artel/artc 0.6.25191

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

@@ -0,0 +1,174 @@
+import { Tag } from '../analysis/Tags.js';
+import { Analyzer } from '../analysis/index.js';
+import { Name } from '../common/index.js';
+import { MethodBlockLiteral, MethodLiteral, NestedMethodDeclaration, PackageMethodDeclaration, TypeMethodDeclaration } from '../tree/index.js';
+import * as types from '../types/index.js';
+import type { PackageEntity } from './index.js';
+import { DefinitionKind, Entity, EntityHidingLevel, EntityKind, ParameterVariableEntity, SubstitutionApplicationMode, TypeMemberEntityContainer, TypeParameterEntity } from './index.js';
+export type MethodEntity = PackageMethodEntity | TypeMethodEntity | NestedMethodEntity;
+export interface PackageMethodEntity extends IMethodEntity {
+    readonly subkind: 'package';
+    getContainingPackage(): PackageEntity;
+}
+export interface TypeMethodEntity extends IMethodEntity {
+    readonly subkind: 'type';
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isModifyingOwningPlainObject(): boolean;
+    isMethodTypeInvokeMethod(): boolean;
+}
+export interface NestedMethodEntity extends IMethodEntity {
+    readonly subkind: 'nested';
+    getContainingEntity(): Entity;
+}
+interface IMethodEntity {
+    readonly kind: EntityKind.Method;
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): MethodEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export type MethodEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: PackageMethodDeclaration | TypeMethodDeclaration | NestedMethodDeclaration | MethodLiteral | MethodBlockLiteral;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export declare class PackageMethodDeclarationEntity implements PackageMethodEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Method;
+    readonly subkind = "package";
+    private readonly _typeParameters;
+    private readonly _valueParameters;
+    constructor(_analyzer: Analyzer, _node: PackageMethodDeclaration);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): MethodEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class TypeMethodDeclarationEntity implements TypeMethodEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Method;
+    readonly subkind = "type";
+    private readonly _typeParameters;
+    private readonly _valueParameters;
+    constructor(_analyzer: Analyzer, _node: TypeMethodDeclaration);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): MethodEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    isMethodTypeInvokeMethod(): boolean;
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isModifyingOwningPlainObject(): boolean;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class NestedMethodDeclarationEntity implements NestedMethodEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Method;
+    readonly subkind = "nested";
+    private readonly _typeParameters;
+    private readonly _valueParameters;
+    constructor(_analyzer: Analyzer, _node: NestedMethodDeclaration);
+    getName(): Name;
+    getContainingEntity(): Entity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): MethodEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class IntrinsicPackageMethodEntity implements PackageMethodEntity {
+    private readonly _name;
+    private readonly _typeParameters;
+    private readonly _valueParameters;
+    private readonly _returnType;
+    private readonly _isAsync;
+    private readonly _isHidden;
+    private readonly _tags;
+    private readonly _containingPackage;
+    readonly kind = EntityKind.Method;
+    readonly subkind = "package";
+    constructor(_name: Name, _typeParameters: readonly TypeParameterEntity[], _valueParameters: readonly ParameterVariableEntity[], _returnType: types.Type, _isAsync: boolean, _isHidden: EntityHidingLevel | undefined, _tags: readonly Tag[], _containingPackage: PackageEntity);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): MethodEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class IntrinsicTypeMethodEntity implements TypeMethodEntity {
+    private readonly _name;
+    private readonly _typeParameters;
+    private readonly _valueParameters;
+    private readonly _returnType;
+    private readonly _isAsync;
+    private readonly _isHidden;
+    private readonly _tags;
+    private readonly _isMethodTypeInvokeMethod;
+    private readonly _container;
+    private readonly _isStatic;
+    private readonly _isRedefinable;
+    private readonly _isRedefined;
+    private readonly _isAbstract;
+    private readonly _isModifyingOwningPlainObject;
+    readonly kind = EntityKind.Method;
+    readonly subkind = "type";
+    constructor(_name: Name, _typeParameters: readonly TypeParameterEntity[], _valueParameters: readonly ParameterVariableEntity[], _returnType: types.Type, _isAsync: boolean, _isHidden: EntityHidingLevel | undefined, _tags: readonly Tag[], _isMethodTypeInvokeMethod: boolean, _container: TypeMemberEntityContainer, _isStatic: boolean, _isRedefinable: boolean, _isRedefined: boolean, _isAbstract: boolean, _isModifyingOwningPlainObject: boolean);
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): MethodEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    isMethodTypeInvokeMethod(): boolean;
+    getContainer(): TypeMemberEntityContainer;
+    isStatic(): boolean;
+    isRedefinable(): boolean;
+    isRedefined(): boolean;
+    isAbstract(): boolean;
+    isModifyingOwningPlainObject(): boolean;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export {};

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

@@ -0,0 +1,98 @@
+import { Tag } from '../analysis/Tags.js';
+import { Analyzer } from '../analysis/index.js';
+import { Name } from '../common/index.js';
+import { AnonymousMethodTypeDeclaration, PackageMethodTypeDeclaration } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { EntityNaming } from './EntityNaming.js';
+import { OriginalTypeEntityMembers } from './TypeEntityMembers.js';
+import type { PackageEntity } from './index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, ParameterVariableEntity, SubstitutionApplicationMode, TypeParameterEntity } from './index.js';
+export type MethodTypeEntity = PackageMethodTypeEntity | AnonymousMethodTypeEntity;
+export interface PackageMethodTypeEntity extends IMethodTypeEntity {
+    readonly subkind: 'package';
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+}
+export interface AnonymousMethodTypeEntity extends IMethodTypeEntity {
+    readonly subkind: 'anonymous';
+    getContainingPackage(): PackageEntity;
+}
+interface IMethodTypeEntity {
+    readonly kind: EntityKind.MethodType;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getMembers(): OriginalTypeEntityMembers;
+    getDefinition(): MethodTypeEntityDefinition;
+    isAsync(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export type MethodTypeEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: PackageMethodTypeDeclaration | AnonymousMethodTypeDeclaration;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export declare class PackageMethodTypeDeclarationEntity implements PackageMethodTypeEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.MethodType;
+    readonly subkind = "package";
+    private readonly _typeParameters;
+    private readonly _valueParameters;
+    private readonly _members;
+    constructor(_analyzer: Analyzer, _node: PackageMethodTypeDeclaration);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getMembers(): OriginalTypeEntityMembers;
+    getDefinition(): MethodTypeEntityDefinition;
+    isAsync(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export declare class AnonymousMethodTypeDeclarationEntity implements AnonymousMethodTypeEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.MethodType;
+    readonly subkind = "anonymous";
+    private readonly _valueParameters;
+    private readonly _members;
+    constructor(_analyzer: Analyzer, _node: AnonymousMethodTypeDeclaration);
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getValueParameters(): readonly ParameterVariableEntity[];
+    getReturnType(): types.Type;
+    getMembers(): OriginalTypeEntityMembers;
+    getDefinition(): MethodTypeEntityDefinition;
+    isAsync(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContainingPackage(): PackageEntity;
+}
+export declare class UnfinishedIntrinsicAnonymousMethodTypeEntity {
+    private readonly _unfinishedValue;
+    get unfinishedValue(): AnonymousMethodTypeEntity;
+    constructor(analyzer: Analyzer, returnType: types.Type, isAsync: boolean, substitutionApplicationMode: SubstitutionApplicationMode, containingPackage: PackageEntity, isHidden: EntityHidingLevel | undefined);
+    finish(typeParameters: readonly TypeParameterEntity[], valueParameters: readonly ParameterVariableEntity[]): AnonymousMethodTypeEntity;
+}
+export declare class UnfinishedIntrinsicPackageMethodTypeEntity {
+    private readonly _unfinishedValue;
+    get unfinishedValue(): PackageMethodTypeEntity;
+    constructor(analyzer: Analyzer, name: Name, returnType: types.Type, isAsync: boolean, substitutionApplicationMode: SubstitutionApplicationMode, containingPackage: PackageEntity, isHidden: EntityHidingLevel | undefined);
+    finish(typeParameters: readonly TypeParameterEntity[], valueParameters: readonly ParameterVariableEntity[]): PackageMethodTypeEntity;
+}
+export {};

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

@@ -0,0 +1,30 @@
+import { Analyzer } from '../analysis/index.js';
+import { Name } from '../common/index.js';
+import type { Identifier } from '../tree/index.js';
+import { PackageImport } from '../tree/index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, PackageEntity } from './index.js';
+export interface PackageAliasEntity {
+    readonly kind: EntityKind.PackageAlias;
+    getName(): Name;
+    getDefinition(): PackageAliasEntityDefinition;
+    getPackage(): PackageEntity | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    getContainingPackage(): PackageEntity;
+}
+type PackageAliasEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: PackageImport;
+};
+export declare class AliasedPackageImportEntity implements PackageAliasEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _alias;
+    readonly kind = EntityKind.PackageAlias;
+    constructor(_analyzer: Analyzer, _node: PackageImport, _alias: Identifier);
+    getName(): Name;
+    getDefinition(): PackageAliasEntityDefinition;
+    getPackage(): PackageEntity | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    getContainingPackage(): PackageEntity;
+}
+export {};

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

@@ -0,0 +1,56 @@
+import { Analyzer } from '../analysis/index.js';
+import { PackageLocale } from '../common/index.js';
+import * as packageMembers from '../entities/PackageMembers.js';
+import type { JavaScriptImplementationConfig, SourcePackage } from '../project/index.js';
+import { PackageName, PlatformKind } from '../project/index.js';
+import { DefinitionKind, EntityKind } from './index.js';
+export interface PackageEntity {
+    readonly kind: EntityKind.Package;
+    getName(): PackageName;
+    getLocale(): PackageLocale;
+    getMembers(): packageMembers.OriginalPackageMembers;
+    isInterface(): InterfacePackageEntityInfo | undefined;
+    getImplementedInterfacePackage(): PackageEntity | undefined;
+    getSupportedPlatforms(): readonly PlatformKind[];
+    getDefinition(): PackageEntityDefinition;
+}
+export type PackageEntityDefinition = {
+    kind: DefinitionKind.Source;
+    package: SourcePackage;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export type InterfacePackageEntityInfo = InterfacePackageEntityInfo.MultiPlatform | InterfacePackageEntityInfo.JavaScript | InterfacePackageEntityInfo.DotNet;
+export declare namespace InterfacePackageEntityInfo {
+    class MultiPlatform {
+        readonly kind = "multi-platform";
+    }
+    class JavaScript {
+        readonly implementation: JavaScriptImplementationConfig;
+        readonly kind = "javascript";
+        constructor(implementation: JavaScriptImplementationConfig);
+    }
+    class DotNet {
+        readonly assemblyName: string;
+        readonly kind = "dotnet";
+        constructor(assemblyName: string);
+    }
+}
+export declare class SourcePackageEntity implements PackageEntity {
+    private readonly _analyzer;
+    private readonly _package;
+    readonly kind = EntityKind.Package;
+    private readonly _members;
+    private readonly _isInterface;
+    private readonly _implementedInterfacePackage;
+    constructor(_analyzer: Analyzer, _package: SourcePackage);
+    getName(): PackageName;
+    getLocale(): PackageLocale;
+    getMembers(): packageMembers.OriginalPackageMembers;
+    isInterface(): InterfacePackageEntityInfo | undefined;
+    getImplementedInterfacePackage(): PackageEntity | undefined;
+    getSupportedPlatforms(): readonly PlatformKind[];
+    getDefinition(): PackageEntityDefinition;
+}

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

@@ -0,0 +1,98 @@
+import { Analyzer } from '../analysis/index.js';
+import { Name } from '../common/index.js';
+import { AliasTypeEntity, EntityHidingLevel, PackageMethodEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageTypeEntity, PackageVariableEntity, PackageVariantTypeEntity, TypeEntity, TypeExtensionEntity, TypeParameterEntity } from '../entities/index.js';
+import * as types from '../types/index.js';
+export declare class OriginalPackageMembers {
+    private readonly _namedMembers;
+    private readonly _typeExtensions;
+    private readonly _membersByUniversalName;
+    private get membersByUniversalName();
+    constructor(_namedMembers: readonly NamedMember[], _typeExtensions: readonly TypeExtensionEntity[]);
+    getNamedMembers(): readonly NamedMember[];
+    getNamedMembersByName(name: Name): readonly NamedMember[];
+    getTypeExtensions(type: TypeEntity): readonly TypeExtensionEntity[];
+}
+export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_variant | TypeDeclaration_method | TypeDeclaration_alias;
+export declare class TypeDeclaration_structured implements ITypeDeclaration {
+    readonly value: PackageStructuredTypeEntity;
+    readonly kind = "structured";
+    constructor(value: PackageStructuredTypeEntity);
+    getName(): Name;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): PackageTypeEntity;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+export declare class TypeDeclaration_variant implements ITypeDeclaration {
+    readonly value: PackageVariantTypeEntity;
+    readonly kind = "variant";
+    constructor(value: PackageVariantTypeEntity);
+    getName(): Name;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): PackageTypeEntity;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+export declare class TypeDeclaration_method implements ITypeDeclaration {
+    readonly value: PackageMethodTypeEntity;
+    readonly kind = "method";
+    constructor(value: PackageMethodTypeEntity);
+    getName(): Name;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): PackageTypeEntity;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+export declare class TypeDeclaration_alias implements ITypeDeclaration {
+    readonly value: AliasTypeEntity;
+    readonly kind = "alias";
+    constructor(value: AliasTypeEntity);
+    getName(): Name;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): PackageTypeEntity;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+interface ITypeDeclaration {
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): PackageTypeEntity;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+export type NamedMember = NamedMember_variable | NamedMember_method | NamedMember_type;
+export declare class NamedMember_variable implements INamedMember {
+    readonly value: PackageVariableEntity;
+    readonly kind = "variable";
+    constructor(value: PackageVariableEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): PackageVariableEntity;
+}
+export declare class NamedMember_method implements INamedMember {
+    readonly value: PackageMethodEntity;
+    readonly kind = "method";
+    constructor(value: PackageMethodEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): PackageMethodEntity;
+}
+export declare class NamedMember_type implements INamedMember {
+    readonly value: TypeDeclaration;
+    readonly kind = "type";
+    constructor(value: TypeDeclaration);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): PackageTypeEntity;
+}
+interface INamedMember {
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+    getEntity(): NamedPackageMemberEntity;
+}
+export type NamedPackageMemberEntity = PackageVariableEntity | PackageMethodEntity | PackageTypeEntity;
+export {};

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

@@ -0,0 +1,78 @@
+import { Analyzer } from '../analysis/index.js';
+import { SetterDeclaration } from '../analysis/NodeTypeUtils.js';
+import { Tag } from '../analysis/Tags.js';
+import { PackageVariableSetterDeclaration, TypeIndexedSetterDeclaration, TypeDereferencedVariableSetterDeclaration, TypeVariableSetterDeclaration } from '../tree/index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, IndexerEntity, PackageVariableEntity, DereferenceOperatorEntity, TypeVariableEntity } from './index.js';
+export interface SetterEntity {
+    readonly kind: EntityKind.Setter;
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}
+export type SetterEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: SetterDeclaration;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export type EntityOwningSetter = PackageVariableEntity | TypeVariableEntity | IndexerEntity | DereferenceOperatorEntity;
+export declare class PackageVariableSetterDeclarationEntity implements SetterEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Setter;
+    constructor(_analyzer: Analyzer, _node: PackageVariableSetterDeclaration);
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}
+export declare class TypeVariableSetterDeclarationEntity implements SetterEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Setter;
+    constructor(_analyzer: Analyzer, _node: TypeVariableSetterDeclaration);
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}
+export declare class TypeIndexedSetterDeclarationEntity implements SetterEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Setter;
+    constructor(_analyzer: Analyzer, _node: TypeIndexedSetterDeclaration);
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}
+export declare class TypeDereferencedVariableSetterDeclarationEntity implements SetterEntity {
+    private readonly _analyzer;
+    private readonly _node;
+    readonly kind = EntityKind.Setter;
+    constructor(_analyzer: Analyzer, _node: TypeDereferencedVariableSetterDeclaration);
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}
+export declare class IntrinsicSetterEntity implements SetterEntity {
+    private readonly _owningEntity;
+    private readonly _isHidden;
+    private readonly _isModifyingPlainObject;
+    readonly kind = EntityKind.Setter;
+    constructor(_owningEntity: EntityOwningSetter, _isHidden: EntityHidingLevel | undefined, _isModifyingPlainObject: boolean);
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+}