@artel/artc 0.6.25259 → 0.6.25260

package/build/types/analysis/SourcePackageDependencyGraph.d.ts

@@ -2,9 +2,9 @@ import { PlatformKind, SourcePackage } from '../project/index.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
 import { Analyzer } from './Analyzer.js';
 export declare class SourcePackageDependencyGraph {
-    private readonly _analyzer;
-    private readonly _rootPackages;
-    private readonly _nodeByPackage;
+    private readonly analyzer;
+    private readonly rootPackages;
+    private readonly nodeByPackage;
     constructor(analyzer: Analyzer, rootPackages?: readonly SourcePackage[]);
     /**
      * Перечислить все пакеты и их зависимости, включая транзитивные, начиная от корневых пакетов.

package/build/types/analysis/SubstitutedFunction.d.ts

@@ -1,15 +1,15 @@
 import { Name } from '../common/index.js';
 import { FunctionEntity, PackageOrNestedFunctionEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
-import { AccessedFunctionValueParameter } from './AccessedFunction.js';
+import { AccessedFunctionParameter } from './AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
 export type SubstitutedFunction = SubstitutedFunction_entity | SubstitutedFunction_typeMember;
 export declare class SubstitutedFunction_entity implements ISubstitutedFunction {
     readonly entity: PackageOrNestedFunctionEntity;
     readonly substitutions: types.Substitutions;
     readonly kind = "entity";
-    private readonly _signatureType;
-    private readonly _valueParameters;
+    private readonly signatureType;
+    private readonly parameters;
     get debuggerDisplay(): string;
     constructor(entity: PackageOrNestedFunctionEntity, substitutions: types.Substitutions);
     getEntity(): PackageOrNestedFunctionEntity;
@@ -17,7 +17,7 @@ export declare class SubstitutedFunction_entity implements ISubstitutedFunction
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
     getOuterSubstitutions(): types.Substitutions | undefined;
-    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
 }
@@ -25,8 +25,8 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     readonly method: types.Method;
     readonly substitutions: types.Substitutions;
     readonly kind = "type-member";
-    private readonly _signatureType;
-    private readonly _valueParameters;
+    private readonly signatureType;
+    private readonly parameters;
     get debuggerDisplay(): string;
     constructor(method: types.Method, substitutions: types.Substitutions);
     getEntity(): FunctionEntity;
@@ -34,7 +34,7 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
     getOuterSubstitutions(): types.Substitutions | undefined;
-    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
 }
@@ -44,7 +44,7 @@ interface ISubstitutedFunction {
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
     getOuterSubstitutions(): types.Substitutions | undefined;
-    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
 }

package/build/types/analysis/TagMeaning.d.ts

@@ -7,11 +7,11 @@ import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer } from './index.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class Resolver {
-    private readonly _analyzer;
-    private readonly _node;
-    private readonly _semanticContext;
+    private readonly analyzer;
+    private readonly node;
+    private readonly semanticContext_;
     private get semanticContext();
-    constructor(_analyzer: Analyzer, _node: Tag);
+    constructor(analyzer: Analyzer, node: Tag);
     resolve(): ResolutionResult;
     private resolveNameInScope;
     private resolveNameInPackage;

package/build/types/analysis/Tags.d.ts

@@ -1,23 +1,23 @@
-import { ParameterVariableEntity } from '../entities/index.js';
+import { ParameterEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 export type Tag = TagType | TagFunction;
 declare abstract class TagBase {
-    readonly argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>;
-    private readonly _argumentByName;
-    get argumentByOriginalName(): ReadonlyMap<string, TagArgument>;
-    constructor(argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
+    readonly argumentByParameter: ReadonlyMap<ParameterEntity, TagArgument>;
+    private readonly argumentByNameKey_;
+    get argumentByNameKey(): ReadonlyMap<string, TagArgument>;
+    constructor(argumentByParameter: ReadonlyMap<ParameterEntity, TagArgument>);
 }
 export declare class TagType extends TagBase {
     readonly kind = "type";
     readonly type: types.Type;
     readonly constructor_: types.Constructor;
-    constructor(type: types.Type, constructor_: types.Constructor, argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
+    constructor(type: types.Type, constructor_: types.Constructor, argumentByParameter: ReadonlyMap<ParameterEntity, TagArgument>);
 }
 export declare class TagFunction extends TagBase {
     readonly kind = "function";
     readonly func: AccessedFunction;
-    constructor(func: AccessedFunction, argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
+    constructor(func: AccessedFunction, argumentByParameter: ReadonlyMap<ParameterEntity, TagArgument>);
 }
 export type TagArgument = TagArgument_string | TagArgument_numeric | TagArgument_boolean | TagArgument_invalid;
 export declare class TagArgument_string {
@@ -38,4 +38,5 @@ export declare class TagArgument_boolean {
 export declare class TagArgument_invalid {
     readonly kind = "invalid";
 }
+export declare const emptyTags: readonly Tag[];
 export {};

package/build/types/analysis/{Localization.d.ts → Translation.d.ts}

@@ -1,33 +1,11 @@
 import { PackageLocale } from '../common/index.js';
-import { Entity } from '../entities/index.js';
 import { TranslationPackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
-export type Localization = Localization.Original | Localization.Translated;
-export declare namespace Localization {
-    export class Original implements ILocalization {
-        readonly locale: PackageLocale;
-        readonly kind = "original";
-        constructor(locale: PackageLocale);
-        equals(other: Localization): boolean;
-        static ofEntity(entity: Entity): Localization.Original;
-    }
-    export class Translated implements ILocalization {
-        readonly translation: Translation;
-        readonly kind = "translated";
-        get locale(): PackageLocale;
-        constructor(translation: Translation);
-        equals(other: Localization): boolean;
-    }
-    interface ILocalization {
-        readonly locale: PackageLocale;
-        equals(other: Localization): boolean;
-    }
-    export {};
-}
 export declare class Translation {
     readonly translationPackage: AnalyzedTranslationPackage;
     readonly definition: TranslationDefinition;
+    get locale(): PackageLocale;
     constructor(translationPackage: AnalyzedTranslationPackage, definition: TranslationDefinition);
     equals(other: Translation): boolean;
 }

package/build/types/analysis/TypeArgumentInferrer.d.ts

@@ -17,18 +17,18 @@ export declare class ArgumentWithTargetParameterInfo {
     constructor(value: Argument, parameterType: types.Type);
 }
 export declare class TypeArgumentInferrer {
-    private readonly _analyzer;
-    private readonly _typeParameters;
-    private readonly _arguments;
-    private readonly _analysisOptions;
-    private readonly _returnType;
-    private readonly _outerSubstitutions;
-    private readonly _inferenceStates;
+    private readonly analyzer;
+    private readonly typeParameters;
+    private readonly arguments;
+    private readonly analysisOptions;
+    private readonly returnType;
+    private readonly outerSubstitutions;
+    private readonly inferenceStates;
     /**
      * Специальный экземпляр типа, который используется как признак того, что вывод аргументов типа не удался.
      */
-    private readonly _unresolvedType;
-    private _inferenceHasFailed;
+    private readonly unresolvedType;
+    private inferenceHasFailed;
     constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], args: readonly ArgumentWithTargetParameterInfo[], analysisOptions: ExpressionAnalysisOptions, returnType: types.Type | undefined, outerTypeSubstitutions: types.Substitutions | undefined);
     infer(): readonly types.Type[] | undefined;
     private inferFirstStage;

