@artel/artc 0.6.25224 → 0.6.25226

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

@@ -3,10 +3,10 @@ import { ConstructorEntity } from './ConstructorEntity.js';
 import { DereferenceOperatorEntity } from './DereferenceOperatorEntity.js';
 import { DestructorEntity } from './DestructorEntity.js';
 import { IndexerEntity } from './IndexerEntity.js';
-import { TypeMethodEntity } from './MethodEntity.js';
+import { MethodEntity } from './FunctionEntity.js';
 import { OperatorEntity } from './OperatorEntity.js';
 import { OperatorKind } from './OperatorKind.js';
-import { TypeVariableEntity } from './VariableEntity.js';
+import { FieldEntity } from './VariableEntity.js';
 export declare class OriginalTypeEntityMembers {
     private readonly _namedMembers;
     private readonly _operators;
@@ -28,4 +28,4 @@ export declare class OriginalTypeEntityMembers {
     getConstructors(): readonly ConstructorEntity[];
     getDestructors(): readonly DestructorEntity[];
 }
-export type NamedTypeMemberEntity = TypeVariableEntity | TypeMethodEntity;
+export type NamedTypeMemberEntity = FieldEntity | MethodEntity;

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

@@ -3,7 +3,7 @@ import { Tag } from '../analysis/Tags.js';
 import { Name } from '../common/index.js';
 import { TypeParameterDeclaration } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AliasTypeEntity, DefinitionKind, EntityHidingLevel, EntityKind, ITypeEntity, MethodEntity, MethodTypeEntity, StructuredTypeEntity, TypeEntityKind, VariantTypeEntity } from './index.js';
