tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/checker-types.d.ts

@@ -0,0 +1,1093 @@
+import type { ProgramLifetime } from '@scriptc/types';
+import type { Node } from './ast.js';
+import { type Symbol, type SymbolTable } from './symbol.js';
+export declare const enum TypeFlags {
+    None = 0,
+    Any = 1,
+    Unknown = 2,
+    Undefined = 4,
+    Null = 8,
+    Void = 16,
+    String = 32,
+    Number = 64,
+    BigInt = 128,
+    Boolean = 256,
+    ESSymbol = 512,
+    StringLiteral = 1024,
+    NumberLiteral = 2048,
+    BigIntLiteral = 4096,
+    BooleanLiteral = 8192,
+    UniqueESSymbol = 16384,
+    /** Always combined with StringLiteral, NumberLiteral, or Union. */
+    EnumLiteral = 32768,
+    /** A numeric enum member with a computed value. */
+    Enum = 65536,
+    NonPrimitive = 131072,
+    Never = 262144,
+    TypeParameter = 524288,
+    Object = 1048576,
+    Index = 2097152,
+    TemplateLiteral = 4194304,
+    StringMapping = 8388608,
+    Substitution = 16777216,
+    IndexedAccess = 33554432,
+    Conditional = 67108864,
+    Union = 134217728,
+    Intersection = 268435456,
+    Reserved1 = 536870912,
+    Reserved2 = 1073741824,
+    AnyOrUnknown = 3,
+    Nullable = 12,
+    Literal = 15360,
+    Unit = 97292,
+    Freshable = 80896,
+    StringOrNumberLiteral = 3072,
+    StringOrNumberLiteralOrUnique = 19456,
+    DefinitelyFalsy = 15388,
+    PossiblyFalsy = 15868,
+    Intrinsic = 393983,
+    StringLike = 12583968,
+    NumberLike = 67648,
+    BigIntLike = 4224,
+    BooleanLike = 8448,
+    EnumLike = 98304,
+    ESSymbolLike = 16896,
+    VoidLike = 20,
+    Primitive = 12713980,
+    DefinitelyNonNullable = 13893600,
+    DisjointDomains = 12812284,
+    UnionOrIntersection = 402653184,
+    StructuredType = 403701760,
+    TypeVariable = 34078720,
+    InstantiableNonPrimitive = 117964800,
+    InstantiablePrimitive = 14680064,
+    Instantiable = 132644864,
+    StructuredOrInstantiable = 536346624,
+    ObjectFlagsType = 403963917,
+    Simplifiable = 102760448,
+    Singleton = 394239,
+    /** Types where narrowing actually narrows. */
+    Narrowable = 536575971,
+    /** Aggregated during union and intersection construction. */
+    IncludesMask = 416808959,
+    IncludesMissingType = 524288,
+    IncludesNonWideningType = 2097152,
+    IncludesWildcard = 33554432,
+    IncludesEmptyObject = 67108864,
+    IncludesInstantiable = 16777216,
+    IncludesConstrainedTypeVariable = 536870912,
+    IncludesError = 1073741824,
+    NotPrimitiveUnion = 286523411
+}
+/** The sign bit, which TypeScript enums can't hold as a positive flag. */
+export declare const typeFlagsReserved3 = -2147483648;
+export declare const enum ObjectFlags {
+    None = 0,
+    Class = 1,
+    Interface = 2,
+    /** A generic type reference. */
+    Reference = 4,
+    Tuple = 8,
+    Anonymous = 16,
+    Mapped = 32,
+    /** An instantiated anonymous or mapped type. */
+    Instantiated = 64,
+    ObjectLiteral = 128,
+    EvolvingArray = 256,
+    ObjectLiteralPatternWithComputedProperties = 512,
+    ReverseMapped = 1024,
+    JsxAttributes = 2048,
+    /** Declared in JS: reads and writes of missing members are allowed. */
+    JSLiteral = 4096,
+    FreshLiteral = 8192,
+    ArrayLiteral = 16384,
+    PrimitiveUnion = 32768,
+    ContainsWideningType = 65536,
+    ContainsObjectOrArrayLiteral = 131072,
+    /** Is or contains anyFunctionType or silentNeverType. */
+    NonInferrableType = 262144,
+    CouldContainTypeVariablesComputed = 524288,
+    CouldContainTypeVariables = 1048576,
+    MembersResolved = 2097152,
+    ClassOrInterface = 3,
+    RequiresWidening = 196608,
+    PropagatingFlags = 458752,
+    InstantiatedMapped = 96,
+    ContainsSpread = 4194304,
+    ObjectRestType = 8388608,
+    InstantiationExpressionType = 16777216,
+    SingleSignatureType = 33554432,
+    IsClassInstanceClone = 67108864,
+    IdenticalBaseTypeCalculated = 134217728,
+    IdenticalBaseTypeExists = 268435456,
+    UnresolvedMembers = 536870912,
+    FromTypeNode = 1073741824,
+    /**
+     * The type keeps the state that is computed lazily in the checker's side tables instead of its
+     * own fields, which stay unset (`sideOf`). Every type with `TSC_TS_SIDE_STATE=1`.
+     */
+    SideState = -2147483648,
+    IsGenericTypeComputed = 4194304,
+    IsGenericObjectType = 8388608,
+    IsGenericIndexType = 16777216,
+    IsGenericType = 25165824,
+    ContainsIntersections = 33554432,
+    IsUnknownLikeUnionComputed = 67108864,
+    IsUnknownLikeUnion = 134217728,
+    IsNeverIntersectionComputed = 33554432,
+    IsNeverIntersection = 67108864,
+    IsConstrainedTypeVariable = 134217728,
+    ObjectTypeKindMask = 50332991
+}
+export declare const enum ElementFlags {
+    None = 0,
+    Required = 1,
+    Optional = 2,
+    Rest = 4,
+    Variadic = 8,
+    Fixed = 3,
+    Variable = 12,
+    NonRequired = 14,
+    NonRest = 11
+}
+export declare const enum SignatureFlags {
+    None = 0,
+    HasRestParameter = 1,
+    HasLiteralTypes = 2,
+    Construct = 4,
+    Abstract = 8,
+    IsInnerCallChain = 16,
+    IsOuterCallChain = 32,
+    IsUntypedSignatureInJSFile = 64,
+    IsNonInferrable = 128,
+    IsSignatureCandidateForOverloadFailure = 256,
+    /** The signature keeps its lazily computed state in the checker's side tables (`signatureSideOf`). */
+    SideState = 512,
+    PropagatingFlags = 335,
+    CallChainFlags = 48
+}
+export declare const enum SignatureKind {
+    Call = 0,
+    Construct = 1
+}
+export declare const enum IndexFlags {
+    None = 0,
+    StringsOnly = 1,
+    NoIndexSignatures = 2,
+    NoReducibleCheck = 4
+}
+export declare const enum AccessFlags {
+    None = 0,
+    IncludeUndefined = 1,
+    NoIndexSignatures = 2,
+    Writing = 4,
+    CacheSymbol = 8,
+    AllowMissing = 16,
+    ExpressionPosition = 32,
+    ReportDeprecated = 64,
+    SuppressNoImplicitAnyError = 128,
+    Contextual = 256,
+    Persistent = 1
+}
+export declare const enum VarianceFlags {
+    Invariant = 0,
+    Covariant = 1,
+    Contravariant = 2,
+    Bivariant = 3,
+    /** An unwitnessed type parameter. */
+    Independent = 4,
+    VarianceMask = 7,
+    /** Relies on structural comparisons not reflected in generic relationships. */
+    Unmeasurable = 8,
+    /** May produce false negatives, never false positives. */
+    Unreliable = 16,
+    AllowsStructuralFallback = 24
+}
+/** `x & y` picks the lesser in False < Unknown < Maybe < True; `x | y` the greater. */
+export declare const enum Ternary {
+    False = 0,
+    Unknown = 1,
+    Maybe = 3,
+    True = -1
+}
+export declare const enum TypePredicateKind {
+    This = 0,
+    Identifier = 1,
+    AssertsThis = 2,
+    AssertsIdentifier = 3
+}
+export declare const enum NodeCheckFlags {
+    None = 0,
+    TypeChecked = 1,
+    UnusedChecked = 2,
+    ContextChecked = 64,
+    EnumValuesComputed = 1024,
+    AssignmentsMarked = 131072,
+    ContainsClassWithPrivateIdentifiers = 1048576,
+    ContainsSuperPropertyInStaticInitializer = 2097152,
+    InCheckIdentifier = 4194304,
+    InitializerIsUndefined = 16777216,
+    InitializerIsUndefinedComputed = 33554432
+}
+export declare const enum CheckMode {
+    Normal = 0,
+    Contextual = 1,
+    Inferential = 2,
+    SkipContextSensitive = 4,
+    SkipGenericFunctions = 8,
+    IsForSignatureHelp = 16,
+    RestBindingElement = 32,
+    TypeOnly = 64,
+    ForceTuple = 128
+}
+export declare const enum TypeFormatFlags {
+    None = 0,
+    NoTruncation = 1,
+    WriteArrayAsGenericType = 2,
+    UseStructuralFallback = 8,
+    WriteTypeArgumentsOfSignature = 32,
+    UseFullyQualifiedType = 64,
+    SuppressAnyReturnType = 256,
+    MultilineObjectLiterals = 1024,
+    WriteClassExpressionAsTypeLiteral = 2048,
+    UseTypeOfFunction = 4096,
+    OmitParameterModifiers = 8192,
+    UseAliasDefinedOutsideCurrentScope = 16384,
+    AllowUniqueESSymbolType = 1048576,
+    AddUndefined = 131072,
+    WriteArrowStyleSignature = 262144,
+    InArrayType = 524288,
+    InElementType = 2097152,
+    InFirstTypeArgument = 4194304,
+    InTypeAlias = 8388608,
+    OmitThisParameter = 33554432,
+    WriteCallStyleSignature = 134217728,
+    UseSingleQuotesForStringLiteralType = 268435456,
+    NoTypeReduction = 536870912
+}
+/** Kinds of the checker's `cachedTypesById` entries, which are keyed by kind and type id (tsgo's CachedTypeKey). */
+export declare const enum CachedTypeKind {
+    LiteralUnionBaseType = 0,
+    IndexType = 1,
+    StringIndexType = 2,
+    EquivalentBaseType = 3,
+    Apparent = 4,
+    Awaited = 5,
+    EvolvingArray = 6,
+    ArrayLiteral = 7,
+    PermissiveInstantiation = 8,
+    RestrictiveInstantiation = 9,
+    RestrictiveTypeParameter = 10,
+    IndexedAccessForReading = 11,
+    IndexedAccessForWriting = 12,
+    Widened = 13,
+    RegularObjectLiteral = 14,
+    PromisedTypeOfPromise = 15,
+    Optional = 16,
+    OptionalProperty = 17
+}
+export declare function cachedTypeKey(kind: CachedTypeKind, id: number): number;
+/** The `cachedTypesByPair` key of two type ids and four bits, or -1 when an id is too large to pack. */
+export declare function cachedTypePairKey(a: number, b: number, bits: number): number;
+/** An alias symbol and its type arguments, for types written through a type alias. */
+export declare class TypeAlias {
+    readonly symbol: Symbol;
+    readonly typeArguments: Type[];
+    constructor(symbol: Symbol, typeArguments: Type[]);
+}
+/**
+ * Values keyed by a list of types, an optional alias and a small tag: the keys `typeListKey(types) +
+ * aliasKey(alias)` plus a suffix spelled, without building them. A lookup takes a number hashing the
+ * parts (`typeListHash`); entries keep their parts, so a match is exact and keys sharing a hash chain.
+ * Like tsgo's hashed type list keys. A list must not change after it keys an entry.
+ *
+ * Entries are numbered in the order they are added: `heads` maps a hash to its first entry, and the
+ * lists and values of the entries are kept in arrays by number. Aliases, tags and the chains of
+ * entries that share a hash get arrays once an entry needs them.
+ */
+export declare class TypeListCache<V> {
+    private heads;
+    private lists;
+    private values;
+    private aliases;
+    private tags;
+    /** The next entry with the same hash, or -1. */
+    private nexts;
+    constructor();
+    get(hash: number, types: readonly Type[], alias: TypeAlias | undefined, tag: number): V | undefined;
+    set(hash: number, types: readonly Type[], alias: TypeAlias | undefined, tag: number, value: V): void;
+    clear(): void;
+    /** The number of the entry with these parts, or -1. */
+    private find;
+    private findFrom;
+}
+/**
+ * One list for each sequence of types that a checker keeps (`Checker.typeLists`): references and
+ * instantiation caches hold the same type arguments in many places, mostly lists of one or two types,
+ * and share one list for them. A list must not change once it is in the table.
+ */
+export declare class TypeListTable {
+    private readonly heads;
+    private readonly lists;
+    /** The next list with the same hash, or -1, once two lists share one. */
+    private nexts;
+    /**
+     * The list in the table with the types of `types`, in order, or `types` itself, which joins the
+     * table. `hash` is `typeListHash(types, undefined, 0)`.
+     */
+    intern(hash: number, types: Type[]): Type[];
+}
+/**
+ * The references to a generic class, interface or tuple type, by the hash of their type arguments
+ * (`createTypeReference`). A reference is its own entry: a lookup compares its type arguments. A
+ * reference whose hash another reference has is kept in `collisions`.
+ */
+export declare class ReferenceCache {
+    private readonly references;
+    private collisions;
+    get(hash: number, typeArguments: readonly Type[]): TypeReference | undefined;
+    /** Adds `reference`, whose type arguments `get` did not find. */
+    add(hash: number, reference: TypeReference): void;
+}
+/**
+ * Fields that few types set, kept out of line in `Type.extra`, which is created on the first write
+ * of a value other than the field's default. A type then costs one slot for all of them. Each field
+ * is read and written through an accessor of the type class it belongs to, which returns the
+ * default while the type has no extra fields. Rare fields that hot paths read stay inline (the
+ * alias, construct signatures): a native accessor returns an owned reference, which costs reference
+ * counting on every read of a counted value.
+ */
+export declare class TypeExtra implements ProgramLifetime {
+    objectTypeWithoutAbstractConstructSignatures: Type | undefined;
+    instantiations: TypeListCache<Type> | undefined;
+    node: Node | undefined;
+    resolvedReducedType: Type | undefined;
+    regularType: Type | undefined;
+    origin: Type | undefined;
+    keyPropertyName: string;
+    constituentMap: Map<Type, Type> | undefined;
+    constituentIds: Int32Array | undefined;
+    membershipTests: number;
+    uniqueLiteralFilledInstantiation: Type | undefined;
+    constructor();
+}
+/** The extra fields of `t`, created if it has none yet. */
+export declare function typeExtra(t: Type): TypeExtra;
+/**
+ * The base of every type. Narrow by `flags` (and `objectFlags` for object types), then cast to
+ * the subclass, as tsgo does with `AsUnionType()` etc.
+ */
+/**
+ * `TSC_TS_SIDE_STATE=1` (a test of the side tables): every type and signature keeps its lazily
+ * computed state in the checker's side tables (`ObjectFlags.SideState`, `SignatureFlags.SideState`).
+ */
+export declare const sideStateForAll: boolean;
+/**
+ * What the methods of types that tsc-ts's public API calls need from the checker that created the type
+ * (`InterfaceType.checking`, `ConditionalType.checking`); the Checker implements it.
+ */
+export interface TypeChecking {
+    baseTypesOf(t: InterfaceType): readonly Type[];
+    trueTypeOf(t: ConditionalType): Type;
+    falseTypeOf(t: ConditionalType): Type;
+}
+export declare class Type implements ProgramLifetime {
+    flags: TypeFlags;
+    objectFlags: ObjectFlags;
+    readonly id: number;
+    symbol: Symbol | undefined;
+    alias: TypeAlias | undefined;
+    /** For types with a computed base constraint (type variables, structured types, …). */
+    resolvedBaseConstraint: Type | undefined;
+    /** Rarely set fields; undefined while all of them have their defaults. */
+    extra: TypeExtra | undefined;
+    constructor(flags: TypeFlags, objectFlags: ObjectFlags, id: number, symbol: Symbol | undefined);
+    getSymbol(): Symbol | undefined;
+    getAliasSymbol(): Symbol | undefined;
+    getAliasTypeArguments(): readonly Type[];
+    /** The target of a type reference, index type or string mapping type. */
+    getTarget(): Type | undefined;
+    /** The members of a union or intersection type, or the types of a template literal type. */
+    getTypes(): readonly Type[];
+    getFreshType(): Type | undefined;
+    getRegularType(): Type | undefined;
+    getObjectType(): Type | undefined;
+    getIndexType(): Type | undefined;
+    getCheckType(): Type | undefined;
+    getExtendsType(): Type | undefined;
+    getTrueType(): Type | undefined;
+    getFalseType(): Type | undefined;
+    /** The base type of a substitution type. */
+    getBaseType(): Type | undefined;
+    /** The constraint of a substitution type. */
+    getConstraint(): Type | undefined;
+    /** The type parameters of a class or interface type, outer and local, without its `this` type. */
+    getTypeParameters(): readonly Type[];
+    getOuterTypeParameters(): readonly Type[];
+    getLocalTypeParameters(): readonly Type[];
+    /** The base types of a class or interface type, or undefined for any other type. */
+    getBaseTypes(): readonly Type[] | undefined;
+    isClassOrInterface(): boolean;
+    isUnionType(): boolean;
+    isIntersectionType(): boolean;
+    isObjectType(): boolean;
+    isIntrinsicType(): boolean;
+    /** Whether this is the error type: an intrinsic type named `error`. */
+    isErrorType(): boolean;
+    isLiteralType(): boolean;
+    isStringLiteralType(): boolean;
+    isNumberLiteralType(): boolean;
+    isBigIntLiteralType(): boolean;
+    isBooleanLiteralType(): boolean;
+    isTypeReference(): boolean;
+    isTupleType(): boolean;
+    isIndexType(): boolean;
+    isIndexedAccessType(): boolean;
+    isConditionalType(): boolean;
+    isSubstitutionType(): boolean;
+    isTemplateLiteralType(): boolean;
+    isStringMappingType(): boolean;
+    isTypeParameter(): boolean;
+}
+export declare class IntrinsicType extends Type {
+    readonly intrinsicName: string;
+    constructor(flags: TypeFlags, objectFlags: ObjectFlags, id: number, intrinsicName: string);
+}
+/**
+ * A literal or enum member type. `value` is the string of string literals, the number of number
+ * literals, `true`/`false` for booleans, the decimal digits (with a leading `-`) of bigints, and
+ * unset for computed enum members.
+ */
+export declare class LiteralType extends Type {
+    readonly stringValue: string;
+    readonly numberValue: number;
+    /** Created on first use, except for `true` and `false`. */
+    freshType: LiteralType | undefined;
+    regularType: LiteralType;
+    constructor(flags: TypeFlags, id: number, symbol: Symbol | undefined, stringValue: string, numberValue: number);
+    /** The value, as TypeScript 7's API gives it: a string, number, bigint or boolean. */
+    get value(): string | number | bigint | boolean;
+}
+export declare class UniqueESSymbolType extends Type {
+    readonly name: string;
+    constructor(id: number, symbol: Symbol, name: string);
+}
+/**
+ * The members table of a type, built when `members` is read (checker-members.ts): of an instantiated
+ * type whose member symbols are instantiated on demand (`PendingInstantiatedMembers`), where reading
+ * `properties` builds the properties too, as tsgo builds them when it resolves the members, and
+ * lookups by name instantiate only the member asked for; or of a type whose members are all
+ * properties (`PropertyMembers`), where lookups by name read the properties.
+ */
+export declare abstract class PendingMembers {
+    /**
+     * Set when `properties` is built and the members table is not (`PropertyMembers`): the type's
+     * properties, which lookups by name then read.
+     */
+    materializedProperties: Symbol[] | undefined;
+    /**
+     * Sets `t.propertiesValue`. Where lookups can read the properties, it replaces `t.pendingMembers`
+     * with a `PropertyMembers`; otherwise it sets `t.membersValue` too and clears `t.pendingMembers`.
+     */
+    abstract materialize(t: StructuredType): void;
+    /** Sets `t.membersValue` and `t.propertiesValue` and clears `t.pendingMembers`. */
+    abstract materializeTable(t: StructuredType): void;
+    /** `members.get(name)` of the table tsgo would have built by now. */
+    abstract get(name: string): Symbol | undefined;
+}
+/**
+ * The property names of instantiated types whose members tables are built on demand, shared by the
+ * instantiations of one source that have the same names in the same order: most instantiations of
+ * a class or interface have the members of their source and of the same bases.
+ */
+export declare class MemberNames {
+    /** The names of the properties, in order. */
+    readonly names: string[];
+    /** The index of each name in `names`. */
+    readonly positions: Map<string, number>;
+    /** The indexes in `names` of the members table's names, in table order. */
+    readonly tableOrder: number[];
+    constructor(names: string[], positions: Map<string, number>, tableOrder: number[]);
+}
+/** A type with members: object types, unions and intersections. */
+export declare class StructuredType extends Type {
+    membersValue: SymbolTable | undefined;
+    propertiesValue: Symbol[];
+    /** Set while the member symbols of an instantiated type are not instantiated yet. */
+    pendingMembers: PendingMembers | undefined;
+    callSignatures: Signature[];
+    constructSignatures: Signature[];
+    indexInfos: IndexInfo[];
+    constructor(flags: TypeFlags, objectFlags: ObjectFlags, id: number, symbol: Symbol | undefined);
+    get objectTypeWithoutAbstractConstructSignatures(): Type | undefined;
+    set objectTypeWithoutAbstractConstructSignatures(t: Type | undefined);
+    get members(): SymbolTable | undefined;
+    set members(members: SymbolTable | undefined);
+    get properties(): Symbol[];
+    set properties(properties: Symbol[]);
+}
+export declare class ObjectType extends StructuredType {
+    /** The generic type this one instantiates. */
+    target: Type | undefined;
+    mapper: TypeMapper | undefined;
+    constructor(objectFlags: ObjectFlags, id: number, symbol: Symbol | undefined);
+    get instantiations(): TypeListCache<Type> | undefined;
+    set instantiations(instantiations: TypeListCache<Type> | undefined);
+}
+/** An instantiation of a generic class, interface or tuple type. */
+export declare class TypeReference extends ObjectType {
+    resolvedTypeArguments: Type[] | undefined;
+    constructor(objectFlags: ObjectFlags, id: number, symbol: Symbol | undefined);
+    /** The type node of a deferred reference, else undefined. */
+    get node(): Node | undefined;
+    set node(node: Node | undefined);
+}
+/** A class or interface; when generic, also the reference to itself instantiated with its own type parameters. */
+export declare class InterfaceType extends TypeReference {
+    /** Outer, then local type parameters, then the `this` type. */
+    allTypeParameters: Type[];
+    outerTypeParameterCount: number;
+    thisType: Type | undefined;
+    baseTypesResolved: boolean;
+    declaredMembersResolved: boolean;
+    resolvedBaseConstructorType: Type | undefined;
+    resolvedBaseTypes: Type[];
+    declaredMembers: SymbolTable | undefined;
+    declaredCallSignatures: Signature[];
+    declaredConstructSignatures: Signature[];
+    declaredIndexInfos: IndexInfo[];
+    /** Positions of the declared members by name, for lazily instantiated members of instantiations. */
+    declaredMemberPositions: Map<string, number> | undefined;
+    /** The member states of the last pending instantiation of the type's members (`sharedStates`). */
+    lastMemberStates: number[] | undefined;
+    /** The property names of the last instantiation whose members table is built on demand. */
+    lastMemberNames: MemberNames | undefined;
+    /** The references to a generic class, interface or tuple type, by their type arguments. */
+    references: ReferenceCache | undefined;
+    /** The checker that created the type, for `getBaseTypes()`. */
+    checking: TypeChecking | undefined;
+    constructor(objectFlags: ObjectFlags, id: number, symbol: Symbol | undefined);
+    outerTypeParameters(): Type[];
+    localTypeParameters(): Type[];
+    typeParameters(): Type[];
+    /** `typeParameters().length`, without copying them. */
+    typeParameterCount(): number;
+}
+export declare class TupleElementInfo {
+    readonly flags: ElementFlags;
+    /** A NamedTupleMember or ParameterDeclaration, if labeled. */
+    readonly labeledDeclaration: Node | undefined;
+    constructor(flags: ElementFlags, labeledDeclaration: Node | undefined);
+}
+export declare class TupleType extends InterfaceType {
+    elementInfos: TupleElementInfo[];
+    /** Required or variadic elements. */
+    minLength: number;
+    /** Leading required or optional elements. */
+    fixedLength: number;
+    combinedFlags: ElementFlags;
+    readonly: boolean;
+    constructor(objectFlags: ObjectFlags, id: number);
+    /** The flags of each element (TypeScript 7's API). */
+    get elementFlags(): ElementFlags[];
+}
+export declare class InstantiationExpressionType extends ObjectType {
+    node: Node | undefined;
+    constructor(objectFlags: ObjectFlags, id: number, symbol: Symbol | undefined);
+}
+export declare class MappedType extends ObjectType {
+    declaration: Node | undefined;
+    typeParameter: Type | undefined;
+    constraintType: Type | undefined;
+    nameType: Type | undefined;
+    templateType: Type | undefined;
+    modifiersType: Type | undefined;
+    resolvedApparentType: Type | undefined;
+    containsError: boolean;
+    constructor(objectFlags: ObjectFlags, id: number, symbol: Symbol | undefined);
+}
+export declare class ReverseMappedType extends ObjectType {
+    source: Type | undefined;
+    mappedType: Type | undefined;
+    constraintType: Type | undefined;
+    constructor(objectFlags: ObjectFlags, id: number);
+}
+export declare class EvolvingArrayType extends ObjectType {
+    elementType: Type | undefined;
+    finalArrayType: Type | undefined;
+    constructor(objectFlags: ObjectFlags, id: number);
+}
+/**
+ * A union or intersection. Few have their members resolved or their properties cached, so those
+ * live in `membersOf` (`UnionOrIntersectionMembers`), which is created when they are first written.
+ */
+export declare class UnionOrIntersectionType extends Type {
+    readonly types: Type[];
+    membersOf: UnionOrIntersectionMembers | undefined;
+    constructor(flags: TypeFlags, objectFlags: ObjectFlags, id: number, types: Type[]);
+}
+/**
+ * The resolved members of a union or intersection (`membersHolder`) and the caches of its
+ * properties, created on first use.
+ */
+export declare class UnionOrIntersectionMembers extends StructuredType {
+    propertyCache: SymbolTable | undefined;
+    propertyCacheWithoutFunctionPropertyAugment: SymbolTable | undefined;
+    resolvedProperties: Symbol[] | undefined;
+    constructor(flags: TypeFlags, id: number);
+}
+/** The members holder of a union or intersection, created if it has none yet. */
+export declare function unionOrIntersectionMembers(t: UnionOrIntersectionType): UnionOrIntersectionMembers;
+/** A union; all of its own fields are rarely set and live in `extra`. */
+export declare class UnionType extends UnionOrIntersectionType {
+    constructor(objectFlags: ObjectFlags, id: number, types: Type[]);
+    get resolvedReducedType(): Type | undefined;
+    set resolvedReducedType(t: Type | undefined);
+    get regularType(): Type | undefined;
+    set regularType(t: Type | undefined);
+    /** The denormalized union, intersection or index type the union came from. */
+    get origin(): Type | undefined;
+    set origin(t: Type | undefined);
+    /** A property with a unique unit type in every object of the union; '' if not computed, '\0' if none. */
+    get keyPropertyName(): string;
+    set keyPropertyName(name: string);
+    get constituentMap(): Map<Type, Type> | undefined;
+    set constituentMap(map: Map<Type, Type> | undefined);
+    /**
+     * A hash table of the ids of a large union's constituents, for membership tests; created on the
+     * second test (`constituentTable`). About eight bytes a constituent, where a set of them took
+     * about five times that.
+     */
+    get constituentIds(): Int32Array | undefined;
+    set constituentIds(ids: Int32Array | undefined);
+    get membershipTests(): number;
+    set membershipTests(tests: number);
+}
+export declare class IntersectionType extends UnionOrIntersectionType {
+    resolvedApparentType: Type | undefined;
+    constructor(objectFlags: ObjectFlags, id: number, types: Type[]);
+    get uniqueLiteralFilledInstantiation(): Type | undefined;
+    set uniqueLiteralFilledInstantiation(t: Type | undefined);
+}
+export declare class TypeParameter extends Type {
+    constraint: Type | undefined;
+    target: Type | undefined;
+    mapper: TypeMapper | undefined;
+    isThisType: boolean;
+    resolvedDefaultType: Type | undefined;
+    constructor(id: number, symbol: Symbol | undefined);
+}
+/** `keyof T`. */
+export declare class IndexType extends Type {
+    readonly target: Type;
+    readonly indexFlags: IndexFlags;
+    constructor(id: number, target: Type, indexFlags: IndexFlags);
+}
+/** `T[K]`. */
+export declare class IndexedAccessType extends Type {
+    readonly objectType: Type;
+    readonly indexType: Type;
+    /** Only AccessFlags.Persistent. */
+    readonly accessFlags: AccessFlags;
+    constructor(id: number, objectType: Type, indexType: Type, accessFlags: AccessFlags);
+}
+export declare class TemplateLiteralType extends Type {
+    /** One longer than `types`. */
+    readonly texts: string[];
+    readonly types: Type[];
+    constructor(id: number, texts: string[], types: Type[]);
+}
+/** `Uppercase<T>` and friends. */
+export declare class StringMappingType extends Type {
+    readonly target: Type;
+    constructor(id: number, symbol: Symbol, target: Type);
+}
+export declare class SubstitutionType extends Type {
+    readonly baseType: Type;
+    /** What the base type is known to satisfy. */
+    readonly constraint: Type;
+    constructor(id: number, baseType: Type, constraint: Type);
+}
+export declare class ConditionalRoot {
+    readonly node: Node;
+    readonly checkType: Type;
+    readonly extendsType: Type;
+    readonly isDistributive: boolean;
+    readonly inferTypeParameters: Type[];
+    readonly outerTypeParameters: Type[];
+    readonly instantiations: TypeListCache<Type>;
+    readonly alias: TypeAlias | undefined;
+    /**
+     * The type arguments of an extends type that is a reference to a class or interface; null for
+     * other extends types, undefined until computed.
+     */
+    referenceArgs: ReferenceArgs | null | undefined;
+    constructor(node: Node, checkType: Type, extendsType: Type, isDistributive: boolean, inferTypeParameters: Type[], outerTypeParameters: Type[], alias: TypeAlias | undefined);
+}
+/** What each type argument of a conditional type's extends type is, for `isFalseForEveryInference`. */
+export declare class ReferenceArgs {
+    readonly kinds: ReferenceArgKind[];
+    /** The `infer` type parameter of each `ReferenceArgKind.Infer` type argument. */
+    readonly inferTypeParameters: (Type | undefined)[];
+    constructor(kinds: ReferenceArgKind[], inferTypeParameters: (Type | undefined)[]);
+}
+export declare const enum ReferenceArgKind {
+    /** Has no `infer` type parameters, so inference doesn't change it. */
+    Fixed = 0,
+    /** Just an `infer` type parameter that occurs nowhere else in the extends type. */
+    Infer = 1,
+    /** An object type with `infer` type parameters: an instantiation of it is an object type. */
+    Object = 2,
+    Other = 3
+}
+export declare class ConditionalType extends Type {
+    readonly root: ConditionalRoot;
+    readonly checkType: Type;
+    readonly extendsType: Type;
+    resolvedTrueType: Type | undefined;
+    resolvedFalseType: Type | undefined;
+    /** The true and false types, as one list (getBranchTypesFromConditionalType). */
+    resolvedBranchTypes: Type[] | undefined;
+    resolvedInferredTrueType: Type | undefined;
+    resolvedDefaultConstraint: Type | undefined;
+    resolvedConstraintOfDistributive: Type | undefined;
+    readonly mapper: TypeMapper | undefined;
+    readonly combinedMapper: TypeMapper | undefined;
+    /** The checker that created the type, for `getTrueType()` and `getFalseType()`. */
+    checking: TypeChecking | undefined;
+    constructor(id: number, root: ConditionalRoot, checkType: Type, extendsType: Type, mapper: TypeMapper | undefined, combinedMapper: TypeMapper | undefined);
+}
+export declare class TypePredicate {
+    readonly kind: TypePredicateKind;
+    readonly parameterIndex: number;
+    readonly parameterName: string;
+    readonly type: Type | undefined;
+    constructor(kind: TypePredicateKind, parameterName: string, parameterIndex: number, type: Type | undefined);
+}
+export declare class CompositeSignature {
+    /** False for an intersection. */
+    readonly isUnion: boolean;
+    readonly signatures: Signature[];
+    constructor(isUnion: boolean, signatures: Signature[]);
+}
+/**
+ * Fields that few signatures set, kept out of line in `Signature.extra` (see TypeExtra): the `this`
+ * parameter, composite signatures and the caches of derived signatures.
+ */
+export declare class SignatureExtra implements ProgramLifetime {
+    thisParameter: Symbol | undefined;
+    isolatedSignatureType: Type | undefined;
+    composite: CompositeSignature | undefined;
+    erasedSignatureCache: Signature | undefined;
+    canonicalSignatureCache: Signature | undefined;
+    baseSignatureCache: Signature | undefined;
+    optionalCallSignatureCache: Signature | undefined;
+    instantiations: TypeListCache<Signature> | undefined;
+    constructor();
+}
+/** The extra fields of `s`, created if it has none yet. */
+export declare function signatureExtra(s: Signature): SignatureExtra;
+export declare class Signature implements ProgramLifetime {
+    readonly id: number;
+    flags: SignatureFlags;
+    minArgumentCount: number;
+    /** -1 until computed. */
+    resolvedMinArgumentCount: number;
+    declaration: Node | undefined;
+    typeParameters: Type[];
+    parameters: Symbol[];
+    resolvedReturnType: Type | undefined;
+    resolvedTypePredicate: TypePredicate | undefined;
+    target: Signature | undefined;
+    mapper: TypeMapper | undefined;
+    /** Rarely set fields; undefined while all of them have their defaults. */
+    extra: SignatureExtra | undefined;
+    constructor(id: number, flags: SignatureFlags, declaration: Node | undefined, typeParameters: Type[], thisParameter: Symbol | undefined, parameters: Symbol[], resolvedReturnType: Type | undefined, resolvedTypePredicate: TypePredicate | undefined, minArgumentCount: number);
+    get thisParameter(): Symbol | undefined;
+    set thisParameter(symbol: Symbol | undefined);
+    getTypeParameters(): readonly Type[];
+    getParameters(): readonly Symbol[];
+    getThisParameter(): Symbol | undefined;
+    /** The signature this one was instantiated from. */
+    getTarget(): Signature | undefined;
+    get isolatedSignatureType(): Type | undefined;
+    set isolatedSignatureType(t: Type | undefined);
+    get composite(): CompositeSignature | undefined;
+    set composite(composite: CompositeSignature | undefined);
+    /** Caches of derived signatures. */
+    get erasedSignatureCache(): Signature | undefined;
+    set erasedSignatureCache(s: Signature | undefined);
+    get canonicalSignatureCache(): Signature | undefined;
+    set canonicalSignatureCache(s: Signature | undefined);
+    get baseSignatureCache(): Signature | undefined;
+    set baseSignatureCache(s: Signature | undefined);
+    get optionalCallSignatureCache(): Signature | undefined;
+    set optionalCallSignatureCache(s: Signature | undefined);
+    get instantiations(): TypeListCache<Signature> | undefined;
+    set instantiations(instantiations: TypeListCache<Signature> | undefined);
+    hasRestParameter(): boolean;
+}
+export declare class IndexInfo implements ProgramLifetime {
+    readonly keyType: Type;
+    readonly valueType: Type;
+    readonly isReadonly: boolean;
+    /** The IndexSignatureDeclaration. */
+    readonly declaration: Node | undefined;
+    /** Elements with computed property names that make up the index signature. */
+    readonly components: Node[];
+    indexSymbol: Symbol | undefined;
+    constructor(keyType: Type, valueType: Type, isReadonly: boolean, declaration: Node | undefined, components: Node[]);
+    /** The value type (TypeScript 7's API). */
+    get type(): Type;
+}
+export declare const emptyTypes: Type[];
+export declare const emptySymbols: Symbol[];
+export declare const emptySignatures: Signature[];
+export declare const emptyIndexInfos: IndexInfo[];
+export declare const enum TypeMapperKind {
+    Unknown = 0,
+    Simple = 1,
+    Array = 2,
+    Merged = 3
+}
+/** Maps type parameters to types. Subclasses replace tsgo's function mappers. */
+export declare abstract class TypeMapper {
+    abstract map(type: Type): Type;
+    kind(): TypeMapperKind;
+    /** Whether the mapper only maps a `this` type parameter. */
+    mapsThisOnly(): boolean;
+}
+export declare class SimpleTypeMapper extends TypeMapper {
+    readonly source: Type;
+    readonly target: Type;
+    constructor(source: Type, target: Type);
+    map(type: Type): Type;
+    kind(): TypeMapperKind;
+    mapsThisOnly(): boolean;
+}
+export declare class ArrayTypeMapper extends TypeMapper {
+    readonly sources: Type[];
+    readonly targets: Type[];
+    constructor(sources: Type[], targets: Type[]);
+    map(type: Type): Type;
+    kind(): TypeMapperKind;
+    mapsThisOnly(): boolean;
+    /** The number of targets, one per source. */
+    targetCount(): number;
+    /** The target of the source at `index`. */
+    targetAt(index: number): Type;
+}
+/**
+ * The mapper of a type reference's members: its type arguments, then the reference itself for the
+ * last source, the class or interface's `this` type. `targets` holds the type arguments only, so the
+ * reference's own list serves without a copy that adds the reference.
+ */
+export declare class ThisArgumentTypeMapper extends ArrayTypeMapper {
+    readonly thisTarget: Type;
+    constructor(sources: Type[], typeArguments: Type[], thisTarget: Type);
+    map(type: Type): Type;
+    targetCount(): number;
+    targetAt(index: number): Type;
+}
+/** An ArrayTypeMapper that looks its sources up in an index, built on its first lookup. */
+export declare class IndexedArrayTypeMapper extends ArrayTypeMapper {
+    /** The index of each source's first occurrence. */
+    index: Map<Type, number> | undefined;
+    /** The number of sources `index` was built from. */
+    indexedLength: number;
+    map(type: Type): Type;
+}
+/** Maps each of `sources` to one target. */
+export declare class ArrayToSingleTypeMapper extends TypeMapper {
+    readonly sources: Type[];
+    readonly target: Type;
+    constructor(sources: Type[], target: Type);
+    map(type: Type): Type;
+    mapsThisOnly(): boolean;
+}
+/** Applies `m1`, then `m2`. */
+export declare class MergedTypeMapper extends TypeMapper {
+    readonly m1: TypeMapper;
+    readonly m2: TypeMapper;
+    constructor(m1: TypeMapper, m2: TypeMapper);
+    map(type: Type): Type;
+    kind(): TypeMapperKind;
+}
+export declare function newTypeMapper(sources: Type[], targets: Type[]): TypeMapper;
+/** `newTypeMapper(sources, [...typeArguments, thisTarget])`, without building that list where it can. */
+export declare function newThisArgumentTypeMapper(sources: Type[], typeArguments: Type[], thisTarget: Type): TypeMapper;
+export declare function mergeTypeMappers(m1: TypeMapper | undefined, m2: TypeMapper): TypeMapper;
+export declare function prependTypeMapping(source: Type, target: Type, mapper: TypeMapper | undefined): TypeMapper;
+export declare function appendTypeMapping(mapper: TypeMapper | undefined, source: Type, target: Type): TypeMapper;
+/**
+ * What the checker caches per symbol and rarely sets. Common values (the type, target, mapper, name type
+ * and others) are columns of `Checker` instead; see link-tables.ts. The fields most links objects have
+ * are fields of this class; the others are in a RareSymbolLinks object, created on the first write of
+ * one of them, behind accessors.
+ */
+export declare class SymbolLinks implements ProgramLifetime {
+    /** Constituents of a deferred union/intersection property type. */
+    deferralParent: Type | undefined;
+    deferralConstituents: Type[] | undefined;
+    immediateTarget: Symbol | undefined;
+    aliasTarget: Symbol | undefined;
+    resolvedExports: SymbolTable | undefined;
+    resolvedMembers: SymbolTable | undefined;
+    declaredType: Type | undefined;
+    /** The other links, created on first write. */
+    private rareLinks;
+    functionOrConstructorChecked: boolean;
+    aliasReferenced: boolean;
+    constructor();
+    private rare;
+    get writeType(): Type | undefined;
+    set writeType(value: Type | undefined);
+    get deferralWriteConstituents(): Type[] | undefined;
+    set deferralWriteConstituents(value: Type[] | undefined);
+    get typeOnlyDeclaration(): Node | undefined;
+    set typeOnlyDeclaration(value: Node | undefined);
+    get typeOnlyExportStarMap(): Map<string, Node> | undefined;
+    set typeOnlyExportStarMap(value: Map<string, Node> | undefined);
+    get exportsChecked(): boolean;
+    set exportsChecked(value: boolean);
+    get lateSymbol(): Symbol | undefined;
+    set lateSymbol(value: Symbol | undefined);
+    get typeParameters(): Type[] | undefined;
+    set typeParameters(value: Type[] | undefined);
+    get instantiations(): Map<string, Type> | undefined;
+    set instantiations(value: Map<string, Type> | undefined);
+    get interfaceChecked(): boolean;
+    set interfaceChecked(value: boolean);
+    get indexSignaturesChecked(): boolean;
+    set indexSignaturesChecked(value: boolean);
+    get typeParametersChecked(): boolean;
+    set typeParametersChecked(value: boolean);
+    get enumChecked(): boolean;
+    set enumChecked(value: boolean);
+    get variances(): VarianceFlags[] | undefined;
+    set variances(value: VarianceFlags[] | undefined);
+    get lastAssignmentPos(): number;
+    set lastAssignmentPos(value: number);
+    get hasDefiniteAssignment(): boolean;
+    set hasDefiniteAssignment(value: boolean);
+    get isConstructorDeclaredProperty(): boolean;
+    set isConstructorDeclaredProperty(value: boolean);
+    get thisAssignmentKind(): number;
+    set thisAssignmentKind(value: number);
+    get thisAssignmentLocation(): Node | undefined;
+    set thisAssignmentLocation(value: Node | undefined);
+    get reverseMappedPropertyType(): Type | undefined;
+    set reverseMappedPropertyType(value: Type | undefined);
+    get reverseMappedMappedType(): Type | undefined;
+    set reverseMappedMappedType(value: Type | undefined);
+    get reverseMappedConstraintType(): Type | undefined;
+    set reverseMappedConstraintType(value: Type | undefined);
+}
+/** The links of a symbol that few symbols have (SymbolLinks). */
+export declare class RareSymbolLinks implements ProgramLifetime {
+    writeType: Type | undefined;
+    deferralWriteConstituents: Type[] | undefined;
+    typeOnlyDeclaration: Node | undefined;
+    /** Exports reached only through `export type *`, by name. */
+    typeOnlyExportStarMap: Map<string, Node> | undefined;
+    exportsChecked: boolean;
+    lateSymbol: Symbol | undefined;
+    /** Type parameters of a type alias. */
+    typeParameters: Type[] | undefined;
+    /** Instantiations of a generic type alias. */
+    instantiations: Map<string, Type> | undefined;
+    interfaceChecked: boolean;
+    indexSignaturesChecked: boolean;
+    typeParametersChecked: boolean;
+    enumChecked: boolean;
+    variances: VarianceFlags[] | undefined;
+    lastAssignmentPos: number;
+    hasDefiniteAssignment: boolean;
+    isConstructorDeclaredProperty: boolean;
+    /** A `ThisAssignmentKind` plus one; zero until computed. */
+    thisAssignmentKind: number;
+    thisAssignmentLocation: Node | undefined;
+    reverseMappedPropertyType: Type | undefined;
+    reverseMappedMappedType: Type | undefined;
+    reverseMappedConstraintType: Type | undefined;
+    constructor();
+}
+/**
+ * What the checker caches per node and rarely sets. The resolved symbol, type and signature are columns of
+ * `Checker` instead; see link-tables.ts. As in SymbolLinks, the fields few links objects have are in a
+ * RareNodeLinks object behind accessors.
+ */
+export declare class NodeLinks implements ProgramLifetime {
+    /** Outer type parameters of an anonymous object type node. */
+    outerTypeParameters: Type[] | undefined;
+    effectsSignature: Signature | undefined;
+    /** Type of an assertion's operand. */
+    assertionExpressionType: Type | undefined;
+    /** The other links, created on first write. */
+    private rareLinks;
+    flags: NodeCheckFlags;
+    constructor();
+    private rare;
+    get contextFreeType(): Type | undefined;
+    set contextFreeType(value: Type | undefined);
+    get enumStringValue(): string;
+    set enumStringValue(value: string);
+    get enumNumberValue(): number;
+    set enumNumberValue(value: number);
+    get enumValueKind(): number;
+    set enumValueKind(value: number);
+    get enumValueFlags(): number;
+    set enumValueFlags(value: number);
+    get hasReportedStatementInAmbientContext(): boolean;
+    set hasReportedStatementInAmbientContext(value: boolean);
+    get declarationRequiresScopeChange(): number;
+    set declarationRequiresScopeChange(value: number);
+    get typeChecked(): boolean;
+    set typeChecked(value: boolean);
+    get deferredNodes(): Node[] | undefined;
+    set deferredNodes(value: Node[] | undefined);
+    get switchTypes(): Type[] | undefined;
+    set switchTypes(value: Type[] | undefined);
+    get switchWitnesses(): string[] | undefined;
+    set switchWitnesses(value: string[] | undefined);
+    get switchWitnessesValid(): boolean;
+    set switchWitnessesValid(value: boolean);
+    get exhaustiveState(): number;
+    set exhaustiveState(value: number);
+    get decoratorSignature(): Signature | undefined;
+    set decoratorSignature(value: Signature | undefined);
+    get containsArgumentsReference(): number;
+    set containsArgumentsReference(value: number);
+    get mentionsArguments(): number;
+    set mentionsArguments(value: number);
+}
+/** The links of a node that few nodes have (NodeLinks). */
+export declare class RareNodeLinks implements ProgramLifetime {
+    /** Context-free type of an expression. */
+    contextFreeType: Type | undefined;
+    /** Enum member value: a string, or a number when `enumValueIsNumber`. */
+    enumStringValue: string;
+    enumNumberValue: number;
+    enumValueKind: number;
+    /** EvaluatedFlags of the enum member value. */
+    enumValueFlags: number;
+    hasReportedStatementInAmbientContext: boolean;
+    declarationRequiresScopeChange: number;
+    /** For source files: whether the file has been checked, and its nodes waiting for a deferred check. */
+    typeChecked: boolean;
+    deferredNodes: Node[] | undefined;
+    /** Case clause types of a switch statement. */
+    switchTypes: Type[] | undefined;
+    /** `typeof` case texts of a switch statement; '' for default and duplicates. */
+    switchWitnesses: string[] | undefined;
+    switchWitnessesValid: boolean;
+    /** 0 unknown, 1 computing, 2 not exhaustive, 3 exhaustive. */
+    exhaustiveState: number;
+    /** The signature the runtime calls a decorator of this declaration with. */
+    decoratorSignature: Signature | undefined;
+    /** Whether a function body references `arguments`: 0 until computed, 1 for no, 2 for yes. */
+    containsArgumentsReference: number;
+    /** For source files: whether the file has an identifier `arguments`: 0 until computed, 1 for no, 2 for yes. */
+    mentionsArguments: number;
+    constructor();
+}