package/build/types/analysis/TypeInferrer.d.ts

@@ -1,10 +1,10 @@
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
 export declare class TypeInferrer {
-    private readonly _analyzer;
-    private _getType;
-    private _typeInferringState;
-    private _hasDetectedInferenceCycle;
+    private readonly analyzer;
+    private getType;
+    private typeInferringState;
+    private hasDetectedInferenceCycle_;
     get hasDetectedInferenceCycle(): boolean;
     constructor(analyzer: Analyzer, getType: () => types.Type);
     inferType(): types.Type;

package/build/types/analysis/TypeMemberConflictsValidator.d.ts

@@ -2,10 +2,10 @@ import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { TypeEntityMembers } from '../entities/TypeEntityMembers.js';
 import { Analyzer } from './Analyzer.js';
 export declare class TypeMemberConflictsValidator {
-    private readonly _analyzer;
-    private readonly _members;
-    private readonly _diagnostics;
-    constructor(_analyzer: Analyzer, _members: TypeEntityMembers, _diagnostics: DiagnosticAcceptor);
+    private readonly analyzer;
+    private readonly members;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, members: TypeEntityMembers, diagnostics: DiagnosticAcceptor);
     validate(): void;
     private validateNamedMembers;
     private validateNamedMembersWithoutIsStaticCheck;

package/build/types/analysis/TypeMemberImplementationChecker.d.ts

@@ -3,9 +3,9 @@ import { TypeEntityWithMembers } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class TypeMemberImplementationChecker {
-    private readonly _analyzer;
-    private readonly _typeEntity;
-    constructor(_analyzer: Analyzer, _typeEntity: TypeEntityWithMembers);
+    private readonly analyzer;
+    private readonly typeEntity;
+    constructor(analyzer: Analyzer, typeEntity: TypeEntityWithMembers);
     check(): TypeMemberImplementationCheckResult;
 }
 export declare class TypeMemberImplementationCheckResult {

package/build/types/analysis/TypeMemberLookup.d.ts

@@ -4,9 +4,9 @@ import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { SemanticContext } from './semantic-context/SemanticContext.js';
 export declare class TypeMemberLookup {
-    private readonly _analyzer;
-    private readonly _typeOrExtension;
-    private readonly _contextLocale;
+    private readonly analyzer;
+    private readonly typeOrExtension;
+    private readonly contextLocale;
     private constructor();
     static ofType(analyzer: Analyzer, type: types.Type, contextLocale: PackageLocale | undefined): TypeMemberLookup;
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, contextLocale: PackageLocale | undefined): TypeMemberLookup;
@@ -21,10 +21,10 @@ export declare class TypeMemberLookup {
     getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.DereferenceOperator[];
 }
 export declare class BoundTypeMemberLookup {
-    private readonly _lookup;
-    private readonly _options;
-    private readonly _hidingMatcher;
-    private readonly _typeExtensionLookup;
+    private readonly lookup;
+    private readonly options;
+    private readonly hidingMatcher;
+    private readonly typeExtensionLookup;
     private constructor();
     static ofType(analyzer: Analyzer, type: types.Type, contextLocale: PackageLocale | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, contextLocale: PackageLocale | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;

package/build/types/analysis/TypeNarrower.d.ts

@@ -4,13 +4,13 @@ import { Analyzer } from './Analyzer.js';
 import * as controlFlow from './control-flow/index.js';
 import { NarrowableReference } from './control-flow/index.js';
 export declare class TypeNarrower {
-    private readonly _analyzer;
-    private readonly _reference;
-    private readonly _initialType;
-    private readonly _locale;
-    private readonly _controlFlowNode;
-    private readonly _typeByNode;
-    private readonly _isVariableAssignedInLoopCheckResults;
+    private readonly analyzer;
+    private readonly reference;
+    private readonly initialType;
+    private readonly locale;
+    private readonly controlFlowNode;
+    private readonly typeByNode;
+    private readonly isVariableAssignedInLoopCheckResults;
     constructor(analyzer: Analyzer, reference: NarrowableReference, locale: PackageLocale, initialType: types.Type, controlFlowNode: controlFlow.Node);
     static getTypeOfExpression(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node): types.Type;
     getType(): types.Type;

package/build/types/analysis/UserDefinableBinaryOperatorResolver.d.ts

@@ -21,12 +21,12 @@ import { Analyzer } from './index.js';
  * 5. Если ни один оператор не подошёл - алгоритм завершается с соответствующим сообщением об ошибке.
  */
 export declare class UserDefinableBinaryOperatorResolver {
-    private readonly _analyzer;
-    private readonly _left;
-    private readonly _right;
-    private readonly _operatorKind;
-    private readonly _operatorNodeForDiagnostic;
-    constructor(_analyzer: Analyzer, _left: tree.Expression, _right: tree.Expression, _operatorKind: BinaryOperatorKind, _operatorNodeForDiagnostic: tree.Node);
+    private readonly analyzer;
+    private readonly left;
+    private readonly right;
+    private readonly operatorKind;
+    private readonly operatorNodeForDiagnostic;
+    constructor(analyzer: Analyzer, left: tree.Expression, right: tree.Expression, operatorKind: BinaryOperatorKind, operatorNodeForDiagnostic: tree.Node);
     resolve(): WithDiagnostics<types.Operator>;
     private chooseSuitableOperators;
 }

package/build/types/analysis/UserDefinableUnaryOperatorResolver.d.ts

@@ -14,9 +14,9 @@ import { Analyzer } from './index.js';
  *    Если не подошёл ни один - алгоритм завершается с соответствующим сообщением об ошибке.
  */
 export declare class UserDefinableUnaryOperatorResolver {
-    private readonly _analyzer;
-    private readonly _node;
+    private readonly analyzer;
+    private readonly node;
     private get operatorKind();
-    constructor(_analyzer: Analyzer, _node: tree.PrefixUnaryExpression);
+    constructor(analyzer: Analyzer, node: tree.PrefixUnaryExpression);
     resolve(): WithDiagnostics<types.Operator>;
 }

package/build/types/analysis/Utils.d.ts

@@ -1,4 +1,4 @@
-import { Entity, FunctionEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
+import { Entity, FunctionEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
@@ -11,7 +11,6 @@ export declare function getParentGenericSpecializationExpression(expression: tre
 export declare function getGenericSpecializationExpressionOfCallee(callee: tree.Expression): tree.GenericSpecializationExpression | undefined;
 export declare function unaliasType(type: types.Type): types.Type;
 export declare function unaliasType(type: types.Type | undefined): types.Type | undefined;
-export declare function getPackageContainingEntity(entity: Entity): PackageEntity;
 export declare function findTag(tagTypeEntity: StructuredTypeEntity, tags: readonly Tag[]): TagType | undefined;
 export declare function findTag(tagFunctionEntity: FunctionEntity, tags: readonly Tag[]): TagFunction | undefined;
 export declare function getRequiredTypeParameterCount(typeParameters: readonly TypeParameterEntity[]): number;

package/build/types/analysis/WellKnownDeclarations.d.ts

@@ -38,38 +38,38 @@ export interface WellKnownDeclarations {
     readonly javaScriptDecorator: StructuredTypeEntity;
 }
 export declare class LocalizedWellKnownDeclarations implements WellKnownDeclarations {
-    private readonly _analyzer;
-    private readonly _locale;
-    private _refObject;
-    private _plainObject;
-    private _number;
-    private _integer;
-    private _text;
-    private _textTemplate;
-    private _char;
-    private _yesNo;
-    private _null;
-    private _enumerable;
-    private _enumerator;
-    private _enumeratorMethod;
-    private _array;
-    private _readonlyArray;
-    private _map;
-    private _readonlyMap;
-    private _set;
-    private _readonlySet;
-    private _measure;
-    private _reference;
-    private _task;
-    private _error;
-    private _func;
-    private _parameterArray;
-    private _defaultImport;
-    private _realName;
-    private _builtIntoPlatform;
-    private _fieldProxy;
-    private _javaScriptDecorator;
-    constructor(_analyzer: Analyzer, _locale: PackageLocale);
+    private readonly analyzer;
+    private readonly locale;
+    private refObject_;
+    private plainObject_;
+    private number_;
+    private integer_;
+    private text_;
+    private textTemplate_;
+    private char_;
+    private yesNo_;
+    private null_;
+    private enumerable_;
+    private enumerator_;
+    private enumeratorMethod_;
+    private array_;
+    private readonlyArray_;
+    private map_;
+    private readonlyMap_;
+    private set_;
+    private readonlySet_;
+    private measure_;
+    private reference_;
+    private task_;
+    private error_;
+    private func_;
+    private parameterArray_;
+    private defaultImport_;
+    private realName_;
+    private builtIntoPlatform_;
+    private fieldProxy_;
+    private javaScriptDecorator_;
+    constructor(analyzer: Analyzer, locale: PackageLocale);
     get refObject(): StructuredTypeEntity;
     get plainObject(): StructuredTypeEntity;
     get number(): StructuredTypeEntity;

package/build/types/analysis/control-flow/GraphBuilder.d.ts

@@ -4,17 +4,17 @@ import { SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
 import { NarrowableReferenceExpression } from './NarrowableExpression.js';
 import { Node } from './Nodes.js';
 export declare class GraphBuilder {
-    private readonly _sourceFile;
-    private readonly _controlFlowNodeByReference;
-    private readonly _controlFlowNodesEndingSubprogram;
-    private readonly _unreachableCodeDiagnostics;
-    private _isInRebuildingFinallyClauseGraphMode;
-    private _currentPredecessor;
-    private _currentContinueLoopTarget;
-    private _currentBreakLoopTarget;
-    private _currentErrorTarget;
-    private _currentReturnTarget;
-    private _currentRangeWithReportedUnreachableCodeDiagnostic;
+    private readonly sourceFile;
+    private readonly controlFlowNodeByReference;
+    private readonly controlFlowNodesEndingSubprogram;
+    private readonly unreachableCodeDiagnostics;
+    private isInRebuildingFinallyClauseGraphMode;
+    private currentPredecessor;
+    private currentContinueLoopTarget;
+    private currentBreakLoopTarget;
+    private currentErrorTarget;
+    private currentReturnTarget;
+    private currentRangeWithReportedUnreachableCodeDiagnostic;
     constructor(sourceFile: SourceFile);
     build(): GraphBuildResult;
     private visitNode;

package/build/types/analysis/control-flow/NarrowableReference.d.ts

@@ -1,45 +1,45 @@
-import { FieldEntity, LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity, TextTemplateParameterVariableEntity } from '../../entities/VariableEntity.js';
+import { FieldEntity, LocalVariableEntity, PackageVariableEntity, ParameterEntity, TextTemplateParameterEntity } from '../../entities/VariableEntity.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { NarrowableReferenceExpression } from '../control-flow/NarrowableExpression.js';
 export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.InstanceField | NarrowableReference.StaticField | NarrowableReference.ObjectAutoVariable;
 export declare namespace NarrowableReference {
     export class LocalVariable implements INarrowableReference {
-        private readonly _analyzer;
-        readonly entity: LocalVariableEntity | ParameterVariableEntity | TextTemplateParameterVariableEntity;
+        private readonly analyzer;
+        readonly entity: LocalVariableEntity | ParameterEntity | TextTemplateParameterEntity;
         readonly kind = "local-variable";
-        constructor(_analyzer: Analyzer, entity: LocalVariableEntity | ParameterVariableEntity | TextTemplateParameterVariableEntity);
+        constructor(analyzer: Analyzer, entity: LocalVariableEntity | ParameterEntity | TextTemplateParameterEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;
         containsExpression(_expression: NarrowableReferenceExpression): boolean;
     }
     export class PackageVariable implements INarrowableReference {
-        private readonly _analyzer;
+        private readonly analyzer;
         readonly entity: PackageVariableEntity;
         readonly kind = "package-variable";
-        constructor(_analyzer: Analyzer, entity: PackageVariableEntity);
+        constructor(analyzer: Analyzer, entity: PackageVariableEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;
         containsExpression(_expression: NarrowableReferenceExpression): boolean;
     }
     export class InstanceField implements INarrowableReference {
-        private readonly _analyzer;
+        private readonly analyzer;
         readonly field: FieldEntity;
         readonly receiver: NarrowableReference;
         readonly kind = "instance-field";
-        constructor(_analyzer: Analyzer, field: FieldEntity, receiver: NarrowableReference);
+        constructor(analyzer: Analyzer, field: FieldEntity, receiver: NarrowableReference);
         equals(other: NarrowableReference): boolean;
         contains(other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;
         containsExpression(expression: NarrowableReferenceExpression): boolean;
     }
     export class StaticField implements INarrowableReference {
-        private readonly _analyzer;
+        private readonly analyzer;
         readonly field: FieldEntity;
         readonly kind = "static-field";
-        constructor(_analyzer: Analyzer, field: FieldEntity);
+        constructor(analyzer: Analyzer, field: FieldEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
         equalsExpression(expression: NarrowableReferenceExpression): boolean;

package/build/types/analysis/semantic-context/Declarations.d.ts

@@ -14,51 +14,27 @@ export declare class NamedDeclaration_function implements INamedDeclaration {
 export type NamedDeclarationFunction = NamedDeclarationFunction_entity | NamedDeclarationFunction_typeMember;
 export declare class NamedDeclarationFunction_entity implements INamedDeclarationFunction {
     readonly kind = "entity";
-    private readonly _valueParameters;
     readonly value: PackageOrNestedFunctionEntity;
     constructor(value: PackageOrNestedFunctionEntity);
     getName(): Name;
     getEntity(): PackageOrNestedFunctionEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
-    getValueParameters(): readonly ValueParameter[];
 }
 export declare class NamedDeclarationFunction_typeMember implements INamedDeclarationFunction {
     readonly kind = "type-member";
-    private readonly _valueParameters;
     readonly value: types.Method;
     constructor(value: types.Method);
     getName(): Name;
     getEntity(): FunctionEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
-    getValueParameters(): readonly ValueParameter[];
 }
 interface INamedDeclarationFunction {
     getName(): Name;
     getEntity(): FunctionEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
-    getValueParameters(): readonly ValueParameter[];
-}
-export type ValueParameter = ValueParameter_entity | ValueParameter_typeMember;
-export declare class ValueParameter_entity implements IValueParameter {
-    readonly value: VariableEntity;
-    readonly kind = "entity";
-    constructor(value: VariableEntity);
-    getName(): Name;
-    getType(): types.Type;
-}
-export declare class ValueParameter_typeMember implements IValueParameter {
-    readonly value: types.ValueParameter;
-    readonly kind = "type-member";
-    constructor(value: types.ValueParameter);
-    getName(): Name;
-    getType(): types.Type;
-}
-interface IValueParameter {
-    getName(): Name;
-    getType(): types.Type;
 }
 export declare class NamedDeclaration_variable implements INamedDeclaration {
     readonly value: NamedDeclarationVariable;

package/build/types/analysis/semantic-context/FieldWithInitializerSemanticContext.d.ts

@@ -10,8 +10,8 @@ export declare class FieldWithInitializerSemanticContext extends SemanticContext
     readonly kind = "field-initializer";
     readonly outer: SemanticContextContainingTypeMember;
     protected readonly asContext: SemanticContext;
-    private readonly _analyzer;
-    private readonly _node;
+    private readonly analyzer;
+    private readonly node;
     constructor(analyzer: Analyzer, node: tree.FieldDeclaration, outer: SemanticContextContainingTypeMember);
     isStatic(): boolean;
     getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];