+import { AliasTypeEntity, DefinitionKind, EntityHidingLevel, EntityKind, ITypeEntity, FunctionEntity, FunctionTypeEntity, StructuredTypeEntity, TypeEntityKind, VariantTypeEntity } from './index.js';
 export interface TypeParameterEntity extends ITypeEntity {
     readonly kind: EntityKind.Type;
     readonly typeEntityKind: TypeEntityKind.Parameter;
@@ -27,7 +27,7 @@ export type TypeParameterEntityDefinition = {
 } | {
     kind: DefinitionKind.TypeScript;
 };
-export type EntityContainingTypeParameter = VariantTypeEntity | MethodEntity | MethodTypeEntity | StructuredTypeEntity | AliasTypeEntity;
+export type EntityContainingTypeParameter = VariantTypeEntity | FunctionEntity | FunctionTypeEntity | StructuredTypeEntity | AliasTypeEntity;
 /**
  * Класс позволяет работать с ограничением параметра шаблона, исключая циклы.
  *

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

@@ -1,17 +1,17 @@
 import { Tag } from '../analysis/Tags.js';
 import { Analyzer } from '../analysis/index.js';
 import { Lazy, Name } from '../common/index.js';
-import { EnumerationVariableDeclaration, ErrorVariableDeclaration, LocalVariableDeclaration, MethodLiteral, PackageVariableDeclaration, PackageVariableGetterDeclaration, PackageVariableSetterDeclaration, ParameterDeclaration, TypeVariableDeclaration, TypeVariableGetterDeclaration, TypeVariableSetterDeclaration, VariantDeclaration } from '../tree/index.js';
+import { EnumerationVariableDeclaration, ErrorVariableDeclaration, FieldDeclaration, FieldGetterDeclaration, FieldSetterDeclaration, FunctionLiteral, LocalVariableDeclaration, PackageVariableDeclaration, PackageVariableGetterDeclaration, PackageVariableSetterDeclaration, ParameterDeclaration, VariantDeclaration } from '../tree/index.js';
 import * as types from '../types/index.js';
 import type { Entity, IndexerEntity, PackageEntity } from './index.js';
-import { Entity as ActualEntity, ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, GetterEntity, MethodEntity, MethodTypeEntity, OperatorEntity, SetterEntity, TypeMemberEntityContainer } from './index.js';
-export type VariableEntity = PackageVariableEntity | TypeVariableEntity | ParameterVariableEntity | LocalVariableEntity;
+import { Entity as ActualEntity, ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, FunctionEntity, FunctionTypeEntity, GetterEntity, OperatorEntity, SetterEntity, TypeMemberEntityContainer } from './index.js';
+export type VariableEntity = PackageVariableEntity | FieldEntity | ParameterVariableEntity | LocalVariableEntity;
 export interface PackageVariableEntity extends IVariableEntity {
     readonly subkind: 'package';
     getContainingPackage(): PackageEntity;
 }
-export interface TypeVariableEntity extends IVariableEntity {
-    readonly subkind: 'type';
+export interface FieldEntity extends IVariableEntity {
+    readonly subkind: 'field';
     getContainer(): TypeMemberEntityContainer;
     isStatic(): boolean;
     isRedefinable(): boolean;
@@ -42,20 +42,20 @@ interface IVariableEntity {
     isSpecial(): SpecialVariableEntityInfo | undefined;
     getTags(): readonly Tag[];
 }
-export type ParameterVariableEntityContainer = ParameterVariableEntityContainer.Entity | ParameterVariableEntityContainer.MethodLiteral;
+export type ParameterVariableEntityContainer = ParameterVariableEntityContainer.Entity | ParameterVariableEntityContainer.FunctionLiteral;
 export declare namespace ParameterVariableEntityContainer {
     class Entity {
         readonly entity: EntityContainingValueParameter;
         readonly kind = "entity";
         constructor(entity: EntityContainingValueParameter);
     }
-    class MethodLiteral {
-        readonly entityContainingMethod: ActualEntity;
-        readonly kind = "method-literal";
-        constructor(entityContainingMethod: ActualEntity);
+    class FunctionLiteral {
+        readonly entityContainingFunction: ActualEntity;
+        readonly kind = "function-literal";
+        constructor(entityContainingFunction: ActualEntity);
     }
 }
-export type EntityContainingValueParameter = MethodEntity | IndexerEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | SetterEntity | OperatorEntity;
+export type EntityContainingValueParameter = FunctionEntity | IndexerEntity | ConstructorEntity | DestructorEntity | FunctionTypeEntity | SetterEntity | OperatorEntity;
 export type VariableEntityDefinition = {
     kind: DefinitionKind.Source;
     value: SourceVariableEntityDefinition;
@@ -67,18 +67,18 @@ export type VariableEntityDefinition = {
 export type SourceVariableEntityDefinition = SingleSourceVariableEntityDefinition | MultiSourceVariableEntityDefinition;
 export type SingleSourceVariableEntityDefinition = {
     kind: 'single';
-    node: PackageVariableDeclaration | TypeVariableDeclaration | LocalVariableDeclaration | EnumerationVariableDeclaration | ErrorVariableDeclaration | ParameterDeclaration | VariantDeclaration;
+    node: PackageVariableDeclaration | FieldDeclaration | LocalVariableDeclaration | EnumerationVariableDeclaration | ErrorVariableDeclaration | ParameterDeclaration | VariantDeclaration;
 };
 export type MultiSourceVariableEntityDefinition = {
     kind: 'multi';
-    nodes: ReadonlyArray<PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | TypeVariableGetterDeclaration | TypeVariableSetterDeclaration | ParameterDeclaration>;
+    nodes: ReadonlyArray<PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | FieldGetterDeclaration | FieldSetterDeclaration | ParameterDeclaration>;
 };
-export declare class ImplicitMethodBlockParameterSpecialVariableEntityInfo {
+export declare class ImplicitFunctionBlockParameterSpecialVariableEntityInfo {
     readonly targetTypeParameter: types.ValueParameter;
-    readonly kind = "implicit-method-block-parameter";
+    readonly kind = "implicit-function-block-parameter";
     constructor(targetTypeParameter: types.ValueParameter);
 }
-export type SpecialVariableEntityInfo = ResultSpecialVariableEntityInfo | ValueSpecialVariableEntityInfo | BackingSpecialVariableEntityInfo | ImplicitMethodBlockParameterSpecialVariableEntityInfo;
+export type SpecialVariableEntityInfo = ResultSpecialVariableEntityInfo | ValueSpecialVariableEntityInfo | BackingSpecialVariableEntityInfo | ImplicitFunctionBlockParameterSpecialVariableEntityInfo;
 export declare class ResultSpecialVariableEntityInfo {
     readonly kind = "result";
 }
@@ -86,9 +86,9 @@ export declare class ValueSpecialVariableEntityInfo {
     readonly kind = "value";
 }
 export declare class BackingSpecialVariableEntityInfo {
-    readonly computedVariable: PackageVariableEntity | TypeVariableEntity;
+    readonly computedVariable: PackageVariableEntity | FieldEntity;
     readonly kind = "backing";
-    constructor(computedVariable: PackageVariableEntity | TypeVariableEntity);
+    constructor(computedVariable: PackageVariableEntity | FieldEntity);
 }
 export declare class PackageVariableDeclarationEntity implements PackageVariableEntity {
     private readonly _analyzer;
@@ -131,16 +131,16 @@ export declare class ComputedPackageVariableDeclarationEntity implements Package
     isSpecial(): SpecialVariableEntityInfo | undefined;
     getTags(): readonly Tag[];
 }
-export declare class TypeVariableDeclarationEntity implements TypeVariableEntity {
+export declare class FieldDeclarationEntity implements FieldEntity {
     readonly kind = EntityKind.Variable;
-    readonly subkind = "type";
+    readonly subkind = "field";
     private readonly _analyzer;
     private readonly _node;
     private readonly _typeInferrer;
     private readonly _overriddenMembers;
     private readonly _modifierFlags;
     private get modifierFlags();
-    constructor(analyzer: Analyzer, node: TypeVariableDeclaration);
+    constructor(analyzer: Analyzer, node: FieldDeclaration);
     getName(): Name;
     getType(): types.Type;
     getDefinition(): VariableEntityDefinition;
@@ -158,9 +158,9 @@ export declare class TypeVariableDeclarationEntity implements TypeVariableEntity
     getOverriddenMembers(): readonly types.Variable[];
     isVariant(): boolean;
 }
-export declare class ComputedTypeVariableDeclarationEntity implements TypeVariableEntity {
+export declare class ComputedFieldDeclarationEntity implements FieldEntity {
     readonly kind = EntityKind.Variable;
-    readonly subkind = "type";
+    readonly subkind = "field";
     private readonly _analyzer;
     private readonly _getterDeclaration;
     private readonly _setterDeclaration;
@@ -168,7 +168,7 @@ export declare class ComputedTypeVariableDeclarationEntity implements TypeVariab
     private readonly _overriddenMembers;
     private readonly _modifierFlags;
     private get modifierFlags();
-    constructor(analyzer: Analyzer, getterDeclaration: TypeVariableGetterDeclaration | undefined, setterDeclaration: TypeVariableSetterDeclaration | undefined);
+    constructor(analyzer: Analyzer, getterDeclaration: FieldGetterDeclaration | undefined, setterDeclaration: FieldSetterDeclaration | undefined);
     getName(): Name;
     getType(): types.Type;
     getContainer(): TypeMemberEntityContainer;
@@ -186,9 +186,9 @@ export declare class ComputedTypeVariableDeclarationEntity implements TypeVariab
     getOverriddenMembers(): readonly types.Variable[];
     isVariant(): boolean;
 }
-export declare class VariantDeclarationEntity implements TypeVariableEntity {
+export declare class VariantDeclarationEntity implements FieldEntity {
     readonly kind = EntityKind.Variable;
-    readonly subkind = "type";
+    readonly subkind = "field";
     private readonly _analyzer;
     private readonly _node;
     private readonly _variantTypeDeclaration;
@@ -284,7 +284,7 @@ export declare class ParameterDeclarationEntity implements ParameterVariableEnti
     isOptional(): boolean;
     isVariadic(): boolean;
 }
-export declare class TypeIndexerParameterDeclarationEntity implements ParameterVariableEntity {
+export declare class IndexParameterDeclarationEntity implements ParameterVariableEntity {
     private readonly _analyzer;
     private readonly _getterParameterDeclaration;
     private readonly _setterParameterDeclaration;
@@ -307,14 +307,14 @@ export declare class TypeIndexerParameterDeclarationEntity implements ParameterV
     isOptional(): boolean;
     isVariadic(): boolean;
 }
-export declare class MethodLiteralParameterDeclarationEntity implements ParameterVariableEntity {
+export declare class FunctionLiteralParameterDeclarationEntity implements ParameterVariableEntity {
     private readonly _analyzer;
     private readonly _node;
-    private readonly _methodLiteral;
+    private readonly _functionLiteral;
     readonly kind = EntityKind.Variable;
     readonly subkind = "parameter";
     private readonly _parameterIndex;
-    constructor(_analyzer: Analyzer, _node: ParameterDeclaration, _methodLiteral: MethodLiteral);
+    constructor(_analyzer: Analyzer, _node: ParameterDeclaration, _functionLiteral: FunctionLiteral);
     getName(): Name;
     getType(): types.Type;
     getDefinition(): VariableEntityDefinition;
@@ -350,7 +350,7 @@ export declare class IntrinsicPackageVariableEntity implements PackageVariableEn
     getTags(): readonly Tag[];
     getContainingPackage(): PackageEntity;
 }
-export declare class IntrinsicTypeVariableEntity implements TypeVariableEntity {
+export declare class IntrinsicFieldEntity implements FieldEntity {
     private readonly _name;
     private readonly _type;
     private readonly _container;
@@ -364,7 +364,7 @@ export declare class IntrinsicTypeVariableEntity implements TypeVariableEntity {
     private readonly _setter;
     private readonly _overriddenMembers;
     readonly kind = EntityKind.Variable;
-    readonly subkind = "type";
+    readonly subkind = "field";
     constructor(_name: Name, _type: types.Type, _container: TypeMemberEntityContainer, _isStatic: boolean, _isRedefinable: boolean, _isRedefined: boolean, _isAbstract: boolean, _isSpecial: SpecialVariableEntityInfo | undefined, _isHidden: EntityHidingLevel | undefined, _getter: GetterEntity | undefined, _setter: SetterEntity | undefined, _overriddenMembers: readonly types.Variable[]);
     getName(): Name;
     getType(): types.Type;

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

@@ -4,8 +4,8 @@ import { DereferenceOperatorEntity } from './DereferenceOperatorEntity.js';
 import { DestructorEntity } from './DestructorEntity.js';
 import { GetterEntity } from './GetterEntity.js';
 import { IndexerEntity } from './IndexerEntity.js';
-import { MethodEntity, PackageMethodEntity, TypeMethodEntity } from './MethodEntity.js';
-import { MethodTypeEntity, PackageMethodTypeEntity } from './MethodTypeEntity.js';
+import { FunctionEntity, MethodEntity, PackageFunctionEntity } from './FunctionEntity.js';
+import { FunctionTypeEntity, PackageFunctionTypeEntity } from './FunctionTypeEntity.js';
 import { OperatorEntity } from './OperatorEntity.js';
 import { PackageAliasEntity } from './PackageAliasEntity.js';
 import { PackageEntity } from './PackageEntity.js';
@@ -14,7 +14,7 @@ import { PackageStructuredTypeEntity, StructuredTypeEntity } from './StructuredT
 import { TypeEntity } from './TypeEntity.js';
 import { TypeExtensionEntity } from './TypeExtensionEntity.js';
 import { TypeParameterEntity } from './TypeParameterEntity.js';
-import { PackageVariableEntity, TypeVariableEntity, VariableEntity } from './VariableEntity.js';
+import { PackageVariableEntity, FieldEntity, VariableEntity } from './VariableEntity.js';
 import { PackageVariantTypeEntity, VariantTypeEntity } from './VariantTypeEntity.js';
 export * from './AliasTypeEntity.js';
 export * from './ConstructorEntity.js';
@@ -24,8 +24,8 @@ export * from './EntityHiding.js';
 export * from './EntityNaming.js';
 export * from './GetterEntity.js';
 export * from './IndexerEntity.js';
-export * from './MethodEntity.js';
-export * from './MethodTypeEntity.js';
+export * from './FunctionEntity.js';
+export * from './FunctionTypeEntity.js';
 export * from './OperatorEntity.js';
 export * from './OperatorKind.js';
 export * from './PackageAliasEntity.js';
@@ -46,7 +46,7 @@ export declare const enum DefinitionKind {
 }
 export declare const enum EntityKind {
     Variable = 0,
-    Method = 1,
+    Function = 1,
     Type = 2,
     Getter = 3,
     Setter = 4,
@@ -59,23 +59,23 @@ export declare const enum EntityKind {
     TypeExtension = 11,
     Package = 12
 }
-export type Entity = PackageEntity | VariableEntity | VariantTypeEntity | GetterEntity | SetterEntity | MethodEntity | TypeParameterEntity | OperatorEntity | IndexerEntity | DereferenceOperatorEntity | ConstructorEntity | DestructorEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity | TypeExtensionEntity;
-export type PackageTypeEntity = PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageVariantTypeEntity | AliasTypeEntity;
+export type Entity = PackageEntity | VariableEntity | VariantTypeEntity | GetterEntity | SetterEntity | FunctionEntity | TypeParameterEntity | OperatorEntity | IndexerEntity | DereferenceOperatorEntity | ConstructorEntity | DestructorEntity | FunctionTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity | TypeExtensionEntity;
+export type PackageTypeEntity = PackageFunctionTypeEntity | PackageStructuredTypeEntity | PackageVariantTypeEntity | AliasTypeEntity;
 export declare function isPackageTypeEntity(entity: TypeEntity): entity is PackageTypeEntity;
-export type NamedTypeEntity = PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageVariantTypeEntity | AliasTypeEntity | TypeParameterEntity;
-export type TypeEntityWithMembers = MethodTypeEntity | StructuredTypeEntity | VariantTypeEntity | AliasTypeEntity;
+export type NamedTypeEntity = PackageFunctionTypeEntity | PackageStructuredTypeEntity | PackageVariantTypeEntity | AliasTypeEntity | TypeParameterEntity;
+export type TypeEntityWithMembers = FunctionTypeEntity | StructuredTypeEntity | VariantTypeEntity | AliasTypeEntity;
 export declare function isTypeEntityWithMembers(entity: TypeEntity): entity is TypeEntityWithMembers;
 export type TypeOrExtensionEntity = TypeEntity | TypeExtensionEntity;
 export type TypeWithMembersOrExtensionEntity = TypeEntityWithMembers | TypeExtensionEntity;
 export declare function isTypeWithMembersOrExtensionEntity(entity: Entity): entity is TypeWithMembersOrExtensionEntity;
 export declare function isTypeEntity(entity: Entity): entity is TypeEntity;
 export declare function isNamedTypeEntity(entity: TypeEntity): entity is NamedTypeEntity;
-export type PackageMemberEntity = PackageVariableEntity | PackageMethodEntity | PackageTypeEntity | TypeExtensionEntity;
+export type PackageMemberEntity = PackageVariableEntity | PackageFunctionEntity | PackageTypeEntity | TypeExtensionEntity;
 export declare function isPackageMemberEntity(entity: Entity): entity is PackageMemberEntity;
-export type NamedPackageMemberEntity = PackageVariableEntity | PackageMethodEntity | PackageTypeEntity;
-export type EntityWithTags = ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | MethodEntity | VariableEntity | GetterEntity | SetterEntity | TypeEntity | OperatorEntity;
+export type NamedPackageMemberEntity = PackageVariableEntity | PackageFunctionEntity | PackageTypeEntity;
+export type EntityWithTags = ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity | FunctionEntity | VariableEntity | GetterEntity | SetterEntity | TypeEntity | OperatorEntity;
 export declare function isEntityWithTags(entity: Entity): entity is EntityWithTags;
-export type TypeMemberEntity = TypeVariableEntity | TypeMethodEntity | OperatorEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity;
+export type TypeMemberEntity = FieldEntity | MethodEntity | OperatorEntity | ConstructorEntity | DestructorEntity | IndexerEntity | DereferenceOperatorEntity;
 export declare function isTypeMemberEntity(entity: Entity): entity is TypeMemberEntity;
 export declare function entityToStringDecorator<T extends {
     new (...args: any[]): Entity;

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

@@ -50,7 +50,7 @@ export declare class CompletionService {
     private getTopLevelAliasListCompletionItemInfos;
     private getTypeAliasMemberListItemInfos;
     private getOperatorNameItemInfos;
-    private mergeOverloadedMethods;
+    private mergeOverloadedFunctions;
     private removeCompletionItemsWithDuplicateLabels;
     private convertCompletionItemInfos;
     private convertCompletionItemInfo;
@@ -69,23 +69,23 @@ export declare class CompletionItem {
 export declare const enum CompletionItemKind {
     PackageNameSegment = 0,
     PackageAlias = 1,
-    TypeVariable = 2,
-    TypeMethod = 3,
+    Field = 2,
+    Method = 3,
     Operator = 4,
-    TypeIndexer = 5,
-    TypeConstructor = 6,
+    Indexer = 5,
+    Constructor = 6,
     PackageVariable = 7,
-    PackageMethod = 8,
+    PackageFunction = 8,
     LocalVariable = 9,
     ParameterVariable = 10,
-    NestedMethod = 11,
+    NestedFunction = 11,
     Variant = 12,
     RefObjectType = 13,
     PlainObjectType = 14,
     AspectType = 15,
     VariantType = 16,
     TypeParameter = 17,
-    MethodType = 18,
+    FunctionType = 18,
     AliasType = 19,
     InvalidType = 20,
     Keyword = 21,

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

@@ -1,8 +1,8 @@
-import { AccessedMethod } from '../analysis/AccessedMethod.js';
+import { AccessedFunction } from '../analysis/AccessedFunction.js';
 import { PackageNameTreeNode } from '../analysis/ImportedPackageNameTree.js';
 import { Localization } from '../analysis/Localization.js';
 import { LocalizationContext, NamedEntity } from '../analysis/LocalizationContext.js';
-import { SubstitutedMethod } from '../analysis/SubstitutedMethod.js';
+import { SubstitutedFunction } from '../analysis/SubstitutedFunction.js';
 import { Analyzer } from '../analysis/index.js';
 import { HelperPhraseKind } from '../common/HelperPhrases.js';
 import { PackageDialect, PackageLocale } from '../common/index.js';
@@ -16,15 +16,15 @@ export declare class DisplayService {
     constructor(_analyzer: Analyzer | undefined, _lctxOrLocale: LocalizationContext | PackageLocale, _dialect?: PackageDialect | undefined);
     displayVariableDeclaration(variable: VariableDeclaration): string;
     displayType(type: types.Type): string;
-    getMethodTypeBodyDisplayParts(type: types.MethodType): MethodTypeBodyDisplayParts;
+    getFunctionTypeBodyDisplayParts(type: types.FunctionType): FunctionTypeBodyDisplayParts;
     getNamedTypeDisplayParts(type: NamedType): NamedTypeDisplayParts;
     displayPackageAliasEntity(entity: e.PackageAliasEntity): string;
     displayPackage(package_: e.PackageEntity): string;
     displayPackageNameTreeNode(node: PackageNameTreeNode): string;
     displayValueParameterDeclaration(parameter: ValueParameterDeclaration, typeDisplayOptions?: TypeDisplayOptions): string;
     getValueParameterDeclarationDisplayParts(parameter: ValueParameterDeclaration, typeDisplayOptions?: TypeDisplayOptions): ValueParameterDeclarationDisplayParts;
-    displayMethodDeclaration(method: MethodDeclaration): string;
-    getMethodDeclarationDisplayParts(method: MethodDeclaration): MethodDeclarationDisplayParts;
+    displayFunctionDeclaration(func: FunctionDeclaration): string;
+    getFunctionDeclarationDisplayParts(func: FunctionDeclaration): FunctionDeclarationDisplayParts;
     displayOperatorDeclaration(operator: OperatorDeclaration): string;
     getOperatorDeclarationDisplayParts(operator: OperatorDeclaration): OperatorDeclarationDisplayParts;
     displayOperatorKind(kind: e.OperatorKind, locale: PackageLocale): string;
@@ -51,7 +51,7 @@ export declare class DisplayService {
     private displayTypeEntityAsUsage;
     private displayStructuredTypeUsage;
     private displayVariantTypeUsage;
-    private displayMethodTypeUsage;
+    private displayFunctionTypeUsage;
     private displayParameterTypeUsage;
     private displayAliasTypeUsage;
     private displayUnionOrIntersectionTypeUsage;
@@ -64,7 +64,7 @@ export declare class DisplayService {
 }
 interface TypeDisplayOptions {
     readonly unionAndAliasTypeDisplayKind: UnionAndAliasTypeDisplayKind;
-    readonly displayFullVersionOfNamedMethodType: boolean;
+    readonly displayFullVersionOfNamedFunctionType: boolean;
     readonly displayContainer: boolean;
 }
 declare const enum UnionAndAliasTypeDisplayKind {
@@ -104,15 +104,15 @@ interface IVariableDeclaration {
     isOptionalParameter(): boolean;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export type MethodDeclaration = MethodDeclaration_entity | MethodDeclaration_typeMember | MethodDeclaration_substitutedMethod | MethodDeclaration_accessedMethod;
-export declare class MethodDeclaration_entity implements IMethodDeclaration {
+export type FunctionDeclaration = FunctionDeclaration_entity | FunctionDeclaration_typeMember | FunctionDeclaration_substitutedFunction | FunctionDeclaration_accessedFunction;
+export declare class FunctionDeclaration_entity implements IFunctionDeclaration {
     readonly kind = "entity";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    readonly method: e.MethodEntity;
+    readonly func: e.FunctionEntity;
     readonly localization: Localization;
-    constructor(method: e.MethodEntity, localization: Localization);
-    getEntity(): e.MethodEntity;
+    constructor(func: e.FunctionEntity, localization: Localization);
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -120,14 +120,14 @@ export declare class MethodDeclaration_entity implements IMethodDeclaration {
     isAsync(): boolean;
     getContainer(): DeclarationContainer | undefined;
 }
-export declare class MethodDeclaration_typeMember implements IMethodDeclaration {
+export declare class FunctionDeclaration_typeMember implements IFunctionDeclaration {
     readonly kind = "type-member";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    readonly method: types.Method;
+    readonly func: types.Method;
     readonly localization: Localization;
-    constructor(method: types.Method, localization: Localization);
-    getEntity(): e.MethodEntity;
+    constructor(func: types.Method, localization: Localization);
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -135,14 +135,14 @@ export declare class MethodDeclaration_typeMember implements IMethodDeclaration
     isAsync(): boolean;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export declare class MethodDeclaration_substitutedMethod implements IMethodDeclaration {
-    readonly method: SubstitutedMethod;
+export declare class FunctionDeclaration_substitutedFunction implements IFunctionDeclaration {
+    readonly func: SubstitutedFunction;
     readonly localization: Localization;
-    readonly kind = "substituted-method";
+    readonly kind = "substituted-function";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    constructor(method: SubstitutedMethod, localization: Localization);
-    getEntity(): e.MethodEntity;
+    constructor(func: SubstitutedFunction, localization: Localization);
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -150,14 +150,14 @@ export declare class MethodDeclaration_substitutedMethod implements IMethodDecla
     isAsync(): boolean;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export declare class MethodDeclaration_accessedMethod implements IMethodDeclaration {
-    readonly method: AccessedMethod;
+export declare class FunctionDeclaration_accessedFunction implements IFunctionDeclaration {
+    readonly func: AccessedFunction;
     readonly localization: Localization;
-    readonly kind = "accessed-method";
+    readonly kind = "accessed-function";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    constructor(method: AccessedMethod, localization: Localization);
-    getEntity(): e.MethodEntity;
+    constructor(func: AccessedFunction, localization: Localization);
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -165,8 +165,8 @@ export declare class MethodDeclaration_accessedMethod implements IMethodDeclarat
     isAsync(): boolean;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-interface IMethodDeclaration {
-    getEntity(): e.MethodEntity;
+interface IFunctionDeclaration {
+    getEntity(): e.FunctionEntity;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getValueParameters(): readonly ValueParameterDeclaration[];
@@ -262,7 +262,7 @@ interface IIndexerDeclaration {
     getType(): types.Type;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export type ValueParameterDeclaration = ValueParameterDeclaration_entity | ValueParameterDeclaration_typeMember | ValueParameterDeclaration_substitutedMethod | ValueParameterDeclaration_matchResultValueParameter | ValueParameterDeclaration_universal;
+export type ValueParameterDeclaration = ValueParameterDeclaration_entity | ValueParameterDeclaration_typeMember | ValueParameterDeclaration_substitutedFunction | ValueParameterDeclaration_matchResultValueParameter | ValueParameterDeclaration_universal;
 export declare class ValueParameterDeclaration_entity implements IValueParameter {
     readonly value: e.VariableEntity;
     readonly localization: Localization;
@@ -285,7 +285,7 @@ export declare class ValueParameterDeclaration_typeMember implements IValueParam
     isOptional(): boolean;
     getType(): types.Type;
 }
-export declare class ValueParameterDeclaration_substitutedMethod implements IValueParameter {
+export declare class ValueParameterDeclaration_substitutedFunction implements IValueParameter {
     readonly entity: e.VariableEntity;
     readonly type: types.Type;
     readonly localization: Localization;
@@ -343,7 +343,7 @@ export declare class TypeParameterValue_typeArgument {
     readonly kind = "type-argument";
     constructor(value: types.Type);
 }
-export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_method | TypeDeclaration_variant | TypeDeclaration_alias | TypeDeclaration_parameter | TypeDeclaration_unresolved;
+export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_function | TypeDeclaration_variant | TypeDeclaration_alias | TypeDeclaration_parameter | TypeDeclaration_unresolved;
 export declare class TypeDeclaration_structured implements ITypeDeclaration {
     readonly value: TypeDeclarationStructured;
     readonly kind = "structured";
@@ -391,23 +391,23 @@ interface ITypeDeclarationStructured {
     isAspect(): boolean;
     getContainer(): DeclarationContainer | undefined;
 }
-export declare class TypeDeclaration_method implements ITypeDeclaration {
-    readonly value: TypeDeclarationMethod;
-    readonly kind = "method";
-    constructor(value: TypeDeclarationMethod);
+export declare class TypeDeclaration_function implements ITypeDeclaration {
+    readonly value: TypeDeclarationFunction;
+    readonly kind = "function";
+    constructor(value: TypeDeclarationFunction);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
-export type TypeDeclarationMethod = TypeDeclarationMethod_entity | TypeDeclarationMethod_type;
-export declare class TypeDeclarationMethod_entity implements ITypeDeclarationMethod {
-    readonly entity: e.MethodTypeEntity;
+export type TypeDeclarationFunction = TypeDeclarationFunction_entity | TypeDeclarationFunction_type;
+export declare class TypeDeclarationFunction_entity implements ITypeDeclarationFunction {
+    readonly entity: e.FunctionTypeEntity;
     readonly localization: Localization;
     readonly kind = "entity";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    constructor(entity: e.MethodTypeEntity, localization: Localization);
+    constructor(entity: e.FunctionTypeEntity, localization: Localization);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -416,13 +416,13 @@ export declare class TypeDeclarationMethod_entity implements ITypeDeclarationMet
     isAsync(): boolean;
     getContainer(): DeclarationContainer | undefined;
 }
-export declare class TypeDeclarationMethod_type implements ITypeDeclarationMethod {
-    readonly type: types.MethodType;
+export declare class TypeDeclarationFunction_type implements ITypeDeclarationFunction {
+    readonly type: types.FunctionType;
     readonly localization: Localization;
     readonly kind = "type";
     private readonly _typeParameterValues;
     private readonly _valueParameters;
-    constructor(type: types.MethodType, localization: Localization);
+    constructor(type: types.FunctionType, localization: Localization);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -431,7 +431,7 @@ export declare class TypeDeclarationMethod_type implements ITypeDeclarationMetho
     isAsync(): boolean;
     getContainer(): DeclarationContainer | undefined;
 }
-interface ITypeDeclarationMethod {
+interface ITypeDeclarationFunction {
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getLocalization(): Localization;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -544,11 +544,11 @@ interface ITypeDeclaration {
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
-type NamedType = NamedType_method | NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias;
-export declare class NamedType_method implements INamedType {
-    readonly value: e.PackageMethodTypeEntity;
-    readonly kind = "method";
-    constructor(value: e.PackageMethodTypeEntity);
+type NamedType = NamedType_function | NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias;
+export declare class NamedType_function implements INamedType {
+    readonly value: e.PackageFunctionTypeEntity;
+    readonly kind = "function";
+    constructor(value: e.PackageFunctionTypeEntity);
     getEntity(): e.NamedTypeEntity;
     getTypeParameters(): readonly e.TypeParameterEntity[];
 }
@@ -616,7 +616,7 @@ interface IOperatorDeclaration {
     getReturnType(): types.Type;
     getContainer(analyzer: Analyzer | undefined): DeclarationContainer | undefined;
 }
-export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | MethodTypeUsage | AliasTypeUsage | ParameterTypeUsage | UnionOrIntersectionTypeUsage | UnresolvedTypeUsage;
+export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | FunctionTypeUsage | AliasTypeUsage | ParameterTypeUsage | UnionOrIntersectionTypeUsage | UnresolvedTypeUsage;
 export type StructuredTypeUsage = StructuredTypeUsage_type | StructuredTypeUsage_entity;
 export declare class StructuredTypeUsage_type implements IStructuredTypeUsage {
     readonly type: types.StructuredType;
@@ -664,11 +664,11 @@ interface IVariantTypeUsage {
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getContainer(): DeclarationContainer | undefined;
 }
-export type MethodTypeUsage = MethodTypeUsage_type | MethodTypeUsage_entity;
-export declare class MethodTypeUsage_type implements IMethodTypeUsage {
-    readonly type: types.MethodType;
-    readonly kind = "method";
-    constructor(type: types.MethodType);
+export type FunctionTypeUsage = FunctionTypeUsage_type | FunctionTypeUsage_entity;
+export declare class FunctionTypeUsage_type implements IFunctionTypeUsage {
+    readonly type: types.FunctionType;
+    readonly kind = "function";
+    constructor(type: types.FunctionType);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     isAsync(): boolean;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -676,10 +676,10 @@ export declare class MethodTypeUsage_type implements IMethodTypeUsage {
     getReturnType(): types.Type;
     getContainer(): DeclarationContainer | undefined;
 }
-export declare class MethodTypeUsage_entity implements IMethodTypeUsage {
-    readonly entity: e.MethodTypeEntity;
-    readonly kind = "method";
-    constructor(entity: e.MethodTypeEntity);
+export declare class FunctionTypeUsage_entity implements IFunctionTypeUsage {
+    readonly entity: e.FunctionTypeEntity;
+    readonly kind = "function";
+    constructor(entity: e.FunctionTypeEntity);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     isAsync(): boolean;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -687,8 +687,8 @@ export declare class MethodTypeUsage_entity implements IMethodTypeUsage {
     getReturnType(): types.Type;
     getContainer(): DeclarationContainer | undefined;
 }
-interface IMethodTypeUsage {
-    readonly kind: 'method';
+interface IFunctionTypeUsage {
+    readonly kind: 'function';
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     isAsync(): boolean;
     getTypeParameterValues(): readonly TypeParameterValue[];
@@ -776,7 +776,7 @@ declare namespace DeclarationContainer {
         constructor(entity: e.PackageEntity);
     }
 }
-export declare class MethodDeclarationDisplayParts {
+export declare class FunctionDeclarationDisplayParts {
     readonly asyncKeywordWithWhitespace: string;
     readonly functionKeyword: string;
     readonly whitespaceAfterFunctionKeyword: string;
@@ -867,7 +867,7 @@ export declare class NamedTypeDisplayParts {
     readonly postfix: string;
     constructor(prefix: string, typeParameters: readonly string[], typeParameterSeparator: string, postfix: string);
 }
-export declare class MethodTypeBodyDisplayParts {
+export declare class FunctionTypeBodyDisplayParts {
     readonly asyncKeywordWithWhitespace: string;
     readonly functionKeyword: string;
     readonly valueParametersStart: string;