@artel/artc 0.6.25191

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

@@ -0,0 +1,830 @@
+import { Localization } from '../analysis/Localization.js';
+import { LocalizationContext, NamedEntity } from '../analysis/LocalizationContext.js';
+import { SubstitutedMethod } from '../analysis/SubstitutedMethod.js';
+import { Analyzer } from '../analysis/index.js';
+import { HelperPhraseKind } from '../common/HelperPhrases.js';
+import { PackageDialect, PackageLocale } from '../common/index.js';
+import { AliasTypeEntity, BinaryOperatorEntity, BinaryOperatorKind, ConstructorEntity, DestructorEntity, Entity, GetterEntity, IndexerEntity, MethodEntity, MethodTypeEntity, NamedTypeEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, DereferenceOperatorEntity, SetterEntity, StructuredTypeEntity, TypeEntity, TypeExtensionEntity, TypeParameterEntity, UnaryOperatorEntity, UnaryOperatorKind, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
+import { KeywordKind } from '../tree/index.js';
+import * as types from '../types/index.js';
+export declare class DisplayService {
+    private readonly _analyzer;
+    private readonly _lctxOrLocale;
+    private readonly _dialect?;
+    constructor(_analyzer: Analyzer | undefined, _lctxOrLocale: LocalizationContext | PackageLocale, _dialect?: PackageDialect | undefined);
+    displayVariableDeclaration(variable: VariableDeclaration): string;
+    displayType(type: types.Type): string;
+    getMethodTypeBodyDisplayParts(type: types.MethodType): MethodTypeBodyDisplayParts;
+    getNamedTypeDisplayParts(type: NamedType): NamedTypeDisplayParts;
+    displayVariantEntity(entity: VariantEntity, localization: Localization): string;
+    displayPackageAliasEntity(entity: PackageAliasEntity): string;
+    displayPackage(package_: PackageEntity): string;
+    displayValueParameterDeclaration(parameter: ValueParameterDeclaration, typeDisplayOptions?: TypeDisplayOptions): string;
+    getValueParameterDeclarationDisplayParts(parameter: ValueParameterDeclaration, typeDisplayOptions?: TypeDisplayOptions): ValueParameterDeclarationDisplayParts;
+    displayMethodDeclaration(method: MethodDeclaration): string;
+    getMethodDeclarationDisplayParts(method: MethodDeclaration): MethodDeclarationDisplayParts;
+    displayConstructorDeclaration(constructor: ConstructorDeclaration): string;
+    getConstructorDeclarationDisplayParts(constructor: ConstructorDeclaration): ConstructorDeclarationDisplayParts;
+    displayDestructorDeclaration(constructor: DestructorDeclaration): string;
+    displayIndexerDeclaration(indexer: IndexerDeclaration): string;
+    getIndexerDeclarationDisplayParts(indexer: IndexerDeclaration): IndexerDeclarationDisplayParts;
+    displayDereferenceOperatorDeclaration(referenceOperator: DereferenceOperatorDeclaration): string;
+    getDereferenceOperatorDeclarationDisplayParts(dereferenceOperator: DereferenceOperatorDeclaration): DereferenceOperatorDeclarationDisplayParts;
+    displayTypeDeclaration(type: TypeDeclaration): string;
+    displayTypeDeclarationEntity(entity: TypeEntity, localization: Localization): string;
+    getTypeDeclarationDisplayParts(type: TypeDeclaration): TypeDeclarationDisplayParts;
+    getTypeDeclarationEntityDisplayParts(entity: TypeEntity, localization: Localization): TypeDeclarationDisplayParts;
+    displayTypeParameterValue(value: TypeParameterValue): string;
+    displayUnaryOperatorDeclaration(operator: UnaryOperatorDeclaration): string;
+    displayBinaryOperatorDeclaration(operator: BinaryOperatorDeclaration): string;
+    displayBinaryOperatorKind(operatorKind: BinaryOperatorKind): string;
+    displayUnaryOperatorKind(operatorKind: UnaryOperatorKind): string;
+    displayGetterEntity(entity: GetterEntity): string;
+    displaySetterEntity(entity: SetterEntity): string;
+    displayTypeExtensionEntity(entity: TypeExtensionEntity): string;
+    displayEntity(entity: Entity, localization?: Localization): string;
+    displayKeyword(kind: KeywordKind): string;
+    displayHelperPhrase(kind: HelperPhraseKind): string;
+    displayEntityName(entity: NamedEntity, localization: Localization | undefined): string;
+    private displayTypeEntityAsUsage;
+    private displayStructuredTypeUsage;
+    private displayVariantTypeUsage;
+    private displayMethodTypeUsage;
+    private displayParameterTypeUsage;
+    private displayAliasTypeUsage;
+    private displayUnionTypeUsage;
+    private displayUnresolvedTypeUsage;
+    private displayTypeInternal;
+    private displayTypeUsageInternal;
+    private displayUnionTypeTypes;
+    private displayTypeMemberContainer;
+    private getEntityName;
+}
+interface TypeDisplayOptions {
+    readonly unionAndAliasTypeDisplayKind: UnionAndAliasTypeDisplayKind;
+    readonly displayFullVersionOfNamedMethodType: boolean;
+}
+declare const enum UnionAndAliasTypeDisplayKind {
+    Full = 0,
+    OnlyOriginalType = 1,
+    OnlyFlattenedUnaliasedTypes = 2
+}
+export type VariableDeclaration = VariableDeclaration_entity | VariableDeclaration_typeMember;
+export declare class VariableDeclaration_entity implements IVariableDeclaration {
+    readonly value: VariableEntity;
+    readonly localization: Localization;
+    readonly kind = "entity";
+    constructor(value: VariableEntity, localization: Localization);
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    getType(): types.Type;
+    isOptionalParameter(): boolean;
+    getTypeMemberContainer(): TypeMemberContainer | undefined;
+}
+export declare class VariableDeclaration_typeMember implements IVariableDeclaration {
+    readonly value: types.Variable;
+    readonly localization: Localization;
+    readonly kind = "type-member";
+    constructor(value: types.Variable, localization: Localization);
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    getType(): types.Type;
+    isOptionalParameter(): boolean;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+interface IVariableDeclaration {
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    getType(): types.Type;
+    isOptionalParameter(): boolean;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+export type MethodDeclaration = MethodDeclaration_entity | MethodDeclaration_typeMember | MethodDeclaration_substitutedMethod;
+export declare class MethodDeclaration_entity implements IMethodDeclaration {
+    readonly kind = "entity";
+    private readonly _typeParameterValues;
+    private readonly _valueParameters;
+    readonly method: MethodEntity;
+    readonly localization: Localization;
+    constructor(method: MethodEntity, localization: Localization);
+    getEntity(): MethodEntity;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+    getTypeMemberContainer(): TypeMemberContainer | undefined;
+}
+export declare class MethodDeclaration_typeMember implements IMethodDeclaration {
+    readonly kind = "type-member";
+    private readonly _typeParameterValues;
+    private readonly _valueParameters;
+    readonly method: types.Method;
+    readonly localization: Localization;
+    constructor(method: types.Method, localization: Localization);
+    getEntity(): MethodEntity;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+export declare class MethodDeclaration_substitutedMethod implements IMethodDeclaration {
+    readonly method: SubstitutedMethod;
+    readonly localization: Localization;
+    readonly kind = "substituted-method";
+    private readonly _typeParameterValues;
+    private readonly _valueParameters;
+    constructor(method: SubstitutedMethod, localization: Localization);
+    getEntity(): MethodEntity;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+interface IMethodDeclaration {
+    getEntity(): MethodEntity;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+export type ConstructorDeclaration = ConstructorDeclaration_entity | ConstructorDeclaration_typeMember;
+export declare class ConstructorDeclaration_entity implements IConstructorDeclaration {
+    readonly kind = "type-member";
+    private readonly _valueParameters;
+    readonly value: ConstructorEntity;
+    readonly localization: Localization;
+    constructor(value: ConstructorEntity, localization: Localization);
+    getType(): TypeContainingConstructorDeclaration;
+    getValueParameters(): readonly ValueParameterDeclaration[];
+}
+export declare class ConstructorDeclaration_typeMember implements IConstructorDeclaration {
+    readonly value: types.Constructor;
+    readonly localization: Localization;
+    readonly kind = "type-member";
+    private readonly _valueParameters;
+    constructor(value: types.Constructor, localization: Localization);
+    getType(): TypeContainingConstructorDeclaration;
+    getValueParameters(): readonly ValueParameterDeclaration[];
+}
+interface IConstructorDeclaration {
+    getType(): TypeContainingConstructorDeclaration;
+    getValueParameters(): readonly ValueParameterDeclaration[];
+}
+type TypeContainingConstructorDeclaration = TypeContainingConstructorDeclaration_entity | TypeContainingConstructorDeclaration_type;
+declare class TypeContainingConstructorDeclaration_entity {
+    readonly value: TypeEntity;
+    readonly kind = "entity";
+    constructor(value: TypeEntity);
+}
+declare class TypeContainingConstructorDeclaration_type {
+    readonly value: types.Type;
+    readonly kind = "type";
+    constructor(value: types.Type);
+}
+export type DestructorDeclaration = DestructorDeclaration_entity | DestructorDeclaration_typeMember;
+export declare class DestructorDeclaration_entity implements IDestructorDeclaration {
+    readonly kind = "entity";
+    private readonly _valueParameters;
+    readonly value: DestructorEntity;
+    readonly localization: Localization;
+    constructor(value: DestructorEntity, localization: Localization);
+    getValueParameters(): readonly ValueParameterDeclaration[];
+}
+export declare class DestructorDeclaration_typeMember implements IDestructorDeclaration {
+    readonly value: types.Destructor;
+    readonly localization: Localization;
+    readonly kind = "type-member";
+    private readonly _valueParameters;
+    constructor(value: types.Destructor, localization: Localization);
+    getValueParameters(): readonly ValueParameterDeclaration[];
+}
+interface IDestructorDeclaration {
+    getValueParameters(): readonly ValueParameterDeclaration[];
+}
+export type DereferenceOperatorDeclaration = DereferenceOperatorDeclaration_entity | DereferenceOperatorDeclaration_typeMember;
+export declare class DereferenceOperatorDeclaration_entity implements IDereferenceOperatorDeclaration {
+    readonly value: DereferenceOperatorEntity;
+    readonly kind = "entity";
+    constructor(value: DereferenceOperatorEntity);
+    getType(): types.Type;
+    getTypeMemberContainer(): TypeMemberContainer | undefined;
+}
+export declare class DereferenceOperatorDeclaration_typeMember implements IDereferenceOperatorDeclaration {
+    readonly value: types.DereferenceOperator;
+    readonly kind = "type-member";
+    constructor(value: types.DereferenceOperator);
+    getType(): types.Type;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+interface IDereferenceOperatorDeclaration {
+    getType(): types.Type;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+export type IndexerDeclaration = IndexerDeclaration_entity | IndexerDeclaration_typeMember;
+export declare class IndexerDeclaration_entity implements IIndexerDeclaration {
+    readonly value: IndexerEntity;
+    readonly localization: Localization;
+    readonly kind = "entity";
+    private readonly _valueParameters;
+    constructor(value: IndexerEntity, localization: Localization);
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getType(): types.Type;
+    getTypeMemberContainer(): TypeMemberContainer | undefined;
+}
+export declare class IndexerDeclaration_typeMember implements IIndexerDeclaration {
+    readonly value: types.Indexer;
+    readonly localization: Localization;
+    readonly kind = "type-member";
+    private readonly _valueParameters;
+    constructor(value: types.Indexer, localization: Localization);
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getType(): types.Type;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+interface IIndexerDeclaration {
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getType(): types.Type;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+export type ValueParameterDeclaration = ValueParameterDeclaration_entity | ValueParameterDeclaration_typeMember | ValueParameterDeclaration_substitutedMethod | ValueParameterDeclaration_matchResultValueParameter | ValueParameterDeclaration_universal;
+export declare class ValueParameterDeclaration_entity implements IValueParameter {
+    readonly value: VariableEntity;
+    readonly localization: Localization;
+    readonly kind = "entity";
+    constructor(value: VariableEntity, localization: Localization);
+    getName(): string;
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    isOptional(): boolean;
+    getType(): types.Type;
+}
+export declare class ValueParameterDeclaration_typeMember implements IValueParameter {
+    readonly value: types.ValueParameter;
+    readonly localization: Localization;
+    readonly kind = "type-member";
+    constructor(value: types.ValueParameter, localization: Localization);
+    getName(): string;
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    isOptional(): boolean;
+    getType(): types.Type;
+}
+export declare class ValueParameterDeclaration_substitutedMethod implements IValueParameter {
+    readonly entity: VariableEntity;
+    readonly type: types.Type;
+    readonly localization: Localization;
+    constructor(entity: VariableEntity, type: types.Type, localization: Localization);
+    getName(): string;
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    isOptional(): boolean;
+    getType(): types.Type;
+}
+export declare class ValueParameterDeclaration_matchResultValueParameter implements IValueParameter {
+    readonly parameter: {
+        entity: VariableEntity;
+        type: types.Type;
+    };
+    readonly localization: Localization;
+    readonly kind = "type-member";
+    constructor(parameter: {
+        entity: VariableEntity;
+        type: types.Type;
+    }, localization: Localization);
+    getName(): string;
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    isOptional(): boolean;
+    getType(): types.Type;
+}
+export declare class ValueParameterDeclaration_universal implements IValueParameter {
+    readonly entity: VariableEntity;
+    readonly type: types.Type;
+    readonly localization: Localization;
+    constructor(entity: VariableEntity, type: types.Type, localization: Localization);
+    getName(): string;
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    isOptional(): boolean;
+    getType(): types.Type;
+}
+interface IValueParameter {
+    getName(): string;
+    getEntity(): VariableEntity;
+    getLocalization(): Localization;
+    isOptional(): boolean;
+    getType(): types.Type;
+}
+export type TypeParameterValue = TypeParameterValue_typeParameter | TypeParameterValue_typeArgument;
+export declare class TypeParameterValue_typeParameter {
+    readonly value: TypeParameterEntity;
+    readonly localization: Localization;
+    readonly kind = "type-parameter";
+    constructor(value: TypeParameterEntity, localization: Localization);
+}
+export declare class TypeParameterValue_typeArgument {
+    readonly value: types.Type;
+    readonly kind = "type-argument";
+    constructor(value: types.Type);
+}
+export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_method | TypeDeclaration_variant | TypeDeclaration_alias | TypeDeclaration_parameter | TypeDeclaration_unresolved;
+export declare class TypeDeclaration_structured implements ITypeDeclaration {
+    readonly value: TypeDeclarationStructured;
+    readonly kind = "structured";
+    constructor(value: TypeDeclarationStructured);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+export type TypeDeclarationStructured = TypeDeclarationStructured_entity | TypeDeclarationStructured_type;
+export declare class TypeDeclarationStructured_entity implements ITypeDeclarationStructured {
+    readonly entity: StructuredTypeEntity;
+    readonly localization: Localization;
+    readonly kind = "entity";
+    private readonly _typeParameterValues;
+    constructor(entity: StructuredTypeEntity, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    isAspect(): boolean;
+}
+export declare class TypeDeclarationStructured_type implements ITypeDeclarationStructured {
+    readonly type: types.StructuredType;
+    readonly localization: Localization;
+    readonly kind = "type";
+    private readonly _typeParameterValues;
+    constructor(type: types.StructuredType, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    isAspect(): boolean;
+}
+interface ITypeDeclarationStructured {
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    isAspect(): boolean;
+}
+export declare class TypeDeclaration_method implements ITypeDeclaration {
+    readonly value: TypeDeclarationMethod;
+    readonly kind = "method";
+    constructor(value: TypeDeclarationMethod);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+export type TypeDeclarationMethod = TypeDeclarationMethod_entity | TypeDeclarationMethod_type;
+export declare class TypeDeclarationMethod_entity implements ITypeDeclarationMethod {
+    readonly entity: MethodTypeEntity;
+    readonly localization: Localization;
+    readonly kind = "entity";
+    private readonly _typeParameterValues;
+    private readonly _valueParameters;
+    constructor(entity: MethodTypeEntity, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+}
+export declare class TypeDeclarationMethod_type implements ITypeDeclarationMethod {
+    readonly type: types.MethodType;
+    readonly localization: Localization;
+    readonly kind = "type";
+    private readonly _typeParameterValues;
+    private readonly _valueParameters;
+    constructor(type: types.MethodType, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+}
+interface ITypeDeclarationMethod {
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+    isAsync(): boolean;
+}
+export declare class TypeDeclaration_variant implements ITypeDeclaration {
+    readonly value: TypeDeclarationVariant;
+    readonly kind = "variant";
+    constructor(value: TypeDeclarationVariant);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+export type TypeDeclarationVariant = TypeDeclarationVariant_entity | TypeDeclarationVariant_type;
+export declare class TypeDeclarationVariant_entity implements ITypeDeclarationVariant {
+    readonly entity: VariantTypeEntity;
+    readonly localization: Localization;
+    readonly kind = "entity";
+    private readonly _typeParameterValues;
+    constructor(entity: VariantTypeEntity, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+export declare class TypeDeclarationVariant_type implements ITypeDeclarationVariant {
+    readonly type: types.VariantType;
+    readonly localization: Localization;
+    readonly kind = "type";
+    private readonly _typeParameterValues;
+    constructor(type: types.VariantType, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+interface ITypeDeclarationVariant {
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+export declare class TypeDeclaration_alias implements ITypeDeclaration {
+    readonly value: TypeDeclarationAlias;
+    readonly kind = "alias";
+    constructor(value: TypeDeclarationAlias);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+export type TypeDeclarationAlias = TypeDeclarationAlias_entity | TypeDeclarationAlias_type;
+export declare class TypeDeclarationAlias_entity implements ITypeDeclarationAlias {
+    readonly entity: AliasTypeEntity;
+    readonly localization: Localization;
+    readonly kind = "entity";
+    private readonly _typeParameterValues;
+    constructor(entity: AliasTypeEntity, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getAliasedType(): types.Type;
+}
+export declare class TypeDeclarationAlias_type implements ITypeDeclarationAlias {
+    readonly type: types.AliasType;
+    readonly localization: Localization;
+    readonly kind = "type";
+    private readonly _typeParameterValues;
+    constructor(type: types.AliasType, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getAliasedType(): types.Type;
+}
+interface ITypeDeclarationAlias {
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getAliasedType(): types.Type;
+}
+export declare class TypeDeclaration_parameter implements ITypeDeclaration {
+    readonly entity: TypeParameterEntity;
+    readonly localization: Localization;
+    readonly kind = "parameter";
+    constructor(entity: TypeParameterEntity, localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+export declare class TypeDeclaration_unresolved implements ITypeDeclaration {
+    readonly localization: Localization;
+    readonly kind = "unresolved";
+    constructor(localization: Localization);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+interface ITypeDeclaration {
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getLocalization(): Localization;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+type NamedType = NamedType_method | NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias;
+export declare class NamedType_method implements INamedType {
+    readonly value: PackageMethodTypeEntity;
+    readonly kind = "method";
+    constructor(value: PackageMethodTypeEntity);
+    getEntity(): NamedTypeEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+}
+export declare class NamedType_structured implements INamedType {
+    readonly value: PackageStructuredTypeEntity;
+    readonly kind = "structured";
+    constructor(value: PackageStructuredTypeEntity);
+    getEntity(): NamedTypeEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+}
+export declare class NamedType_typeParameter implements INamedType {
+    readonly value: TypeParameterEntity;
+    readonly kind = "typeParam";
+    constructor(value: TypeParameterEntity);
+    getEntity(): NamedTypeEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+}
+export declare class NamedType_variant implements INamedType {
+    readonly value: PackageVariantTypeEntity;
+    readonly kind = "variant";
+    constructor(value: PackageVariantTypeEntity);
+    getEntity(): NamedTypeEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+}
+export declare class NamedType_alias implements INamedType {
+    readonly value: AliasTypeEntity;
+    readonly kind = "alias";
+    constructor(value: AliasTypeEntity);
+    getEntity(): NamedTypeEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+}
+interface INamedType {
+    getEntity(): NamedTypeEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+}
+export type UnaryOperatorDeclaration = UnaryOperatorDeclaration_entity | UnaryOperatorDeclaration_typeMember;
+export declare class UnaryOperatorDeclaration_entity implements IUnaryOperatorDeclaration {
+    readonly operator: UnaryOperatorEntity;
+    readonly kind = "entity";
+    constructor(operator: UnaryOperatorEntity);
+    getOperatorKind(): UnaryOperatorKind;
+    getOperandType(): types.Type;
+    getResultType(): types.Type;
+    getTypeMemberContainer(): TypeMemberContainer | undefined;
+}
+export declare class UnaryOperatorDeclaration_typeMember implements IUnaryOperatorDeclaration {
+    readonly operator: types.UnaryOperator;
+    readonly kind = "typeMember";
+    constructor(operator: types.UnaryOperator);
+    getOperatorKind(): UnaryOperatorKind;
+    getOperandType(): types.Type;
+    getResultType(): types.Type;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+interface IUnaryOperatorDeclaration {
+    getOperatorKind(): UnaryOperatorKind;
+    getOperandType(): types.Type;
+    getResultType(): types.Type;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+export type BinaryOperatorDeclaration = BinaryOperatorDeclaration_entity | BinaryOperatorDeclaration_typeMember;
+export declare class BinaryOperatorDeclaration_entity implements IBinaryOperatorDeclaration {
+    readonly operator: BinaryOperatorEntity;
+    readonly kind = "entity";
+    constructor(operator: BinaryOperatorEntity);
+    getOperatorKind(): BinaryOperatorKind;
+    getLeftOperandType(): types.Type;
+    getRightOperandType(): types.Type;
+    getResultType(): types.Type;
+    getTypeMemberContainer(): TypeMemberContainer | undefined;
+}
+export declare class BinaryOperatorDeclaration_typeMember implements IBinaryOperatorDeclaration {
+    readonly operator: types.BinaryOperator;
+    readonly kind = "type-member";
+    constructor(operator: types.BinaryOperator);
+    getOperatorKind(): BinaryOperatorKind;
+    getLeftOperandType(): types.Type;
+    getRightOperandType(): types.Type;
+    getResultType(): types.Type;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+interface IBinaryOperatorDeclaration {
+    getOperatorKind(): BinaryOperatorKind;
+    getLeftOperandType(): types.Type;
+    getRightOperandType(): types.Type;
+    getResultType(): types.Type;
+    getTypeMemberContainer(analyzer: Analyzer | undefined): TypeMemberContainer | undefined;
+}
+export type TypeUsage = StructuredTypeUsage | VariantTypeUsage | MethodTypeUsage | AliasTypeUsage | ParameterTypeUsage | UnionTypeUsage | UnresolvedTypeUsage;
+export type StructuredTypeUsage = StructuredTypeUsage_type | StructuredTypeUsage_entity;
+export declare class StructuredTypeUsage_type implements IStructuredTypeUsage {
+    readonly type: types.StructuredType;
+    readonly kind = "structured";
+    constructor(type: types.StructuredType);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+export declare class StructuredTypeUsage_entity implements IStructuredTypeUsage {
+    readonly entity: StructuredTypeEntity;
+    readonly kind = "structured";
+    constructor(entity: StructuredTypeEntity);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+interface IStructuredTypeUsage {
+    readonly kind: 'structured';
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+}
+type StructuredTypeKind = 'ref-object' | 'plain-object' | 'aspect';
+export type VariantTypeUsage = VariantTypeUsage_type | VariantTypeUsage_entity;
+export declare class VariantTypeUsage_type implements IVariantTypeUsage {
+    readonly type: types.VariantType;
+    readonly kind = "variant";
+    constructor(type: types.VariantType);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+}
+export declare class VariantTypeUsage_entity implements IVariantTypeUsage {
+    readonly entity: VariantTypeEntity;
+    readonly kind = "variant";
+    constructor(entity: VariantTypeEntity);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+}
+interface IVariantTypeUsage {
+    readonly kind: 'variant';
+    ifNamedThenEntity(): NamedTypeEntity | 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);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    isAsync(): boolean;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+}
+export declare class MethodTypeUsage_entity implements IMethodTypeUsage {
+    readonly entity: MethodTypeEntity;
+    readonly kind = "method";
+    constructor(entity: MethodTypeEntity);
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    isAsync(): boolean;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+}
+interface IMethodTypeUsage {
+    readonly kind: 'method';
+    ifNamedThenEntity(): NamedTypeEntity | undefined;
+    isAsync(): boolean;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getValueParameters(): readonly ValueParameterDeclaration[];
+    getReturnType(): types.Type;
+}
+export type AliasTypeUsage = AliasTypeUsage_type | AliasTypeUsage_entity;
+export declare class AliasTypeUsage_type implements IAliasTypeUsage {
+    readonly type: types.AliasType;
+    readonly kind = "alias";
+    constructor(type: types.AliasType);
+    getEntity(): NamedTypeEntity;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getAliasedType(): types.Type;
+}
+export declare class AliasTypeUsage_entity implements IAliasTypeUsage {
+    readonly entity: AliasTypeEntity;
+    readonly kind = "alias";
+    constructor(entity: AliasTypeEntity);
+    getEntity(): NamedTypeEntity;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getAliasedType(): types.Type;
+}
+interface IAliasTypeUsage {
+    readonly kind: 'alias';
+    getEntity(): NamedTypeEntity;
+    getTypeParameterValues(): readonly TypeParameterValue[];
+    getAliasedType(): types.Type;
+}
+export type ParameterTypeUsage = ParameterTypeUsage_type | ParameterTypeUsage_entity;
+export declare class ParameterTypeUsage_type implements IParameterTypeUsage {
+    readonly type: types.ParameterType;
+    readonly kind = "parameter";
+    constructor(type: types.ParameterType);
+    getEntity(): NamedTypeEntity;
+    isNoneExcluded(): boolean;
+}
+export declare class ParameterTypeUsage_entity implements IParameterTypeUsage {
+    readonly entity: TypeParameterEntity;
+    readonly kind = "parameter";
+    constructor(entity: TypeParameterEntity);
+    getEntity(): NamedTypeEntity;
+    isNoneExcluded(): boolean;
+}
+interface IParameterTypeUsage {
+    readonly kind: 'parameter';
+    getEntity(): NamedTypeEntity;
+    isNoneExcluded(): boolean;
+}
+type UnionTypeUsage = UnionTypeUsage_type;
+declare class UnionTypeUsage_type {
+    readonly type: types.UnionType;
+    readonly kind = "union";
+    constructor(type: types.UnionType);
+    getOriginalTypes(): readonly types.Type[];
+    getUnaliasedFlattenedTypes(): readonly types.Type[];
+}
+type UnresolvedTypeUsage = UnresolvedTypeUsage_type;
+declare class UnresolvedTypeUsage_type {
+    readonly kind = "unresolved";
+}
+declare class TypeMemberContainer {
+    readonly typeUsage: TypeUsage;
+    constructor(typeUsage: TypeUsage);
+}
+export declare class MethodDeclarationDisplayParts {
+    readonly asyncKeywordWithWhitespace: string;
+    readonly operationKeyword: string;
+    readonly whitespaceAfterOperationKeyword: string;
+    readonly container: string;
+    readonly name: string;
+    readonly typeParametersStart: string;
+    readonly typeParameters: readonly string[];
+    readonly typeParameterSeparator: string;
+    readonly typeParametersEnd: string;
+    readonly valueParametersStart: string;
+    readonly valueParameters: readonly ValueParameterDeclarationDisplayParts[];
+    readonly valueParameterSeparator: string;
+    readonly valueParametersEnd: string;
+    readonly returnTypeAnnotationColon: string;
+    readonly returnType: string;
+    constructor(asyncKeywordWithWhitespace: string, operationKeyword: string, whitespaceAfterOperationKeyword: string, container: string, name: string, typeParametersStart: string, typeParameters: readonly string[], typeParameterSeparator: string, typeParametersEnd: string, valueParametersStart: string, valueParameters: readonly ValueParameterDeclarationDisplayParts[], valueParameterSeparator: string, valueParametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
+    toString(): string;
+}
+export declare class ValueParameterDeclarationDisplayParts {
+    readonly name: string;
+    readonly optionalityText: string;
+    readonly colonWithWhitespace: string;
+    readonly type: string;
+    constructor(name: string, optionalityText: string, colonWithWhitespace: string, type: string);
+    toString(): string;
+}
+export declare class TypeDeclarationDisplayParts {
+    readonly typeKeyword: string;
+    readonly whitespaceAfterTypeKeyword: string;
+    readonly name: string;
+    readonly constraint: string;
+    readonly typeParametersStart: string;
+    readonly typeParameters: readonly string[];
+    readonly typeParameterSeparator: string;
+    readonly typeParametersEnd: string;
+    readonly equalsSignWithWhitespace: string;
+    readonly typeBody: string;
+    constructor(typeKeyword: string, whitespaceAfterTypeKeyword: string, name: string, constraint: string, typeParametersStart: string, typeParameters: readonly string[], typeParameterSeparator: string, typeParametersEnd: string, equalsSignWithWhitespace: string, typeBody: string);
+    toString(): string;
+}
+export declare class ConstructorDeclarationDisplayParts {
+    readonly typeText: string;
+    readonly valueParametersStart: string;
+    readonly valueParameters: readonly ValueParameterDeclarationDisplayParts[];
+    readonly valueParameterSeparator: string;
+    readonly valueParametersEnd: string;
+    constructor(typeText: string, valueParametersStart: string, valueParameters: readonly ValueParameterDeclarationDisplayParts[], valueParameterSeparator: string, valueParametersEnd: string);
+    toString(): string;
+}
+export declare class IndexerDeclarationDisplayParts {
+    readonly container: string;
+    readonly valueParametersStart: string;
+    readonly valueParameters: readonly ValueParameterDeclarationDisplayParts[];
+    readonly valueParameterSeparator: string;
+    readonly valueParametersEnd: string;
+    readonly typeAnnotationColon: string;
+    readonly type: string;
+    constructor(container: string, valueParametersStart: string, valueParameters: readonly ValueParameterDeclarationDisplayParts[], valueParameterSeparator: string, valueParametersEnd: string, typeAnnotationColon: string, type: string);
+    toString(): string;
+}
+export declare class DereferenceOperatorDeclarationDisplayParts {
+    readonly container: string;
+    readonly operatorToken: string;
+    readonly typeAnnotationColon: string;
+    readonly type: string;
+    constructor(container: string, operatorToken: string, typeAnnotationColon: string, type: string);
+    toString(): string;
+}
+export declare class NamedTypeDisplayParts {
+    readonly prefix: string;
+    readonly typeParameters: readonly string[];
+    readonly typeParameterSeparator: string;
+    readonly postfix: string;
+    constructor(prefix: string, typeParameters: readonly string[], typeParameterSeparator: string, postfix: string);
+}
+export declare class MethodTypeBodyDisplayParts {
+    readonly asyncKeywordWithWhitespace: string;
+    readonly operationKeyword: string;
+    readonly valueParametersStart: string;
+    readonly valueParameters: readonly ValueParameterDeclarationDisplayParts[];
+    readonly valueParameterSeparator: string;
+    readonly valueParametersEnd: string;
+    readonly returnTypeAnnotationColon: string;
+    readonly returnType: string;
+    constructor(asyncKeywordWithWhitespace: string, operationKeyword: string, valueParametersStart: string, valueParameters: readonly ValueParameterDeclarationDisplayParts[], valueParameterSeparator: string, valueParametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
+    toString(): string;
+}
+export {};