diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts
index 3de4f3962e69a..f98463b240bf0 100644
--- a/src/harness/typeWriter.ts
+++ b/src/harness/typeWriter.ts
@@ -115,31 +115,39 @@ namespace Harness {
                 // let type = this.checker.getTypeAtLocation(node);
                 let type = ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) ? this.checker.getTypeAtLocation(node.parent) : undefined;
                 if (!type || type.flags & ts.TypeFlags.Any) type = this.checker.getTypeAtLocation(node);
-                const typeString =
-                    // Distinguish `errorType`s from `any`s; but only if the file has no errors.
-                    // Additionally,
-                    // * the LHS of a qualified name
-                    // * a binding pattern name
-                    // * labels
-                    // * the "global" in "declare global"
-                    // * the "target" in "new.target"
-                    // * names in import statements
-                    // * type-only names in export statements
-                    // * and intrinsic jsx tag names
-                    // return `error`s via `getTypeAtLocation`
-                    // But this is generally expected, so we don't call those out, either
-                    (!this.hadErrorBaseline &&
-                        type.flags & ts.TypeFlags.Any &&
-                        !ts.isBindingElement(node.parent) &&
-                        !ts.isPropertyAccessOrQualifiedName(node.parent) &&
-                        !ts.isLabelName(node) &&
-                        !(ts.isModuleDeclaration(node.parent) && ts.isGlobalScopeAugmentation(node.parent)) &&
-                        !ts.isMetaProperty(node.parent) &&
-                        !this.isImportStatementName(node) &&
-                        !this.isExportStatementName(node) &&
-                        !this.isIntrinsicJsxTag(node)) ?
-                        (type as ts.IntrinsicType).intrinsicName :
-                        this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType);
+                // Distinguish `errorType`s from `any`s; but only if the file has no errors.
+                // Additionally,
+                // * the LHS of a qualified name
+                // * a binding pattern name
+                // * labels
+                // * the "global" in "declare global"
+                // * the "target" in "new.target"
+                // * names in import statements
+                // * type-only names in export statements
+                // * and intrinsic jsx tag names
+                // return `error`s via `getTypeAtLocation`
+                // But this is generally expected, so we don't call those out, either
+                let typeString: string;
+                if (!this.hadErrorBaseline &&
+                    type.flags & ts.TypeFlags.Any &&
+                    !ts.isBindingElement(node.parent) &&
+                    !ts.isPropertyAccessOrQualifiedName(node.parent) &&
+                    !ts.isLabelName(node) &&
+                    !(ts.isModuleDeclaration(node.parent) && ts.isGlobalScopeAugmentation(node.parent)) &&
+                    !ts.isMetaProperty(node.parent) &&
+                    !this.isImportStatementName(node) &&
+                    !this.isExportStatementName(node) &&
+                    !this.isIntrinsicJsxTag(node)) {
+                    typeString = (type as ts.IntrinsicType).intrinsicName;
+                }
+                else {
+                    typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType);
+                    if (ts.isIdentifier(node) && ts.isTypeAliasDeclaration(node.parent) && node.parent.name === node && typeString === ts.idText(node)) {
+                        // for a complex type alias `type T = ...`, showing "T : T" isn't very helpful for type tests. When the type produced is the same as
+                        // the name of the type alias, recreate the type string without reusing the alias name
+                        typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType | ts.TypeFormatFlags.InTypeAlias);
+                    }
+                }
                 return {
                     line: lineAndCharacter.line,
                     syntaxKind: node.kind,
diff --git a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.types b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.types
index 553563168a867..5e79973b27b15 100644
--- a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.types
+++ b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts ===
 type T = { x : number }
->T : T
+>T : { x: number; }
 >x : number
 
 export interface I {
diff --git a/tests/baselines/reference/abstractClassUnionInstantiation.types b/tests/baselines/reference/abstractClassUnionInstantiation.types
index 969f0b85c44a5..1f1458a7283ed 100644
--- a/tests/baselines/reference/abstractClassUnionInstantiation.types
+++ b/tests/baselines/reference/abstractClassUnionInstantiation.types
@@ -14,17 +14,17 @@ abstract class AbstractB { b: string; }
 >b : string
 
 type Abstracts = typeof AbstractA | typeof AbstractB;
->Abstracts : Abstracts
+>Abstracts : typeof AbstractA | typeof AbstractB
 >AbstractA : typeof AbstractA
 >AbstractB : typeof AbstractB
 
 type Concretes = typeof ConcreteA | typeof ConcreteB;
->Concretes : Concretes
+>Concretes : typeof ConcreteA | typeof ConcreteB
 >ConcreteA : typeof ConcreteA
 >ConcreteB : typeof ConcreteB
 
 type ConcretesOrAbstracts = Concretes | Abstracts;
->ConcretesOrAbstracts : ConcretesOrAbstracts
+>ConcretesOrAbstracts : Abstracts | Concretes
 
 declare const cls1: ConcretesOrAbstracts;
 >cls1 : ConcretesOrAbstracts
diff --git a/tests/baselines/reference/accessorBodyInTypeContext.types b/tests/baselines/reference/accessorBodyInTypeContext.types
index ad04c25524d88..41a1a234e1bab 100644
--- a/tests/baselines/reference/accessorBodyInTypeContext.types
+++ b/tests/baselines/reference/accessorBodyInTypeContext.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/accessorBodyInTypeContext.ts ===
 type A = {
->A : A
+>A : { readonly foo: number; }
 
     get foo() { return 0 }
 >foo : number
@@ -9,7 +9,7 @@ type A = {
 };
 
 type B = {
->B : B
+>B : { foo: any; }
 
     set foo(v: any) { }
 >foo : any
diff --git a/tests/baselines/reference/aliasOfGenericFunctionWithRestBehavedSameAsUnaliased.types b/tests/baselines/reference/aliasOfGenericFunctionWithRestBehavedSameAsUnaliased.types
index 6377ed3cd7315..8b580c9cb3268 100644
--- a/tests/baselines/reference/aliasOfGenericFunctionWithRestBehavedSameAsUnaliased.types
+++ b/tests/baselines/reference/aliasOfGenericFunctionWithRestBehavedSameAsUnaliased.types
@@ -8,10 +8,10 @@ type ExtendedMapper<HandledInputT, OutputT, ArgsT extends any[]> = (name : strin
 >args : ArgsT
 
 type a = ExtendedMapper<any, any, [any]>;
->a : a
+>a : (name: string, mixed: any, args_0: any) => any
 
 type b = ExtendedMapper<any, any, any[]>;
->b : b
+>b : (name: string, mixed: any, ...args: any[]) => any
 
 type test = a extends b ? "y" : "n"
 >test : "y"
@@ -32,10 +32,10 @@ type ExtendedMapper1<HandledInputT, OutputT, ArgsT extends any[]> = (
 );
 
 type a1 = ExtendedMapper1<any, any, [any]>;
->a1 : a1
+>a1 : (name: string, mixed: any, args_0: any) => any
 
 type b1 = ExtendedMapper1<any, any, any[]>;
->b1 : b1
+>b1 : (name: string, mixed: any, ...args: any[]) => any
 
 type test1 = a1 extends b1 ? "y" : "n"
 >test1 : "y"
@@ -56,10 +56,10 @@ type ExtendedMapper2<HandledInputT, OutputT, ArgsT extends any[]> = (
 );
 
 type a2 = ExtendedMapper2<any, any, [any]>;
->a2 : a2
+>a2 : (name: string, mixed: any, args_0: any) => any
 
 type b2 = ExtendedMapper2<any, any, any[]>;
->b2 : b2
+>b2 : (name: string, mixed: any, ...args: any[]) => any
 
 type test2 = a2 extends b2 ? "y" : "n"
 >test2 : "y"
@@ -69,13 +69,13 @@ let check2: test2 = "y";
 >"y" : "y"
 
 type a3 = (name: string, mixed: any, args_0: any) => any
->a3 : a3
+>a3 : (name: string, mixed: any, args_0: any) => any
 >name : string
 >mixed : any
 >args_0 : any
 
 type b3 = (name: string, mixed: any, ...args: any[]) => any
->b3 : b3
+>b3 : (name: string, mixed: any, ...args: any[]) => any
 >name : string
 >mixed : any
 >args : any[]
diff --git a/tests/baselines/reference/anyMappedTypesError.types b/tests/baselines/reference/anyMappedTypesError.types
index 876d29194414f..e30f65d142ec1 100644
--- a/tests/baselines/reference/anyMappedTypesError.types
+++ b/tests/baselines/reference/anyMappedTypesError.types
@@ -1,4 +1,4 @@
 === tests/cases/compiler/anyMappedTypesError.ts ===
 type Foo = {[P in "bar"]};
->Foo : Foo
+>Foo : { bar: any; }
 
diff --git a/tests/baselines/reference/argumentsAsPropertyName.types b/tests/baselines/reference/argumentsAsPropertyName.types
index 86bbd8474702c..b5753c3da720f 100644
--- a/tests/baselines/reference/argumentsAsPropertyName.types
+++ b/tests/baselines/reference/argumentsAsPropertyName.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/argumentsAsPropertyName.ts ===
 // target: es5
 type MyType = {
->MyType : MyType
+>MyType : { arguments: Array<string>; }
 
     arguments: Array<string>
 >arguments : string[]
diff --git a/tests/baselines/reference/arrayDestructuringInSwitch1.types b/tests/baselines/reference/arrayDestructuringInSwitch1.types
index dfb06774cec16..56d48f6a30075 100644
--- a/tests/baselines/reference/arrayDestructuringInSwitch1.types
+++ b/tests/baselines/reference/arrayDestructuringInSwitch1.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/arrayDestructuringInSwitch1.ts ===
 export type Expression = BooleanLogicExpression | 'true' | 'false';
->Expression : Expression
+>Expression : BooleanLogicExpression | "true" | "false"
 
 export type BooleanLogicExpression = ['and', ...Expression[]] | ['not', Expression];
->BooleanLogicExpression : BooleanLogicExpression
+>BooleanLogicExpression : ["and", ...Expression[]] | ["not", Expression]
 
 export function evaluate(expression: Expression): boolean {
 >evaluate : (expression: Expression) => boolean
diff --git a/tests/baselines/reference/arrayDestructuringInSwitch2.types b/tests/baselines/reference/arrayDestructuringInSwitch2.types
index 727a2fc68ebc3..62b0999fcbd6b 100644
--- a/tests/baselines/reference/arrayDestructuringInSwitch2.types
+++ b/tests/baselines/reference/arrayDestructuringInSwitch2.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/arrayDestructuringInSwitch2.ts ===
 type X = { kind: "a", a: [1] } | { kind: "b", a: [] }
->X : X
+>X : { kind: "a"; a: [1]; } | { kind: "b"; a: []; }
 >kind : "a"
 >a : [1]
 >kind : "b"
diff --git a/tests/baselines/reference/assertionFunctionsCanNarrowByDiscriminant.types b/tests/baselines/reference/assertionFunctionsCanNarrowByDiscriminant.types
index aa4b32692b10d..9384922fa7a29 100644
--- a/tests/baselines/reference/assertionFunctionsCanNarrowByDiscriminant.types
+++ b/tests/baselines/reference/assertionFunctionsCanNarrowByDiscriminant.types
@@ -18,7 +18,7 @@ interface Dog {
 }
 
 type Animal = Cat | Dog;
->Animal : Animal
+>Animal : Cat | Dog
 
 declare function assertEqual<T>(value: any, type: T): asserts value is T;
 >assertEqual : <T>(value: any, type: T) => asserts value is T
diff --git a/tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.types b/tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.types
index cc88ed30c0738..58784a84667ad 100644
--- a/tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.types
+++ b/tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.types
@@ -6,12 +6,12 @@ namespace Example1 {
 >Example1 : typeof Example1
 
     type S = { done: boolean, value: number };
->S : S
+>S : { done: boolean; value: number; }
 >done : boolean
 >value : number
 
     type T =
->T : T
+>T : { done: true; value: number; } | { done: false; value: number; }
 
         | { done: true, value: number }     // T0
 >done : true
@@ -42,12 +42,12 @@ namespace Example2 {
 >Example2 : typeof Example2
 
     type S = { a: 0 | 2, b: 4 };
->S : S
+>S : { a: 0 | 2; b: 4; }
 >a : 0 | 2
 >b : 4
 
     type T = { a: 0,     b: 1 | 4 }     // T0
->T : T
+>T : { a: 0; b: 1 | 4; } | { a: 1; b: 2; } | { a: 2; b: 3 | 4; }
 >a : 0
 >b : 4 | 1
 
@@ -78,12 +78,12 @@ namespace Example3 {
 >Example3 : typeof Example3
 
     type S = { a: 0 | 2, b: 4 };
->S : S
+>S : { a: 0 | 2; b: 4; }
 >a : 0 | 2
 >b : 4
 
     type T = { a: 0,     b: 1 | 4 }     // T0
->T : T
+>T : { a: 0; b: 1 | 4; } | { a: 1; b: 2 | 4; } | { a: 2; b: 3; }
 >a : 0
 >b : 4 | 1
 
@@ -115,12 +115,12 @@ namespace Example4 {
 >Example4 : typeof Example4
 
     type S = { a: 0 | 2, b: 4 };
->S : S
+>S : { a: 0 | 2; b: 4; }
 >a : 0 | 2
 >b : 4
 
     type T = { a: 0,     b: 1 | 4 }             // T0
->T : T
+>T : { a: 0; b: 1 | 4; } | { a: 1; b: 2; } | { a: 2; b: 3 | 4; c: string; }
 >a : 0
 >b : 4 | 1
 
@@ -155,16 +155,16 @@ namespace Example5 {
     //       3 discriminant properties with 3 types a piece
     //       is 27 possible combinations.
     type N = 0 | 1 | 2;
->N : N
+>N : 0 | 2 | 1
 
     type S = { a: N, b: N, c: N };
->S : S
+>S : { a: N; b: N; c: N; }
 >a : N
 >b : N
 >c : N
 
     type T = { a: 0, b: N, c: N }
->T : T
+>T : { a: 0; b: N; c: N; } | { a: 1; b: N; c: N; } | { a: 2; b: N; c: N; } | { a: N; b: 0; c: N; } | { a: N; b: 1; c: N; } | { a: N; b: 2; c: N; } | { a: N; b: N; c: 0; } | { a: N; b: N; c: 1; } | { a: N; b: N; c: 2; }
 >a : 0
 >b : N
 >c : N
@@ -228,7 +228,7 @@ namespace GH14865 {
 >GH14865 : typeof GH14865
 
     type Style1 = {
->Style1 : Style1
+>Style1 : { type: "A"; data: string; } | { type: "B"; data: string; }
 
         type: "A";
 >type : "A"
@@ -246,7 +246,7 @@ namespace GH14865 {
     };
 
     type Style2 = {
->Style2 : Style2
+>Style2 : { type: "A" | "B"; data: string; }
 
         type: "A" | "B";
 >type : "A" | "B"
@@ -322,10 +322,10 @@ namespace GH12052 {
 >type : "categorical"
 
     type IAxis = ILinearAxis | ICategoricalAxis;
->IAxis : IAxis
+>IAxis : ILinearAxis | ICategoricalAxis
 
     type IAxisType = "linear" | "categorical";
->IAxisType : IAxisType
+>IAxisType : "linear" | "categorical"
 
     function getAxisType(): IAxisType {
 >getAxisType : () => IAxisType
@@ -381,10 +381,10 @@ namespace GH18421 {
     }
 
     type ThingType = 'one' | 'two';
->ThingType : ThingType
+>ThingType : "one" | "two"
 
     type Thing = ThingTypeOne | ThingTypeTwo;
->Thing : Thing
+>Thing : ThingTypeOne | ThingTypeTwo
 
     function makeNewThing(thingType: ThingType): Thing {
 >makeNewThing : (thingType: ThingType) => Thing
@@ -406,7 +406,7 @@ namespace GH15907 {
 >GH15907 : typeof GH15907
 
     type Action = { type: 'activate' } | { type: 'disactivate' };
->Action : Action
+>Action : { type: 'activate'; } | { type: 'disactivate'; }
 >type : "activate"
 >type : "disactivate"
 
@@ -445,7 +445,7 @@ namespace GH20889 {
 >type : "A2"
     }
     type AU = A1 | A2;
->AU : AU
+>AU : A1 | A2
 
     function foo(obj1: AU) {
 >foo : (obj1: AU) => void
@@ -470,10 +470,10 @@ namespace GH39357 {
 >GH39357 : typeof GH39357
 
     type A = ["a", number] | ["b", number] | ["c", string];
->A : A
+>A : ["a", number] | ["b", number] | ["c", string]
 
     type B = "a" | "b" | "c";
->B : B
+>B : "a" | "b" | "c"
 
     declare const b: B;
 >b : B
diff --git a/tests/baselines/reference/asyncFunctionContextuallyTypedReturns.types b/tests/baselines/reference/asyncFunctionContextuallyTypedReturns.types
index 15a26ac4a9a2f..a5b9c879c7580 100644
--- a/tests/baselines/reference/asyncFunctionContextuallyTypedReturns.types
+++ b/tests/baselines/reference/asyncFunctionContextuallyTypedReturns.types
@@ -64,7 +64,7 @@ g(async v => v ? "contextuallyTypable" : Promise.reject());
 >reject : <T = never>(reason?: any) => Promise<T>
 
 type MyCallback = (thing: string) => void;
->MyCallback : MyCallback
+>MyCallback : (thing: string) => void
 >thing : string
 
 declare function h(cb: (v: boolean) => MyCallback | PromiseLike<MyCallback>): void;
diff --git a/tests/baselines/reference/awaitedType.types b/tests/baselines/reference/awaitedType.types
index 9bca225ef3de3..5af5babaedf12 100644
--- a/tests/baselines/reference/awaitedType.types
+++ b/tests/baselines/reference/awaitedType.types
@@ -9,7 +9,7 @@ type T3 = Awaited<number | Promise<number>>;
 >T3 : number
 
 type T4 = Awaited<number | Promise<string>>;
->T4 : T4
+>T4 : string | number
 
 type T5 = Awaited<{ then: number }>;
 >T5 : { then: number; }
diff --git a/tests/baselines/reference/awaitedTypeStrictNull.types b/tests/baselines/reference/awaitedTypeStrictNull.types
index 574161fa592e4..e3deb7d2247df 100644
--- a/tests/baselines/reference/awaitedTypeStrictNull.types
+++ b/tests/baselines/reference/awaitedTypeStrictNull.types
@@ -9,7 +9,7 @@ type T3 = Awaited<number | Promise<number>>;
 >T3 : number
 
 type T4 = Awaited<number | Promise<string>>;
->T4 : T4
+>T4 : string | number
 
 type T5 = Awaited<{ then: number }>;
 >T5 : { then: number; }
diff --git a/tests/baselines/reference/booleanLiteralTypes1.types b/tests/baselines/reference/booleanLiteralTypes1.types
index f40f964eacc0b..4de330f57ae6d 100644
--- a/tests/baselines/reference/booleanLiteralTypes1.types
+++ b/tests/baselines/reference/booleanLiteralTypes1.types
@@ -1,11 +1,11 @@
 === tests/cases/conformance/types/literal/booleanLiteralTypes1.ts ===
 type A1 = true | false;
->A1 : A1
+>A1 : boolean
 >true : true
 >false : false
 
 type A2 = false | true;
->A2 : A2
+>A2 : boolean
 >false : false
 >true : true
 
@@ -244,7 +244,7 @@ function f13(x: true | false) {
 }
 
 type Item =
->Item : Item
+>Item : { kind: true; a: string; } | { kind: false; b: string; }
 
     { kind: true, a: string } |
 >kind : true
diff --git a/tests/baselines/reference/booleanLiteralTypes2.types b/tests/baselines/reference/booleanLiteralTypes2.types
index 16323492d7a72..484d83fefd889 100644
--- a/tests/baselines/reference/booleanLiteralTypes2.types
+++ b/tests/baselines/reference/booleanLiteralTypes2.types
@@ -1,11 +1,11 @@
 === tests/cases/conformance/types/literal/booleanLiteralTypes2.ts ===
 type A1 = true | false;
->A1 : A1
+>A1 : boolean
 >true : true
 >false : false
 
 type A2 = false | true;
->A2 : A2
+>A2 : boolean
 >false : false
 >true : true
 
@@ -244,7 +244,7 @@ function f13(x: true | false) {
 }
 
 type Item =
->Item : Item
+>Item : { kind: true; a: string; } | { kind: false; b: string; }
 
     { kind: true, a: string } |
 >kind : true
diff --git a/tests/baselines/reference/booleanLiteralsContextuallyTypedFromUnion.types b/tests/baselines/reference/booleanLiteralsContextuallyTypedFromUnion.types
index d30986c385910..77b32edaf0acd 100644
--- a/tests/baselines/reference/booleanLiteralsContextuallyTypedFromUnion.types
+++ b/tests/baselines/reference/booleanLiteralsContextuallyTypedFromUnion.types
@@ -10,7 +10,7 @@ interface B { isIt: false; value: number; }
 >value : number
 
 type C = A | B;
->C : C
+>C : A | B
 
 const isIt = Math.random() > 0.5;
 >isIt : boolean
@@ -50,7 +50,7 @@ const cc: C = isIt ? { isIt: isIt, text: 'hey' } : { isIt: isIt, value: 123 };
 >123 : 123
 
 type ComponentProps =
->ComponentProps : ComponentProps
+>ComponentProps : { optionalBool: true; mandatoryFn: () => void; } | { optionalBool: false; }
 
     | {
         optionalBool: true;
diff --git a/tests/baselines/reference/callWithSpread4.types b/tests/baselines/reference/callWithSpread4.types
index 5caef4eb70173..5d1a4a4de3065 100644
--- a/tests/baselines/reference/callWithSpread4.types
+++ b/tests/baselines/reference/callWithSpread4.types
@@ -1,14 +1,14 @@
 === tests/cases/conformance/expressions/functionCalls/callWithSpread4.ts ===
 type R = { a: number }
->R : R
+>R : { a: number; }
 >a : number
 
 type W = { b: number }
->W : W
+>W : { b: number; }
 >b : number
 
 type RW = { a: number, b: number }
->RW : RW
+>RW : { a: number; b: number; }
 >a : number
 >b : number
 
diff --git a/tests/baselines/reference/caseInsensitiveFileSystemWithCapsImportTypeDeclarations.types b/tests/baselines/reference/caseInsensitiveFileSystemWithCapsImportTypeDeclarations.types
index 0b18a2d650270..c59089053583e 100644
--- a/tests/baselines/reference/caseInsensitiveFileSystemWithCapsImportTypeDeclarations.types
+++ b/tests/baselines/reference/caseInsensitiveFileSystemWithCapsImportTypeDeclarations.types
@@ -21,7 +21,7 @@ import { TypeA } from './type-a';
 >TypeA : any
 
 export type TypeB = Merge<TypeA, {
->TypeB : TypeB
+>TypeB : TypeA & { b: string; }
 
     b: string;
 >b : string
@@ -29,7 +29,7 @@ export type TypeB = Merge<TypeA, {
 }>;
 === tests/cases/compiler/Uppercased_Dir/src/type-a.ts ===
 export type TypeA = {
->TypeA : TypeA
+>TypeA : { a: string; }
 
     a: string;
 >a : string
diff --git a/tests/baselines/reference/circularAccessorAnnotations.types b/tests/baselines/reference/circularAccessorAnnotations.types
index 1945fdc51092a..9a4041b526ca0 100644
--- a/tests/baselines/reference/circularAccessorAnnotations.types
+++ b/tests/baselines/reference/circularAccessorAnnotations.types
@@ -35,14 +35,14 @@ declare const c3: {
 }
 
 type T1 = {
->T1 : T1
+>T1 : { readonly foo: any; }
 
     get foo(): T1["foo"];
 >foo : any
 }
 
 type T2 = {
->T2 : T2
+>T2 : { foo: any; }
 
     set foo(value: T2["foo"]);
 >foo : any
@@ -50,7 +50,7 @@ type T2 = {
 }
 
 type T3 = {
->T3 : T3
+>T3 : { foo: string; }
 
     get foo(): string;
 >foo : string
diff --git a/tests/baselines/reference/circularIndexedAccessErrors.types b/tests/baselines/reference/circularIndexedAccessErrors.types
index 9ffde7a1f3c12..5085b290b690b 100644
--- a/tests/baselines/reference/circularIndexedAccessErrors.types
+++ b/tests/baselines/reference/circularIndexedAccessErrors.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/keyof/circularIndexedAccessErrors.ts ===
 type T1 = {
->T1 : T1
+>T1 : { x: any; }
 
     x: T1["x"];  // Error
 >x : any
diff --git a/tests/baselines/reference/circularTypeAliasForUnionWithClass.types b/tests/baselines/reference/circularTypeAliasForUnionWithClass.types
index 4127d1c30de00..6a60d579dc618 100644
--- a/tests/baselines/reference/circularTypeAliasForUnionWithClass.types
+++ b/tests/baselines/reference/circularTypeAliasForUnionWithClass.types
@@ -3,7 +3,7 @@ var v0: T0;
 >v0 : T0
 
 type T0 = string | I0;
->T0 : T0
+>T0 : string | I0
 
 class I0 {
 >I0 : I0
@@ -16,7 +16,7 @@ var v3: T3;
 >v3 : T3
 
 type T3 = string | I3;
->T3 : T3
+>T3 : string | I3
 
 class I3 {
 >I3 : I3
@@ -29,7 +29,7 @@ var v4: T4;
 >v4 : T4
 
 type T4 = string | I4;
->T4 : T4
+>T4 : string | I4
 
 class I4 {
 >I4 : I4
diff --git a/tests/baselines/reference/circularTypeAliasForUnionWithInterface.types b/tests/baselines/reference/circularTypeAliasForUnionWithInterface.types
index fa192f67db485..03a7e966828d4 100644
--- a/tests/baselines/reference/circularTypeAliasForUnionWithInterface.types
+++ b/tests/baselines/reference/circularTypeAliasForUnionWithInterface.types
@@ -3,7 +3,7 @@ var v0: T0;
 >v0 : T0
 
 type T0 = string | I0;
->T0 : T0
+>T0 : string | I0
 
 interface I0 {
     x: T0;
@@ -14,7 +14,7 @@ var v1: T1;
 >v1 : T1
 
 type T1 = string | I1;
->T1 : T1
+>T1 : string | I1
 
 interface I1 {
     (): T1;
@@ -24,7 +24,7 @@ var v2: T2;
 >v2 : T2
 
 type T2 = string | I2;
->T2 : T2
+>T2 : string | I2
 
 interface I2 {
     new (): T2;
@@ -34,7 +34,7 @@ var v3: T3;
 >v3 : T3
 
 type T3 = string | I3;
->T3 : T3
+>T3 : string | I3
 
 interface I3 {
     [x: number]: T3;
@@ -45,7 +45,7 @@ var v4: T4;
 >v4 : T4
 
 type T4 = string | I4;
->T4 : T4
+>T4 : string | I4
 
 interface I4 {
     [x: string]: T4;
diff --git a/tests/baselines/reference/circularlyReferentialInterfaceAccessNoCrash.types b/tests/baselines/reference/circularlyReferentialInterfaceAccessNoCrash.types
index 37dc9060f0bdd..47ac25fbd4068 100644
--- a/tests/baselines/reference/circularlyReferentialInterfaceAccessNoCrash.types
+++ b/tests/baselines/reference/circularlyReferentialInterfaceAccessNoCrash.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/circularlyReferentialInterfaceAccessNoCrash.ts ===
 type Mxs = Mx<'list', Mxs['p1']>;
->Mxs : Mxs
+>Mxs : Mx<any, any>
 
 interface Mx<T, K> {
   p1: T;
@@ -11,8 +11,8 @@ interface Mx<T, K> {
 }
 
 type ArrElem = ['list', ArrElem[number][0]][];
->ArrElem : ArrElem
+>ArrElem : [any, any][]
 
 type TupleElem = [['list', TupleElem[0][0]]];
->TupleElem : TupleElem
+>TupleElem : [[any, any]]
 
diff --git a/tests/baselines/reference/classDoesNotDependOnBaseTypes.types b/tests/baselines/reference/classDoesNotDependOnBaseTypes.types
index c50aef1cf1482..22a44a1608678 100644
--- a/tests/baselines/reference/classDoesNotDependOnBaseTypes.types
+++ b/tests/baselines/reference/classDoesNotDependOnBaseTypes.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/typeAliases/classDoesNotDependOnBaseTypes.ts ===
 type StringTree = string | StringTreeCollection;
->StringTree : StringTree
+>StringTree : string | StringTreeCollection
 
 class StringTreeCollectionBase {
 >StringTreeCollectionBase : StringTreeCollectionBase
diff --git a/tests/baselines/reference/classPropertyErrorOnNameOnly.types b/tests/baselines/reference/classPropertyErrorOnNameOnly.types
index 4dece714b92b3..232ca92cd000b 100644
--- a/tests/baselines/reference/classPropertyErrorOnNameOnly.types
+++ b/tests/baselines/reference/classPropertyErrorOnNameOnly.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/classPropertyErrorOnNameOnly.ts ===
 type Values = 1 | 2 | 3 | 4 | 5 | 6
->Values : Values
+>Values : 1 | 2 | 3 | 4 | 5 | 6
 
 type FuncType = (arg: Values) => string
->FuncType : FuncType
+>FuncType : (arg: Values) => string
 >arg : Values
 
 // turn on strictNullChecks
diff --git a/tests/baselines/reference/coAndContraVariantInferences.types b/tests/baselines/reference/coAndContraVariantInferences.types
index b8d48b413397f..33ef1c87d4806 100644
--- a/tests/baselines/reference/coAndContraVariantInferences.types
+++ b/tests/baselines/reference/coAndContraVariantInferences.types
@@ -1,10 +1,10 @@
 === tests/cases/compiler/coAndContraVariantInferences.ts ===
 type A = { kind: 'a' };
->A : A
+>A : { kind: 'a'; }
 >kind : "a"
 
 type B = { kind: 'b' };
->B : B
+>B : { kind: 'b'; }
 >kind : "b"
 
 declare const a: A;
diff --git a/tests/baselines/reference/comparisonOperatorWithNumericLiteral.types b/tests/baselines/reference/comparisonOperatorWithNumericLiteral.types
index ae32097c462c3..4ebbecbc555e8 100644
--- a/tests/baselines/reference/comparisonOperatorWithNumericLiteral.types
+++ b/tests/baselines/reference/comparisonOperatorWithNumericLiteral.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithNumericLiteral.ts ===
 type BrandedNum = number & { __numberBrand: any };
->BrandedNum : BrandedNum
+>BrandedNum : number & { __numberBrand: any; }
 >__numberBrand : any
 
 var x : BrandedNum;
diff --git a/tests/baselines/reference/complicatedIndexedAccessKeyofReliesOnKeyofNeverUpperBound.types b/tests/baselines/reference/complicatedIndexedAccessKeyofReliesOnKeyofNeverUpperBound.types
index 0132151408814..a499495da42c2 100644
--- a/tests/baselines/reference/complicatedIndexedAccessKeyofReliesOnKeyofNeverUpperBound.types
+++ b/tests/baselines/reference/complicatedIndexedAccessKeyofReliesOnKeyofNeverUpperBound.types
@@ -22,7 +22,7 @@ interface EmailChannel {
 }
 
 type Channel = TextChannel | EmailChannel;
->Channel : Channel
+>Channel : TextChannel | EmailChannel
 
 export type ChannelType = Channel extends { type: infer R } ? R : never;
 >ChannelType : "text" | "email"
diff --git a/tests/baselines/reference/computedPropertyName.types b/tests/baselines/reference/computedPropertyName.types
index caab943f248ec..98722138b8c32 100644
--- a/tests/baselines/reference/computedPropertyName.types
+++ b/tests/baselines/reference/computedPropertyName.types
@@ -16,7 +16,7 @@ interface Component {
 }
 
 type T = {
->T : T
+>T : { [onInit]: any; }
 
   [onInit]: any;
 >[onInit] : any
diff --git a/tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.types b/tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.types
index 6adec9195f253..ecf52ba235433 100644
--- a/tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.types
+++ b/tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.types
@@ -18,11 +18,11 @@ type OmitIndex<T, I extends string | number> = {
 };
 
 type IndexObject = { [key: string]: unknown; };
->IndexObject : IndexObject
+>IndexObject : { [key: string]: unknown; }
 >key : string
 
 type FooBar = { foo: "hello"; bar: "world"; };
->FooBar : FooBar
+>FooBar : { foo: "hello"; bar: "world"; }
 >foo : "hello"
 >bar : "world"
 
diff --git a/tests/baselines/reference/conditionalTypeDiscriminatingLargeUnionRegularTypeFetchingSpeedReasonable.types b/tests/baselines/reference/conditionalTypeDiscriminatingLargeUnionRegularTypeFetchingSpeedReasonable.types
index a4709500c7789..50391d7c0dc3d 100644
--- a/tests/baselines/reference/conditionalTypeDiscriminatingLargeUnionRegularTypeFetchingSpeedReasonable.types
+++ b/tests/baselines/reference/conditionalTypeDiscriminatingLargeUnionRegularTypeFetchingSpeedReasonable.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/conditionalTypeDiscriminatingLargeUnionRegularTypeFetchingSpeedReasonable.ts ===
 type BigUnion =
->BigUnion : BigUnion
+>BigUnion : { name: '0'; children: BigUnion[]; } | { name: '1'; children: BigUnion[]; } | { name: '2'; children: BigUnion[]; } | { name: '3'; children: BigUnion[]; } | { name: '4'; children: BigUnion[]; } | { name: '5'; children: BigUnion[]; } | { name: '6'; children: BigUnion[]; } | { name: '7'; children: BigUnion[]; } | { name: '8'; children: BigUnion[]; } | { name: '9'; children: BigUnion[]; } | { name: '10'; children: BigUnion[]; } | { name: '11'; children: BigUnion[]; } | { name: '12'; children: BigUnion[]; } | { name: '13'; children: BigUnion[]; } | { name: '14'; children: BigUnion[]; } | { name: '15'; children: BigUnion[]; } | { name: '16'; children: BigUnion[]; } | { name: '17'; children: BigUnion[]; } | { name: '18'; children: BigUnion[]; } | { name: '19'; children: BigUnion[]; } | { name: '20'; children: BigUnion[]; } | { name: '21'; children: BigUnion[]; } | { name: '22'; children: BigUnion[]; } | { name: '23'; children: BigUnion[]; } | { name: '24'; children: BigUnion[]; } | { name: '25'; children: BigUnion[]; } | { name: '26'; children: BigUnion[]; } | { name: '27'; children: BigUnion[]; } | { name: '28'; children: BigUnion[]; } | { name: '29'; children: BigUnion[]; } | { name: '30'; children: BigUnion[]; } | { name: '31'; children: BigUnion[]; } | { name: '32'; children: BigUnion[]; } | { name: '33'; children: BigUnion[]; } | { name: '34'; children: BigUnion[]; } | { name: '35'; children: BigUnion[]; } | { name: '36'; children: BigUnion[]; } | { name: '37'; children: BigUnion[]; } | { name: '38'; children: BigUnion[]; } | { name: '39'; children: BigUnion[]; } | { name: '40'; children: BigUnion[]; } | { name: '41'; children: BigUnion[]; } | { name: '42'; children: BigUnion[]; } | { name: '43'; children: BigUnion[]; } | { name: '44'; children: BigUnion[]; } | { name: '45'; children: BigUnion[]; } | { name: '46'; children: BigUnion[]; } | { name: '47'; children: BigUnion[]; } | { name: '48'; children: BigUnion[]; } | { name: '49'; children: BigUnion[]; } | { name: '50'; children: BigUnion[]; } | { name: '51'; children: BigUnion[]; } | { name: '52'; children: BigUnion[]; } | { name: '53'; children: BigUnion[]; } | { name: '54'; children: BigUnion[]; } | { name: '55'; children: BigUnion[]; } | { name: '56'; children: BigUnion[]; } | { name: '57'; children: BigUnion[]; } | { name: '58'; children: BigUnion[]; } | { name: '59'; children: BigUnion[]; } | { name: '60'; children: BigUnion[]; } | { name: '61'; children: BigUnion[]; } | { name: '62'; children: BigUnion[]; } | { name: '63'; children: BigUnion[]; } | { name: '64'; children: BigUnion[]; } | { name: '65'; children: BigUnion[]; } | { name: '66'; children: BigUnion[]; } | { name: '67'; children: BigUnion[]; } | { name: '68'; children: BigUnion[]; } | { name: '69'; children: BigUnion[]; } | { name: '70'; children: BigUnion[]; } | { name: '71'; children: BigUnion[]; } | { name: '72'; children: BigUnion[]; } | { name: '73'; children: BigUnion[]; } | { name: '74'; children: BigUnion[]; } | { name: '75'; children: BigUnion[]; } | { name: '76'; children: BigUnion[]; } | { name: '77'; children: BigUnion[]; } | { name: '78'; children: BigUnion[]; } | { name: '79'; children: BigUnion[]; } | { name: '80'; children: BigUnion[]; } | { name: '81'; children: BigUnion[]; } | { name: '82'; children: BigUnion[]; } | { name: '83'; children: BigUnion[]; } | { name: '84'; children: BigUnion[]; } | { name: '85'; children: BigUnion[]; } | { name: '86'; children: BigUnion[]; } | { name: '87'; children: BigUnion[]; } | { name: '88'; children: BigUnion[]; } | { name: '89'; children: BigUnion[]; } | { name: '90'; children: BigUnion[]; } | { name: '91'; children: BigUnion[]; } | { name: '92'; children: BigUnion[]; } | { name: '93'; children: BigUnion[]; } | { name: '94'; children: BigUnion[]; } | { name: '95'; children: BigUnion[]; } | { name: '96'; children: BigUnion[]; } | { name: '97'; children: BigUnion[]; } | { name: '98'; children: BigUnion[]; } | { name: '99'; children: BigUnion[]; } | { name: '100'; children: BigUnion[]; } | { name: '101'; children: BigUnion[]; } | { name: '102'; children: BigUnion[]; } | { name: '103'; children: BigUnion[]; } | { name: '104'; children: BigUnion[]; } | { name: '105'; children: BigUnion[]; } | { name: '106'; children: BigUnion[]; } | { name: '107'; children: BigUnion[]; } | { name: '108'; children: BigUnion[]; } | { name: '109'; children: BigUnion[]; } | { name: '110'; children: BigUnion[]; } | { name: '111'; children: BigUnion[]; } | { name: '112'; children: BigUnion[]; } | { name: '113'; children: BigUnion[]; } | { name: '114'; children: BigUnion[]; } | { name: '115'; children: BigUnion[]; } | { name: '116'; children: BigUnion[]; } | { name: '117'; children: BigUnion[]; } | { name: '118'; children: BigUnion[]; } | { name: '119'; children: BigUnion[]; } | { name: '120'; children: BigUnion[]; } | { name: '121'; children: BigUnion[]; } | { name: '122'; children: BigUnion[]; } | { name: '123'; children: BigUnion[]; } | { name: '124'; children: BigUnion[]; } | { name: '125'; children: BigUnion[]; } | { name: '126'; children: BigUnion[]; } | { name: '127'; children: BigUnion[]; } | { name: '128'; children: BigUnion[]; } | { name: '129'; children: BigUnion[]; } | { name: '130'; children: BigUnion[]; } | { name: '131'; children: BigUnion[]; } | { name: '132'; children: BigUnion[]; } | { name: '133'; children: BigUnion[]; } | { name: '134'; children: BigUnion[]; } | { name: '135'; children: BigUnion[]; } | { name: '136'; children: BigUnion[]; } | { name: '137'; children: BigUnion[]; } | { name: '138'; children: BigUnion[]; } | { name: '139'; children: BigUnion[]; } | { name: '140'; children: BigUnion[]; } | { name: '141'; children: BigUnion[]; } | { name: '142'; children: BigUnion[]; } | { name: '143'; children: BigUnion[]; } | { name: '144'; children: BigUnion[]; } | { name: '145'; children: BigUnion[]; } | { name: '146'; children: BigUnion[]; } | { name: '147'; children: BigUnion[]; } | { name: '148'; children: BigUnion[]; } | { name: '149'; children: BigUnion[]; } | { name: '150'; children: BigUnion[]; } | { name: '151'; children: BigUnion[]; } | { name: '152'; children: BigUnion[]; } | { name: '153'; children: BigUnion[]; } | { name: '154'; children: BigUnion[]; } | { name: '155'; children: BigUnion[]; } | { name: '156'; children: BigUnion[]; } | { name: '157'; children: BigUnion[]; } | { name: '158'; children: BigUnion[]; } | { name: '159'; children: BigUnion[]; } | { name: '160'; children: BigUnion[]; } | { name: '161'; children: BigUnion[]; } | { name: '162'; children: BigUnion[]; } | { name: '163'; children: BigUnion[]; } | { name: '164'; children: BigUnion[]; } | { name: '165'; children: BigUnion[]; } | { name: '166'; children: BigUnion[]; } | { name: '167'; children: BigUnion[]; } | { name: '168'; children: BigUnion[]; } | { name: '169'; children: BigUnion[]; } | { name: '170'; children: BigUnion[]; } | { name: '171'; children: BigUnion[]; } | { name: '172'; children: BigUnion[]; } | { name: '173'; children: BigUnion[]; } | { name: '174'; children: BigUnion[]; } | { name: '175'; children: BigUnion[]; } | { name: '176'; children: BigUnion[]; } | { name: '177'; children: BigUnion[]; } | { name: '178'; children: BigUnion[]; } | { name: '179'; children: BigUnion[]; } | { name: '180'; children: BigUnion[]; } | { name: '181'; children: BigUnion[]; } | { name: '182'; children: BigUnion[]; } | { name: '183'; children: BigUnion[]; } | { name: '184'; children: BigUnion[]; } | { name: '185'; children: BigUnion[]; } | { name: '186'; children: BigUnion[]; } | { name: '187'; children: BigUnion[]; } | { name: '188'; children: BigUnion[]; } | { name: '189'; children: BigUnion[]; } | { name: '190'; children: BigUnion[]; } | { name: '191'; children: BigUnion[]; } | { name: '192'; children: BigUnion[]; } | { name: '193'; children: BigUnion[]; } | { name: '194'; children: BigUnion[]; } | { name: '195'; children: BigUnion[]; } | { name: '196'; children: BigUnion[]; } | { name: '197'; children: BigUnion[]; } | { name: '198'; children: BigUnion[]; } | { name: '199'; children: BigUnion[]; } | { name: '200'; children: BigUnion[]; } | { name: '201'; children: BigUnion[]; } | { name: '202'; children: BigUnion[]; } | { name: '203'; children: BigUnion[]; } | { name: '204'; children: BigUnion[]; } | { name: '205'; children: BigUnion[]; } | { name: '206'; children: BigUnion[]; } | { name: '207'; children: BigUnion[]; } | { name: '208'; children: BigUnion[]; } | { name: '209'; children: BigUnion[]; } | { name: '210'; children: BigUnion[]; } | { name: '211'; children: BigUnion[]; } | { name: '212'; children: BigUnion[]; } | { name: '213'; children: BigUnion[]; } | { name: '214'; children: BigUnion[]; } | { name: '215'; children: BigUnion[]; } | { name: '216'; children: BigUnion[]; } | { name: '217'; children: BigUnion[]; } | { name: '218'; children: BigUnion[]; } | { name: '219'; children: BigUnion[]; } | { name: '220'; children: BigUnion[]; } | { name: '221'; children: BigUnion[]; } | { name: '222'; children: BigUnion[]; } | { name: '223'; children: BigUnion[]; } | { name: '224'; children: BigUnion[]; } | { name: '225'; children: BigUnion[]; } | { name: '226'; children: BigUnion[]; } | { name: '227'; children: BigUnion[]; } | { name: '228'; children: BigUnion[]; } | { name: '229'; children: BigUnion[]; } | { name: '230'; children: BigUnion[]; } | { name: '231'; children: BigUnion[]; } | { name: '232'; children: BigUnion[]; } | { name: '233'; children: BigUnion[]; } | { name: '234'; children: BigUnion[]; } | { name: '235'; children: BigUnion[]; } | { name: '236'; children: BigUnion[]; } | { name: '237'; children: BigUnion[]; } | { name: '238'; children: BigUnion[]; } | { name: '239'; children: BigUnion[]; } | { name: '240'; children: BigUnion[]; } | { name: '241'; children: BigUnion[]; } | { name: '242'; children: BigUnion[]; } | { name: '243'; children: BigUnion[]; } | { name: '244'; children: BigUnion[]; } | { name: '245'; children: BigUnion[]; } | { name: '246'; children: BigUnion[]; } | { name: '247'; children: BigUnion[]; } | { name: '248'; children: BigUnion[]; } | { name: '249'; children: BigUnion[]; } | { name: '250'; children: BigUnion[]; } | { name: '251'; children: BigUnion[]; } | { name: '252'; children: BigUnion[]; } | { name: '253'; children: BigUnion[]; } | { name: '254'; children: BigUnion[]; } | { name: '255'; children: BigUnion[]; } | { name: '256'; children: BigUnion[]; } | { name: '257'; children: BigUnion[]; } | { name: '258'; children: BigUnion[]; } | { name: '259'; children: BigUnion[]; } | { name: '260'; children: BigUnion[]; } | { name: '261'; children: BigUnion[]; } | { name: '262'; children: BigUnion[]; } | { name: '263'; children: BigUnion[]; } | { name: '264'; children: BigUnion[]; } | { name: '265'; children: BigUnion[]; } | { name: '266'; children: BigUnion[]; } | { name: '267'; children: BigUnion[]; } | { name: '268'; children: BigUnion[]; } | { name: '269'; children: BigUnion[]; } | { name: '270'; children: BigUnion[]; } | { name: '271'; children: BigUnion[]; } | { name: '272'; children: BigUnion[]; } | { name: '273'; children: BigUnion[]; } | { name: '274'; children: BigUnion[]; } | { name: '275'; children: BigUnion[]; } | { name: '276'; children: BigUnion[]; } | { name: '277'; children: BigUnion[]; } | { name: '278'; children: BigUnion[]; } | { name: '279'; children: BigUnion[]; } | { name: '280'; children: BigUnion[]; } | { name: '281'; children: BigUnion[]; } | { name: '282'; children: BigUnion[]; } | { name: '283'; children: BigUnion[]; } | { name: '284'; children: BigUnion[]; } | { name: '285'; children: BigUnion[]; } | { name: '286'; children: BigUnion[]; } | { name: '287'; children: BigUnion[]; } | { name: '288'; children: BigUnion[]; } | { name: '289'; children: BigUnion[]; } | { name: '290'; children: BigUnion[]; } | { name: '291'; children: BigUnion[]; } | { name: '292'; children: BigUnion[]; } | { name: '293'; children: BigUnion[]; } | { name: '294'; children: BigUnion[]; } | { name: '295'; children: BigUnion[]; } | { name: '296'; children: BigUnion[]; } | { name: '297'; children: BigUnion[]; } | { name: '298'; children: BigUnion[]; } | { name: '299'; children: BigUnion[]; } | { name: '300'; children: BigUnion[]; } | { name: '301'; children: BigUnion[]; } | { name: '302'; children: BigUnion[]; } | { name: '303'; children: BigUnion[]; } | { name: '304'; children: BigUnion[]; } | { name: '305'; children: BigUnion[]; } | { name: '306'; children: BigUnion[]; } | { name: '307'; children: BigUnion[]; } | { name: '308'; children: BigUnion[]; } | { name: '309'; children: BigUnion[]; } | { name: '310'; children: BigUnion[]; } | { name: '311'; children: BigUnion[]; } | { name: '312'; children: BigUnion[]; } | { name: '313'; children: BigUnion[]; } | { name: '314'; children: BigUnion[]; } | { name: '315'; children: BigUnion[]; } | { name: '316'; children: BigUnion[]; } | { name: '317'; children: BigUnion[]; } | { name: '318'; children: BigUnion[]; } | { name: '319'; children: BigUnion[]; } | { name: '320'; children: BigUnion[]; } | { name: '321'; children: BigUnion[]; } | { name: '322'; children: BigUnion[]; } | { name: '323'; children: BigUnion[]; } | { name: '324'; children: BigUnion[]; } | { name: '325'; children: BigUnion[]; } | { name: '326'; children: BigUnion[]; } | { name: '327'; children: BigUnion[]; } | { name: '328'; children: BigUnion[]; } | { name: '329'; children: BigUnion[]; } | { name: '330'; children: BigUnion[]; } | { name: '331'; children: BigUnion[]; } | { name: '332'; children: BigUnion[]; } | { name: '333'; children: BigUnion[]; } | { name: '334'; children: BigUnion[]; } | { name: '335'; children: BigUnion[]; } | { name: '336'; children: BigUnion[]; } | { name: '337'; children: BigUnion[]; } | { name: '338'; children: BigUnion[]; } | { name: '339'; children: BigUnion[]; } | { name: '340'; children: BigUnion[]; } | { name: '341'; children: BigUnion[]; } | { name: '342'; children: BigUnion[]; } | { name: '343'; children: BigUnion[]; } | { name: '344'; children: BigUnion[]; } | { name: '345'; children: BigUnion[]; } | { name: '346'; children: BigUnion[]; } | { name: '347'; children: BigUnion[]; } | { name: '348'; children: BigUnion[]; } | { name: '349'; children: BigUnion[]; } | { name: '350'; children: BigUnion[]; } | { name: '351'; children: BigUnion[]; } | { name: '352'; children: BigUnion[]; } | { name: '353'; children: BigUnion[]; } | { name: '354'; children: BigUnion[]; } | { name: '355'; children: BigUnion[]; } | { name: '356'; children: BigUnion[]; } | { name: '357'; children: BigUnion[]; } | { name: '358'; children: BigUnion[]; } | { name: '359'; children: BigUnion[]; } | { name: '360'; children: BigUnion[]; } | { name: '361'; children: BigUnion[]; } | { name: '362'; children: BigUnion[]; } | { name: '363'; children: BigUnion[]; } | { name: '364'; children: BigUnion[]; } | { name: '365'; children: BigUnion[]; } | { name: '366'; children: BigUnion[]; } | { name: '367'; children: BigUnion[]; } | { name: '368'; children: BigUnion[]; } | { name: '369'; children: BigUnion[]; } | { name: '370'; children: BigUnion[]; } | { name: '371'; children: BigUnion[]; } | { name: '372'; children: BigUnion[]; } | { name: '373'; children: BigUnion[]; } | { name: '374'; children: BigUnion[]; } | { name: '375'; children: BigUnion[]; } | { name: '376'; children: BigUnion[]; } | { name: '377'; children: BigUnion[]; } | { name: '378'; children: BigUnion[]; } | { name: '379'; children: BigUnion[]; } | { name: '380'; children: BigUnion[]; } | { name: '381'; children: BigUnion[]; } | { name: '382'; children: BigUnion[]; } | { name: '383'; children: BigUnion[]; } | { name: '384'; children: BigUnion[]; } | { name: '385'; children: BigUnion[]; } | { name: '386'; children: BigUnion[]; } | { name: '387'; children: BigUnion[]; } | { name: '388'; children: BigUnion[]; } | { name: '389'; children: BigUnion[]; } | { name: '390'; children: BigUnion[]; } | { name: '391'; children: BigUnion[]; } | { name: '392'; children: BigUnion[]; } | { name: '393'; children: BigUnion[]; } | { name: '394'; children: BigUnion[]; } | { name: '395'; children: BigUnion[]; } | { name: '396'; children: BigUnion[]; } | { name: '397'; children: BigUnion[]; } | { name: '398'; children: BigUnion[]; } | { name: '399'; children: BigUnion[]; } | { name: '400'; children: BigUnion[]; } | { name: '401'; children: BigUnion[]; } | { name: '402'; children: BigUnion[]; } | { name: '403'; children: BigUnion[]; } | { name: '404'; children: BigUnion[]; } | { name: '405'; children: BigUnion[]; } | { name: '406'; children: BigUnion[]; } | { name: '407'; children: BigUnion[]; } | { name: '408'; children: BigUnion[]; } | { name: '409'; children: BigUnion[]; } | { name: '410'; children: BigUnion[]; } | { name: '411'; children: BigUnion[]; } | { name: '412'; children: BigUnion[]; } | { name: '413'; children: BigUnion[]; } | { name: '414'; children: BigUnion[]; } | { name: '415'; children: BigUnion[]; } | { name: '416'; children: BigUnion[]; } | { name: '417'; children: BigUnion[]; } | { name: '418'; children: BigUnion[]; } | { name: '419'; children: BigUnion[]; } | { name: '420'; children: BigUnion[]; } | { name: '421'; children: BigUnion[]; } | { name: '422'; children: BigUnion[]; } | { name: '423'; children: BigUnion[]; } | { name: '424'; children: BigUnion[]; } | { name: '425'; children: BigUnion[]; } | { name: '426'; children: BigUnion[]; } | { name: '427'; children: BigUnion[]; } | { name: '428'; children: BigUnion[]; } | { name: '429'; children: BigUnion[]; } | { name: '430'; children: BigUnion[]; } | { name: '431'; children: BigUnion[]; } | { name: '432'; children: BigUnion[]; } | { name: '433'; children: BigUnion[]; } | { name: '434'; children: BigUnion[]; } | { name: '435'; children: BigUnion[]; } | { name: '436'; children: BigUnion[]; } | { name: '437'; children: BigUnion[]; } | { name: '438'; children: BigUnion[]; } | { name: '439'; children: BigUnion[]; } | { name: '440'; children: BigUnion[]; } | { name: '441'; children: BigUnion[]; } | { name: '442'; children: BigUnion[]; } | { name: '443'; children: BigUnion[]; } | { name: '444'; children: BigUnion[]; } | { name: '445'; children: BigUnion[]; } | { name: '446'; children: BigUnion[]; } | { name: '447'; children: BigUnion[]; } | { name: '448'; children: BigUnion[]; } | { name: '449'; children: BigUnion[]; } | { name: '450'; children: BigUnion[]; } | { name: '451'; children: BigUnion[]; } | { name: '452'; children: BigUnion[]; } | { name: '453'; children: BigUnion[]; } | { name: '454'; children: BigUnion[]; } | { name: '455'; children: BigUnion[]; } | { name: '456'; children: BigUnion[]; } | { name: '457'; children: BigUnion[]; } | { name: '458'; children: BigUnion[]; } | { name: '459'; children: BigUnion[]; } | { name: '460'; children: BigUnion[]; } | { name: '461'; children: BigUnion[]; } | { name: '462'; children: BigUnion[]; } | { name: '463'; children: BigUnion[]; } | { name: '464'; children: BigUnion[]; } | { name: '465'; children: BigUnion[]; } | { name: '466'; children: BigUnion[]; } | { name: '467'; children: BigUnion[]; } | { name: '468'; children: BigUnion[]; } | { name: '469'; children: BigUnion[]; } | { name: '470'; children: BigUnion[]; } | { name: '471'; children: BigUnion[]; } | { name: '472'; children: BigUnion[]; } | { name: '473'; children: BigUnion[]; } | { name: '474'; children: BigUnion[]; } | { name: '475'; children: BigUnion[]; } | { name: '476'; children: BigUnion[]; } | { name: '477'; children: BigUnion[]; } | { name: '478'; children: BigUnion[]; } | { name: '479'; children: BigUnion[]; } | { name: '480'; children: BigUnion[]; } | { name: '481'; children: BigUnion[]; } | { name: '482'; children: BigUnion[]; } | { name: '483'; children: BigUnion[]; } | { name: '484'; children: BigUnion[]; } | { name: '485'; children: BigUnion[]; } | { name: '486'; children: BigUnion[]; } | { name: '487'; children: BigUnion[]; } | { name: '488'; children: BigUnion[]; } | { name: '489'; children: BigUnion[]; } | { name: '490'; children: BigUnion[]; } | { name: '491'; children: BigUnion[]; } | { name: '492'; children: BigUnion[]; } | { name: '493'; children: BigUnion[]; } | { name: '494'; children: BigUnion[]; } | { name: '495'; children: BigUnion[]; } | { name: '496'; children: BigUnion[]; } | { name: '497'; children: BigUnion[]; } | { name: '498'; children: BigUnion[]; } | { name: '499'; children: BigUnion[]; } | { name: '500'; children: BigUnion[]; } | { name: '501'; children: BigUnion[]; } | { name: '502'; children: BigUnion[]; } | { name: '503'; children: BigUnion[]; } | { name: '504'; children: BigUnion[]; } | { name: '505'; children: BigUnion[]; } | { name: '506'; children: BigUnion[]; } | { name: '507'; children: BigUnion[]; } | { name: '508'; children: BigUnion[]; } | { name: '509'; children: BigUnion[]; } | { name: '510'; children: BigUnion[]; } | { name: '511'; children: BigUnion[]; } | { name: '512'; children: BigUnion[]; } | { name: '513'; children: BigUnion[]; } | { name: '514'; children: BigUnion[]; } | { name: '515'; children: BigUnion[]; } | { name: '516'; children: BigUnion[]; } | { name: '517'; children: BigUnion[]; } | { name: '518'; children: BigUnion[]; } | { name: '519'; children: BigUnion[]; } | { name: '520'; children: BigUnion[]; } | { name: '521'; children: BigUnion[]; } | { name: '522'; children: BigUnion[]; } | { name: '523'; children: BigUnion[]; } | { name: '524'; children: BigUnion[]; } | { name: '525'; children: BigUnion[]; } | { name: '526'; children: BigUnion[]; } | { name: '527'; children: BigUnion[]; } | { name: '528'; children: BigUnion[]; } | { name: '529'; children: BigUnion[]; } | { name: '530'; children: BigUnion[]; } | { name: '531'; children: BigUnion[]; } | { name: '532'; children: BigUnion[]; } | { name: '533'; children: BigUnion[]; } | { name: '534'; children: BigUnion[]; } | { name: '535'; children: BigUnion[]; } | { name: '536'; children: BigUnion[]; } | { name: '537'; children: BigUnion[]; } | { name: '538'; children: BigUnion[]; } | { name: '539'; children: BigUnion[]; } | { name: '540'; children: BigUnion[]; } | { name: '541'; children: BigUnion[]; } | { name: '542'; children: BigUnion[]; } | { name: '543'; children: BigUnion[]; } | { name: '544'; children: BigUnion[]; } | { name: '545'; children: BigUnion[]; } | { name: '546'; children: BigUnion[]; } | { name: '547'; children: BigUnion[]; } | { name: '548'; children: BigUnion[]; } | { name: '549'; children: BigUnion[]; } | { name: '550'; children: BigUnion[]; } | { name: '551'; children: BigUnion[]; } | { name: '552'; children: BigUnion[]; } | { name: '553'; children: BigUnion[]; } | { name: '554'; children: BigUnion[]; } | { name: '555'; children: BigUnion[]; } | { name: '556'; children: BigUnion[]; } | { name: '557'; children: BigUnion[]; } | { name: '558'; children: BigUnion[]; } | { name: '559'; children: BigUnion[]; } | { name: '560'; children: BigUnion[]; } | { name: '561'; children: BigUnion[]; } | { name: '562'; children: BigUnion[]; } | { name: '563'; children: BigUnion[]; } | { name: '564'; children: BigUnion[]; } | { name: '565'; children: BigUnion[]; } | { name: '566'; children: BigUnion[]; } | { name: '567'; children: BigUnion[]; } | { name: '568'; children: BigUnion[]; } | { name: '569'; children: BigUnion[]; } | { name: '570'; children: BigUnion[]; } | { name: '571'; children: BigUnion[]; } | { name: '572'; children: BigUnion[]; } | { name: '573'; children: BigUnion[]; } | { name: '574'; children: BigUnion[]; } | { name: '575'; children: BigUnion[]; } | { name: '576'; children: BigUnion[]; } | { name: '577'; children: BigUnion[]; } | { name: '578'; children: BigUnion[]; } | { name: '579'; children: BigUnion[]; } | { name: '580'; children: BigUnion[]; } | { name: '581'; children: BigUnion[]; } | { name: '582'; children: BigUnion[]; } | { name: '583'; children: BigUnion[]; } | { name: '584'; children: BigUnion[]; } | { name: '585'; children: BigUnion[]; } | { name: '586'; children: BigUnion[]; } | { name: '587'; children: BigUnion[]; } | { name: '588'; children: BigUnion[]; } | { name: '589'; children: BigUnion[]; } | { name: '590'; children: BigUnion[]; } | { name: '591'; children: BigUnion[]; } | { name: '592'; children: BigUnion[]; } | { name: '593'; children: BigUnion[]; } | { name: '594'; children: BigUnion[]; } | { name: '595'; children: BigUnion[]; } | { name: '596'; children: BigUnion[]; } | { name: '597'; children: BigUnion[]; } | { name: '598'; children: BigUnion[]; } | { name: '599'; children: BigUnion[]; } | { name: '600'; children: BigUnion[]; } | { name: '601'; children: BigUnion[]; } | { name: '602'; children: BigUnion[]; } | { name: '603'; children: BigUnion[]; } | { name: '604'; children: BigUnion[]; } | { name: '605'; children: BigUnion[]; } | { name: '606'; children: BigUnion[]; } | { name: '607'; children: BigUnion[]; } | { name: '608'; children: BigUnion[]; } | { name: '609'; children: BigUnion[]; } | { name: '610'; children: BigUnion[]; } | { name: '611'; children: BigUnion[]; } | { name: '612'; children: BigUnion[]; } | { name: '613'; children: BigUnion[]; } | { name: '614'; children: BigUnion[]; } | { name: '615'; children: BigUnion[]; } | { name: '616'; children: BigUnion[]; } | { name: '617'; children: BigUnion[]; } | { name: '618'; children: BigUnion[]; } | { name: '619'; children: BigUnion[]; } | { name: '620'; children: BigUnion[]; } | { name: '621'; children: BigUnion[]; } | { name: '622'; children: BigUnion[]; } | { name: '623'; children: BigUnion[]; } | { name: '624'; children: BigUnion[]; } | { name: '625'; children: BigUnion[]; } | { name: '626'; children: BigUnion[]; } | { name: '627'; children: BigUnion[]; } | { name: '628'; children: BigUnion[]; } | { name: '629'; children: BigUnion[]; } | { name: '630'; children: BigUnion[]; } | { name: '631'; children: BigUnion[]; } | { name: '632'; children: BigUnion[]; } | { name: '633'; children: BigUnion[]; } | { name: '634'; children: BigUnion[]; } | { name: '635'; children: BigUnion[]; } | { name: '636'; children: BigUnion[]; } | { name: '637'; children: BigUnion[]; } | { name: '638'; children: BigUnion[]; } | { name: '639'; children: BigUnion[]; } | { name: '640'; children: BigUnion[]; } | { name: '641'; children: BigUnion[]; } | { name: '642'; children: BigUnion[]; } | { name: '643'; children: BigUnion[]; } | { name: '644'; children: BigUnion[]; } | { name: '645'; children: BigUnion[]; } | { name: '646'; children: BigUnion[]; } | { name: '647'; children: BigUnion[]; } | { name: '648'; children: BigUnion[]; } | { name: '649'; children: BigUnion[]; } | { name: '650'; children: BigUnion[]; } | { name: '651'; children: BigUnion[]; } | { name: '652'; children: BigUnion[]; } | { name: '653'; children: BigUnion[]; } | { name: '654'; children: BigUnion[]; } | { name: '655'; children: BigUnion[]; } | { name: '656'; children: BigUnion[]; } | { name: '657'; children: BigUnion[]; } | { name: '658'; children: BigUnion[]; } | { name: '659'; children: BigUnion[]; } | { name: '660'; children: BigUnion[]; } | { name: '661'; children: BigUnion[]; } | { name: '662'; children: BigUnion[]; } | { name: '663'; children: BigUnion[]; } | { name: '664'; children: BigUnion[]; } | { name: '665'; children: BigUnion[]; } | { name: '666'; children: BigUnion[]; } | { name: '667'; children: BigUnion[]; } | { name: '668'; children: BigUnion[]; } | { name: '669'; children: BigUnion[]; } | { name: '670'; children: BigUnion[]; } | { name: '671'; children: BigUnion[]; } | { name: '672'; children: BigUnion[]; } | { name: '673'; children: BigUnion[]; } | { name: '674'; children: BigUnion[]; } | { name: '675'; children: BigUnion[]; } | { name: '676'; children: BigUnion[]; } | { name: '677'; children: BigUnion[]; } | { name: '678'; children: BigUnion[]; } | { name: '679'; children: BigUnion[]; } | { name: '680'; children: BigUnion[]; } | { name: '681'; children: BigUnion[]; } | { name: '682'; children: BigUnion[]; } | { name: '683'; children: BigUnion[]; } | { name: '684'; children: BigUnion[]; } | { name: '685'; children: BigUnion[]; } | { name: '686'; children: BigUnion[]; } | { name: '687'; children: BigUnion[]; } | { name: '688'; children: BigUnion[]; } | { name: '689'; children: BigUnion[]; } | { name: '690'; children: BigUnion[]; } | { name: '691'; children: BigUnion[]; } | { name: '692'; children: BigUnion[]; } | { name: '693'; children: BigUnion[]; } | { name: '694'; children: BigUnion[]; } | { name: '695'; children: BigUnion[]; } | { name: '696'; children: BigUnion[]; } | { name: '697'; children: BigUnion[]; } | { name: '698'; children: BigUnion[]; } | { name: '699'; children: BigUnion[]; } | { name: '700'; children: BigUnion[]; } | { name: '701'; children: BigUnion[]; } | { name: '702'; children: BigUnion[]; } | { name: '703'; children: BigUnion[]; } | { name: '704'; children: BigUnion[]; } | { name: '705'; children: BigUnion[]; } | { name: '706'; children: BigUnion[]; } | { name: '707'; children: BigUnion[]; } | { name: '708'; children: BigUnion[]; } | { name: '709'; children: BigUnion[]; } | { name: '710'; children: BigUnion[]; } | { name: '711'; children: BigUnion[]; } | { name: '712'; children: BigUnion[]; } | { name: '713'; children: BigUnion[]; } | { name: '714'; children: BigUnion[]; } | { name: '715'; children: BigUnion[]; } | { name: '716'; children: BigUnion[]; } | { name: '717'; children: BigUnion[]; } | { name: '718'; children: BigUnion[]; } | { name: '719'; children: BigUnion[]; } | { name: '720'; children: BigUnion[]; } | { name: '721'; children: BigUnion[]; } | { name: '722'; children: BigUnion[]; } | { name: '723'; children: BigUnion[]; } | { name: '724'; children: BigUnion[]; } | { name: '725'; children: BigUnion[]; } | { name: '726'; children: BigUnion[]; } | { name: '727'; children: BigUnion[]; } | { name: '728'; children: BigUnion[]; } | { name: '729'; children: BigUnion[]; } | { name: '730'; children: BigUnion[]; } | { name: '731'; children: BigUnion[]; } | { name: '732'; children: BigUnion[]; } | { name: '733'; children: BigUnion[]; } | { name: '734'; children: BigUnion[]; } | { name: '735'; children: BigUnion[]; } | { name: '736'; children: BigUnion[]; } | { name: '737'; children: BigUnion[]; } | { name: '738'; children: BigUnion[]; } | { name: '739'; children: BigUnion[]; } | { name: '740'; children: BigUnion[]; } | { name: '741'; children: BigUnion[]; } | { name: '742'; children: BigUnion[]; } | { name: '743'; children: BigUnion[]; } | { name: '744'; children: BigUnion[]; } | { name: '745'; children: BigUnion[]; } | { name: '746'; children: BigUnion[]; } | { name: '747'; children: BigUnion[]; } | { name: '748'; children: BigUnion[]; } | { name: '749'; children: BigUnion[]; } | { name: '750'; children: BigUnion[]; } | { name: '751'; children: BigUnion[]; } | { name: '752'; children: BigUnion[]; } | { name: '753'; children: BigUnion[]; } | { name: '754'; children: BigUnion[]; } | { name: '755'; children: BigUnion[]; } | { name: '756'; children: BigUnion[]; } | { name: '757'; children: BigUnion[]; } | { name: '758'; children: BigUnion[]; } | { name: '759'; children: BigUnion[]; } | { name: '760'; children: BigUnion[]; } | { name: '761'; children: BigUnion[]; } | { name: '762'; children: BigUnion[]; } | { name: '763'; children: BigUnion[]; } | { name: '764'; children: BigUnion[]; } | { name: '765'; children: BigUnion[]; } | { name: '766'; children: BigUnion[]; } | { name: '767'; children: BigUnion[]; } | { name: '768'; children: BigUnion[]; } | { name: '769'; children: BigUnion[]; } | { name: '770'; children: BigUnion[]; } | { name: '771'; children: BigUnion[]; } | { name: '772'; children: BigUnion[]; } | { name: '773'; children: BigUnion[]; } | { name: '774'; children: BigUnion[]; } | { name: '775'; children: BigUnion[]; } | { name: '776'; children: BigUnion[]; } | { name: '777'; children: BigUnion[]; } | { name: '778'; children: BigUnion[]; } | { name: '779'; children: BigUnion[]; } | { name: '780'; children: BigUnion[]; } | { name: '781'; children: BigUnion[]; } | { name: '782'; children: BigUnion[]; } | { name: '783'; children: BigUnion[]; } | { name: '784'; children: BigUnion[]; } | { name: '785'; children: BigUnion[]; } | { name: '786'; children: BigUnion[]; } | { name: '787'; children: BigUnion[]; } | { name: '788'; children: BigUnion[]; } | { name: '789'; children: BigUnion[]; } | { name: '790'; children: BigUnion[]; } | { name: '791'; children: BigUnion[]; } | { name: '792'; children: BigUnion[]; } | { name: '793'; children: BigUnion[]; } | { name: '794'; children: BigUnion[]; } | { name: '795'; children: BigUnion[]; } | { name: '796'; children: BigUnion[]; } | { name: '797'; children: BigUnion[]; } | { name: '798'; children: BigUnion[]; } | { name: '799'; children: BigUnion[]; } | { name: '800'; children: BigUnion[]; } | { name: '801'; children: BigUnion[]; } | { name: '802'; children: BigUnion[]; } | { name: '803'; children: BigUnion[]; } | { name: '804'; children: BigUnion[]; } | { name: '805'; children: BigUnion[]; } | { name: '806'; children: BigUnion[]; } | { name: '807'; children: BigUnion[]; } | { name: '808'; children: BigUnion[]; } | { name: '809'; children: BigUnion[]; } | { name: '810'; children: BigUnion[]; } | { name: '811'; children: BigUnion[]; } | { name: '812'; children: BigUnion[]; } | { name: '813'; children: BigUnion[]; } | { name: '814'; children: BigUnion[]; } | { name: '815'; children: BigUnion[]; } | { name: '816'; children: BigUnion[]; } | { name: '817'; children: BigUnion[]; } | { name: '818'; children: BigUnion[]; } | { name: '819'; children: BigUnion[]; } | { name: '820'; children: BigUnion[]; } | { name: '821'; children: BigUnion[]; } | { name: '822'; children: BigUnion[]; } | { name: '823'; children: BigUnion[]; } | { name: '824'; children: BigUnion[]; } | { name: '825'; children: BigUnion[]; } | { name: '826'; children: BigUnion[]; } | { name: '827'; children: BigUnion[]; } | { name: '828'; children: BigUnion[]; } | { name: '829'; children: BigUnion[]; } | { name: '830'; children: BigUnion[]; } | { name: '831'; children: BigUnion[]; } | { name: '832'; children: BigUnion[]; } | { name: '833'; children: BigUnion[]; } | { name: '834'; children: BigUnion[]; } | { name: '835'; children: BigUnion[]; } | { name: '836'; children: BigUnion[]; } | { name: '837'; children: BigUnion[]; } | { name: '838'; children: BigUnion[]; } | { name: '839'; children: BigUnion[]; } | { name: '840'; children: BigUnion[]; } | { name: '841'; children: BigUnion[]; } | { name: '842'; children: BigUnion[]; } | { name: '843'; children: BigUnion[]; } | { name: '844'; children: BigUnion[]; } | { name: '845'; children: BigUnion[]; } | { name: '846'; children: BigUnion[]; } | { name: '847'; children: BigUnion[]; } | { name: '848'; children: BigUnion[]; } | { name: '849'; children: BigUnion[]; } | { name: '850'; children: BigUnion[]; } | { name: '851'; children: BigUnion[]; } | { name: '852'; children: BigUnion[]; } | { name: '853'; children: BigUnion[]; } | { name: '854'; children: BigUnion[]; } | { name: '855'; children: BigUnion[]; } | { name: '856'; children: BigUnion[]; } | { name: '857'; children: BigUnion[]; } | { name: '858'; children: BigUnion[]; } | { name: '859'; children: BigUnion[]; } | { name: '860'; children: BigUnion[]; } | { name: '861'; children: BigUnion[]; } | { name: '862'; children: BigUnion[]; } | { name: '863'; children: BigUnion[]; } | { name: '864'; children: BigUnion[]; } | { name: '865'; children: BigUnion[]; } | { name: '866'; children: BigUnion[]; } | { name: '867'; children: BigUnion[]; } | { name: '868'; children: BigUnion[]; } | { name: '869'; children: BigUnion[]; } | { name: '870'; children: BigUnion[]; } | { name: '871'; children: BigUnion[]; } | { name: '872'; children: BigUnion[]; } | { name: '873'; children: BigUnion[]; } | { name: '874'; children: BigUnion[]; } | { name: '875'; children: BigUnion[]; } | { name: '876'; children: BigUnion[]; } | { name: '877'; children: BigUnion[]; } | { name: '878'; children: BigUnion[]; } | { name: '879'; children: BigUnion[]; } | { name: '880'; children: BigUnion[]; } | { name: '881'; children: BigUnion[]; } | { name: '882'; children: BigUnion[]; } | { name: '883'; children: BigUnion[]; } | { name: '884'; children: BigUnion[]; } | { name: '885'; children: BigUnion[]; } | { name: '886'; children: BigUnion[]; } | { name: '887'; children: BigUnion[]; } | { name: '888'; children: BigUnion[]; } | { name: '889'; children: BigUnion[]; } | { name: '890'; children: BigUnion[]; } | { name: '891'; children: BigUnion[]; } | { name: '892'; children: BigUnion[]; } | { name: '893'; children: BigUnion[]; } | { name: '894'; children: BigUnion[]; } | { name: '895'; children: BigUnion[]; } | { name: '896'; children: BigUnion[]; } | { name: '897'; children: BigUnion[]; } | { name: '898'; children: BigUnion[]; } | { name: '899'; children: BigUnion[]; } | { name: '900'; children: BigUnion[]; } | { name: '901'; children: BigUnion[]; } | { name: '902'; children: BigUnion[]; } | { name: '903'; children: BigUnion[]; } | { name: '904'; children: BigUnion[]; } | { name: '905'; children: BigUnion[]; } | { name: '906'; children: BigUnion[]; } | { name: '907'; children: BigUnion[]; } | { name: '908'; children: BigUnion[]; } | { name: '909'; children: BigUnion[]; } | { name: '910'; children: BigUnion[]; } | { name: '911'; children: BigUnion[]; } | { name: '912'; children: BigUnion[]; } | { name: '913'; children: BigUnion[]; } | { name: '914'; children: BigUnion[]; } | { name: '915'; children: BigUnion[]; } | { name: '916'; children: BigUnion[]; } | { name: '917'; children: BigUnion[]; } | { name: '918'; children: BigUnion[]; } | { name: '919'; children: BigUnion[]; } | { name: '920'; children: BigUnion[]; } | { name: '921'; children: BigUnion[]; } | { name: '922'; children: BigUnion[]; } | { name: '923'; children: BigUnion[]; } | { name: '924'; children: BigUnion[]; } | { name: '925'; children: BigUnion[]; } | { name: '926'; children: BigUnion[]; } | { name: '927'; children: BigUnion[]; } | { name: '928'; children: BigUnion[]; } | { name: '929'; children: BigUnion[]; } | { name: '930'; children: BigUnion[]; } | { name: '931'; children: BigUnion[]; } | { name: '932'; children: BigUnion[]; } | { name: '933'; children: BigUnion[]; } | { name: '934'; children: BigUnion[]; } | { name: '935'; children: BigUnion[]; } | { name: '936'; children: BigUnion[]; } | { name: '937'; children: BigUnion[]; } | { name: '938'; children: BigUnion[]; } | { name: '939'; children: BigUnion[]; } | { name: '940'; children: BigUnion[]; } | { name: '941'; children: BigUnion[]; } | { name: '942'; children: BigUnion[]; } | { name: '943'; children: BigUnion[]; } | { name: '944'; children: BigUnion[]; } | { name: '945'; children: BigUnion[]; } | { name: '946'; children: BigUnion[]; } | { name: '947'; children: BigUnion[]; } | { name: '948'; children: BigUnion[]; } | { name: '949'; children: BigUnion[]; } | { name: '950'; children: BigUnion[]; } | { name: '951'; children: BigUnion[]; } | { name: '952'; children: BigUnion[]; } | { name: '953'; children: BigUnion[]; } | { name: '954'; children: BigUnion[]; } | { name: '955'; children: BigUnion[]; } | { name: '956'; children: BigUnion[]; } | { name: '957'; children: BigUnion[]; } | { name: '958'; children: BigUnion[]; } | { name: '959'; children: BigUnion[]; } | { name: '960'; children: BigUnion[]; } | { name: '961'; children: BigUnion[]; } | { name: '962'; children: BigUnion[]; } | { name: '963'; children: BigUnion[]; } | { name: '964'; children: BigUnion[]; } | { name: '965'; children: BigUnion[]; } | { name: '966'; children: BigUnion[]; } | { name: '967'; children: BigUnion[]; } | { name: '968'; children: BigUnion[]; } | { name: '969'; children: BigUnion[]; } | { name: '970'; children: BigUnion[]; } | { name: '971'; children: BigUnion[]; } | { name: '972'; children: BigUnion[]; } | { name: '973'; children: BigUnion[]; } | { name: '974'; children: BigUnion[]; } | { name: '975'; children: BigUnion[]; } | { name: '976'; children: BigUnion[]; } | { name: '977'; children: BigUnion[]; } | { name: '978'; children: BigUnion[]; } | { name: '979'; children: BigUnion[]; } | { name: '980'; children: BigUnion[]; } | { name: '981'; children: BigUnion[]; } | { name: '982'; children: BigUnion[]; } | { name: '983'; children: BigUnion[]; } | { name: '984'; children: BigUnion[]; } | { name: '985'; children: BigUnion[]; } | { name: '986'; children: BigUnion[]; } | { name: '987'; children: BigUnion[]; } | { name: '988'; children: BigUnion[]; } | { name: '989'; children: BigUnion[]; } | { name: '990'; children: BigUnion[]; } | { name: '991'; children: BigUnion[]; } | { name: '992'; children: BigUnion[]; } | { name: '993'; children: BigUnion[]; } | { name: '994'; children: BigUnion[]; } | { name: '995'; children: BigUnion[]; } | { name: '996'; children: BigUnion[]; } | { name: '997'; children: BigUnion[]; } | { name: '998'; children: BigUnion[]; } | { name: '999'; children: BigUnion[]; } | { name: '1000'; children: BigUnion[]; } | { name: '1001'; children: BigUnion[]; } | { name: '1002'; children: BigUnion[]; } | { name: '1003'; children: BigUnion[]; } | { name: '1004'; children: BigUnion[]; } | { name: '1005'; children: BigUnion[]; } | { name: '1006'; children: BigUnion[]; } | { name: '1007'; children: BigUnion[]; } | { name: '1008'; children: BigUnion[]; } | { name: '1009'; children: BigUnion[]; } | { name: '1010'; children: BigUnion[]; } | { name: '1011'; children: BigUnion[]; } | { name: '1012'; children: BigUnion[]; } | { name: '1013'; children: BigUnion[]; } | { name: '1014'; children: BigUnion[]; } | { name: '1015'; children: BigUnion[]; } | { name: '1016'; children: BigUnion[]; } | { name: '1017'; children: BigUnion[]; } | { name: '1018'; children: BigUnion[]; } | { name: '1019'; children: BigUnion[]; } | { name: '1020'; children: BigUnion[]; } | { name: '1021'; children: BigUnion[]; } | { name: '1022'; children: BigUnion[]; } | { name: '1023'; children: BigUnion[]; } | { name: '1024'; children: BigUnion[]; } | { name: '1025'; children: BigUnion[]; } | { name: '1026'; children: BigUnion[]; } | { name: '1027'; children: BigUnion[]; } | { name: '1028'; children: BigUnion[]; } | { name: '1029'; children: BigUnion[]; } | { name: '1030'; children: BigUnion[]; } | { name: '1031'; children: BigUnion[]; } | { name: '1032'; children: BigUnion[]; } | { name: '1033'; children: BigUnion[]; } | { name: '1034'; children: BigUnion[]; } | { name: '1035'; children: BigUnion[]; } | { name: '1036'; children: BigUnion[]; } | { name: '1037'; children: BigUnion[]; } | { name: '1038'; children: BigUnion[]; } | { name: '1039'; children: BigUnion[]; } | { name: '1040'; children: BigUnion[]; } | { name: '1041'; children: BigUnion[]; } | { name: '1042'; children: BigUnion[]; } | { name: '1043'; children: BigUnion[]; } | { name: '1044'; children: BigUnion[]; } | { name: '1045'; children: BigUnion[]; } | { name: '1046'; children: BigUnion[]; } | { name: '1047'; children: BigUnion[]; } | { name: '1048'; children: BigUnion[]; } | { name: '1049'; children: BigUnion[]; } | { name: '1050'; children: BigUnion[]; } | { name: '1051'; children: BigUnion[]; } | { name: '1052'; children: BigUnion[]; } | { name: '1053'; children: BigUnion[]; } | { name: '1054'; children: BigUnion[]; } | { name: '1055'; children: BigUnion[]; } | { name: '1056'; children: BigUnion[]; } | { name: '1057'; children: BigUnion[]; } | { name: '1058'; children: BigUnion[]; } | { name: '1059'; children: BigUnion[]; } | { name: '1060'; children: BigUnion[]; } | { name: '1061'; children: BigUnion[]; } | { name: '1062'; children: BigUnion[]; } | { name: '1063'; children: BigUnion[]; } | { name: '1064'; children: BigUnion[]; } | { name: '1065'; children: BigUnion[]; } | { name: '1066'; children: BigUnion[]; } | { name: '1067'; children: BigUnion[]; } | { name: '1068'; children: BigUnion[]; } | { name: '1069'; children: BigUnion[]; } | { name: '1070'; children: BigUnion[]; } | { name: '1071'; children: BigUnion[]; } | { name: '1072'; children: BigUnion[]; } | { name: '1073'; children: BigUnion[]; } | { name: '1074'; children: BigUnion[]; } | { name: '1075'; children: BigUnion[]; } | { name: '1076'; children: BigUnion[]; } | { name: '1077'; children: BigUnion[]; } | { name: '1078'; children: BigUnion[]; } | { name: '1079'; children: BigUnion[]; } | { name: '1080'; children: BigUnion[]; } | { name: '1081'; children: BigUnion[]; } | { name: '1082'; children: BigUnion[]; } | { name: '1083'; children: BigUnion[]; } | { name: '1084'; children: BigUnion[]; } | { name: '1085'; children: BigUnion[]; } | { name: '1086'; children: BigUnion[]; } | { name: '1087'; children: BigUnion[]; } | { name: '1088'; children: BigUnion[]; } | { name: '1089'; children: BigUnion[]; } | { name: '1090'; children: BigUnion[]; } | { name: '1091'; children: BigUnion[]; } | { name: '1092'; children: BigUnion[]; } | { name: '1093'; children: BigUnion[]; } | { name: '1094'; children: BigUnion[]; } | { name: '1095'; children: BigUnion[]; } | { name: '1096'; children: BigUnion[]; } | { name: '1097'; children: BigUnion[]; } | { name: '1098'; children: BigUnion[]; } | { name: '1099'; children: BigUnion[]; } | { name: '1100'; children: BigUnion[]; } | { name: '1101'; children: BigUnion[]; } | { name: '1102'; children: BigUnion[]; } | { name: '1103'; children: BigUnion[]; } | { name: '1104'; children: BigUnion[]; } | { name: '1105'; children: BigUnion[]; } | { name: '1106'; children: BigUnion[]; } | { name: '1107'; children: BigUnion[]; } | { name: '1108'; children: BigUnion[]; } | { name: '1109'; children: BigUnion[]; } | { name: '1110'; children: BigUnion[]; } | { name: '1111'; children: BigUnion[]; } | { name: '1112'; children: BigUnion[]; } | { name: '1113'; children: BigUnion[]; } | { name: '1114'; children: BigUnion[]; } | { name: '1115'; children: BigUnion[]; } | { name: '1116'; children: BigUnion[]; } | { name: '1117'; children: BigUnion[]; } | { name: '1118'; children: BigUnion[]; } | { name: '1119'; children: BigUnion[]; } | { name: '1120'; children: BigUnion[]; } | { name: '1121'; children: BigUnion[]; } | { name: '1122'; children: BigUnion[]; } | { name: '1123'; children: BigUnion[]; } | { name: '1124'; children: BigUnion[]; } | { name: '1125'; children: BigUnion[]; } | { name: '1126'; children: BigUnion[]; } | { name: '1127'; children: BigUnion[]; } | { name: '1128'; children: BigUnion[]; } | { name: '1129'; children: BigUnion[]; } | { name: '1130'; children: BigUnion[]; } | { name: '1131'; children: BigUnion[]; } | { name: '1132'; children: BigUnion[]; } | { name: '1133'; children: BigUnion[]; } | { name: '1134'; children: BigUnion[]; } | { name: '1135'; children: BigUnion[]; } | { name: '1136'; children: BigUnion[]; } | { name: '1137'; children: BigUnion[]; } | { name: '1138'; children: BigUnion[]; } | { name: '1139'; children: BigUnion[]; } | { name: '1140'; children: BigUnion[]; } | { name: '1141'; children: BigUnion[]; } | { name: '1142'; children: BigUnion[]; } | { name: '1143'; children: BigUnion[]; } | { name: '1144'; children: BigUnion[]; } | { name: '1145'; children: BigUnion[]; } | { name: '1146'; children: BigUnion[]; } | { name: '1147'; children: BigUnion[]; } | { name: '1148'; children: BigUnion[]; } | { name: '1149'; children: BigUnion[]; } | { name: '1150'; children: BigUnion[]; } | { name: '1151'; children: BigUnion[]; } | { name: '1152'; children: BigUnion[]; } | { name: '1153'; children: BigUnion[]; } | { name: '1154'; children: BigUnion[]; } | { name: '1155'; children: BigUnion[]; } | { name: '1156'; children: BigUnion[]; } | { name: '1157'; children: BigUnion[]; } | { name: '1158'; children: BigUnion[]; } | { name: '1159'; children: BigUnion[]; } | { name: '1160'; children: BigUnion[]; } | { name: '1161'; children: BigUnion[]; } | { name: '1162'; children: BigUnion[]; } | { name: '1163'; children: BigUnion[]; } | { name: '1164'; children: BigUnion[]; } | { name: '1165'; children: BigUnion[]; } | { name: '1166'; children: BigUnion[]; } | { name: '1167'; children: BigUnion[]; } | { name: '1168'; children: BigUnion[]; } | { name: '1169'; children: BigUnion[]; } | { name: '1170'; children: BigUnion[]; } | { name: '1171'; children: BigUnion[]; } | { name: '1172'; children: BigUnion[]; } | { name: '1173'; children: BigUnion[]; } | { name: '1174'; children: BigUnion[]; } | { name: '1175'; children: BigUnion[]; } | { name: '1176'; children: BigUnion[]; } | { name: '1177'; children: BigUnion[]; } | { name: '1178'; children: BigUnion[]; } | { name: '1179'; children: BigUnion[]; } | { name: '1180'; children: BigUnion[]; } | { name: '1181'; children: BigUnion[]; } | { name: '1182'; children: BigUnion[]; } | { name: '1183'; children: BigUnion[]; } | { name: '1184'; children: BigUnion[]; } | { name: '1185'; children: BigUnion[]; } | { name: '1186'; children: BigUnion[]; } | { name: '1187'; children: BigUnion[]; } | { name: '1188'; children: BigUnion[]; } | { name: '1189'; children: BigUnion[]; } | { name: '1190'; children: BigUnion[]; } | { name: '1191'; children: BigUnion[]; } | { name: '1192'; children: BigUnion[]; } | { name: '1193'; children: BigUnion[]; } | { name: '1194'; children: BigUnion[]; } | { name: '1195'; children: BigUnion[]; } | { name: '1196'; children: BigUnion[]; } | { name: '1197'; children: BigUnion[]; } | { name: '1198'; children: BigUnion[]; } | { name: '1199'; children: BigUnion[]; } | { name: '1200'; children: BigUnion[]; } | { name: '1201'; children: BigUnion[]; } | { name: '1202'; children: BigUnion[]; } | { name: '1203'; children: BigUnion[]; } | { name: '1204'; children: BigUnion[]; } | { name: '1205'; children: BigUnion[]; } | { name: '1206'; children: BigUnion[]; } | { name: '1207'; children: BigUnion[]; } | { name: '1208'; children: BigUnion[]; } | { name: '1209'; children: BigUnion[]; } | { name: '1210'; children: BigUnion[]; } | { name: '1211'; children: BigUnion[]; } | { name: '1212'; children: BigUnion[]; } | { name: '1213'; children: BigUnion[]; } | { name: '1214'; children: BigUnion[]; } | { name: '1215'; children: BigUnion[]; } | { name: '1216'; children: BigUnion[]; } | { name: '1217'; children: BigUnion[]; } | { name: '1218'; children: BigUnion[]; } | { name: '1219'; children: BigUnion[]; } | { name: '1220'; children: BigUnion[]; } | { name: '1221'; children: BigUnion[]; } | { name: '1222'; children: BigUnion[]; } | { name: '1223'; children: BigUnion[]; } | { name: '1224'; children: BigUnion[]; } | { name: '1225'; children: BigUnion[]; } | { name: '1226'; children: BigUnion[]; } | { name: '1227'; children: BigUnion[]; } | { name: '1228'; children: BigUnion[]; } | { name: '1229'; children: BigUnion[]; } | { name: '1230'; children: BigUnion[]; } | { name: '1231'; children: BigUnion[]; } | { name: '1232'; children: BigUnion[]; } | { name: '1233'; children: BigUnion[]; } | { name: '1234'; children: BigUnion[]; } | { name: '1235'; children: BigUnion[]; } | { name: '1236'; children: BigUnion[]; } | { name: '1237'; children: BigUnion[]; } | { name: '1238'; children: BigUnion[]; } | { name: '1239'; children: BigUnion[]; } | { name: '1240'; children: BigUnion[]; } | { name: '1241'; children: BigUnion[]; } | { name: '1242'; children: BigUnion[]; } | { name: '1243'; children: BigUnion[]; } | { name: '1244'; children: BigUnion[]; } | { name: '1245'; children: BigUnion[]; } | { name: '1246'; children: BigUnion[]; } | { name: '1247'; children: BigUnion[]; } | { name: '1248'; children: BigUnion[]; } | { name: '1249'; children: BigUnion[]; } | { name: '1250'; children: BigUnion[]; } | { name: '1251'; children: BigUnion[]; } | { name: '1252'; children: BigUnion[]; } | { name: '1253'; children: BigUnion[]; } | { name: '1254'; children: BigUnion[]; } | { name: '1255'; children: BigUnion[]; } | { name: '1256'; children: BigUnion[]; } | { name: '1257'; children: BigUnion[]; } | { name: '1258'; children: BigUnion[]; } | { name: '1259'; children: BigUnion[]; } | { name: '1260'; children: BigUnion[]; } | { name: '1261'; children: BigUnion[]; } | { name: '1262'; children: BigUnion[]; } | { name: '1263'; children: BigUnion[]; } | { name: '1264'; children: BigUnion[]; } | { name: '1265'; children: BigUnion[]; } | { name: '1266'; children: BigUnion[]; } | { name: '1267'; children: BigUnion[]; } | { name: '1268'; children: BigUnion[]; } | { name: '1269'; children: BigUnion[]; } | { name: '1270'; children: BigUnion[]; } | { name: '1271'; children: BigUnion[]; } | { name: '1272'; children: BigUnion[]; } | { name: '1273'; children: BigUnion[]; } | { name: '1274'; children: BigUnion[]; } | { name: '1275'; children: BigUnion[]; } | { name: '1276'; children: BigUnion[]; } | { name: '1277'; children: BigUnion[]; } | { name: '1278'; children: BigUnion[]; } | { name: '1279'; children: BigUnion[]; } | { name: '1280'; children: BigUnion[]; } | { name: '1281'; children: BigUnion[]; } | { name: '1282'; children: BigUnion[]; } | { name: '1283'; children: BigUnion[]; } | { name: '1284'; children: BigUnion[]; } | { name: '1285'; children: BigUnion[]; } | { name: '1286'; children: BigUnion[]; } | { name: '1287'; children: BigUnion[]; } | { name: '1288'; children: BigUnion[]; } | { name: '1289'; children: BigUnion[]; } | { name: '1290'; children: BigUnion[]; } | { name: '1291'; children: BigUnion[]; } | { name: '1292'; children: BigUnion[]; } | { name: '1293'; children: BigUnion[]; } | { name: '1294'; children: BigUnion[]; } | { name: '1295'; children: BigUnion[]; } | { name: '1296'; children: BigUnion[]; } | { name: '1297'; children: BigUnion[]; } | { name: '1298'; children: BigUnion[]; } | { name: '1299'; children: BigUnion[]; } | { name: '1300'; children: BigUnion[]; } | { name: '1301'; children: BigUnion[]; } | { name: '1302'; children: BigUnion[]; } | { name: '1303'; children: BigUnion[]; } | { name: '1304'; children: BigUnion[]; } | { name: '1305'; children: BigUnion[]; } | { name: '1306'; children: BigUnion[]; } | { name: '1307'; children: BigUnion[]; } | { name: '1308'; children: BigUnion[]; } | { name: '1309'; children: BigUnion[]; } | { name: '1310'; children: BigUnion[]; } | { name: '1311'; children: BigUnion[]; } | { name: '1312'; children: BigUnion[]; } | { name: '1313'; children: BigUnion[]; } | { name: '1314'; children: BigUnion[]; } | { name: '1315'; children: BigUnion[]; } | { name: '1316'; children: BigUnion[]; } | { name: '1317'; children: BigUnion[]; } | { name: '1318'; children: BigUnion[]; } | { name: '1319'; children: BigUnion[]; } | { name: '1320'; children: BigUnion[]; } | { name: '1321'; children: BigUnion[]; } | { name: '1322'; children: BigUnion[]; } | { name: '1323'; children: BigUnion[]; } | { name: '1324'; children: BigUnion[]; } | { name: '1325'; children: BigUnion[]; } | { name: '1326'; children: BigUnion[]; } | { name: '1327'; children: BigUnion[]; } | { name: '1328'; children: BigUnion[]; } | { name: '1329'; children: BigUnion[]; } | { name: '1330'; children: BigUnion[]; } | { name: '1331'; children: BigUnion[]; } | { name: '1332'; children: BigUnion[]; } | { name: '1333'; children: BigUnion[]; } | { name: '1334'; children: BigUnion[]; } | { name: '1335'; children: BigUnion[]; } | { name: '1336'; children: BigUnion[]; } | { name: '1337'; children: BigUnion[]; } | { name: '1338'; children: BigUnion[]; } | { name: '1339'; children: BigUnion[]; } | { name: '1340'; children: BigUnion[]; } | { name: '1341'; children: BigUnion[]; } | { name: '1342'; children: BigUnion[]; } | { name: '1343'; children: BigUnion[]; } | { name: '1344'; children: BigUnion[]; } | { name: '1345'; children: BigUnion[]; } | { name: '1346'; children: BigUnion[]; } | { name: '1347'; children: BigUnion[]; } | { name: '1348'; children: BigUnion[]; } | { name: '1349'; children: BigUnion[]; } | { name: '1350'; children: BigUnion[]; } | { name: '1351'; children: BigUnion[]; } | { name: '1352'; children: BigUnion[]; } | { name: '1353'; children: BigUnion[]; } | { name: '1354'; children: BigUnion[]; } | { name: '1355'; children: BigUnion[]; } | { name: '1356'; children: BigUnion[]; } | { name: '1357'; children: BigUnion[]; } | { name: '1358'; children: BigUnion[]; } | { name: '1359'; children: BigUnion[]; } | { name: '1360'; children: BigUnion[]; } | { name: '1361'; children: BigUnion[]; } | { name: '1362'; children: BigUnion[]; } | { name: '1363'; children: BigUnion[]; } | { name: '1364'; children: BigUnion[]; } | { name: '1365'; children: BigUnion[]; } | { name: '1366'; children: BigUnion[]; } | { name: '1367'; children: BigUnion[]; } | { name: '1368'; children: BigUnion[]; } | { name: '1369'; children: BigUnion[]; } | { name: '1370'; children: BigUnion[]; } | { name: '1371'; children: BigUnion[]; } | { name: '1372'; children: BigUnion[]; } | { name: '1373'; children: BigUnion[]; } | { name: '1374'; children: BigUnion[]; } | { name: '1375'; children: BigUnion[]; } | { name: '1376'; children: BigUnion[]; } | { name: '1377'; children: BigUnion[]; } | { name: '1378'; children: BigUnion[]; } | { name: '1379'; children: BigUnion[]; } | { name: '1380'; children: BigUnion[]; } | { name: '1381'; children: BigUnion[]; } | { name: '1382'; children: BigUnion[]; } | { name: '1383'; children: BigUnion[]; } | { name: '1384'; children: BigUnion[]; } | { name: '1385'; children: BigUnion[]; } | { name: '1386'; children: BigUnion[]; } | { name: '1387'; children: BigUnion[]; } | { name: '1388'; children: BigUnion[]; } | { name: '1389'; children: BigUnion[]; } | { name: '1390'; children: BigUnion[]; } | { name: '1391'; children: BigUnion[]; } | { name: '1392'; children: BigUnion[]; } | { name: '1393'; children: BigUnion[]; } | { name: '1394'; children: BigUnion[]; } | { name: '1395'; children: BigUnion[]; } | { name: '1396'; children: BigUnion[]; } | { name: '1397'; children: BigUnion[]; } | { name: '1398'; children: BigUnion[]; } | { name: '1399'; children: BigUnion[]; } | { name: '1400'; children: BigUnion[]; } | { name: '1401'; children: BigUnion[]; } | { name: '1402'; children: BigUnion[]; } | { name: '1403'; children: BigUnion[]; } | { name: '1404'; children: BigUnion[]; } | { name: '1405'; children: BigUnion[]; } | { name: '1406'; children: BigUnion[]; } | { name: '1407'; children: BigUnion[]; } | { name: '1408'; children: BigUnion[]; } | { name: '1409'; children: BigUnion[]; } | { name: '1410'; children: BigUnion[]; } | { name: '1411'; children: BigUnion[]; } | { name: '1412'; children: BigUnion[]; } | { name: '1413'; children: BigUnion[]; } | { name: '1414'; children: BigUnion[]; } | { name: '1415'; children: BigUnion[]; } | { name: '1416'; children: BigUnion[]; } | { name: '1417'; children: BigUnion[]; } | { name: '1418'; children: BigUnion[]; } | { name: '1419'; children: BigUnion[]; } | { name: '1420'; children: BigUnion[]; } | { name: '1421'; children: BigUnion[]; } | { name: '1422'; children: BigUnion[]; } | { name: '1423'; children: BigUnion[]; } | { name: '1424'; children: BigUnion[]; } | { name: '1425'; children: BigUnion[]; } | { name: '1426'; children: BigUnion[]; } | { name: '1427'; children: BigUnion[]; } | { name: '1428'; children: BigUnion[]; } | { name: '1429'; children: BigUnion[]; } | { name: '1430'; children: BigUnion[]; } | { name: '1431'; children: BigUnion[]; } | { name: '1432'; children: BigUnion[]; } | { name: '1433'; children: BigUnion[]; } | { name: '1434'; children: BigUnion[]; } | { name: '1435'; children: BigUnion[]; } | { name: '1436'; children: BigUnion[]; } | { name: '1437'; children: BigUnion[]; } | { name: '1438'; children: BigUnion[]; } | { name: '1439'; children: BigUnion[]; } | { name: '1440'; children: BigUnion[]; } | { name: '1441'; children: BigUnion[]; } | { name: '1442'; children: BigUnion[]; } | { name: '1443'; children: BigUnion[]; } | { name: '1444'; children: BigUnion[]; } | { name: '1445'; children: BigUnion[]; } | { name: '1446'; children: BigUnion[]; } | { name: '1447'; children: BigUnion[]; } | { name: '1448'; children: BigUnion[]; } | { name: '1449'; children: BigUnion[]; } | { name: '1450'; children: BigUnion[]; } | { name: '1451'; children: BigUnion[]; } | { name: '1452'; children: BigUnion[]; } | { name: '1453'; children: BigUnion[]; } | { name: '1454'; children: BigUnion[]; } | { name: '1455'; children: BigUnion[]; } | { name: '1456'; children: BigUnion[]; } | { name: '1457'; children: BigUnion[]; } | { name: '1458'; children: BigUnion[]; } | { name: '1459'; children: BigUnion[]; } | { name: '1460'; children: BigUnion[]; } | { name: '1461'; children: BigUnion[]; } | { name: '1462'; children: BigUnion[]; } | { name: '1463'; children: BigUnion[]; } | { name: '1464'; children: BigUnion[]; } | { name: '1465'; children: BigUnion[]; } | { name: '1466'; children: BigUnion[]; } | { name: '1467'; children: BigUnion[]; } | { name: '1468'; children: BigUnion[]; } | { name: '1469'; children: BigUnion[]; } | { name: '1470'; children: BigUnion[]; } | { name: '1471'; children: BigUnion[]; } | { name: '1472'; children: BigUnion[]; } | { name: '1473'; children: BigUnion[]; } | { name: '1474'; children: BigUnion[]; } | { name: '1475'; children: BigUnion[]; } | { name: '1476'; children: BigUnion[]; } | { name: '1477'; children: BigUnion[]; } | { name: '1478'; children: BigUnion[]; } | { name: '1479'; children: BigUnion[]; } | { name: '1480'; children: BigUnion[]; } | { name: '1481'; children: BigUnion[]; } | { name: '1482'; children: BigUnion[]; } | { name: '1483'; children: BigUnion[]; } | { name: '1484'; children: BigUnion[]; } | { name: '1485'; children: BigUnion[]; } | { name: '1486'; children: BigUnion[]; } | { name: '1487'; children: BigUnion[]; } | { name: '1488'; children: BigUnion[]; } | { name: '1489'; children: BigUnion[]; } | { name: '1490'; children: BigUnion[]; } | { name: '1491'; children: BigUnion[]; } | { name: '1492'; children: BigUnion[]; } | { name: '1493'; children: BigUnion[]; } | { name: '1494'; children: BigUnion[]; } | { name: '1495'; children: BigUnion[]; } | { name: '1496'; children: BigUnion[]; } | { name: '1497'; children: BigUnion[]; } | { name: '1498'; children: BigUnion[]; } | { name: '1499'; children: BigUnion[]; } | { name: '1500'; children: BigUnion[]; } | { name: '1501'; children: BigUnion[]; } | { name: '1502'; children: BigUnion[]; } | { name: '1503'; children: BigUnion[]; } | { name: '1504'; children: BigUnion[]; } | { name: '1505'; children: BigUnion[]; } | { name: '1506'; children: BigUnion[]; } | { name: '1507'; children: BigUnion[]; } | { name: '1508'; children: BigUnion[]; } | { name: '1509'; children: BigUnion[]; } | { name: '1510'; children: BigUnion[]; } | { name: '1511'; children: BigUnion[]; } | { name: '1512'; children: BigUnion[]; } | { name: '1513'; children: BigUnion[]; } | { name: '1514'; children: BigUnion[]; } | { name: '1515'; children: BigUnion[]; } | { name: '1516'; children: BigUnion[]; } | { name: '1517'; children: BigUnion[]; } | { name: '1518'; children: BigUnion[]; } | { name: '1519'; children: BigUnion[]; } | { name: '1520'; children: BigUnion[]; } | { name: '1521'; children: BigUnion[]; } | { name: '1522'; children: BigUnion[]; } | { name: '1523'; children: BigUnion[]; } | { name: '1524'; children: BigUnion[]; } | { name: '1525'; children: BigUnion[]; } | { name: '1526'; children: BigUnion[]; } | { name: '1527'; children: BigUnion[]; } | { name: '1528'; children: BigUnion[]; } | { name: '1529'; children: BigUnion[]; } | { name: '1530'; children: BigUnion[]; } | { name: '1531'; children: BigUnion[]; } | { name: '1532'; children: BigUnion[]; } | { name: '1533'; children: BigUnion[]; } | { name: '1534'; children: BigUnion[]; } | { name: '1535'; children: BigUnion[]; } | { name: '1536'; children: BigUnion[]; } | { name: '1537'; children: BigUnion[]; } | { name: '1538'; children: BigUnion[]; } | { name: '1539'; children: BigUnion[]; } | { name: '1540'; children: BigUnion[]; } | { name: '1541'; children: BigUnion[]; } | { name: '1542'; children: BigUnion[]; } | { name: '1543'; children: BigUnion[]; } | { name: '1544'; children: BigUnion[]; } | { name: '1545'; children: BigUnion[]; } | { name: '1546'; children: BigUnion[]; } | { name: '1547'; children: BigUnion[]; } | { name: '1548'; children: BigUnion[]; } | { name: '1549'; children: BigUnion[]; } | { name: '1550'; children: BigUnion[]; } | { name: '1551'; children: BigUnion[]; } | { name: '1552'; children: BigUnion[]; } | { name: '1553'; children: BigUnion[]; } | { name: '1554'; children: BigUnion[]; } | { name: '1555'; children: BigUnion[]; } | { name: '1556'; children: BigUnion[]; } | { name: '1557'; children: BigUnion[]; } | { name: '1558'; children: BigUnion[]; } | { name: '1559'; children: BigUnion[]; } | { name: '1560'; children: BigUnion[]; } | { name: '1561'; children: BigUnion[]; } | { name: '1562'; children: BigUnion[]; } | { name: '1563'; children: BigUnion[]; } | { name: '1564'; children: BigUnion[]; } | { name: '1565'; children: BigUnion[]; } | { name: '1566'; children: BigUnion[]; } | { name: '1567'; children: BigUnion[]; } | { name: '1568'; children: BigUnion[]; } | { name: '1569'; children: BigUnion[]; } | { name: '1570'; children: BigUnion[]; } | { name: '1571'; children: BigUnion[]; } | { name: '1572'; children: BigUnion[]; } | { name: '1573'; children: BigUnion[]; } | { name: '1574'; children: BigUnion[]; } | { name: '1575'; children: BigUnion[]; } | { name: '1576'; children: BigUnion[]; } | { name: '1577'; children: BigUnion[]; } | { name: '1578'; children: BigUnion[]; } | { name: '1579'; children: BigUnion[]; } | { name: '1580'; children: BigUnion[]; } | { name: '1581'; children: BigUnion[]; } | { name: '1582'; children: BigUnion[]; } | { name: '1583'; children: BigUnion[]; } | { name: '1584'; children: BigUnion[]; } | { name: '1585'; children: BigUnion[]; } | { name: '1586'; children: BigUnion[]; } | { name: '1587'; children: BigUnion[]; } | { name: '1588'; children: BigUnion[]; } | { name: '1589'; children: BigUnion[]; } | { name: '1590'; children: BigUnion[]; } | { name: '1591'; children: BigUnion[]; } | { name: '1592'; children: BigUnion[]; } | { name: '1593'; children: BigUnion[]; } | { name: '1594'; children: BigUnion[]; } | { name: '1595'; children: BigUnion[]; } | { name: '1596'; children: BigUnion[]; } | { name: '1597'; children: BigUnion[]; } | { name: '1598'; children: BigUnion[]; } | { name: '1599'; children: BigUnion[]; } | { name: '1600'; children: BigUnion[]; } | { name: '1601'; children: BigUnion[]; } | { name: '1602'; children: BigUnion[]; } | { name: '1603'; children: BigUnion[]; } | { name: '1604'; children: BigUnion[]; } | { name: '1605'; children: BigUnion[]; } | { name: '1606'; children: BigUnion[]; } | { name: '1607'; children: BigUnion[]; } | { name: '1608'; children: BigUnion[]; } | { name: '1609'; children: BigUnion[]; } | { name: '1610'; children: BigUnion[]; } | { name: '1611'; children: BigUnion[]; } | { name: '1612'; children: BigUnion[]; } | { name: '1613'; children: BigUnion[]; } | { name: '1614'; children: BigUnion[]; } | { name: '1615'; children: BigUnion[]; } | { name: '1616'; children: BigUnion[]; } | { name: '1617'; children: BigUnion[]; } | { name: '1618'; children: BigUnion[]; } | { name: '1619'; children: BigUnion[]; } | { name: '1620'; children: BigUnion[]; } | { name: '1621'; children: BigUnion[]; } | { name: '1622'; children: BigUnion[]; } | { name: '1623'; children: BigUnion[]; } | { name: '1624'; children: BigUnion[]; } | { name: '1625'; children: BigUnion[]; } | { name: '1626'; children: BigUnion[]; } | { name: '1627'; children: BigUnion[]; } | { name: '1628'; children: BigUnion[]; } | { name: '1629'; children: BigUnion[]; } | { name: '1630'; children: BigUnion[]; } | { name: '1631'; children: BigUnion[]; } | { name: '1632'; children: BigUnion[]; } | { name: '1633'; children: BigUnion[]; } | { name: '1634'; children: BigUnion[]; } | { name: '1635'; children: BigUnion[]; } | { name: '1636'; children: BigUnion[]; } | { name: '1637'; children: BigUnion[]; } | { name: '1638'; children: BigUnion[]; } | { name: '1639'; children: BigUnion[]; } | { name: '1640'; children: BigUnion[]; } | { name: '1641'; children: BigUnion[]; } | { name: '1642'; children: BigUnion[]; } | { name: '1643'; children: BigUnion[]; } | { name: '1644'; children: BigUnion[]; } | { name: '1645'; children: BigUnion[]; } | { name: '1646'; children: BigUnion[]; } | { name: '1647'; children: BigUnion[]; } | { name: '1648'; children: BigUnion[]; } | { name: '1649'; children: BigUnion[]; } | { name: '1650'; children: BigUnion[]; } | { name: '1651'; children: BigUnion[]; } | { name: '1652'; children: BigUnion[]; } | { name: '1653'; children: BigUnion[]; } | { name: '1654'; children: BigUnion[]; } | { name: '1655'; children: BigUnion[]; } | { name: '1656'; children: BigUnion[]; } | { name: '1657'; children: BigUnion[]; } | { name: '1658'; children: BigUnion[]; } | { name: '1659'; children: BigUnion[]; } | { name: '1660'; children: BigUnion[]; } | { name: '1661'; children: BigUnion[]; } | { name: '1662'; children: BigUnion[]; } | { name: '1663'; children: BigUnion[]; } | { name: '1664'; children: BigUnion[]; } | { name: '1665'; children: BigUnion[]; } | { name: '1666'; children: BigUnion[]; } | { name: '1667'; children: BigUnion[]; } | { name: '1668'; children: BigUnion[]; } | { name: '1669'; children: BigUnion[]; } | { name: '1670'; children: BigUnion[]; } | { name: '1671'; children: BigUnion[]; } | { name: '1672'; children: BigUnion[]; } | { name: '1673'; children: BigUnion[]; } | { name: '1674'; children: BigUnion[]; } | { name: '1675'; children: BigUnion[]; } | { name: '1676'; children: BigUnion[]; } | { name: '1677'; children: BigUnion[]; } | { name: '1678'; children: BigUnion[]; } | { name: '1679'; children: BigUnion[]; } | { name: '1680'; children: BigUnion[]; } | { name: '1681'; children: BigUnion[]; } | { name: '1682'; children: BigUnion[]; } | { name: '1683'; children: BigUnion[]; } | { name: '1684'; children: BigUnion[]; } | { name: '1685'; children: BigUnion[]; } | { name: '1686'; children: BigUnion[]; } | { name: '1687'; children: BigUnion[]; } | { name: '1688'; children: BigUnion[]; } | { name: '1689'; children: BigUnion[]; } | { name: '1690'; children: BigUnion[]; } | { name: '1691'; children: BigUnion[]; } | { name: '1692'; children: BigUnion[]; } | { name: '1693'; children: BigUnion[]; } | { name: '1694'; children: BigUnion[]; } | { name: '1695'; children: BigUnion[]; } | { name: '1696'; children: BigUnion[]; } | { name: '1697'; children: BigUnion[]; } | { name: '1698'; children: BigUnion[]; } | { name: '1699'; children: BigUnion[]; } | { name: '1700'; children: BigUnion[]; } | { name: '1701'; children: BigUnion[]; } | { name: '1702'; children: BigUnion[]; } | { name: '1703'; children: BigUnion[]; } | { name: '1704'; children: BigUnion[]; } | { name: '1705'; children: BigUnion[]; } | { name: '1706'; children: BigUnion[]; } | { name: '1707'; children: BigUnion[]; } | { name: '1708'; children: BigUnion[]; } | { name: '1709'; children: BigUnion[]; } | { name: '1710'; children: BigUnion[]; } | { name: '1711'; children: BigUnion[]; } | { name: '1712'; children: BigUnion[]; } | { name: '1713'; children: BigUnion[]; } | { name: '1714'; children: BigUnion[]; } | { name: '1715'; children: BigUnion[]; } | { name: '1716'; children: BigUnion[]; } | { name: '1717'; children: BigUnion[]; } | { name: '1718'; children: BigUnion[]; } | { name: '1719'; children: BigUnion[]; } | { name: '1720'; children: BigUnion[]; } | { name: '1721'; children: BigUnion[]; } | { name: '1722'; children: BigUnion[]; } | { name: '1723'; children: BigUnion[]; } | { name: '1724'; children: BigUnion[]; } | { name: '1725'; children: BigUnion[]; } | { name: '1726'; children: BigUnion[]; } | { name: '1727'; children: BigUnion[]; } | { name: '1728'; children: BigUnion[]; } | { name: '1729'; children: BigUnion[]; } | { name: '1730'; children: BigUnion[]; } | { name: '1731'; children: BigUnion[]; } | { name: '1732'; children: BigUnion[]; } | { name: '1733'; children: BigUnion[]; } | { name: '1734'; children: BigUnion[]; } | { name: '1735'; children: BigUnion[]; } | { name: '1736'; children: BigUnion[]; } | { name: '1737'; children: BigUnion[]; } | { name: '1738'; children: BigUnion[]; } | { name: '1739'; children: BigUnion[]; } | { name: '1740'; children: BigUnion[]; } | { name: '1741'; children: BigUnion[]; } | { name: '1742'; children: BigUnion[]; } | { name: '1743'; children: BigUnion[]; } | { name: '1744'; children: BigUnion[]; } | { name: '1745'; children: BigUnion[]; } | { name: '1746'; children: BigUnion[]; } | { name: '1747'; children: BigUnion[]; } | { name: '1748'; children: BigUnion[]; } | { name: '1749'; children: BigUnion[]; } | { name: '1750'; children: BigUnion[]; } | { name: '1751'; children: BigUnion[]; } | { name: '1752'; children: BigUnion[]; } | { name: '1753'; children: BigUnion[]; } | { name: '1754'; children: BigUnion[]; } | { name: '1755'; children: BigUnion[]; } | { name: '1756'; children: BigUnion[]; } | { name: '1757'; children: BigUnion[]; } | { name: '1758'; children: BigUnion[]; } | { name: '1759'; children: BigUnion[]; } | { name: '1760'; children: BigUnion[]; } | { name: '1761'; children: BigUnion[]; } | { name: '1762'; children: BigUnion[]; } | { name: '1763'; children: BigUnion[]; } | { name: '1764'; children: BigUnion[]; } | { name: '1765'; children: BigUnion[]; } | { name: '1766'; children: BigUnion[]; } | { name: '1767'; children: BigUnion[]; } | { name: '1768'; children: BigUnion[]; } | { name: '1769'; children: BigUnion[]; } | { name: '1770'; children: BigUnion[]; } | { name: '1771'; children: BigUnion[]; } | { name: '1772'; children: BigUnion[]; } | { name: '1773'; children: BigUnion[]; } | { name: '1774'; children: BigUnion[]; } | { name: '1775'; children: BigUnion[]; } | { name: '1776'; children: BigUnion[]; } | { name: '1777'; children: BigUnion[]; } | { name: '1778'; children: BigUnion[]; } | { name: '1779'; children: BigUnion[]; } | { name: '1780'; children: BigUnion[]; } | { name: '1781'; children: BigUnion[]; } | { name: '1782'; children: BigUnion[]; } | { name: '1783'; children: BigUnion[]; } | { name: '1784'; children: BigUnion[]; } | { name: '1785'; children: BigUnion[]; } | { name: '1786'; children: BigUnion[]; } | { name: '1787'; children: BigUnion[]; } | { name: '1788'; children: BigUnion[]; } | { name: '1789'; children: BigUnion[]; } | { name: '1790'; children: BigUnion[]; } | { name: '1791'; children: BigUnion[]; } | { name: '1792'; children: BigUnion[]; } | { name: '1793'; children: BigUnion[]; } | { name: '1794'; children: BigUnion[]; } | { name: '1795'; children: BigUnion[]; } | { name: '1796'; children: BigUnion[]; } | { name: '1797'; children: BigUnion[]; } | { name: '1798'; children: BigUnion[]; } | { name: '1799'; children: BigUnion[]; } | { name: '1800'; children: BigUnion[]; } | { name: '1801'; children: BigUnion[]; } | { name: '1802'; children: BigUnion[]; } | { name: '1803'; children: BigUnion[]; } | { name: '1804'; children: BigUnion[]; } | { name: '1805'; children: BigUnion[]; } | { name: '1806'; children: BigUnion[]; } | { name: '1807'; children: BigUnion[]; } | { name: '1808'; children: BigUnion[]; } | { name: '1809'; children: BigUnion[]; } | { name: '1810'; children: BigUnion[]; } | { name: '1811'; children: BigUnion[]; } | { name: '1812'; children: BigUnion[]; } | { name: '1813'; children: BigUnion[]; } | { name: '1814'; children: BigUnion[]; } | { name: '1815'; children: BigUnion[]; } | { name: '1816'; children: BigUnion[]; } | { name: '1817'; children: BigUnion[]; } | { name: '1818'; children: BigUnion[]; } | { name: '1819'; children: BigUnion[]; } | { name: '1820'; children: BigUnion[]; } | { name: '1821'; children: BigUnion[]; } | { name: '1822'; children: BigUnion[]; } | { name: '1823'; children: BigUnion[]; } | { name: '1824'; children: BigUnion[]; } | { name: '1825'; children: BigUnion[]; } | { name: '1826'; children: BigUnion[]; } | { name: '1827'; children: BigUnion[]; } | { name: '1828'; children: BigUnion[]; } | { name: '1829'; children: BigUnion[]; } | { name: '1830'; children: BigUnion[]; } | { name: '1831'; children: BigUnion[]; } | { name: '1832'; children: BigUnion[]; } | { name: '1833'; children: BigUnion[]; } | { name: '1834'; children: BigUnion[]; } | { name: '1835'; children: BigUnion[]; } | { name: '1836'; children: BigUnion[]; } | { name: '1837'; children: BigUnion[]; } | { name: '1838'; children: BigUnion[]; } | { name: '1839'; children: BigUnion[]; } | { name: '1840'; children: BigUnion[]; } | { name: '1841'; children: BigUnion[]; } | { name: '1842'; children: BigUnion[]; } | { name: '1843'; children: BigUnion[]; } | { name: '1844'; children: BigUnion[]; } | { name: '1845'; children: BigUnion[]; } | { name: '1846'; children: BigUnion[]; } | { name: '1847'; children: BigUnion[]; } | { name: '1848'; children: BigUnion[]; } | { name: '1849'; children: BigUnion[]; } | { name: '1850'; children: BigUnion[]; } | { name: '1851'; children: BigUnion[]; } | { name: '1852'; children: BigUnion[]; } | { name: '1853'; children: BigUnion[]; } | { name: '1854'; children: BigUnion[]; } | { name: '1855'; children: BigUnion[]; } | { name: '1856'; children: BigUnion[]; } | { name: '1857'; children: BigUnion[]; } | { name: '1858'; children: BigUnion[]; } | { name: '1859'; children: BigUnion[]; } | { name: '1860'; children: BigUnion[]; } | { name: '1861'; children: BigUnion[]; } | { name: '1862'; children: BigUnion[]; } | { name: '1863'; children: BigUnion[]; } | { name: '1864'; children: BigUnion[]; } | { name: '1865'; children: BigUnion[]; } | { name: '1866'; children: BigUnion[]; } | { name: '1867'; children: BigUnion[]; } | { name: '1868'; children: BigUnion[]; } | { name: '1869'; children: BigUnion[]; } | { name: '1870'; children: BigUnion[]; } | { name: '1871'; children: BigUnion[]; } | { name: '1872'; children: BigUnion[]; } | { name: '1873'; children: BigUnion[]; } | { name: '1874'; children: BigUnion[]; } | { name: '1875'; children: BigUnion[]; } | { name: '1876'; children: BigUnion[]; } | { name: '1877'; children: BigUnion[]; } | { name: '1878'; children: BigUnion[]; } | { name: '1879'; children: BigUnion[]; } | { name: '1880'; children: BigUnion[]; } | { name: '1881'; children: BigUnion[]; } | { name: '1882'; children: BigUnion[]; } | { name: '1883'; children: BigUnion[]; } | { name: '1884'; children: BigUnion[]; } | { name: '1885'; children: BigUnion[]; } | { name: '1886'; children: BigUnion[]; } | { name: '1887'; children: BigUnion[]; } | { name: '1888'; children: BigUnion[]; } | { name: '1889'; children: BigUnion[]; } | { name: '1890'; children: BigUnion[]; } | { name: '1891'; children: BigUnion[]; } | { name: '1892'; children: BigUnion[]; } | { name: '1893'; children: BigUnion[]; } | { name: '1894'; children: BigUnion[]; } | { name: '1895'; children: BigUnion[]; } | { name: '1896'; children: BigUnion[]; } | { name: '1897'; children: BigUnion[]; } | { name: '1898'; children: BigUnion[]; } | { name: '1899'; children: BigUnion[]; } | { name: '1900'; children: BigUnion[]; } | { name: '1901'; children: BigUnion[]; } | { name: '1902'; children: BigUnion[]; } | { name: '1903'; children: BigUnion[]; } | { name: '1904'; children: BigUnion[]; } | { name: '1905'; children: BigUnion[]; } | { name: '1906'; children: BigUnion[]; } | { name: '1907'; children: BigUnion[]; } | { name: '1908'; children: BigUnion[]; } | { name: '1909'; children: BigUnion[]; } | { name: '1910'; children: BigUnion[]; } | { name: '1911'; children: BigUnion[]; } | { name: '1912'; children: BigUnion[]; } | { name: '1913'; children: BigUnion[]; } | { name: '1914'; children: BigUnion[]; } | { name: '1915'; children: BigUnion[]; } | { name: '1916'; children: BigUnion[]; } | { name: '1917'; children: BigUnion[]; } | { name: '1918'; children: BigUnion[]; } | { name: '1919'; children: BigUnion[]; } | { name: '1920'; children: BigUnion[]; } | { name: '1921'; children: BigUnion[]; } | { name: '1922'; children: BigUnion[]; } | { name: '1923'; children: BigUnion[]; } | { name: '1924'; children: BigUnion[]; } | { name: '1925'; children: BigUnion[]; } | { name: '1926'; children: BigUnion[]; } | { name: '1927'; children: BigUnion[]; } | { name: '1928'; children: BigUnion[]; } | { name: '1929'; children: BigUnion[]; } | { name: '1930'; children: BigUnion[]; } | { name: '1931'; children: BigUnion[]; } | { name: '1932'; children: BigUnion[]; } | { name: '1933'; children: BigUnion[]; } | { name: '1934'; children: BigUnion[]; } | { name: '1935'; children: BigUnion[]; } | { name: '1936'; children: BigUnion[]; } | { name: '1937'; children: BigUnion[]; } | { name: '1938'; children: BigUnion[]; } | { name: '1939'; children: BigUnion[]; } | { name: '1940'; children: BigUnion[]; } | { name: '1941'; children: BigUnion[]; } | { name: '1942'; children: BigUnion[]; } | { name: '1943'; children: BigUnion[]; } | { name: '1944'; children: BigUnion[]; } | { name: '1945'; children: BigUnion[]; } | { name: '1946'; children: BigUnion[]; } | { name: '1947'; children: BigUnion[]; } | { name: '1948'; children: BigUnion[]; } | { name: '1949'; children: BigUnion[]; } | { name: '1950'; children: BigUnion[]; } | { name: '1951'; children: BigUnion[]; } | { name: '1952'; children: BigUnion[]; } | { name: '1953'; children: BigUnion[]; } | { name: '1954'; children: BigUnion[]; } | { name: '1955'; children: BigUnion[]; } | { name: '1956'; children: BigUnion[]; } | { name: '1957'; children: BigUnion[]; } | { name: '1958'; children: BigUnion[]; } | { name: '1959'; children: BigUnion[]; } | { name: '1960'; children: BigUnion[]; } | { name: '1961'; children: BigUnion[]; } | { name: '1962'; children: BigUnion[]; } | { name: '1963'; children: BigUnion[]; } | { name: '1964'; children: BigUnion[]; } | { name: '1965'; children: BigUnion[]; } | { name: '1966'; children: BigUnion[]; } | { name: '1967'; children: BigUnion[]; } | { name: '1968'; children: BigUnion[]; } | { name: '1969'; children: BigUnion[]; } | { name: '1970'; children: BigUnion[]; } | { name: '1971'; children: BigUnion[]; } | { name: '1972'; children: BigUnion[]; } | { name: '1973'; children: BigUnion[]; } | { name: '1974'; children: BigUnion[]; } | { name: '1975'; children: BigUnion[]; } | { name: '1976'; children: BigUnion[]; } | { name: '1977'; children: BigUnion[]; } | { name: '1978'; children: BigUnion[]; } | { name: '1979'; children: BigUnion[]; } | { name: '1980'; children: BigUnion[]; } | { name: '1981'; children: BigUnion[]; } | { name: '1982'; children: BigUnion[]; } | { name: '1983'; children: BigUnion[]; } | { name: '1984'; children: BigUnion[]; } | { name: '1985'; children: BigUnion[]; } | { name: '1986'; children: BigUnion[]; } | { name: '1987'; children: BigUnion[]; } | { name: '1988'; children: BigUnion[]; } | { name: '1989'; children: BigUnion[]; } | { name: '1990'; children: BigUnion[]; } | { name: '1991'; children: BigUnion[]; } | { name: '1992'; children: BigUnion[]; } | { name: '1993'; children: BigUnion[]; } | { name: '1994'; children: BigUnion[]; } | { name: '1995'; children: BigUnion[]; } | { name: '1996'; children: BigUnion[]; } | { name: '1997'; children: BigUnion[]; } | { name: '1998'; children: BigUnion[]; } | { name: '1999'; children: BigUnion[]; }
     {
         name: '0';
 >name : "0"
diff --git a/tests/baselines/reference/conditionalTypeRelaxingConstraintAssignability.types b/tests/baselines/reference/conditionalTypeRelaxingConstraintAssignability.types
index 20a281417631d..c67699df0d8e9 100644
--- a/tests/baselines/reference/conditionalTypeRelaxingConstraintAssignability.types
+++ b/tests/baselines/reference/conditionalTypeRelaxingConstraintAssignability.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/conditionalTypeRelaxingConstraintAssignability.ts ===
 export type ElChildren =
->ElChildren : ElChildren
+>ElChildren : string | undefined
 
   | ElChildren.Void
 >ElChildren : any
diff --git a/tests/baselines/reference/conditionalTypes1.types b/tests/baselines/reference/conditionalTypes1.types
index d655e3d6b040a..27b295caa8b50 100644
--- a/tests/baselines/reference/conditionalTypes1.types
+++ b/tests/baselines/reference/conditionalTypes1.types
@@ -1,21 +1,21 @@
 === tests/cases/conformance/types/conditional/conditionalTypes1.ts ===
 type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "b" | "d"
->T00 : T00
+>T00 : "b" | "d"
 
 type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "a" | "c"
->T01 : T01
+>T01 : "a" | "c"
 
 type T02 = Exclude<string | number | (() => void), Function>;  // string | number
->T02 : T02
+>T02 : string | number
 
 type T03 = Extract<string | number | (() => void), Function>;  // () => void
 >T03 : () => void
 
 type T04 = NonNullable<string | number | undefined>;  // string | number
->T04 : T04
+>T04 : string | number
 
 type T05 = NonNullable<(() => string) | string[] | null | undefined>;  // (() => string) | string[]
->T05 : T05
+>T05 : (() => string) | string[]
 >null : null
 
 function f1<T>(x: T, y: NonNullable<T>) {
@@ -100,7 +100,7 @@ function f4<T extends { x: string | undefined }>(x: T["x"], y: NonNullable<T["x"
 }
 
 type Options = { k: "a", a: number } | { k: "b", b: string } | { k: "c", c: boolean };
->Options : Options
+>Options : { k: "a"; a: number; } | { k: "b"; b: string; } | { k: "c"; c: boolean; }
 >k : "a"
 >a : number
 >k : "b"
@@ -113,7 +113,7 @@ type T10 = Exclude<Options, { k: "a" | "b" }>;  // { k: "c", c: boolean }
 >k : "a" | "b"
 
 type T11 = Extract<Options, { k: "a" | "b" }>;  // { k: "a", a: number } | { k: "b", b: string }
->T11 : T11
+>T11 : { k: "a"; a: number; } | { k: "b"; b: string; }
 >k : "a" | "b"
 
 type T12 = Exclude<Options, { k: "a" } | { k: "b" }>;  // { k: "c", c: boolean }
@@ -122,12 +122,12 @@ type T12 = Exclude<Options, { k: "a" } | { k: "b" }>;  // { k: "c", c: boolean }
 >k : "b"
 
 type T13 = Extract<Options, { k: "a" } | { k: "b" }>;  // { k: "a", a: number } | { k: "b", b: string }
->T13 : T13
+>T13 : { k: "a"; a: number; } | { k: "b"; b: string; }
 >k : "a"
 >k : "b"
 
 type T14 = Exclude<Options, { q: "a" }>;  // Options
->T14 : T14
+>T14 : { k: "a"; a: number; } | { k: "b"; b: string; } | { k: "c"; c: boolean; }
 >q : "a"
 
 type T15 = Extract<Options, { q: "a" }>;  // never
@@ -150,13 +150,13 @@ type OptionsOfKind<K extends Options["k"]> = Extract<Options, { k: K }>;
 >k : K
 
 type T16 = OptionsOfKind<"a" | "b">;  // { k: "a", a: number } | { k: "b", b: string }
->T16 : T16
+>T16 : { k: "a"; a: number; } | { k: "b"; b: string; }
 
 type Select<T, K extends keyof T, V extends T[K]> = Extract<T, { [P in K]: V }>;
 >Select : Select<T, K, V>
 
 type T17 = Select<Options, "k", "a" | "b">;  // // { k: "a", a: number } | { k: "b", b: string }
->T17 : T17
+>T17 : { k: "a"; a: number; } | { k: "b"; b: string; }
 
 type TypeName<T> =
 >TypeName : TypeName<T>
@@ -169,7 +169,7 @@ type TypeName<T> =
     "object";
 
 type T20 = TypeName<string | (() => void)>;  // "string" | "function"
->T20 : T20
+>T20 : "string" | "function"
 
 type T21 = TypeName<any>;  // "string" | "number" | "boolean" | "undefined" | "function" | "object"
 >T21 : "string" | "number" | "boolean" | "undefined" | "object" | "function"
@@ -239,10 +239,10 @@ type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
 >NonFunctionProperties : NonFunctionProperties<T>
 
 type T30 = FunctionProperties<Part>;
->T30 : T30
+>T30 : { updatePart: (newName: string) => void; }
 
 type T31 = NonFunctionProperties<Part>;
->T31 : T31
+>T31 : { id: number; name: string; subparts: Part[]; }
 
 function f7<T>(x: T, y: FunctionProperties<T>, z: NonFunctionProperties<T>) {
 >f7 : <T>(x: T, y: FunctionProperties<T>, z: NonFunctionProperties<T>) => void
@@ -559,7 +559,7 @@ type N2 = Not<true>;  // false
 >true : true
 
 type N3 = Not<boolean>;  // boolean
->N3 : N3
+>N3 : boolean
 
 type A1 = And<false, false>;  // false
 >A1 : false
@@ -590,7 +590,7 @@ type A6 = And<false, boolean>;  // false
 >false : false
 
 type A7 = And<boolean, true>;  // boolean
->A7 : A7
+>A7 : boolean
 >true : true
 
 type A8 = And<true, boolean>;  // boolean
@@ -598,7 +598,7 @@ type A8 = And<true, boolean>;  // boolean
 >true : true
 
 type A9 = And<boolean, boolean>;  // boolean
->A9 : A9
+>A9 : boolean
 
 type O1 = Or<false, false>;  // false
 >O1 : false
@@ -621,7 +621,7 @@ type O4 = Or<true, true>;  // true
 >true : true
 
 type O5 = Or<boolean, false>;  // boolean
->O5 : O5
+>O5 : boolean
 >false : false
 
 type O6 = Or<false, boolean>;  // boolean
@@ -637,7 +637,7 @@ type O8 = Or<true, boolean>;  // true
 >true : true
 
 type O9 = Or<boolean, boolean>;  // boolean
->O9 : O9
+>O9 : boolean
 
 type T40 = never extends never ? true : false;  // true
 >T40 : true
@@ -977,13 +977,13 @@ type NonFooKeys2<T extends object> = Exclude<keyof T, 'foo'>;
 >NonFooKeys2 : NonFooKeys2<T>
 
 type Test1 = NonFooKeys1<{foo: 1, bar: 2, baz: 3}>;  // "bar" | "baz"
->Test1 : Test1
+>Test1 : "bar" | "baz"
 >foo : 1
 >bar : 2
 >baz : 3
 
 type Test2 = NonFooKeys2<{foo: 1, bar: 2, baz: 3}>;  // "bar" | "baz"
->Test2 : Test2
+>Test2 : "bar" | "baz"
 >foo : 1
 >bar : 2
 >baz : 3
@@ -997,7 +997,7 @@ interface Bar2 { bar: string; }
 >bar : string
 
 type FooBar = Foo2 | Bar2;
->FooBar : FooBar
+>FooBar : Foo2 | Bar2
 
 declare interface ExtractFooBar<FB extends FooBar> { }
 
diff --git a/tests/baselines/reference/conditionalTypes2.types b/tests/baselines/reference/conditionalTypes2.types
index d5344f98e3501..8c72188b7925e 100644
--- a/tests/baselines/reference/conditionalTypes2.types
+++ b/tests/baselines/reference/conditionalTypes2.types
@@ -141,11 +141,11 @@ function f12(x: string | (() => string) | undefined) {
 }
 
 type Foo = { foo: string };
->Foo : Foo
+>Foo : { foo: string; }
 >foo : string
 
 type Bar = { bar: string };
->Bar : Bar
+>Bar : { bar: string; }
 >bar : string
 
 declare function fooBar(x: { foo: string, bar: string }): void;
@@ -369,7 +369,7 @@ type T3 = MaybeTrue<{ b: boolean }>;  // "yes"
 // Repro from #28824
 
 type Union = 'a' | 'b';
->Union : Union
+>Union : "b" | "a"
 
 type Product<A extends Union, B> = { f1: A, f2: B};
 >Product : Product<A, B>
@@ -377,11 +377,11 @@ type Product<A extends Union, B> = { f1: A, f2: B};
 >f2 : B
 
 type ProductUnion = Product<'a', 0> | Product<'b', 1>;
->ProductUnion : ProductUnion
+>ProductUnion : Product<"a", 0> | Product<"b", 1>
 
 // {a: "b"; b: "a"}
 type UnionComplement = {
->UnionComplement : UnionComplement
+>UnionComplement : { b: "a"; a: "b"; }
 
   [K in Union]: Exclude<Union, K>
 };
@@ -393,7 +393,7 @@ type UCB = UnionComplement['b'];
 
 // {a: "a"; b: "b"}
 type UnionComplementComplement = {
->UnionComplementComplement : UnionComplementComplement
+>UnionComplementComplement : { b: "b"; a: "a"; }
 
   [K in Union]: Exclude<Union, Exclude<Union, K>>
 };
@@ -405,7 +405,7 @@ type UCCB = UnionComplementComplement['b'];
 
 // {a: Product<'b', 1>; b: Product<'a', 0>}
 type ProductComplement = {
->ProductComplement : ProductComplement
+>ProductComplement : { b: Product<"a", 0>; a: Product<"b", 1>; }
 
   [K in Union]: Exclude<ProductUnion, { f1: K }>
 >f1 : K
@@ -419,7 +419,7 @@ type PCB = ProductComplement['b'];
 
 // {a: Product<'a', 0>; b: Product<'b', 1>}
 type ProductComplementComplement = {
->ProductComplementComplement : ProductComplementComplement
+>ProductComplementComplement : { b: Product<"b", 1>; a: Product<"a", 0>; }
 
   [K in Union]: Exclude<ProductUnion, Exclude<ProductUnion, { f1: K }>>
 >f1 : K
diff --git a/tests/baselines/reference/constAssertions.types b/tests/baselines/reference/constAssertions.types
index 476c197cfb9bc..e764b8c6c3007 100644
--- a/tests/baselines/reference/constAssertions.types
+++ b/tests/baselines/reference/constAssertions.types
@@ -453,10 +453,10 @@ function ff3(x: 'foo' | 'bar', y: object) {
 }
 
 type Action = "verify" | "write";
->Action : Action
+>Action : "verify" | "write"
 
 type ContentMatch = "match" | "nonMatch";
->ContentMatch : ContentMatch
+>ContentMatch : "match" | "nonMatch"
 
 type Outcome = `${Action}_${ContentMatch}`;
 >Outcome : "verify_match" | "verify_nonMatch" | "write_match" | "write_nonMatch"
diff --git a/tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types b/tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types
index 1170aa71c4827..b3f5a0e9f91b0 100644
--- a/tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types
+++ b/tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types
@@ -6,7 +6,7 @@ interface Map<K, V> {
 }
 
 export type ImmutableTypes = IImmutableMap<any>;
->ImmutableTypes : ImmutableTypes
+>ImmutableTypes : IImmutableMap<any>
 
 export type ImmutableModel<T> = { [K in keyof T]: T[K] extends ImmutableTypes ? T[K] : never };
 >ImmutableModel : ImmutableModel<T>
@@ -19,7 +19,7 @@ export interface IImmutableMap<T extends ImmutableModel<T>> extends Map<string,
 }
 
 export type ImmutableTypes2 = IImmutableMap2<any>;
->ImmutableTypes2 : ImmutableTypes2
+>ImmutableTypes2 : IImmutableMap2<any>
 
 type isImmutableType<T> = [T] extends [ImmutableTypes2] ? T : never;
 >isImmutableType : isImmutableType<T>
diff --git a/tests/baselines/reference/contextualOverloadListFromUnionWithPrimitiveNoImplicitAny.types b/tests/baselines/reference/contextualOverloadListFromUnionWithPrimitiveNoImplicitAny.types
index c9a236a44ef10..e561a05bc89b5 100644
--- a/tests/baselines/reference/contextualOverloadListFromUnionWithPrimitiveNoImplicitAny.types
+++ b/tests/baselines/reference/contextualOverloadListFromUnionWithPrimitiveNoImplicitAny.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/contextualOverloadListFromUnionWithPrimitiveNoImplicitAny.ts ===
 // must target esnext for `String.normalize` to exist
 type Validate = (text: string, pos: number, self: Rule) => number | boolean;
->Validate : Validate
+>Validate : (text: string, pos: number, self: Rule) => number | boolean
 >text : string
 >pos : number
 >self : Rule
@@ -17,7 +17,7 @@ interface FullRule {
 }
 
 type Rule = string | FullRule;
->Rule : Rule
+>Rule : string | FullRule
 
 const obj: {field: Rule} = {
 >obj : { field: Rule; }
diff --git a/tests/baselines/reference/contextualTypeOfIndexedAccessParameter.types b/tests/baselines/reference/contextualTypeOfIndexedAccessParameter.types
index c72f7b139912a..5baf2f4a62a49 100644
--- a/tests/baselines/reference/contextualTypeOfIndexedAccessParameter.types
+++ b/tests/baselines/reference/contextualTypeOfIndexedAccessParameter.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/contextualTypeOfIndexedAccessParameter.ts ===
 type Keys = "a" | "b";
->Keys : Keys
+>Keys : "a" | "b"
 
 type OptionsForKey = { a: { cb: (p: number) => number } } & { b: {} };
->OptionsForKey : OptionsForKey
+>OptionsForKey : { a: { cb: (p: number) => number; }; } & { b: {}; }
 >a : { cb: (p: number) => number; }
 >cb : (p: number) => number
 >p : number
diff --git a/tests/baselines/reference/contextualTypeShouldBeLiteral.types b/tests/baselines/reference/contextualTypeShouldBeLiteral.types
index d9795c7e33f7c..56f5b3c363e8a 100644
--- a/tests/baselines/reference/contextualTypeShouldBeLiteral.types
+++ b/tests/baselines/reference/contextualTypeShouldBeLiteral.types
@@ -243,7 +243,7 @@ interface TestString {
 }
 
 type TestGeneric = (TestString | TestObject) & { [k: string]: any; };
->TestGeneric : TestGeneric
+>TestGeneric : (TestObject | TestString) & { [k: string]: any; }
 >k : string
 
 const test: TestGeneric = {
diff --git a/tests/baselines/reference/contextualTypingArrayDestructuringWithDefaults.types b/tests/baselines/reference/contextualTypingArrayDestructuringWithDefaults.types
index 30e35d683dbd3..5425ab030b62c 100644
--- a/tests/baselines/reference/contextualTypingArrayDestructuringWithDefaults.types
+++ b/tests/baselines/reference/contextualTypingArrayDestructuringWithDefaults.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/contextualTypingArrayDestructuringWithDefaults.ts ===
 type I = { a: "a" };
->I : I
+>I : { a: "a"; }
 >a : "a"
 
 let [ c0 = {a: "a"} ]: [I?] = [];
diff --git a/tests/baselines/reference/contextualTypingOfTooShortOverloads.types b/tests/baselines/reference/contextualTypingOfTooShortOverloads.types
index 621bc0751793f..ede485d8360ab 100644
--- a/tests/baselines/reference/contextualTypingOfTooShortOverloads.types
+++ b/tests/baselines/reference/contextualTypingOfTooShortOverloads.types
@@ -60,10 +60,10 @@ interface IRouterMatcher<T> {
 }
 
 type PathParams = string | RegExp | (string | RegExp)[];
->PathParams : PathParams
+>PathParams : string | RegExp | (string | RegExp)[]
 
 type RequestHandlerParams = RequestHandler | ErrorRequestHandler | (RequestHandler | ErrorRequestHandler)[];
->RequestHandlerParams : RequestHandlerParams
+>RequestHandlerParams : RequestHandler | ErrorRequestHandler | (RequestHandler | ErrorRequestHandler)[]
 
 interface RequestHandler {
     (req: Request, res: Response, next: NextFunction): any;
diff --git a/tests/baselines/reference/contextuallyTypedByDiscriminableUnion.types b/tests/baselines/reference/contextuallyTypedByDiscriminableUnion.types
index f67d3948b0003..b3fde6f144846 100644
--- a/tests/baselines/reference/contextuallyTypedByDiscriminableUnion.types
+++ b/tests/baselines/reference/contextuallyTypedByDiscriminableUnion.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/contextuallyTypedByDiscriminableUnion.ts ===
 type ADT = {
->ADT : ADT
+>ADT : { kind: "a"; method(x: string): number; } | { kind: "b"; method(x: number): string; }
 
     kind: "a",
 >kind : "a"
diff --git a/tests/baselines/reference/contextuallyTypedSymbolNamedProperties.types b/tests/baselines/reference/contextuallyTypedSymbolNamedProperties.types
index 7f3da21666af0..508845c83f6c4 100644
--- a/tests/baselines/reference/contextuallyTypedSymbolNamedProperties.types
+++ b/tests/baselines/reference/contextuallyTypedSymbolNamedProperties.types
@@ -14,7 +14,7 @@ const B = Symbol("B");
 >"B" : "B"
 
 type Action =
->Action : Action
+>Action : { type: typeof A; data: string; } | { type: typeof B; data: number; }
 
     | {type: typeof A, data: string}
 >type : unique symbol
diff --git a/tests/baselines/reference/controlFlowAliasing.types b/tests/baselines/reference/controlFlowAliasing.types
index a3c7f9f7f4f19..b7c73a1d9fa62 100644
--- a/tests/baselines/reference/controlFlowAliasing.types
+++ b/tests/baselines/reference/controlFlowAliasing.types
@@ -844,7 +844,7 @@ function f40(obj: { kind: 'foo', foo?: string } | { kind: 'bar', bar?: number })
 // Unsupported narrowing of destructured payload by destructured discriminant
 
 type Data = { kind: 'str', payload: string } | { kind: 'num', payload: number };
->Data : Data
+>Data : { kind: 'str'; payload: string; } | { kind: 'num'; payload: number; }
 >kind : "str"
 >payload : string
 >kind : "num"
diff --git a/tests/baselines/reference/controlFlowAssignmentExpression.types b/tests/baselines/reference/controlFlowAssignmentExpression.types
index d56aee7c76727..8724a73fd8d9c 100644
--- a/tests/baselines/reference/controlFlowAssignmentExpression.types
+++ b/tests/baselines/reference/controlFlowAssignmentExpression.types
@@ -47,7 +47,7 @@ x; // number
 
 // https://github.com/microsoft/TypeScript/issues/35484
 type D = { done: true, value: 1 } | { done: false, value: 2 };
->D : D
+>D : { done: true; value: 1; } | { done: false; value: 2; }
 >done : true
 >true : true
 >value : 1
diff --git a/tests/baselines/reference/controlFlowBinaryOrExpression.types b/tests/baselines/reference/controlFlowBinaryOrExpression.types
index 8e43d38765357..9c188295a82f0 100644
--- a/tests/baselines/reference/controlFlowBinaryOrExpression.types
+++ b/tests/baselines/reference/controlFlowBinaryOrExpression.types
@@ -54,7 +54,7 @@ declare function isHTMLCollection(sourceObj: any): sourceObj is HTMLCollection;
 >sourceObj : any
 
 type EventTargetLike = {a: string} | HTMLCollection | NodeList;
->EventTargetLike : EventTargetLike
+>EventTargetLike : NodeList | HTMLCollection | { a: string; }
 >a : string
 
 var sourceObj: EventTargetLike = <any>undefined;
diff --git a/tests/baselines/reference/controlFlowDestructuringLoop.types b/tests/baselines/reference/controlFlowDestructuringLoop.types
index a4735399f9e4a..c0b86606c0f96 100644
--- a/tests/baselines/reference/controlFlowDestructuringLoop.types
+++ b/tests/baselines/reference/controlFlowDestructuringLoop.types
@@ -8,7 +8,7 @@ interface StrVal { val: string; }
 >val : string
 
 type Val = NumVal | StrVal;
->Val : Val
+>Val : NumVal | StrVal
 
 function isNumVal(x: Val): x is NumVal {
 >isNumVal : (x: Val) => x is NumVal
diff --git a/tests/baselines/reference/controlFlowForCatchAndFinally.types b/tests/baselines/reference/controlFlowForCatchAndFinally.types
index c159655a0a816..450aa2d595d54 100644
--- a/tests/baselines/reference/controlFlowForCatchAndFinally.types
+++ b/tests/baselines/reference/controlFlowForCatchAndFinally.types
@@ -1,11 +1,11 @@
 === tests/cases/compiler/controlFlowForCatchAndFinally.ts ===
 type Page = {close(): Promise<void>; content(): Promise<string>};
->Page : Page
+>Page : { close(): Promise<void>; content(): Promise<string>; }
 >close : () => Promise<void>
 >content : () => Promise<string>
 
 type Browser = {close(): Promise<void>};
->Browser : Browser
+>Browser : { close(): Promise<void>; }
 >close : () => Promise<void>
 
 declare function test1(): Promise<Browser>;
diff --git a/tests/baselines/reference/controlFlowForInStatement2.types b/tests/baselines/reference/controlFlowForInStatement2.types
index 2705b8b7d51ed..bf69cfe70a0dd 100644
--- a/tests/baselines/reference/controlFlowForInStatement2.types
+++ b/tests/baselines/reference/controlFlowForInStatement2.types
@@ -8,12 +8,12 @@ const keywordB = 'b';
 >'b' : "b"
 
 type A = { [keywordA]: number };
->A : A
+>A : { a: number; }
 >[keywordA] : number
 >keywordA : "a"
 
 type B = { [keywordB]: string };
->B : B
+>B : { b: string; }
 >[keywordB] : string
 >keywordB : "b"
 
diff --git a/tests/baselines/reference/controlFlowGenericTypes.types b/tests/baselines/reference/controlFlowGenericTypes.types
index 6ee07abf4d63c..fc502a7dede82 100644
--- a/tests/baselines/reference/controlFlowGenericTypes.types
+++ b/tests/baselines/reference/controlFlowGenericTypes.types
@@ -196,22 +196,22 @@ export function bounceAndTakeIfA<AB extends 'A' | 'B'>(value: AB): AB {
 // Repro from #13995
 
 type Common = { id: number };
->Common : Common
+>Common : { id: number; }
 >id : number
 
 type AA = { tag: 'A', id: number };
->AA : AA
+>AA : { tag: 'A'; id: number; }
 >tag : "A"
 >id : number
 
 type BB = { tag: 'B', id: number, foo: number };
->BB : BB
+>BB : { tag: 'B'; id: number; foo: number; }
 >tag : "B"
 >id : number
 >foo : number
 
 type MyUnion = AA | BB;
->MyUnion : MyUnion
+>MyUnion : AA | BB
 
 const fn = (value: MyUnion) => {
 >fn : (value: MyUnion) => void
@@ -284,7 +284,7 @@ const fn2 = <T extends MyUnion>(value: T): MyUnion => {
 // Repro from #13995
 
 type A1 = {
->A1 : A1
+>A1 : { testable: true; doTest: () => void; }
 
     testable: true
 >testable : true
@@ -294,7 +294,7 @@ type A1 = {
 >doTest : () => void
 }
 type B1 = {
->B1 : B1
+>B1 : { testable: false; }
 
     testable: false
 >testable : false
@@ -303,7 +303,7 @@ type B1 = {
 };
 
 type Union = A1 | B1
->Union : Union
+>Union : A1 | B1
 
 function notWorking<T extends Union>(object: T) {
 >notWorking : <T extends Union>(object: T) => void
@@ -561,7 +561,7 @@ interface Checkbox {
 }
 
 type Control = Button | Checkbox;
->Control : Control
+>Control : Button | Checkbox
 
 function update<T extends Control, K extends keyof T>(control : T | undefined, key: K, value: T[K]): void {
 >update : <T extends Control, K extends keyof T>(control: T | undefined, key: K, value: T[K]) => void
diff --git a/tests/baselines/reference/controlFlowInOperator.types b/tests/baselines/reference/controlFlowInOperator.types
index cae50e4052f8e..fb1c3f8ccc044 100644
--- a/tests/baselines/reference/controlFlowInOperator.types
+++ b/tests/baselines/reference/controlFlowInOperator.types
@@ -12,12 +12,12 @@ const d = 'd';
 >'d' : "d"
 
 type A = { [a]: number; };
->A : A
+>A : { a: number; }
 >[a] : number
 >a : "a"
 
 type B = { [b]: string; };
->B : B
+>B : { b: string; }
 >[b] : string
 >b : "b"
 
diff --git a/tests/baselines/reference/controlFlowOptionalChain.types b/tests/baselines/reference/controlFlowOptionalChain.types
index 4e335fca6d287..823d07ca8bf7d 100644
--- a/tests/baselines/reference/controlFlowOptionalChain.types
+++ b/tests/baselines/reference/controlFlowOptionalChain.types
@@ -635,7 +635,7 @@ function f01(x: unknown) {
 }
 
 type Thing = { foo: string | number, bar(): number, baz: object };
->Thing : Thing
+>Thing : { foo: string | number; bar(): number; baz: object; }
 >foo : string | number
 >bar : () => number
 >baz : object
@@ -1870,7 +1870,7 @@ function f41(o: Thing | undefined) {
 // Repros from #34570
 
 type Shape =
->Shape : Shape
+>Shape : { type: 'rectangle'; width: number; height: number; } | { type: 'circle'; radius: number; }
 
     | { type: 'rectangle', width: number, height: number }
 >type : "rectangle"
@@ -1923,7 +1923,7 @@ function getArea(shape?: Shape) {
 }
 
 type Feature = {
->Feature : Feature
+>Feature : { id: string; geometry?: { type: string; coordinates: number[]; } | undefined; }
 
   id: string;
 >id : string
diff --git a/tests/baselines/reference/controlFlowOptionalChain2.types b/tests/baselines/reference/controlFlowOptionalChain2.types
index f3b2d1cd573d9..c2857e8761637 100644
--- a/tests/baselines/reference/controlFlowOptionalChain2.types
+++ b/tests/baselines/reference/controlFlowOptionalChain2.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/controlFlow/controlFlowOptionalChain2.ts ===
 type A = {
->A : A
+>A : { type: 'A'; name: string; }
 
   type: 'A';
 >type : "A"
@@ -10,7 +10,7 @@ type A = {
 }
 
 type B = {
->B : B
+>B : { type: 'B'; }
 
   type: 'B';
 >type : "B"
@@ -70,18 +70,18 @@ function funcThree(arg: A | B | null) {
 }
 
 type U = { kind: undefined, u: 'u' }
->U : U
+>U : { kind: undefined; u: 'u'; }
 >kind : undefined
 >u : "u"
 
 type N = { kind: null, n: 'n' }
->N : N
+>N : { kind: null; n: 'n'; }
 >kind : null
 >null : null
 >n : "n"
 
 type X = { kind: 'X', x: 'x' }
->X : X
+>X : { kind: 'X'; x: 'x'; }
 >kind : "X"
 >x : "x"
 
diff --git a/tests/baselines/reference/controlFlowStringIndex.types b/tests/baselines/reference/controlFlowStringIndex.types
index 521db65b4af69..4baba673c7e12 100644
--- a/tests/baselines/reference/controlFlowStringIndex.types
+++ b/tests/baselines/reference/controlFlowStringIndex.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/controlFlow/controlFlowStringIndex.ts ===
 type A = {
->A : A
+>A : { [index: string]: number | null; other: number | null; }
 
     other: number | null;
 >other : number | null
diff --git a/tests/baselines/reference/correlatedUnions.types b/tests/baselines/reference/correlatedUnions.types
index ec83dd5426dfa..6d2074195b17c 100644
--- a/tests/baselines/reference/correlatedUnions.types
+++ b/tests/baselines/reference/correlatedUnions.types
@@ -2,7 +2,7 @@
 // Various repros from #30581
 
 type RecordMap = { n: number, s: string, b: boolean };
->RecordMap : RecordMap
+>RecordMap : { n: number; s: string; b: boolean; }
 >n : number
 >s : string
 >b : boolean
@@ -71,16 +71,16 @@ processRecord({ kind: 'n', v: 42, f: v => v.toExponential() });
 // --------
 
 type TextFieldData = { value: string }
->TextFieldData : TextFieldData
+>TextFieldData : { value: string; }
 >value : string
 
 type SelectFieldData = { options: string[], selectedValue: string }
->SelectFieldData : SelectFieldData
+>SelectFieldData : { options: string[]; selectedValue: string; }
 >options : string[]
 >selectedValue : string
 
 type FieldMap = {
->FieldMap : FieldMap
+>FieldMap : { text: TextFieldData; select: SelectFieldData; }
 
     text: TextFieldData;
 >text : TextFieldData
@@ -99,7 +99,7 @@ type RenderFunc<K extends keyof FieldMap> = (props: FieldMap[K]) => void;
 >props : FieldMap[K]
 
 type RenderFuncMap = { [K in keyof FieldMap]: RenderFunc<K> };
->RenderFuncMap : RenderFuncMap
+>RenderFuncMap : { text: RenderFunc<"text">; select: RenderFunc<"select">; }
 
 function renderTextField(props: TextFieldData) {}
 >renderTextField : (props: TextFieldData) => void
@@ -146,7 +146,7 @@ function renderField<K extends keyof FieldMap>(field: FormField<K>) {
 // --------
 
 type TypeMap = {
->TypeMap : TypeMap
+>TypeMap : { foo: string; bar: number; }
 
     foo: string,
 >foo : string
@@ -160,7 +160,7 @@ type Keys = keyof TypeMap;
 >Keys : keyof TypeMap
 
 type HandlerMap = { [P in Keys]: (x: TypeMap[P]) => void };
->HandlerMap : HandlerMap
+>HandlerMap : { foo: (x: string) => void; bar: (x: number) => void; }
 >x : TypeMap[P]
 
 const handlers: HandlerMap = {
@@ -276,7 +276,7 @@ process([{ type: 'foo', data: 'abc' }]);
 // --------
 
 type LetterMap = { A: string, B: number }
->LetterMap : LetterMap
+>LetterMap : { A: string; B: number; }
 >A : string
 >B : number
 
@@ -298,19 +298,19 @@ function call<K extends keyof LetterMap>({ letter, caller }: LetterCaller<K>): v
 }
 
 type A = { A: string };
->A : A
+>A : { A: string; }
 >A : string
 
 type B = { B: number };
->B : B
+>B : { B: number; }
 >B : number
 
 type ACaller = (a: A) => void;
->ACaller : ACaller
+>ACaller : (a: A) => void
 >a : A
 
 type BCaller = (b: B) => void;
->BCaller : BCaller
+>BCaller : (b: B) => void
 >b : B
 
 declare const xx: { letter: A, caller: ACaller } | { letter: B, caller: BCaller };
@@ -552,7 +552,7 @@ function ff1() {
 // Repro from #47368
 
 type ArgMap = { a: number, b: string };
->ArgMap : ArgMap
+>ArgMap : { a: number; b: string; }
 >a : number
 >b : string
 
@@ -561,7 +561,7 @@ type Func<K extends keyof ArgMap> = (x: ArgMap[K]) => void;
 >x : ArgMap[K]
 
 type Funcs = { [K in keyof ArgMap]: Func<K> };
->Funcs : Funcs
+>Funcs : { a: Func<"a">; b: Func<"b">; }
 
 function f1<K extends keyof ArgMap>(funcs: Funcs, key: K, arg: ArgMap[K]) {
 >f1 : <K extends keyof ArgMap>(funcs: Funcs, key: K, arg: ArgMap[K]) => void
@@ -751,5 +751,5 @@ type BarLookup = typeof BAR_LOOKUP;
 >BAR_LOOKUP : { a: { readonly name: "a"; }; b: { readonly name: "b"; }; }
 
 type Baz = { [K in keyof BarLookup]: BarLookup[K]['name'] };
->Baz : Baz
+>Baz : { a: "a"; b: "b"; }
 
diff --git a/tests/baselines/reference/crashInGetTextOfComputedPropertyName.types b/tests/baselines/reference/crashInGetTextOfComputedPropertyName.types
index 7d9ce4aa34b65..d5a97ecb392da 100644
--- a/tests/baselines/reference/crashInGetTextOfComputedPropertyName.types
+++ b/tests/baselines/reference/crashInGetTextOfComputedPropertyName.types
@@ -7,7 +7,7 @@ export interface B { type: 'b' }
 >type : "b"
 
 export type AB = A | B
->AB : AB
+>AB : A | B
 
 const itemId = 'some-id'
 >itemId : "some-id"
diff --git a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types
index 4f8a9cf021867..290628c7128c6 100644
--- a/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types
+++ b/tests/baselines/reference/declFileTypeAnnotationTypeAlias.types
@@ -3,7 +3,7 @@ module M {
 >M : typeof M
 
     export type Value = string | number | boolean;
->Value : Value
+>Value : string | number | boolean
 
     export var x: Value;
 >x : Value
@@ -28,7 +28,7 @@ module M {
 >m : any
 
     export type fc = () => c;
->fc : fc
+>fc : () => c
 }
 
 interface Window {
@@ -40,7 +40,7 @@ module M {
 >M : typeof M
 
     export type W = Window | string;
->W : W
+>W : string | Window
 
     export module N {
 >N : typeof N
diff --git a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types
index e1f08d5893836..06ca2c0f0cb61 100644
--- a/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types
+++ b/tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types
@@ -8,7 +8,7 @@ module M {
 >M : typeof M
 
     type W = Window | string;
->W : W
+>W : string | Window
 
     export module N {
 >N : typeof N
@@ -25,7 +25,7 @@ module M1 {
 >M1 : typeof M1
 
     export type W = Window | string;
->W : W
+>W : string | Window
 
     export module N {
 >N : typeof N
diff --git a/tests/baselines/reference/declarationEmitAliasFromIndirectFile.types b/tests/baselines/reference/declarationEmitAliasFromIndirectFile.types
index a663e3283eae6..db3aae7ef4d8b 100644
--- a/tests/baselines/reference/declarationEmitAliasFromIndirectFile.types
+++ b/tests/baselines/reference/declarationEmitAliasFromIndirectFile.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/locale.d.ts ===
 export type Locale = {
->Locale : Locale
+>Locale : { weekdays: {    shorthand: [string, string, string, string, string, string, string];    longhand: [string, string, string, string, string, string, string];}; }
 
     weekdays: {
 >weekdays : { shorthand: [string, string, string, string, string, string, string]; longhand: [string, string, string, string, string, string, string]; }
@@ -14,7 +14,7 @@ export type Locale = {
     };
 };
 export type CustomLocale = {
->CustomLocale : CustomLocale
+>CustomLocale : { weekdays: {    shorthand: [string, string, string, string, string, string, string];    longhand: [string, string, string, string, string, string, string];}; }
 
     weekdays: {
 >weekdays : { shorthand: [string, string, string, string, string, string, string]; longhand: [string, string, string, string, string, string, string]; }
@@ -28,7 +28,7 @@ export type CustomLocale = {
     };
 };
 export type key = "ar" | "bg";
->key : key
+>key : "ar" | "bg"
 
 === tests/cases/compiler/instance.d.ts ===
 import { Locale, CustomLocale, key as LocaleKey } from "./locale";
diff --git a/tests/baselines/reference/declarationEmitDestructuringParameterProperties.types b/tests/baselines/reference/declarationEmitDestructuringParameterProperties.types
index d76fd67f9d65a..47f57b4693b1c 100644
--- a/tests/baselines/reference/declarationEmitDestructuringParameterProperties.types
+++ b/tests/baselines/reference/declarationEmitDestructuringParameterProperties.types
@@ -10,7 +10,7 @@ class C1 {
 }
 
 type TupleType1 =[string, number, boolean];
->TupleType1 : TupleType1
+>TupleType1 : [string, number, boolean]
 
 class C2 {
 >C2 : C2
@@ -23,7 +23,7 @@ class C2 {
 }
 
 type ObjType1 = { x: number; y: string; z: boolean }
->ObjType1 : ObjType1
+>ObjType1 : { x: number; y: string; z: boolean; }
 >x : number
 >y : string
 >z : boolean
diff --git a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
index bf9666f3082b1..28684e8ea851c 100644
--- a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
+++ b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/Types.ts ===
 type Suit = 'Hearts' | 'Spades' | 'Clubs' | 'Diamonds';
->Suit : Suit
+>Suit : "Hearts" | "Spades" | "Clubs" | "Diamonds"
 
 type Rank = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 'Jack' | 'Queen' | 'King';
->Rank : Rank
+>Rank : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | "Jack" | "Queen" | "King"
 
 export { Suit, Rank };
 >Suit : any
diff --git a/tests/baselines/reference/declarationEmitExpressionWithNonlocalPrivateUniqueSymbol.types b/tests/baselines/reference/declarationEmitExpressionWithNonlocalPrivateUniqueSymbol.types
index 3582fd3db6b80..b92654ce3811c 100644
--- a/tests/baselines/reference/declarationEmitExpressionWithNonlocalPrivateUniqueSymbol.types
+++ b/tests/baselines/reference/declarationEmitExpressionWithNonlocalPrivateUniqueSymbol.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/a.ts ===
 type AX = { readonly A: unique symbol };
->AX : AX
+>AX : { readonly A: unique symbol; }
 >A : unique symbol
 
 export const A: AX = 0 as any;
diff --git a/tests/baselines/reference/declarationEmitInferredTypeAlias5.types b/tests/baselines/reference/declarationEmitInferredTypeAlias5.types
index 63d2cec4b9a99..98a575c0631c1 100644
--- a/tests/baselines/reference/declarationEmitInferredTypeAlias5.types
+++ b/tests/baselines/reference/declarationEmitInferredTypeAlias5.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/0.ts ===
 export type Data = string | boolean;
->Data : Data
+>Data : string | boolean
 
 let obj: Data = true;
 >obj : Data
diff --git a/tests/baselines/reference/declarationEmitInferredTypeAlias7.types b/tests/baselines/reference/declarationEmitInferredTypeAlias7.types
index a035da8453fcc..572315d62ff8a 100644
--- a/tests/baselines/reference/declarationEmitInferredTypeAlias7.types
+++ b/tests/baselines/reference/declarationEmitInferredTypeAlias7.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/0.ts ===
 export type Data = string | boolean;
->Data : Data
+>Data : string | boolean
 
 let obj: Data = true;
 >obj : Data
diff --git a/tests/baselines/reference/declarationEmitPathMappingMonorepo.types b/tests/baselines/reference/declarationEmitPathMappingMonorepo.types
index 8c4c1678c2967..d4fe2b7157b9a 100644
--- a/tests/baselines/reference/declarationEmitPathMappingMonorepo.types
+++ b/tests/baselines/reference/declarationEmitPathMappingMonorepo.types
@@ -3,7 +3,7 @@ declare module "@ts-bug/a" {
 >"@ts-bug/a" : typeof import("@ts-bug/a")
 
     export type AText = {
->AText : AText
+>AText : { value: string; }
 
       value: string;
 >value : string
diff --git a/tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types b/tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types
index e95f15377cc02..2e947507af8af 100644
--- a/tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types
+++ b/tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types
@@ -24,10 +24,10 @@ export enum E {
 }
 
 export type T = G<E>;
->T : T
+>T : { a: string; b: string; }
 
 export type Q = G<E.A>;
->Q : Q
+>Q : { a: string; }
 >E : any
 
 === tests/cases/compiler/index.ts ===
diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference.types b/tests/baselines/reference/declarationEmitReexportedSymlinkReference.types
index 50c770d525718..0ed089b529a91 100644
--- a/tests/baselines/reference/declarationEmitReexportedSymlinkReference.types
+++ b/tests/baselines/reference/declarationEmitReexportedSymlinkReference.types
@@ -2,21 +2,21 @@
 export * from './types';
 No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
 export declare type A = {
->A : A
+>A : { id: string; }
 
     id: string;
 >id : string
 
 };
 export declare type B = {
->B : B
+>B : { id: number; }
 
     id: number;
 >id : number
 
 };
 export declare type IdType = A | B;
->IdType : IdType
+>IdType : A | B
 
 export declare class MetadataAccessor<T, D extends IdType = IdType> {
 >MetadataAccessor : MetadataAccessor<T, D>
diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.types b/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.types
index 1ecb9e7592298..e52c244ccc5a4 100644
--- a/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.types
+++ b/tests/baselines/reference/declarationEmitReexportedSymlinkReference2.types
@@ -2,21 +2,21 @@
 export * from './types';
 No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
 export declare type A = {
->A : A
+>A : { id: string; }
 
     id: string;
 >id : string
 
 };
 export declare type B = {
->B : B
+>B : { id: number; }
 
     id: number;
 >id : number
 
 };
 export declare type IdType = A | B;
->IdType : IdType
+>IdType : A | B
 
 export declare class MetadataAccessor<T, D extends IdType = IdType> {
 >MetadataAccessor : MetadataAccessor<T, D>
diff --git a/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.types b/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.types
index e3f8347888466..06272b7baa950 100644
--- a/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.types
+++ b/tests/baselines/reference/declarationEmitReexportedSymlinkReference3.types
@@ -2,21 +2,21 @@
 export * from './types';
 No type information for this code.=== tests/cases/compiler/monorepo/pkg1/dist/types.d.ts ===
 export declare type A = {
->A : A
+>A : { id: string; }
 
     id: string;
 >id : string
 
 };
 export declare type B = {
->B : B
+>B : { id: number; }
 
     id: number;
 >id : number
 
 };
 export declare type IdType = A | B;
->IdType : IdType
+>IdType : A | B
 
 export declare class MetadataAccessor<T, D extends IdType = IdType> {
 >MetadataAccessor : MetadataAccessor<T, D>
diff --git a/tests/baselines/reference/declarationEmitSymlinkPaths.types b/tests/baselines/reference/declarationEmitSymlinkPaths.types
index 2d79f6b4cc847..2b16d631796a5 100644
--- a/tests/baselines/reference/declarationEmitSymlinkPaths.types
+++ b/tests/baselines/reference/declarationEmitSymlinkPaths.types
@@ -5,10 +5,10 @@ export declare function test<T> (a: () => T): () => T;
 
 === /packages/search-prefix/src/API/NotificationAPIUtils.ts ===
 export type NotificationRequest = {};
->NotificationRequest : NotificationRequest
+>NotificationRequest : {}
 
 export type NotificationResponse = {};
->NotificationResponse : NotificationResponse
+>NotificationResponse : {}
 
 export function getNotification(): NotificationResponse {
 >getNotification : () => NotificationResponse
diff --git a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types
index c15ad37bccca8..1c766f91ab2d0 100644
--- a/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types
+++ b/tests/baselines/reference/declarationsForFileShadowingGlobalNoError.types
@@ -4,7 +4,7 @@ export type DOMNode = Node;
 
 === tests/cases/compiler/custom.ts ===
 export type Node = {};
->Node : Node
+>Node : {}
 
 === tests/cases/compiler/index.ts ===
 import { Node } from './custom'
@@ -14,7 +14,7 @@ import { DOMNode } from './dom'
 >DOMNode : any
 
 type Constructor = new (...args: any[]) => any
->Constructor : Constructor
+>Constructor : new (...args: any[]) => any
 >args : any[]
 
 export const mixin = (Base: Constructor) => {
diff --git a/tests/baselines/reference/declarationsForIndirectTypeAliasReference.types b/tests/baselines/reference/declarationsForIndirectTypeAliasReference.types
index 85ebfca651f13..dfad078a2f35e 100644
--- a/tests/baselines/reference/declarationsForIndirectTypeAliasReference.types
+++ b/tests/baselines/reference/declarationsForIndirectTypeAliasReference.types
@@ -15,7 +15,7 @@ interface Hash<T> {
 }
 
 type StringHash = Hash<string>;
->StringHash : StringHash
+>StringHash : Hash<string>
 
 interface StringHash2 extends Hash<string> {}
 === tests/cases/compiler/a.ts ===
diff --git a/tests/baselines/reference/deeplyNestedConstraints.types b/tests/baselines/reference/deeplyNestedConstraints.types
index 2d8d34729068e..64eb0f1b2103f 100644
--- a/tests/baselines/reference/deeplyNestedConstraints.types
+++ b/tests/baselines/reference/deeplyNestedConstraints.types
@@ -2,7 +2,7 @@
 // Repro from #41931
 
 type Enum = Record<string, string | number>;
->Enum : Enum
+>Enum : { [x: string]: string | number; }
 
 type TypeMap<E extends Enum> = { [key in E[keyof E]]: number | boolean | string | number[] };
 >TypeMap : TypeMap<E>
diff --git a/tests/baselines/reference/defaultParameterAddsUndefinedWithStrictNullChecks.types b/tests/baselines/reference/defaultParameterAddsUndefinedWithStrictNullChecks.types
index ef1aca3806809..2d6e2966a2dd9 100644
--- a/tests/baselines/reference/defaultParameterAddsUndefinedWithStrictNullChecks.types
+++ b/tests/baselines/reference/defaultParameterAddsUndefinedWithStrictNullChecks.types
@@ -117,7 +117,7 @@ function foo4(x: string | undefined = undefined, b: number) {
 }
 
 type OptionalNullableString = string | null | undefined;
->OptionalNullableString : OptionalNullableString
+>OptionalNullableString : string | null | undefined
 >null : null
 
 function allowsNull(val: OptionalNullableString = "") {
diff --git a/tests/baselines/reference/deferredTypeReferenceWithinArrayWithinTuple.types b/tests/baselines/reference/deferredTypeReferenceWithinArrayWithinTuple.types
index f7a124d6ae92e..147d183e05ea5 100644
--- a/tests/baselines/reference/deferredTypeReferenceWithinArrayWithinTuple.types
+++ b/tests/baselines/reference/deferredTypeReferenceWithinArrayWithinTuple.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/deferredTypeReferenceWithinArrayWithinTuple.ts ===
 type TypeStructure =
->TypeStructure : TypeStructure
+>TypeStructure : ["or", TypeStructure[]] | ["string"] | ["number"] | ["list", TypeStructure]
 
   | ["or", TypeStructure[]] // problem is only here, when using array
   | ["string"]
diff --git a/tests/baselines/reference/deleteExpressionMustBeOptional(strict=false).types b/tests/baselines/reference/deleteExpressionMustBeOptional(strict=false).types
index 371bb25e96d82..a1b5f6359a88d 100644
--- a/tests/baselines/reference/deleteExpressionMustBeOptional(strict=false).types
+++ b/tests/baselines/reference/deleteExpressionMustBeOptional(strict=false).types
@@ -37,7 +37,7 @@ interface AA {
 }
 
 type BB = {
->BB : BB
+>BB : { [x: string]: number; }
 
     [P in keyof any]: number
 }
diff --git a/tests/baselines/reference/deleteExpressionMustBeOptional(strict=true).types b/tests/baselines/reference/deleteExpressionMustBeOptional(strict=true).types
index a3d6f52b7c436..b2277d20f6114 100644
--- a/tests/baselines/reference/deleteExpressionMustBeOptional(strict=true).types
+++ b/tests/baselines/reference/deleteExpressionMustBeOptional(strict=true).types
@@ -37,7 +37,7 @@ interface AA {
 }
 
 type BB = {
->BB : BB
+>BB : { [x: string]: number; }
 
     [P in keyof any]: number
 }
diff --git a/tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=false).types b/tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=false).types
index 79da5d0fe05d4..36da93480e881 100644
--- a/tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=false).types
+++ b/tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=false).types
@@ -37,7 +37,7 @@ interface AA {
 }
 
 type BB = {
->BB : BB
+>BB : { [x: string]: number; }
 
     [P in keyof any]: number
 }
diff --git a/tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=true).types b/tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=true).types
index 79da5d0fe05d4..36da93480e881 100644
--- a/tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=true).types
+++ b/tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=true).types
@@ -37,7 +37,7 @@ interface AA {
 }
 
 type BB = {
->BB : BB
+>BB : { [x: string]: number; }
 
     [P in keyof any]: number
 }
diff --git a/tests/baselines/reference/dependentDestructuredVariables.types b/tests/baselines/reference/dependentDestructuredVariables.types
index bfc8a5f2fb882..440c42a38277d 100644
--- a/tests/baselines/reference/dependentDestructuredVariables.types
+++ b/tests/baselines/reference/dependentDestructuredVariables.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/controlFlow/dependentDestructuredVariables.ts ===
 type Action =
->Action : Action
+>Action : { kind: 'A'; payload: number; } | { kind: 'B'; payload: string; }
 
     | { kind: 'A', payload: number }
 >kind : "A"
@@ -107,7 +107,7 @@ function f12({ kind, payload }: Action) {
 }
 
 type Action2 =
->Action2 : Action2
+>Action2 : { kind: 'A'; payload: number | undefined; } | { kind: 'B'; payload: string | undefined; }
 
     | { kind: 'A', payload: number | undefined }
 >kind : "A"
@@ -265,7 +265,7 @@ function f23({ kind, payload }: Action2) {
 }
 
 type Foo =
->Foo : Foo
+>Foo : { kind: 'A'; isA: true; } | { kind: 'B'; isA: false; } | { kind: 'C'; isA: false; }
 
     | { kind: 'A', isA: true }
 >kind : "A"
@@ -324,7 +324,7 @@ function f30({ kind, isA }: Foo) {
 }
 
 type Args = ['A', number] | ['B', string]
->Args : Args
+>Args : ["A", number] | ["B", string]
 
 function f40(...[kind, data]: Args) {
 >f40 : (...[kind, data]: Args) => void
@@ -406,7 +406,7 @@ function unrefined1<T>(ab: AB<T>): void {
 // Repro from #38020
 
 type Action3 =
->Action3 : Action3
+>Action3 : { type: 'add'; payload: {    toAdd: number;}; } | { type: 'remove'; payload: {    toRemove: number;}; }
 
     | {type: 'add', payload: { toAdd: number } }
 >type : "add"
@@ -598,7 +598,7 @@ readFile('hello', (err, data) => {
 });
 
 type ReducerArgs = ["add", { a: number, b: number }] | ["concat", { firstArr: any[], secondArr: any[] }];
->ReducerArgs : ReducerArgs
+>ReducerArgs : ["add", { a: number; b: number; }] | ["concat", { firstArr: any[]; secondArr: any[]; }]
 >a : number
 >b : number
 >firstArr : any[]
@@ -680,7 +680,7 @@ reducer("concat", { firstArr: [1, 2], secondArr: [3, 4] });
 // repro from https://github.com/microsoft/TypeScript/pull/47190#issuecomment-1057603588
 
 type FooMethod = {
->FooMethod : FooMethod
+>FooMethod : { method(...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]): void; }
 
   method(...args:
 >method : (...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]) => void
@@ -724,7 +724,7 @@ let fooM: FooMethod = {
 };
 
 type FooAsyncMethod = {
->FooAsyncMethod : FooAsyncMethod
+>FooAsyncMethod : { method(...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]): Promise<any>; }
 
   method(...args:
 >method : (...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]) => Promise<any>
@@ -768,7 +768,7 @@ let fooAsyncM: FooAsyncMethod = {
 };
 
 type FooGenMethod = {
->FooGenMethod : FooGenMethod
+>FooGenMethod : { method(...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]): Generator<any, any, any>; }
 
   method(...args:
 >method : (...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]) => Generator<any, any, any>
@@ -812,7 +812,7 @@ let fooGenM: FooGenMethod = {
 };
 
 type FooAsyncGenMethod = {
->FooAsyncGenMethod : FooAsyncGenMethod
+>FooAsyncGenMethod : { method(...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]): AsyncGenerator<any, any, any>; }
 
   method(...args:
 >method : (...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]) => AsyncGenerator<any, any, any>
@@ -858,7 +858,7 @@ let fooAsyncGenM: FooAsyncGenMethod = {
 // Repro from #48345
 
 type Func = <T extends ["a", number] | ["b", string]>(...args: T) => void;
->Func : Func
+>Func : <T extends ["a", number] | ["b", string]>(...args: T) => void
 >args : T
 
 const f60: Func = (kind, payload) => {
diff --git a/tests/baselines/reference/destructuringControlFlow.types b/tests/baselines/reference/destructuringControlFlow.types
index 02deb39200688..9fc89eae51deb 100644
--- a/tests/baselines/reference/destructuringControlFlow.types
+++ b/tests/baselines/reference/destructuringControlFlow.types
@@ -161,7 +161,7 @@ function f4() {
 // Repro from #31770
 
 type KeyValue = [string, string?];
->KeyValue : KeyValue
+>KeyValue : [string, (string | undefined)?]
 
 let [key, value]: KeyValue = ["foo"];
 >key : string
diff --git a/tests/baselines/reference/destructuringInFunctionType.types b/tests/baselines/reference/destructuringInFunctionType.types
index b5b0ff041c62b..2b7f0de66ccf7 100644
--- a/tests/baselines/reference/destructuringInFunctionType.types
+++ b/tests/baselines/reference/destructuringInFunctionType.types
@@ -9,46 +9,46 @@ interface c { c }
 >c : any
 
 type T1 = ([a, b, c]);
->T1 : T1
+>T1 : [a, b, c]
 
 type F1 = ([a, b, c]) => void;
->F1 : F1
+>F1 : ([a, b, c]: [any, any, any]) => void
 >a : any
 >b : any
 >c : any
 
 type T2 = ({ a });
->T2 : T2
+>T2 : { a: any; }
 >a : any
 
 type F2 = ({ a }) => void;
->F2 : F2
+>F2 : ({ a }: { a: any; }) => void
 >a : any
 
 type T3 = ([{ a: b }, { b: a }]);
->T3 : T3
+>T3 : [{ a: b; }, { b: a; }]
 >a : b
 >b : a
 
 type F3 = ([{ a: b }, { b: a }]) => void;
->F3 : F3
+>F3 : ([{ a: b }, { b: a }]: [{ a: any; }, { b: any; }]) => void
 >a : any
 >b : any
 >b : any
 >a : any
 
 type T4 = ([{ a: [b, c] }]);
->T4 : T4
+>T4 : [{ a: [b, c]; }]
 >a : [b, c]
 
 type F4 = ([{ a: [b, c] }]) => void;
->F4 : F4
+>F4 : ([{ a: [b, c] }]: [{ a: [any, any]; }]) => void
 >a : any
 >b : any
 >c : any
 
 type C1 = new ([{ a: [b, c] }]) => void;
->C1 : C1
+>C1 : new ([{ a: [b, c] }]: [{ a: [any, any]; }]) => void
 >a : any
 >b : any
 >c : any
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5.types
index 80101e1013895..a7d9b02412a34 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.types
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.types
@@ -6,13 +6,13 @@
 //     ...   Identifier   TypeAnnotation(opt)
 
 type arrayString = Array<String>
->arrayString : arrayString
+>arrayString : String[]
 
 type someArray = Array<String> | number[];
->someArray : someArray
+>someArray : String[] | number[]
 
 type stringOrNumArray = Array<String|Number>;
->stringOrNumArray : stringOrNumArray
+>stringOrNumArray : (String | Number)[]
 
 function a1(...x: (number|string)[]) { }
 >a1 : (...x: (number | string)[]) => void
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types
index 02b43a1006dd0..f09b7387a33dc 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types
@@ -6,13 +6,13 @@
 //     ...   Identifier   TypeAnnotation(opt)
 
 type arrayString = Array<String>
->arrayString : arrayString
+>arrayString : String[]
 
 type someArray = Array<String> | number[];
->someArray : someArray
+>someArray : String[] | number[]
 
 type stringOrNumArray = Array<String|Number>;
->stringOrNumArray : stringOrNumArray
+>stringOrNumArray : (String | Number)[]
 
 function a1(...x: (number|string)[]) { }
 >a1 : (...x: (number | string)[]) => void
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.types b/tests/baselines/reference/destructuringParameterDeclaration3ES6.types
index a2e6a55203f2e..5d56b4163d697 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.types
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.types
@@ -6,13 +6,13 @@
 //     ...   Identifier   TypeAnnotation(opt)
 
 type arrayString = Array<String>
->arrayString : arrayString
+>arrayString : String[]
 
 type someArray = Array<String> | number[];
->someArray : someArray
+>someArray : String[] | number[]
 
 type stringOrNumArray = Array<String|Number>;
->stringOrNumArray : stringOrNumArray
+>stringOrNumArray : (String | Number)[]
 
 function a1(...x: (number|string)[]) { }
 >a1 : (...x: (number | string)[]) => void
diff --git a/tests/baselines/reference/destructuringParameterDeclaration4.types b/tests/baselines/reference/destructuringParameterDeclaration4.types
index 04e01920ee419..08a6474c44c0f 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration4.types
+++ b/tests/baselines/reference/destructuringParameterDeclaration4.types
@@ -6,13 +6,13 @@
 //     ...   Identifier   TypeAnnotation(opt)
 
 type arrayString = Array<String>
->arrayString : arrayString
+>arrayString : String[]
 
 type someArray = Array<String> | number[];
->someArray : someArray
+>someArray : String[] | number[]
 
 type stringOrNumArray = Array<String|Number>;
->stringOrNumArray : stringOrNumArray
+>stringOrNumArray : (String | Number)[]
 
 function a0(...x: [number, number, string]) { }  // Error, rest parameter must be array type
 >a0 : (x_0: number, x_1: number, x_2: string) => void
diff --git a/tests/baselines/reference/destructuringParameterProperties1.types b/tests/baselines/reference/destructuringParameterProperties1.types
index 38174445dcac2..fc0b52893155f 100644
--- a/tests/baselines/reference/destructuringParameterProperties1.types
+++ b/tests/baselines/reference/destructuringParameterProperties1.types
@@ -10,7 +10,7 @@ class C1 {
 }
 
 type TupleType1 = [string, number, boolean];
->TupleType1 : TupleType1
+>TupleType1 : [string, number, boolean]
 
 class C2 {
 >C2 : C2
@@ -23,7 +23,7 @@ class C2 {
 }
 
 type ObjType1 = { x: number; y: string; z: boolean }
->ObjType1 : ObjType1
+>ObjType1 : { x: number; y: string; z: boolean; }
 >x : number
 >y : string
 >z : boolean
diff --git a/tests/baselines/reference/destructuringParameterProperties5.types b/tests/baselines/reference/destructuringParameterProperties5.types
index 58d3b6d005dc6..ed95d0c196909 100644
--- a/tests/baselines/reference/destructuringParameterProperties5.types
+++ b/tests/baselines/reference/destructuringParameterProperties5.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts ===
 type ObjType1 = { x: number; y: string; z: boolean }
->ObjType1 : ObjType1
+>ObjType1 : { x: number; y: string; z: boolean; }
 >x : number
 >y : string
 >z : boolean
 
 type TupleType1 = [ObjType1, number, string]
->TupleType1 : TupleType1
+>TupleType1 : [ObjType1, number, string]
 
 class C1 {
 >C1 : C1
diff --git a/tests/baselines/reference/destructuringTypeGuardFlow.types b/tests/baselines/reference/destructuringTypeGuardFlow.types
index 00953626899bd..7863be76c92e2 100644
--- a/tests/baselines/reference/destructuringTypeGuardFlow.types
+++ b/tests/baselines/reference/destructuringTypeGuardFlow.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/destructuringTypeGuardFlow.ts ===
 type foo = {
->foo : foo
+>foo : { bar: number | null; baz: string; nested: {    a: number;    b: string | null;}; }
 
   bar: number | null;
 >bar : number | null
@@ -79,7 +79,7 @@ if (aFoo.bar && aFoo.nested.b) {
 }
 
 type bar = {
->bar : bar
+>bar : { elem1: number | null; elem2: foo | null; }
 
   elem1: number | null;
 >elem1 : number | null
diff --git a/tests/baselines/reference/didYouMeanStringLiteral.types b/tests/baselines/reference/didYouMeanStringLiteral.types
index c348534c65212..0cc503a11f526 100644
--- a/tests/baselines/reference/didYouMeanStringLiteral.types
+++ b/tests/baselines/reference/didYouMeanStringLiteral.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/didYouMeanStringLiteral.ts ===
 type T1 = "string" | "number" | "boolean";
->T1 : T1
+>T1 : "string" | "number" | "boolean"
 
 type T2 = T1 & ("number" | "boolean"); // "number" | "boolean"
 >T2 : "number" | "boolean"
diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.types b/tests/baselines/reference/directDependenceBetweenTypeAliases.types
index e1d6784b327f8..7a031dd9a5f1d 100644
--- a/tests/baselines/reference/directDependenceBetweenTypeAliases.types
+++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.types
@@ -17,7 +17,7 @@ type T0_3 = T0_1
 // A type reference directly depends on the referenced type and each of the type arguments, if any.
 interface I<T> {}
 type T1 = I<T1>
->T1 : T1
+>T1 : I<T1>
 
 // A union type directly depends on each of the constituent types.
 type T2 = T2 | string
@@ -27,15 +27,15 @@ class C<T> {}
 >C : C<T>
 
 type T2_1 = T2_1[] | number
->T2_1 : T2_1
+>T2_1 : number | T2_1[]
 
 // An array type directly depends on its element type.
 type T3 = T3[]
->T3 : T3
+>T3 : T3[]
 
 // A tuple type directly depends on each of its element types.
 type T4 = [number, T4]
->T4 : T4
+>T4 : [number, T4]
 
 // A type query directly depends on the type of the referenced entity.
 var x: T5[] = []
@@ -50,7 +50,7 @@ class C1<T> {}
 >C1 : C1<T>
 
 type T6 = T7 | number
->T6 : T6
+>T6 : number | [string, T8[]]
 
 type T7 = typeof yy
 >T7 : [string, T8[]]
@@ -60,22 +60,22 @@ var yy: [string, T8[]];
 >yy : [string, T8[]]
 
 type T8 = C<T6>
->T8 : T8
+>T8 : C<T6>
 
 // legal cases
 type T9 = () => T9
->T9 : T9
+>T9 : () => T9
 
 type T10 = { x: T10 } | { new(v: T10): string }
->T10 : T10
+>T10 : { x: T10; } | (new (v: T10) => string)
 >x : T10
 >v : T10
 
 type T11 = T12[]
->T11 : T11
+>T11 : T12[]
 
 type T12 = [T13, string]
->T12 : T12
+>T12 : [{ x: T11; }, string]
 
 type T13 = typeof zz
 >T13 : { x: T11; }
diff --git a/tests/baselines/reference/discriminableUnionWithIntersectedMembers.types b/tests/baselines/reference/discriminableUnionWithIntersectedMembers.types
index 633d23c65c6fd..3cb79ee43ee15 100644
--- a/tests/baselines/reference/discriminableUnionWithIntersectedMembers.types
+++ b/tests/baselines/reference/discriminableUnionWithIntersectedMembers.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/discriminableUnionWithIntersectedMembers.ts ===
 // regression test for https://github.com/microsoft/TypeScript/issues/33243
 type X = 
->X : X
+>X : ({ x: 'x'; y: number; } & { y: number; }) | ({ x: 'y'; y: number; z?: boolean; } & { y: number; })
 
  | { x: 'x', y: number } & { y: number } 
 >x : "x"
@@ -24,7 +24,7 @@ const x: X = 4 as any as { x: 'x' | 'y', y: number };
 >y : number
 
 type Y = 
->Y : Y
+>Y : { x: 'x'; y: number; } | { x: 'y'; y: number; z?: boolean; }
 
  | { x: 'x', y: number } 
 >x : "x"
diff --git a/tests/baselines/reference/discriminantElementAccessCheck.types b/tests/baselines/reference/discriminantElementAccessCheck.types
index 357173b8a0f40..6b378468c83f5 100644
--- a/tests/baselines/reference/discriminantElementAccessCheck.types
+++ b/tests/baselines/reference/discriminantElementAccessCheck.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/discriminantElementAccessCheck.ts ===
 type U = TypeA | TypeB;
->U : U
+>U : TypeA | TypeB
 
 interface TypeA {
     kind: 'A';
diff --git a/tests/baselines/reference/discriminantPropertyCheck.types b/tests/baselines/reference/discriminantPropertyCheck.types
index 10d3b5f117c47..e93ccc20ac759 100644
--- a/tests/baselines/reference/discriminantPropertyCheck.types
+++ b/tests/baselines/reference/discriminantPropertyCheck.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/discriminantPropertyCheck.ts ===
 type Item = Item1 | Item2;
->Item : Item
+>Item : Item1 | Item2
 
 interface Base {
     bar: boolean;
@@ -243,7 +243,7 @@ enum Types { Str = 1, Num = 2 }
 >2 : 2
 
 type Instance = StrType | NumType;
->Instance : Instance
+>Instance : StrType | NumType
 
 interface StrType {
     type: Types.Str;
@@ -335,7 +335,7 @@ interface B {
 }
 
 type U = A | B;
->U : U
+>U : A | B
 
 const u: U = {} as any;
 >u : U
@@ -381,10 +381,10 @@ u.b && u.a && f(u.a, u.b);
 // Repro from #29012
 
 type Additive = '+' | '-';
->Additive : Additive
+>Additive : "+" | "-"
 
 type Multiplicative = '*' | '/';
->Multiplicative : Multiplicative
+>Multiplicative : "*" | "/"
 
 interface AdditiveObj {
     key: Additive
@@ -397,7 +397,7 @@ interface MultiplicativeObj {
 }
 
 type Obj = AdditiveObj | MultiplicativeObj
->Obj : Obj
+>Obj : AdditiveObj | MultiplicativeObj
 
 export function foo(obj: Obj) {
 >foo : (obj: Obj) => void
@@ -450,15 +450,15 @@ const enum BarEnum {
 }
 
 type UnionOfBar = TypeBar1 | TypeBar2;
->UnionOfBar : UnionOfBar
+>UnionOfBar : TypeBar1 | TypeBar2
 
 type TypeBar1 = { type: BarEnum.bar1 };
->TypeBar1 : TypeBar1
+>TypeBar1 : { type: BarEnum.bar1; }
 >type : BarEnum.bar1
 >BarEnum : any
 
 type TypeBar2 = { type: BarEnum.bar2 };
->TypeBar2 : TypeBar2
+>TypeBar2 : { type: BarEnum.bar2; }
 >type : BarEnum.bar2
 >BarEnum : any
 
@@ -520,7 +520,7 @@ interface TypeB {
 }
 
 type Type = TypeA | TypeB;
->Type : Type
+>Type : TypeA | TypeB
 
 declare function isType(x: unknown): x is Type;
 >isType : (x: unknown) => x is Type
@@ -573,7 +573,7 @@ function DoesNotWork(data: unknown) {
 // Repro from #36777
 
 type TestA = {
->TestA : TestA
+>TestA : { type: 'testA'; bananas: 3; }
 
     type: 'testA';
 >type : "testA"
@@ -583,7 +583,7 @@ type TestA = {
 }
   
 type TestB = {
->TestB : TestB
+>TestB : { type: 'testB'; apples: 5; }
 
     type: 'testB';
 >type : "testB"
@@ -593,10 +593,10 @@ type TestB = {
 }
   
 type AllTests = TestA | TestB;
->AllTests : AllTests
+>AllTests : TestA | TestB
 
 type MapOfAllTests = Record<string, AllTests>;
->MapOfAllTests : MapOfAllTests
+>MapOfAllTests : { [x: string]: AllTests; }
 
 const doTestingStuff = (mapOfTests: MapOfAllTests, ids: string[]) => {
 >doTestingStuff : (mapOfTests: MapOfAllTests, ids: string[]) => void
diff --git a/tests/baselines/reference/discriminantPropertyInference.types b/tests/baselines/reference/discriminantPropertyInference.types
index 2ebc6c6a373fe..333b93e0eb19a 100644
--- a/tests/baselines/reference/discriminantPropertyInference.types
+++ b/tests/baselines/reference/discriminantPropertyInference.types
@@ -2,7 +2,7 @@
 // Repro from #41759
 
 type DiscriminatorTrue = {
->DiscriminatorTrue : DiscriminatorTrue
+>DiscriminatorTrue : { disc: true; cb: (x: string) => void; }
 
     disc: true;
 >disc : true
@@ -14,7 +14,7 @@ type DiscriminatorTrue = {
 }
 
 type DiscriminatorFalse = {
->DiscriminatorFalse : DiscriminatorFalse
+>DiscriminatorFalse : { disc?: false | undefined; cb: (x: number) => void; }
 
     disc?: false;
 >disc : false | undefined
@@ -26,7 +26,7 @@ type DiscriminatorFalse = {
 }
 
 type Props = DiscriminatorTrue | DiscriminatorFalse;
->Props : Props
+>Props : DiscriminatorTrue | DiscriminatorFalse
 
 declare function f(options: DiscriminatorTrue | DiscriminatorFalse): any;
 >f : (options: DiscriminatorTrue | DiscriminatorFalse) => any
diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.types b/tests/baselines/reference/discriminantsAndNullOrUndefined.types
index 46cb2095fb5eb..f1814dbe5e27c 100644
--- a/tests/baselines/reference/discriminantsAndNullOrUndefined.types
+++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.types
@@ -8,7 +8,7 @@ interface B { kind: 'B'; }
 >kind : "B"
 
 type C = A | B | undefined;
->C : C
+>C : A | B | undefined
 
 function never(_: never): never {
 >never : (_: never) => never
diff --git a/tests/baselines/reference/discriminantsAndPrimitives.types b/tests/baselines/reference/discriminantsAndPrimitives.types
index 6ad18446bf01f..07b07fdac0a52 100644
--- a/tests/baselines/reference/discriminantsAndPrimitives.types
+++ b/tests/baselines/reference/discriminantsAndPrimitives.types
@@ -142,7 +142,7 @@ const enum EnumTypeNode {
 }
 
 type NodeA = Disjunction | Pattern;
->NodeA : NodeA
+>NodeA : Disjunction | Pattern
 
 interface NodeBase {
     type: NodeA["type"]
diff --git a/tests/baselines/reference/discriminateObjectTypesOnly.types b/tests/baselines/reference/discriminateObjectTypesOnly.types
index 27b686b4a67f3..59de23555e428 100644
--- a/tests/baselines/reference/discriminateObjectTypesOnly.types
+++ b/tests/baselines/reference/discriminateObjectTypesOnly.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/discriminateObjectTypesOnly.ts ===
 type Thing = number | object;
->Thing : Thing
+>Thing : number | object
 
 const k: Thing = { toFixed: null }; // OK, satisfies object
 >k : Thing
@@ -9,7 +9,7 @@ const k: Thing = { toFixed: null }; // OK, satisfies object
 >null : null
 
 type Thing2 = number | { toFixed: null } | object;
->Thing2 : Thing2
+>Thing2 : number | object | { toFixed: null; }
 >toFixed : null
 >null : null
 
@@ -26,7 +26,7 @@ const h: Thing2 = { toString: null }; // OK, satisfies object
 >null : null
 
 type Thing3 = number | { toFixed: null, toString: undefined } | object;
->Thing3 : Thing3
+>Thing3 : number | object | { toFixed: null; toString: undefined; }
 >toFixed : null
 >null : null
 >toString : undefined
diff --git a/tests/baselines/reference/discriminatedUnionErrorMessage.types b/tests/baselines/reference/discriminatedUnionErrorMessage.types
index ca405c5e3dc3a..842b7c5f9b6f1 100644
--- a/tests/baselines/reference/discriminatedUnionErrorMessage.types
+++ b/tests/baselines/reference/discriminatedUnionErrorMessage.types
@@ -1,22 +1,22 @@
 === tests/cases/compiler/discriminatedUnionErrorMessage.ts ===
 type Square = { kind: "sq", size: number }
->Square : Square
+>Square : { kind: "sq"; size: number; }
 >kind : "sq"
 >size : number
 
 type Rectangle = { kind: "rt", x: number, y: number }
->Rectangle : Rectangle
+>Rectangle : { kind: "rt"; x: number; y: number; }
 >kind : "rt"
 >x : number
 >y : number
 
 type Circle = { kind: "cr", radius: number }
->Circle : Circle
+>Circle : { kind: "cr"; radius: number; }
 >kind : "cr"
 >radius : number
 
 type Shape =
->Shape : Shape
+>Shape : Square | Rectangle | Circle
 
     | Square
     | Rectangle
diff --git a/tests/baselines/reference/discriminatedUnionJsxElement.types b/tests/baselines/reference/discriminatedUnionJsxElement.types
index 54ca2b4268f54..4f7b5a1ccdd9c 100644
--- a/tests/baselines/reference/discriminatedUnionJsxElement.types
+++ b/tests/baselines/reference/discriminatedUnionJsxElement.types
@@ -31,7 +31,7 @@ function Menu<MenuItemVariant extends ListItemVariant = ListItemVariant.OneLine>
 }
 
 type IListItemData = { variant: ListItemVariant.Avatar; } | { variant: ListItemVariant.OneLine; };
->IListItemData : IListItemData
+>IListItemData : { variant: ListItemVariant.Avatar; } | { variant: ListItemVariant.OneLine; }
 >variant : ListItemVariant.Avatar
 >ListItemVariant : any
 >variant : ListItemVariant.OneLine
diff --git a/tests/baselines/reference/discriminatedUnionTypes1.types b/tests/baselines/reference/discriminatedUnionTypes1.types
index 7c8c6c48171ba..cec56bde34f1a 100644
--- a/tests/baselines/reference/discriminatedUnionTypes1.types
+++ b/tests/baselines/reference/discriminatedUnionTypes1.types
@@ -27,7 +27,7 @@ interface Circle {
 }
 
 type Shape = Square | Rectangle | Circle;
->Shape : Shape
+>Shape : Square | Rectangle | Circle
 
 function area1(s: Shape) {
 >area1 : (s: Shape) => number
@@ -248,7 +248,7 @@ function area4(s: Shape) {
 }
 
 type Message =
->Message : Message
+>Message : { kind: "A"; x: string; } | { kind: "B" | "C"; y: number; } | { kind: "D"; }
 
     { kind: "A", x: string } |
 >kind : "A"
diff --git a/tests/baselines/reference/discriminatedUnionTypes2.types b/tests/baselines/reference/discriminatedUnionTypes2.types
index 695f0c3768f00..07250ba11fa66 100644
--- a/tests/baselines/reference/discriminatedUnionTypes2.types
+++ b/tests/baselines/reference/discriminatedUnionTypes2.types
@@ -242,7 +242,7 @@ function f20<Data>(carrier: DataCarrier<Data>) {
 // Repro from #28935
 
 type Foo = { tag: true, x: number } | { tag: false, y: number } | { [x: string]: string };
->Foo : Foo
+>Foo : { tag: true; x: number; } | { tag: false; y: number; } | { [x: string]: string; }
 >tag : true
 >true : true
 >x : number
@@ -292,7 +292,7 @@ function f31(foo: Foo) {
 // Repro from #33448
 
 type a = {
->a : a
+>a : { type: 'a'; data: string; }
 
     type: 'a',
 >type : "a"
@@ -301,7 +301,7 @@ type a = {
 >data : string
 }
 type b = {
->b : b
+>b : { type: 'b'; name: string; }
 
     type: 'b',
 >type : "b"
@@ -310,7 +310,7 @@ type b = {
 >name : string
 }
 type c = {
->c : c
+>c : { type: 'c'; other: string; }
 
     type: 'c',
 >type : "c"
@@ -320,7 +320,7 @@ type c = {
 }
 
 type abc = a | b | c;
->abc : abc
+>abc : a | b | c
 
 function f(problem: abc & (b | c)) {
 >f : (problem: abc & (b | c)) => void
@@ -347,7 +347,7 @@ function f(problem: abc & (b | c)) {
 }
 
 type RuntimeValue =
->RuntimeValue : RuntimeValue
+>RuntimeValue : { type: 'number'; value: number; } | { type: 'string'; value: string; } | { type: 'boolean'; value: boolean; }
 
     | { type: 'number', value: number }
 >type : "number"
diff --git a/tests/baselines/reference/discriminatedUnionTypes3.types b/tests/baselines/reference/discriminatedUnionTypes3.types
index 8c645a1773592..1b88a38aa1bab 100644
--- a/tests/baselines/reference/discriminatedUnionTypes3.types
+++ b/tests/baselines/reference/discriminatedUnionTypes3.types
@@ -2,7 +2,7 @@
 // Repro from #44435
 
 type Correct = {
->Correct : Correct
+>Correct : { code: string; property: true; err: undefined; }
 
 	code: string
 >code : string
@@ -15,13 +15,13 @@ type Correct = {
 >err : undefined
 }
 type Err = {
->Err : Err
+>Err : { err: `${string} is wrong!`; }
 
 	err: `${string} is wrong!`
 >err : `${string} is wrong!`
 }
 type SomeReturnType = Correct | Err;
->SomeReturnType : SomeReturnType
+>SomeReturnType : Correct | Err
 
 const example: SomeReturnType = {} as SomeReturnType;
 >example : SomeReturnType
diff --git a/tests/baselines/reference/divergentAccessorsTypes1.types b/tests/baselines/reference/divergentAccessorsTypes1.types
index be4ebc6243c3a..258492ff8717e 100644
--- a/tests/baselines/reference/divergentAccessorsTypes1.types
+++ b/tests/baselines/reference/divergentAccessorsTypes1.types
@@ -48,7 +48,7 @@ interface Test2 {
 }
 
 type Test3 = {
->Test3 : Test3
+>Test3 : { foo: string; bar: string | number; }
 
     get foo(): string;
 >foo : string
diff --git a/tests/baselines/reference/doNotInferUnrelatedTypes.types b/tests/baselines/reference/doNotInferUnrelatedTypes.types
index e3a9522721ae8..21a1f76d2eaf0 100644
--- a/tests/baselines/reference/doNotInferUnrelatedTypes.types
+++ b/tests/baselines/reference/doNotInferUnrelatedTypes.types
@@ -5,7 +5,7 @@ declare function dearray<T>(ara: ReadonlyArray<T>): T;
 >ara : readonly T[]
 
 type LiteralType = "foo" | "bar";
->LiteralType : LiteralType
+>LiteralType : "foo" | "bar"
 
 declare var alt: Array<LiteralType>;
 >alt : LiteralType[]
diff --git a/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.types b/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.types
index 79862e0733069..587f32d6a195a 100644
--- a/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.types
+++ b/tests/baselines/reference/doubleMixinConditionalTypeBaseClassWorks.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/doubleMixinConditionalTypeBaseClassWorks.ts ===
 type Constructor = new (...args: any[]) => {};
->Constructor : Constructor
+>Constructor : new (...args: any[]) => {}
 >args : any[]
 
 const Mixin1 = <C extends Constructor>(Base: C) => class extends Base { private _fooPrivate: {}; }
diff --git a/tests/baselines/reference/dynamicNames.types b/tests/baselines/reference/dynamicNames.types
index 03b6b980f3c67..8a2a1387677af 100644
--- a/tests/baselines/reference/dynamicNames.types
+++ b/tests/baselines/reference/dynamicNames.types
@@ -45,7 +45,7 @@ export declare class T2 extends T1 {
 >T1 : T1
 }
 export declare type T3 = {
->T3 : T3
+>T3 : { a: number; 1: string; [s0]: boolean; }
 
     [c0]: number;
 >[c0] : number
@@ -135,7 +135,7 @@ namespace N {
 >T5 : T5
     }
     export declare type T7 = {
->T7 : T7
+>T7 : { a: number; 1: string; [s0]: boolean; }
 
         [N.c2]: number;
 >[N.c2] : number
@@ -204,7 +204,7 @@ declare class T10 extends T9 {
 >T9 : T9
 }
 declare type T11 = {
->T11 : T11
+>T11 : { a: number; 1: string; [s0]: boolean; }
 
     [c4]: number;
 >[c4] : number
@@ -249,7 +249,7 @@ declare class T14 extends T13 {
 >T13 : T13
 }
 declare type T15 = {
->T15 : T15
+>T15 : { a: number; 1: string; [s0]: boolean; }
 
     a: number;
 >a : number
diff --git a/tests/baselines/reference/dynamicNamesErrors.types b/tests/baselines/reference/dynamicNamesErrors.types
index b4f44376af89b..0ae2e48638ebc 100644
--- a/tests/baselines/reference/dynamicNamesErrors.types
+++ b/tests/baselines/reference/dynamicNamesErrors.types
@@ -127,7 +127,7 @@ export class ClassMemberVisibility {
 }
 
 export type ObjectTypeVisibility = {
->ObjectTypeVisibility : ObjectTypeVisibility
+>ObjectTypeVisibility : { [x]: number; [y](): number; }
 
     [x]: number;
 >[x] : number
diff --git a/tests/baselines/reference/enumLiteralTypes1.types b/tests/baselines/reference/enumLiteralTypes1.types
index b3541381043ad..0314a6d807738 100644
--- a/tests/baselines/reference/enumLiteralTypes1.types
+++ b/tests/baselines/reference/enumLiteralTypes1.types
@@ -6,17 +6,17 @@ const enum Choice { Unknown, Yes, No };
 >No : Choice.No
 
 type YesNo = Choice.Yes | Choice.No;
->YesNo : YesNo
+>YesNo : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type NoYes = Choice.No | Choice.Yes;
->NoYes : NoYes
+>NoYes : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
->UnknownYesNo : UnknownYesNo
+>UnknownYesNo : Choice
 >Choice : any
 >Choice : any
 >Choice : any
@@ -344,7 +344,7 @@ function f13(x: UnknownYesNo) {
 }
 
 type Item =
->Item : Item
+>Item : { kind: Choice.Yes; a: string; } | { kind: Choice.No; b: string; }
 
     { kind: Choice.Yes, a: string } |
 >kind : Choice.Yes
diff --git a/tests/baselines/reference/enumLiteralTypes2.types b/tests/baselines/reference/enumLiteralTypes2.types
index d724072fc1b5e..b5a887094c862 100644
--- a/tests/baselines/reference/enumLiteralTypes2.types
+++ b/tests/baselines/reference/enumLiteralTypes2.types
@@ -6,17 +6,17 @@ const enum Choice { Unknown, Yes, No };
 >No : Choice.No
 
 type YesNo = Choice.Yes | Choice.No;
->YesNo : YesNo
+>YesNo : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type NoYes = Choice.No | Choice.Yes;
->NoYes : NoYes
+>NoYes : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
->UnknownYesNo : UnknownYesNo
+>UnknownYesNo : Choice
 >Choice : any
 >Choice : any
 >Choice : any
@@ -344,7 +344,7 @@ function f13(x: UnknownYesNo) {
 }
 
 type Item =
->Item : Item
+>Item : { kind: Choice.Yes; a: string; } | { kind: Choice.No; b: string; }
 
     { kind: Choice.Yes, a: string } |
 >kind : Choice.Yes
diff --git a/tests/baselines/reference/enumLiteralTypes3.types b/tests/baselines/reference/enumLiteralTypes3.types
index 04b5ceb0697cf..d420a1786462b 100644
--- a/tests/baselines/reference/enumLiteralTypes3.types
+++ b/tests/baselines/reference/enumLiteralTypes3.types
@@ -10,17 +10,17 @@ type Yes = Choice.Yes;
 >Choice : any
 
 type YesNo = Choice.Yes | Choice.No;
->YesNo : YesNo
+>YesNo : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type NoYes = Choice.No | Choice.Yes;
->NoYes : NoYes
+>NoYes : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
->UnknownYesNo : UnknownYesNo
+>UnknownYesNo : Choice
 >Choice : any
 >Choice : any
 >Choice : any
diff --git a/tests/baselines/reference/enumLiteralUnionNotWidened.types b/tests/baselines/reference/enumLiteralUnionNotWidened.types
index 87443fbd54906..1446b2a56ad58 100644
--- a/tests/baselines/reference/enumLiteralUnionNotWidened.types
+++ b/tests/baselines/reference/enumLiteralUnionNotWidened.types
@@ -15,11 +15,11 @@ enum B { foo = "foo", bar = "bar" };
 >"bar" : "bar"
 
 type C = A | B.foo;
->C : C
+>C : A | B.foo
 >B : any
 
 type D = A | "foo";
->D : D
+>D : A | "foo"
 
 class List<T>
 >List : List<T>
diff --git a/tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.types b/tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.types
index 55a7d345f7189..6b0d4e1f32bc5 100644
--- a/tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.types
+++ b/tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.types
@@ -45,7 +45,7 @@ namespace Test3 {
 >Test3 : typeof Test3
 
     export type Foo = {
->Foo : Foo
+>Foo : { bar: string; }
 
         bar: string;
 >bar : string
@@ -67,7 +67,7 @@ namespace Test4 {
 >Test4 : typeof Test4
 
     export type Foo = { bar: number }
->Foo : Foo
+>Foo : { bar: number; } | { bar: string; }
 >bar : number
 
                     | { bar: string }
@@ -89,7 +89,7 @@ namespace Test5 {
 >Test5 : typeof Test5
 
     export type Foo = { bar: number }
->Foo : Foo
+>Foo : { bar: number; } | { wat: string; }
 >bar : number
 
                     | { wat: string }
diff --git a/tests/baselines/reference/errorMessageOnIntersectionsWithDiscriminants01.types b/tests/baselines/reference/errorMessageOnIntersectionsWithDiscriminants01.types
index 4c532de4b272e..5222b5566f853 100644
--- a/tests/baselines/reference/errorMessageOnIntersectionsWithDiscriminants01.types
+++ b/tests/baselines/reference/errorMessageOnIntersectionsWithDiscriminants01.types
@@ -1,17 +1,17 @@
 === tests/cases/compiler/errorMessageOnIntersectionsWithDiscriminants01.ts ===
 export type Common = { test: true } | { test: false };
->Common : Common
+>Common : { test: true; } | { test: false; }
 >test : true
 >true : true
 >test : false
 >false : false
 
 export type A = Common & { foo: 1 };
->A : A
+>A : Common & { foo: 1; }
 >foo : 1
 
 export type B = Common & { bar: 1 };
->B : B
+>B : Common & { bar: 1; }
 >bar : 1
 
 declare const a: A;
diff --git a/tests/baselines/reference/errorsOnUnionsOfOverlappingObjects01.types b/tests/baselines/reference/errorsOnUnionsOfOverlappingObjects01.types
index 1e9b1b8c5ef50..1a705d7973325 100644
--- a/tests/baselines/reference/errorsOnUnionsOfOverlappingObjects01.types
+++ b/tests/baselines/reference/errorsOnUnionsOfOverlappingObjects01.types
@@ -93,7 +93,7 @@ interface Platypus { platypus: any }
 >platypus : any
 
 type ExoticAnimal =
->ExoticAnimal : ExoticAnimal
+>ExoticAnimal : CatDog | ManBearPig | Platypus
 
     | CatDog
     | ManBearPig
diff --git a/tests/baselines/reference/eventEmitterPatternWithRecordOfFunction.types b/tests/baselines/reference/eventEmitterPatternWithRecordOfFunction.types
index 37c9eaacf7a33..61e81fb65a711 100644
--- a/tests/baselines/reference/eventEmitterPatternWithRecordOfFunction.types
+++ b/tests/baselines/reference/eventEmitterPatternWithRecordOfFunction.types
@@ -11,7 +11,7 @@ type Args<F> = F extends (...args: infer A) => void ? A : never;
 >args : A
 
 type EventMap = Record<string, Function>;
->EventMap : EventMap
+>EventMap : { [x: string]: Function; }
 
 interface B<M extends EventMap> extends A {
     emit<Event extends keyof M>(event: Event, ...args: Args<M[Event]>): boolean;
diff --git a/tests/baselines/reference/excessPropertyCheckWithMultipleDiscriminants.types b/tests/baselines/reference/excessPropertyCheckWithMultipleDiscriminants.types
index 1f5d85b10a5b4..2c5b07e591444 100644
--- a/tests/baselines/reference/excessPropertyCheckWithMultipleDiscriminants.types
+++ b/tests/baselines/reference/excessPropertyCheckWithMultipleDiscriminants.types
@@ -33,7 +33,7 @@ interface Bool extends Base<boolean> {
 }
 
 type Primitive = Int | Float | Str | Bool;
->Primitive : Primitive
+>Primitive : Int | Float | Str | Bool
 
 const foo: Primitive = {
 >foo : Primitive
@@ -58,7 +58,7 @@ const foo: Primitive = {
 
 
 type DisjointDiscriminants = { p1: 'left'; p2: true; p3: number } | { p1: 'right'; p2: false; p4: string } | { p1: 'left'; p2: boolean };
->DisjointDiscriminants : DisjointDiscriminants
+>DisjointDiscriminants : { p1: 'left'; p2: true; p3: number; } | { p1: 'right'; p2: false; p4: string; } | { p1: 'left'; p2: boolean; }
 >p1 : "left"
 >p2 : true
 >true : true
diff --git a/tests/baselines/reference/excessPropertyCheckWithUnions.types b/tests/baselines/reference/excessPropertyCheckWithUnions.types
index 1a8cc69eaee08..2b012e13eb14c 100644
--- a/tests/baselines/reference/excessPropertyCheckWithUnions.types
+++ b/tests/baselines/reference/excessPropertyCheckWithUnions.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/excessPropertyCheckWithUnions.ts ===
 type ADT = {
->ADT : ADT
+>ADT : { tag: "A"; a1: string; } | { tag: "D"; d20: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20; } | { tag: "T"; }
 
     tag: "A",
 >tag : "A"
@@ -44,7 +44,7 @@ wrong = { tag: "D" }
 >"D" : "D"
 
 type Ambiguous = {
->Ambiguous : Ambiguous
+>Ambiguous : { tag: "A"; x: string; } | { tag: "A"; y: number; } | { tag: "B"; z: boolean; } | { tag: "C"; }
 
     tag: "A",
 >tag : "A"
@@ -146,7 +146,7 @@ amb = { tag: "A", z: true }
 >true : true
 
 type Overlapping =
->Overlapping : Overlapping
+>Overlapping : { a: 1; b: 1; first: string; } | { a: 2; second: string; } | { b: 3; third: string; }
 
     | { a: 1, b: 1, first: string }
 >a : 1
@@ -220,16 +220,16 @@ t0 = t2
 
 // Nested excess property checks work with discriminated unions
 type AN = { a: string } | { c: string }
->AN : AN
+>AN : { a: string; } | { c: string; }
 >a : string
 >c : string
 
 type BN = { b: string }
->BN : BN
+>BN : { b: string; }
 >b : string
 
 type AB = { kind: "A", n: AN } | { kind: "B", n: BN }
->AB : AB
+>AB : { kind: "A"; n: AN; } | { kind: "B"; n: BN; }
 >kind : "A"
 >n : AN
 >kind : "B"
@@ -280,18 +280,18 @@ const abac: AB = {
 
 // Excess property checks must match all discriminable properties
 type Button = { tag: 'button'; type?: 'submit'; };
->Button : Button
+>Button : { tag: 'button'; type?: "submit" | undefined; }
 >tag : "button"
 >type : "submit" | undefined
 
 type Anchor = { tag: 'a'; type?: string; href: string };
->Anchor : Anchor
+>Anchor : { tag: 'a'; type?: string | undefined; href: string; }
 >tag : "a"
 >type : string | undefined
 >href : string
 
 type Union = Button | Anchor;
->Union : Union
+>Union : Button | Anchor
 
 const obj: Union = {
 >obj : Union
@@ -331,7 +331,7 @@ interface NumberKeys {
 }
 
 type ObjectDataSpecification = StringKeys | NumberKeys;
->ObjectDataSpecification : ObjectDataSpecification
+>ObjectDataSpecification : StringKeys | NumberKeys
 
 
 const dataSpecification: ObjectDataSpecification = {  // Error
@@ -381,7 +381,7 @@ interface I3 extends Record<string, string> {
 }
 
 type Properties =
->Properties : Properties
+>Properties : I1 | I2 | I3 | { [key: string]: never; }
 
     | { [key: string]: never }
 >key : string
diff --git a/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.types b/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.types
index 29019339fa6a7..9e9ef82d54d0a 100644
--- a/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.types
+++ b/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.types
@@ -17,7 +17,7 @@ interface C {
 }
 
 type D = B & C;
->D : D
+>D : B & C
 
 let a: B = { a: { x: 'hello' } }; // ok
 >a : B
@@ -80,7 +80,7 @@ let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // error - y does not exist in typ
 // https://github.com/Microsoft/TypeScript/issues/18075
 
 export type MyType = { id: number; } & { name: string; } & { photo: { id: number; } & { url: string; } }
->MyType : MyType
+>MyType : { id: number; } & { name: string; } & { photo: {    id: number;} & {    url: string;}; }
 >id : number
 >name : string
 >photo : { id: number; } & { url: string; }
diff --git a/tests/baselines/reference/excessPropertyErrorForFunctionTypes.types b/tests/baselines/reference/excessPropertyErrorForFunctionTypes.types
index 9792a38a6612e..5bde8cd170004 100644
--- a/tests/baselines/reference/excessPropertyErrorForFunctionTypes.types
+++ b/tests/baselines/reference/excessPropertyErrorForFunctionTypes.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/excessPropertyErrorForFunctionTypes.ts ===
 type FunctionType = () => any;
->FunctionType : FunctionType
+>FunctionType : () => any
 
 type DoesntWork = { a: number, c: number } | FunctionType;
->DoesntWork : DoesntWork
+>DoesntWork : { a: number; c: number; } | FunctionType
 >a : number
 >c : number
 
diff --git a/tests/baselines/reference/excessiveStackDepthFlatArray.types b/tests/baselines/reference/excessiveStackDepthFlatArray.types
index ae346a034fa67..d84f300a5f7e8 100644
--- a/tests/baselines/reference/excessiveStackDepthFlatArray.types
+++ b/tests/baselines/reference/excessiveStackDepthFlatArray.types
@@ -30,17 +30,17 @@ declare namespace React {
 >children : ReactNode
   }
   type ReactNode = ReactChild | ReactFragment | boolean | null | undefined;
->ReactNode : ReactNode
+>ReactNode : boolean | ReactText | ReactFragment
 >null : null
 
   type ReactText = string | number;
->ReactText : ReactText
+>ReactText : string | number
 
   type ReactChild = ReactText;
 >ReactChild : ReactText
 
   type ReactFragment = {} | ReactNodeArray;
->ReactFragment : ReactFragment
+>ReactFragment : {} | ReactNodeArray
 
   interface ReactNodeArray extends Array<ReactNode> {}
 }
diff --git a/tests/baselines/reference/excessivelyLargeTupleSpread.types b/tests/baselines/reference/excessivelyLargeTupleSpread.types
index 5e1e63a8968f7..9c8c55e22fcf4 100644
--- a/tests/baselines/reference/excessivelyLargeTupleSpread.types
+++ b/tests/baselines/reference/excessivelyLargeTupleSpread.types
@@ -10,7 +10,7 @@ type A = BuildTuple<3>
 >A : any
 
 type T0 = [any];
->T0 : T0
+>T0 : [any]
 
 type T1 = [...T0, ...T0];
 >T1 : [any, any]
diff --git a/tests/baselines/reference/exhaustiveSwitchStatements1.types b/tests/baselines/reference/exhaustiveSwitchStatements1.types
index 4944989ed1d6d..6a74aa70549fa 100644
--- a/tests/baselines/reference/exhaustiveSwitchStatements1.types
+++ b/tests/baselines/reference/exhaustiveSwitchStatements1.types
@@ -155,7 +155,7 @@ interface Triangle { kind: "triangle"; side: number; }
 >side : number
 
 type Shape = Square | Rectangle | Circle | Triangle;
->Shape : Shape
+>Shape : Square | Rectangle | Circle | Triangle
 
 function area(s: Shape): number {
 >area : (s: Shape) => number
@@ -481,7 +481,7 @@ interface Circle2 {
 }
 
 type Shape2 = Square2 | Circle2;
->Shape2 : Shape2
+>Shape2 : Square2 | Circle2
 
 function withDefault(s1: Shape2, s2: Shape2): string {
 >withDefault : (s1: Shape2, s2: Shape2) => string
@@ -665,7 +665,7 @@ function foo() {
 // Repro from #35070
 
 type O = {
->O : O
+>O : { a: number; b: number; }
 
     a: number,
 >a : number
@@ -675,7 +675,7 @@ type O = {
 
 };
 type K = keyof O | 'c';
->K : K
+>K : keyof O | "c"
 
 function ff(o: O, k: K) {
 >ff : (o: O, k: K) => number
@@ -706,7 +706,7 @@ function ff(o: O, k: K) {
 
 // Repro from #35431
 type A = { kind: "abc" } | { kind: "def" };
->A : A
+>A : { kind: "abc"; } | { kind: "def"; }
 >kind : "abc"
 >kind : "def"
 
diff --git a/tests/baselines/reference/exportDeclaration_moduleSpecifier-isolatedModules.types b/tests/baselines/reference/exportDeclaration_moduleSpecifier-isolatedModules.types
index 78d90f12023c3..2bf0be5f3dd08 100644
--- a/tests/baselines/reference/exportDeclaration_moduleSpecifier-isolatedModules.types
+++ b/tests/baselines/reference/exportDeclaration_moduleSpecifier-isolatedModules.types
@@ -1,6 +1,6 @@
 === /a.ts ===
 export type A = {};
->A : A
+>A : {}
 
 === /b.ts ===
 export type { A } from './a'; // should not error, but would without `type`
diff --git a/tests/baselines/reference/exportDefaultTypeAndClass.types b/tests/baselines/reference/exportDefaultTypeAndClass.types
index 273a650257c5e..f6a7969aca11f 100644
--- a/tests/baselines/reference/exportDefaultTypeAndClass.types
+++ b/tests/baselines/reference/exportDefaultTypeAndClass.types
@@ -3,7 +3,7 @@ export default class Foo {}
 >Foo : Foo
 
 type Bar = {}
->Bar : Bar
+>Bar : {}
 
 export default Bar
 >Bar : Bar
diff --git a/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.types b/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.types
index c014cddfa250e..e6b1cc80726fe 100644
--- a/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.types
+++ b/tests/baselines/reference/exportDefaultTypeAndFunctionOverloads.types
@@ -15,7 +15,7 @@ export default function foo(value: string | number): string | number {
 >1 : 1
 }
 type Foo = {}
->Foo : Foo
+>Foo : {}
 
 export default Foo
 >Foo : Foo
diff --git a/tests/baselines/reference/exportDefaultTypeClassAndValue.types b/tests/baselines/reference/exportDefaultTypeClassAndValue.types
index 2896db94a5ebb..de77a17902c18 100644
--- a/tests/baselines/reference/exportDefaultTypeClassAndValue.types
+++ b/tests/baselines/reference/exportDefaultTypeClassAndValue.types
@@ -10,7 +10,7 @@ export default class Foo {}
 >Foo : foo
 
 type Bar = {}
->Bar : Bar
+>Bar : {}
 
 export default Bar
 >Bar : Bar
diff --git a/tests/baselines/reference/exportNamespaceDeclarationRetainsVisibility.types b/tests/baselines/reference/exportNamespaceDeclarationRetainsVisibility.types
index 69422a8458c0f..d500ed29a3529 100644
--- a/tests/baselines/reference/exportNamespaceDeclarationRetainsVisibility.types
+++ b/tests/baselines/reference/exportNamespaceDeclarationRetainsVisibility.types
@@ -11,7 +11,7 @@ namespace X {
     }
 
     export type C = A | B;
->C : C
+>C : A | B
 }
 
 export = X;
diff --git a/tests/baselines/reference/flowControlTypeGuardThenSwitch.types b/tests/baselines/reference/flowControlTypeGuardThenSwitch.types
index 807a322073bd6..e197a80e454f6 100644
--- a/tests/baselines/reference/flowControlTypeGuardThenSwitch.types
+++ b/tests/baselines/reference/flowControlTypeGuardThenSwitch.types
@@ -33,7 +33,7 @@ interface B extends Base {
 }
 
 type Both = A | B;
->Both : Both
+>Both : A | B
 
 function isBoth(x: Base): x is Both {
 >isBoth : (x: Base) => x is Both
diff --git a/tests/baselines/reference/for-of58.types b/tests/baselines/reference/for-of58.types
index f188378dfcec6..5a3470b45fb35 100644
--- a/tests/baselines/reference/for-of58.types
+++ b/tests/baselines/reference/for-of58.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of58.ts ===
 type X = { x: 'x' };
->X : X
+>X : { x: 'x'; }
 >x : "x"
 
 type Y = { y: 'y' };
->Y : Y
+>Y : { y: 'y'; }
 >y : "y"
 
 declare const arr: X[] & Y[];
diff --git a/tests/baselines/reference/forOfStringConstituents.types b/tests/baselines/reference/forOfStringConstituents.types
index c895f3b022cc4..da3427aeb6843 100644
--- a/tests/baselines/reference/forOfStringConstituents.types
+++ b/tests/baselines/reference/forOfStringConstituents.types
@@ -14,10 +14,10 @@ interface D { x: 3; }
 >x : 3
 
 type AB = A | B;
->AB : AB
+>AB : A | B
 
 type CD = C | D;
->CD : CD
+>CD : C | D
 
 declare let x: AB, y: CD;
 >x : AB
diff --git a/tests/baselines/reference/forwardRefInTypeDeclaration.types b/tests/baselines/reference/forwardRefInTypeDeclaration.types
index de487ec372c6a..a6c59cbd4036a 100644
--- a/tests/baselines/reference/forwardRefInTypeDeclaration.types
+++ b/tests/baselines/reference/forwardRefInTypeDeclaration.types
@@ -19,7 +19,7 @@ const s2 = "x";
 
 // or in a type definition
 type Foo3 = { [s3]: number; }
->Foo3 : Foo3
+>Foo3 : { x: number; }
 >[s3] : number
 >s3 : "x"
 
diff --git a/tests/baselines/reference/functionCallOnConstrainedTypeVariable.types b/tests/baselines/reference/functionCallOnConstrainedTypeVariable.types
index fb0318f14ddd3..b5734ef468eb0 100644
--- a/tests/baselines/reference/functionCallOnConstrainedTypeVariable.types
+++ b/tests/baselines/reference/functionCallOnConstrainedTypeVariable.types
@@ -2,7 +2,7 @@
 // Repro from #20196
 
 type A = {
->A : A
+>A : { a: (x: number) => string; }
 
   a: (x: number) => string
 >a : (x: number) => string
@@ -10,7 +10,7 @@ type A = {
 
 };
 type B = {
->B : B
+>B : { a: (x: boolean) => string; }
 
   a: (x: boolean) => string
 >a : (x: boolean) => string
diff --git a/tests/baselines/reference/genericContextualTypes1.types b/tests/baselines/reference/genericContextualTypes1.types
index f617b827ee2c6..d8bebed28bf9f 100644
--- a/tests/baselines/reference/genericContextualTypes1.types
+++ b/tests/baselines/reference/genericContextualTypes1.types
@@ -236,7 +236,7 @@ const f40: <A, B>(b: B, a: A) => [A, B] = flip(zip);
 // Repro from #16293
 
 type fn = <A>(a: A) => A;
->fn : fn
+>fn : <A>(a: A) => A
 >a : A
 
 const fn: fn = a => a;
diff --git a/tests/baselines/reference/genericDefaultsErrors.types b/tests/baselines/reference/genericDefaultsErrors.types
index 2cd4d83c52732..312e130271566 100644
--- a/tests/baselines/reference/genericDefaultsErrors.types
+++ b/tests/baselines/reference/genericDefaultsErrors.types
@@ -70,10 +70,10 @@ type i09t01 = i09<1>; // error
 >i09t01 : any
 
 type i09t02 = i09<1, 2>; // ok
->i09t02 : i09t02
+>i09t02 : i09<1, 2, number>
 
 type i09t03 = i09<1, 2, 3>; // ok
->i09t03 : i09t03
+>i09t03 : i09<1, 2, 3>
 
 type i09t04 = i09<1, 2, 3, 4>; // error
 >i09t04 : any
diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types
index 9ce0b1b2b24bb..d76a85dd43d85 100644
--- a/tests/baselines/reference/genericFunctionInference1.types
+++ b/tests/baselines/reference/genericFunctionInference1.types
@@ -808,7 +808,7 @@ const fn20 = pipe((_a?: {}) => 1);
 // #29904.3
 
 type Fn = (n: number) => number;
->Fn : Fn
+>Fn : (n: number) => number
 >n : number
 
 const fn30: Fn = pipe(
diff --git a/tests/baselines/reference/genericFunctionInference2.types b/tests/baselines/reference/genericFunctionInference2.types
index 85208d6fee42c..79fd0d14fd02c 100644
--- a/tests/baselines/reference/genericFunctionInference2.types
+++ b/tests/baselines/reference/genericFunctionInference2.types
@@ -10,7 +10,7 @@ declare function combineReducers<S>(reducers: { [K in keyof S]: Reducer<S[K]> })
 >reducers : { [K in keyof S]: Reducer<S[K]>; }
 
 type MyState = { combined: { foo: number } };
->MyState : MyState
+>MyState : { combined: {    foo: number;}; }
 >combined : { foo: number; }
 >foo : number
 
@@ -54,7 +54,7 @@ declare function withH<T, U>(handlerCreators: HandleCreatorsFactory<T, U>): U;
 >handlerCreators : HandleCreatorsFactory<T, U>
 
 type Props = { out: number }
->Props : Props
+>Props : { out: number; }
 >out : number
 
 type HandleCreatorsFactory<T, U> = (initialProps: T) => { [P in keyof U]: (props: T) => U[P] };
diff --git a/tests/baselines/reference/genericObjectRest.types b/tests/baselines/reference/genericObjectRest.types
index a10fc4d25c870..48a0ada2e7176 100644
--- a/tests/baselines/reference/genericObjectRest.types
+++ b/tests/baselines/reference/genericObjectRest.types
@@ -88,7 +88,7 @@ function f3<T, K1 extends keyof T, K2 extends keyof T>(obj: T, k1: K1, k2: K2) {
 }
 
 type Item = { a: string, b: number, c: boolean };
->Item : Item
+>Item : { a: string; b: number; c: boolean; }
 >a : string
 >b : number
 >c : boolean
diff --git a/tests/baselines/reference/genericObjectSpreadResultInSwitch.types b/tests/baselines/reference/genericObjectSpreadResultInSwitch.types
index 4c9ca429daa37..40505e8bbf536 100644
--- a/tests/baselines/reference/genericObjectSpreadResultInSwitch.types
+++ b/tests/baselines/reference/genericObjectSpreadResultInSwitch.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/genericObjectSpreadResultInSwitch.ts ===
 type Params = {
->Params : Params
+>Params : { foo: string; } & ({ tag: 'a'; type: number; } | { tag: 'b'; type: string; })
 
     foo: string;
 >foo : string
diff --git a/tests/baselines/reference/genericRestParameters1.types b/tests/baselines/reference/genericRestParameters1.types
index 1e45a3c86621e..687ab9751ddec 100644
--- a/tests/baselines/reference/genericRestParameters1.types
+++ b/tests/baselines/reference/genericRestParameters1.types
@@ -704,7 +704,7 @@ type T09 = Parameters<Function>;
 >T09 : never
 
 type Record1 = {
->Record1 : Record1
+>Record1 : { move: [number, 'left' | 'right']; jump: [number, 'up' | 'down']; stop: string; done: []; }
 
   move: [number, 'left' | 'right'];
 >move : [number, "left" | "right"]
diff --git a/tests/baselines/reference/genericRestParameters3.types b/tests/baselines/reference/genericRestParameters3.types
index be5b2c2091d05..d582932ba8124 100644
--- a/tests/baselines/reference/genericRestParameters3.types
+++ b/tests/baselines/reference/genericRestParameters3.types
@@ -230,10 +230,10 @@ foo2(...x2);
 // Repros from #47754
 
 type RestParams = [y: string] | [y: number];
->RestParams : RestParams
+>RestParams : [y: string] | [y: number]
 
 type Signature = (x: string, ...rest: RestParams) => void;
->Signature : Signature
+>Signature : (x: string, ...rest: RestParams) => void
 >x : string
 >rest : RestParams
 
diff --git a/tests/baselines/reference/genericRestTypes.types b/tests/baselines/reference/genericRestTypes.types
index 63eb00c63ba19..9341cfeefd5cc 100644
--- a/tests/baselines/reference/genericRestTypes.types
+++ b/tests/baselines/reference/genericRestTypes.types
@@ -10,12 +10,12 @@ type Tail<T extends any[]> = ((...args: T) => any) extends ((head: any, ...tail:
 >tail : U
 
 type MyFunctionType = (foo: number, bar: string) => boolean;
->MyFunctionType : MyFunctionType
+>MyFunctionType : (foo: number, bar: string) => boolean
 >foo : number
 >bar : string
 
 type Explicit = (...args: Tail<Parameters<MyFunctionType>>) => ReturnType<MyFunctionType>; // (bar: string) => boolean
->Explicit : Explicit
+>Explicit : (bar: string) => ReturnType<MyFunctionType>
 >args : [bar: string]
 
 type Bind1<T extends (head: any, ...tail: any[]) => any> = (...args: Tail<Parameters<T>>) => ReturnType<T>;
@@ -25,7 +25,7 @@ type Bind1<T extends (head: any, ...tail: any[]) => any> = (...args: Tail<Parame
 >args : Tail<Parameters<T>>
 
 type Generic = Bind1<MyFunctionType>; // (bar: string) => boolean
->Generic : Generic
+>Generic : (bar: string) => boolean
 
 function assignmentWithComplexRest<T extends any[]>() {
 >assignmentWithComplexRest : <T extends any[]>() => void
diff --git a/tests/baselines/reference/getParameterNameAtPosition.types b/tests/baselines/reference/getParameterNameAtPosition.types
index 1e0c92129010b..8eb527b41ec71 100644
--- a/tests/baselines/reference/getParameterNameAtPosition.types
+++ b/tests/baselines/reference/getParameterNameAtPosition.types
@@ -6,7 +6,7 @@ interface Mock<Y extends any[]> extends Function {
 >args : Y
 }
 type Tester = (opts: any, done: (...args: any[]) => any) => any;
->Tester : Tester
+>Tester : (opts: any, done: (...args: any[]) => any) => any
 >opts : any
 >done : (...args: any[]) => any
 >args : any[]
diff --git a/tests/baselines/reference/hugeDeclarationOutputGetsTruncatedWithError.types b/tests/baselines/reference/hugeDeclarationOutputGetsTruncatedWithError.types
index 1db099f87a1a0..28fcd4fd0dffb 100644
--- a/tests/baselines/reference/hugeDeclarationOutputGetsTruncatedWithError.types
+++ b/tests/baselines/reference/hugeDeclarationOutputGetsTruncatedWithError.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/hugeDeclarationOutputGetsTruncatedWithError.ts ===
 type props = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
->props : props
+>props : "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z"
 
 type manyprops = `${props}${props}`;
 >manyprops : "aa" | "ab" | "ac" | "ad" | "ae" | "af" | "ag" | "ah" | "ai" | "aj" | "ak" | "al" | "am" | "an" | "ao" | "ap" | "aq" | "ar" | "as" | "at" | "au" | "av" | "aw" | "ax" | "ay" | "az" | "ba" | "bb" | "bc" | "bd" | "be" | "bf" | "bg" | "bh" | "bi" | "bj" | "bk" | "bl" | "bm" | "bn" | "bo" | "bp" | "bq" | "br" | "bs" | "bt" | "bu" | "bv" | "bw" | "bx" | "by" | "bz" | "ca" | "cb" | "cc" | "cd" | "ce" | "cf" | "cg" | "ch" | "ci" | "cj" | "ck" | "cl" | "cm" | "cn" | "co" | "cp" | "cq" | "cr" | "cs" | "ct" | "cu" | "cv" | "cw" | "cx" | "cy" | "cz" | "da" | "db" | "dc" | "dd" | "de" | "df" | "dg" | "dh" | "di" | "dj" | "dk" | "dl" | "dm" | "dn" | "do" | "dp" | "dq" | "dr" | "ds" | "dt" | "du" | "dv" | "dw" | "dx" | "dy" | "dz" | "ea" | "eb" | "ec" | "ed" | "ee" | "ef" | "eg" | "eh" | "ei" | "ej" | "ek" | "el" | "em" | "en" | "eo" | "ep" | "eq" | "er" | "es" | "et" | "eu" | "ev" | "ew" | "ex" | "ey" | "ez" | "fa" | "fb" | "fc" | "fd" | "fe" | "ff" | "fg" | "fh" | "fi" | "fj" | "fk" | "fl" | "fm" | "fn" | "fo" | "fp" | "fq" | "fr" | "fs" | "ft" | "fu" | "fv" | "fw" | "fx" | "fy" | "fz" | "ga" | "gb" | "gc" | "gd" | "ge" | "gf" | "gg" | "gh" | "gi" | "gj" | "gk" | "gl" | "gm" | "gn" | "go" | "gp" | "gq" | "gr" | "gs" | "gt" | "gu" | "gv" | "gw" | "gx" | "gy" | "gz" | "ha" | "hb" | "hc" | "hd" | "he" | "hf" | "hg" | "hh" | "hi" | "hj" | "hk" | "hl" | "hm" | "hn" | "ho" | "hp" | "hq" | "hr" | "hs" | "ht" | "hu" | "hv" | "hw" | "hx" | "hy" | "hz" | "ia" | "ib" | "ic" | "id" | "ie" | "if" | "ig" | "ih" | "ii" | "ij" | "ik" | "il" | "im" | "in" | "io" | "ip" | "iq" | "ir" | "is" | "it" | "iu" | "iv" | "iw" | "ix" | "iy" | "iz" | "ja" | "jb" | "jc" | "jd" | "je" | "jf" | "jg" | "jh" | "ji" | "jj" | "jk" | "jl" | "jm" | "jn" | "jo" | "jp" | "jq" | "jr" | "js" | "jt" | "ju" | "jv" | "jw" | "jx" | "jy" | "jz" | "ka" | "kb" | "kc" | "kd" | "ke" | "kf" | "kg" | "kh" | "ki" | "kj" | "kk" | "kl" | "km" | "kn" | "ko" | "kp" | "kq" | "kr" | "ks" | "kt" | "ku" | "kv" | "kw" | "kx" | "ky" | "kz" | "la" | "lb" | "lc" | "ld" | "le" | "lf" | "lg" | "lh" | "li" | "lj" | "lk" | "ll" | "lm" | "ln" | "lo" | "lp" | "lq" | "lr" | "ls" | "lt" | "lu" | "lv" | "lw" | "lx" | "ly" | "lz" | "ma" | "mb" | "mc" | "md" | "me" | "mf" | "mg" | "mh" | "mi" | "mj" | "mk" | "ml" | "mm" | "mn" | "mo" | "mp" | "mq" | "mr" | "ms" | "mt" | "mu" | "mv" | "mw" | "mx" | "my" | "mz" | "na" | "nb" | "nc" | "nd" | "ne" | "nf" | "ng" | "nh" | "ni" | "nj" | "nk" | "nl" | "nm" | "nn" | "no" | "np" | "nq" | "nr" | "ns" | "nt" | "nu" | "nv" | "nw" | "nx" | "ny" | "nz" | "oa" | "ob" | "oc" | "od" | "oe" | "of" | "og" | "oh" | "oi" | "oj" | "ok" | "ol" | "om" | "on" | "oo" | "op" | "oq" | "or" | "os" | "ot" | "ou" | "ov" | "ow" | "ox" | "oy" | "oz" | "pa" | "pb" | "pc" | "pd" | "pe" | "pf" | "pg" | "ph" | "pi" | "pj" | "pk" | "pl" | "pm" | "pn" | "po" | "pp" | "pq" | "pr" | "ps" | "pt" | "pu" | "pv" | "pw" | "px" | "py" | "pz" | "qa" | "qb" | "qc" | "qd" | "qe" | "qf" | "qg" | "qh" | "qi" | "qj" | "qk" | "ql" | "qm" | "qn" | "qo" | "qp" | "qq" | "qr" | "qs" | "qt" | "qu" | "qv" | "qw" | "qx" | "qy" | "qz" | "ra" | "rb" | "rc" | "rd" | "re" | "rf" | "rg" | "rh" | "ri" | "rj" | "rk" | "rl" | "rm" | "rn" | "ro" | "rp" | "rq" | "rr" | "rs" | "rt" | "ru" | "rv" | "rw" | "rx" | "ry" | "rz" | "sa" | "sb" | "sc" | "sd" | "se" | "sf" | "sg" | "sh" | "si" | "sj" | "sk" | "sl" | "sm" | "sn" | "so" | "sp" | "sq" | "sr" | "ss" | "st" | "su" | "sv" | "sw" | "sx" | "sy" | "sz" | "ta" | "tb" | "tc" | "td" | "te" | "tf" | "tg" | "th" | "ti" | "tj" | "tk" | "tl" | "tm" | "tn" | "to" | "tp" | "tq" | "tr" | "ts" | "tt" | "tu" | "tv" | "tw" | "tx" | "ty" | "tz" | "ua" | "ub" | "uc" | "ud" | "ue" | "uf" | "ug" | "uh" | "ui" | "uj" | "uk" | "ul" | "um" | "un" | "uo" | "up" | "uq" | "ur" | "us" | "ut" | "uu" | "uv" | "uw" | "ux" | "uy" | "uz" | "va" | "vb" | "vc" | "vd" | "ve" | "vf" | "vg" | "vh" | "vi" | "vj" | "vk" | "vl" | "vm" | "vn" | "vo" | "vp" | "vq" | "vr" | "vs" | "vt" | "vu" | "vv" | "vw" | "vx" | "vy" | "vz" | "wa" | "wb" | "wc" | "wd" | "we" | "wf" | "wg" | "wh" | "wi" | "wj" | "wk" | "wl" | "wm" | "wn" | "wo" | "wp" | "wq" | "wr" | "ws" | "wt" | "wu" | "wv" | "ww" | "wx" | "wy" | "wz" | "xa" | "xb" | "xc" | "xd" | "xe" | "xf" | "xg" | "xh" | "xi" | "xj" | "xk" | "xl" | "xm" | "xn" | "xo" | "xp" | "xq" | "xr" | "xs" | "xt" | "xu" | "xv" | "xw" | "xx" | "xy" | "xz" | "ya" | "yb" | "yc" | "yd" | "ye" | "yf" | "yg" | "yh" | "yi" | "yj" | "yk" | "yl" | "ym" | "yn" | "yo" | "yp" | "yq" | "yr" | "ys" | "yt" | "yu" | "yv" | "yw" | "yx" | "yy" | "yz" | "za" | "zb" | "zc" | "zd" | "ze" | "zf" | "zg" | "zh" | "zi" | "zj" | "zk" | "zl" | "zm" | "zn" | "zo" | "zp" | "zq" | "zr" | "zs" | "zt" | "zu" | "zv" | "zw" | "zx" | "zy" | "zz"
diff --git a/tests/baselines/reference/identicalTypesNoDifferByCheckOrder.types b/tests/baselines/reference/identicalTypesNoDifferByCheckOrder.types
index e4c691c6b952f..55122319b547b 100644
--- a/tests/baselines/reference/identicalTypesNoDifferByCheckOrder.types
+++ b/tests/baselines/reference/identicalTypesNoDifferByCheckOrder.types
@@ -11,7 +11,7 @@ interface SomeProps {
 }
 
 type SomePropsX = Required<Pick<SomeProps, "x">> & Omit<SomeProps, "x">;
->SomePropsX : SomePropsX
+>SomePropsX : Required<Pick<SomeProps, "x">> & Omit<SomeProps, "x">
 
 interface SomePropsClone {
     x?: string;
@@ -25,7 +25,7 @@ interface SomePropsClone {
 }
 
 type SomePropsCloneX = Required<Pick<SomePropsClone, "x">> & Omit<SomePropsClone, "x">;
->SomePropsCloneX : SomePropsCloneX
+>SomePropsCloneX : Required<Pick<SomePropsClone, "x">> & Omit<SomePropsClone, "x">
 
 type Validator<T> = {(): boolean, opt?: T};
 >Validator : Validator<T>
diff --git a/tests/baselines/reference/implementsIncorrectlyNoAssertion.types b/tests/baselines/reference/implementsIncorrectlyNoAssertion.types
index 0c121043e176f..60e193e080be4 100644
--- a/tests/baselines/reference/implementsIncorrectlyNoAssertion.types
+++ b/tests/baselines/reference/implementsIncorrectlyNoAssertion.types
@@ -12,7 +12,7 @@ declare class Bar {
 >y : string
 }
 type Wrapper = Foo & Bar;
->Wrapper : Wrapper
+>Wrapper : Foo & Bar
 
 class Baz implements Wrapper {
 >Baz : Baz
diff --git a/tests/baselines/reference/implicitIndexSignatures.types b/tests/baselines/reference/implicitIndexSignatures.types
index c302edba32fd2..613d0cec7ac5b 100644
--- a/tests/baselines/reference/implicitIndexSignatures.types
+++ b/tests/baselines/reference/implicitIndexSignatures.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/implicitIndexSignatures.ts ===
 type StringMap = { [x: string]: string };
->StringMap : StringMap
+>StringMap : { [x: string]: string; }
 >x : string
 
 const empty1 = {};
diff --git a/tests/baselines/reference/importClause_namedImports.types b/tests/baselines/reference/importClause_namedImports.types
index 64c6c12b3881e..798cdb3928a68 100644
--- a/tests/baselines/reference/importClause_namedImports.types
+++ b/tests/baselines/reference/importClause_namedImports.types
@@ -3,7 +3,7 @@ export class A {}
 >A : A
 
 export type B  = { b: string };
->B : B
+>B : { b: string; }
 >b : string
 
 export const C = "";
diff --git a/tests/baselines/reference/importEqualsError45874.types b/tests/baselines/reference/importEqualsError45874.types
index 9e3c9c2945eae..7a3d70e746585 100644
--- a/tests/baselines/reference/importEqualsError45874.types
+++ b/tests/baselines/reference/importEqualsError45874.types
@@ -3,7 +3,7 @@ namespace globals {
 >globals : typeof globals
 
   export type Foo = {};
->Foo : Foo
+>Foo : {}
 
   export const Bar = {};
 >Bar : {}
diff --git a/tests/baselines/reference/importPropertyFromMappedType.types b/tests/baselines/reference/importPropertyFromMappedType.types
index efc06ad38e4a0..696cb83599dc5 100644
--- a/tests/baselines/reference/importPropertyFromMappedType.types
+++ b/tests/baselines/reference/importPropertyFromMappedType.types
@@ -10,7 +10,7 @@ declare const createHttpError: createHttpError.NamedConstructors;
 
 declare namespace createHttpError {
     type NamedConstructors =  { [P in 'NotFound']: unknown;}
->NamedConstructors : NamedConstructors
+>NamedConstructors : { NotFound: unknown; }
 }
 
 === tests/cases/compiler/main.ts ===
diff --git a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types
index 6501bab43e581..7e71235bb2fb1 100644
--- a/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types
+++ b/tests/baselines/reference/importShouldNotBeElidedInDeclarationEmit.types
@@ -3,7 +3,7 @@ export as namespace UMD;
 >UMD : typeof import("tests/cases/compiler/node_modules/umd")
 
 export type Thing = {
->Thing : Thing
+>Thing : { a: number; }
 
     a: number;
 >a : number
diff --git a/tests/baselines/reference/importTypeGenericArrowTypeParenthesized.types b/tests/baselines/reference/importTypeGenericArrowTypeParenthesized.types
index 1da9f5906973f..fe9cf70f63465 100644
--- a/tests/baselines/reference/importTypeGenericArrowTypeParenthesized.types
+++ b/tests/baselines/reference/importTypeGenericArrowTypeParenthesized.types
@@ -41,7 +41,7 @@ export const works1 = fn((x: number) => x);
 >x : number
 
 type MakeItWork = <T>(x: T) => T;
->MakeItWork : MakeItWork
+>MakeItWork : <T>(x: T) => T
 >x : T
 
 export const works2 = fn<MakeItWork>(x => x);
diff --git a/tests/baselines/reference/importsNotUsedAsValues_error.types b/tests/baselines/reference/importsNotUsedAsValues_error.types
index cbe4fc62703c9..99acfb8041ed2 100644
--- a/tests/baselines/reference/importsNotUsedAsValues_error.types
+++ b/tests/baselines/reference/importsNotUsedAsValues_error.types
@@ -4,7 +4,7 @@ export class A {}
 >A : A
 
 export type B = {};
->B : B
+>B : {}
 
 export const enum C { One, Two }
 >C : C
diff --git a/tests/baselines/reference/inKeywordTypeguard.types b/tests/baselines/reference/inKeywordTypeguard.types
index e0956d838e2ec..cb0c545088822 100644
--- a/tests/baselines/reference/inKeywordTypeguard.types
+++ b/tests/baselines/reference/inKeywordTypeguard.types
@@ -383,7 +383,7 @@ function narrowsToNever(x: { l: number } | { r: number }) {
 }
 
 type AOrB = { aProp: number } | { bProp: number };
->AOrB : AOrB
+>AOrB : { aProp: number; } | { bProp: number; }
 >aProp : number
 >bProp : number
 
diff --git a/tests/baselines/reference/indexSignatureAndMappedType.types b/tests/baselines/reference/indexSignatureAndMappedType.types
index 9f3b3e3fe6cc5..c6b129bc4f7a1 100644
--- a/tests/baselines/reference/indexSignatureAndMappedType.types
+++ b/tests/baselines/reference/indexSignatureAndMappedType.types
@@ -56,7 +56,7 @@ function f3<T, U, K extends string>(x: { [key: string]: T }, y: Record<K, U>) {
 // Repro from #14548
 
 type Dictionary = {
->Dictionary : Dictionary
+>Dictionary : { [key: string]: string; }
 
     [key: string]: string;
 >key : string
diff --git a/tests/baselines/reference/indexSignatureWithTrailingComma.types b/tests/baselines/reference/indexSignatureWithTrailingComma.types
index 095e97c6e2d56..9f37e452ab7d6 100644
--- a/tests/baselines/reference/indexSignatureWithTrailingComma.types
+++ b/tests/baselines/reference/indexSignatureWithTrailingComma.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/indexSignatureWithTrailingComma.ts ===
 type A = {
->A : A
+>A : { [key: string]: string; }
 
     [key: string,]: string;
 >key : string
diff --git a/tests/baselines/reference/indexSignatures1.types b/tests/baselines/reference/indexSignatures1.types
index 720f4357c1904..a114c1cf33dda 100644
--- a/tests/baselines/reference/indexSignatures1.types
+++ b/tests/baselines/reference/indexSignatures1.types
@@ -179,7 +179,7 @@ dom = { date123: 'hello' };  // Error
 // Contextual typing by index signature with template literal pattern
 
 type Funcs = {
->Funcs : Funcs
+>Funcs : { [key: `s${string}`]: (x: string) => void; [key: `n${string}`]: (x: number) => void; }
 
     [key: `s${string}`]: (x: string) => void,
 >key : `s${string}`
@@ -214,7 +214,7 @@ const funcs: Funcs = {
 // Duplicate index signature checking
 
 type Duplicates = {
->Duplicates : Duplicates
+>Duplicates : { [key: string]: any; [key: number]: any; [key: symbol]: any; [key: `foo${string}`]: any; }
 
     [key: string | number]: any;  // Error
 >key : string | number
@@ -232,7 +232,7 @@ type Duplicates = {
 // Conflicting index signature checking
 
 type Conflicting = {
->Conflicting : Conflicting
+>Conflicting : { [key: `a${string}`]: "a"; [key: `${string}a`]: "b"; [key: `a${string}a`]: "c"; }
 
     [key: `a${string}`]: 'a';
 >key : `a${string}`
@@ -265,18 +265,18 @@ type Invalid<T extends string> = {
 // Intersections in index signatures
 
 type Tag1 = { __tag1__: void };
->Tag1 : Tag1
+>Tag1 : { __tag1__: void; }
 >__tag1__ : void
 
 type Tag2 = { __tag2__: void };
->Tag2 : Tag2
+>Tag2 : { __tag2__: void; }
 >__tag2__ : void
 
 type TaggedString1 = string & Tag1;
->TaggedString1 : TaggedString1
+>TaggedString1 : string & Tag1
 
 type TaggedString2 = string & Tag2;
->TaggedString2 : TaggedString2
+>TaggedString2 : string & Tag2
 
 declare let s0: string;
 >s0 : string
@@ -958,7 +958,7 @@ const AmIPseudo: Pseudo = '&';  // Error
 >'&' : "&"
 
 type PseudoDeclaration = { [key in Pseudo]: string };
->PseudoDeclaration : PseudoDeclaration
+>PseudoDeclaration : { [x: `&:${string}`]: string; }
 
 const test: PseudoDeclaration = { 'someKey' : 'someValue' };  // Error
 >test : PseudoDeclaration
@@ -978,7 +978,7 @@ const path2: FieldPattern = 'two';  // Error
 >'two' : "two"
 
 type PathsObject = { [P in FieldPattern]: object; };
->PathsObject : PathsObject
+>PathsObject : { [x: `/${string}`]: object; }
 
 const pathObject: PathsObject = 123;  // Error
 >pathObject : PathsObject
@@ -992,7 +992,7 @@ const id: IdType = '0000-0000-0000-0001';
 >'0000-0000-0000-0001' : "0000-0000-0000-0001"
 
 type A = Record<IdType, string>;
->A : A
+>A : { [x: `${number}-${number}-${number}-${number}`]: string; }
 
 const a: A = { [id]: 'test' }
 >a : A
@@ -1054,15 +1054,15 @@ const obj3: { [key: number]: string } = { [sym]: 'hello '};  // Error
 // Repro from #45772
 
 type Id = string & { __tag: 'id '};
->Id : Id
+>Id : string & { __tag: 'id '; }
 >__tag : "id "
 
 type Rec1 = { [key: Id]: number };
->Rec1 : Rec1
+>Rec1 : { [key: Id]: number; }
 >key : Id
 
 type Rec2 = Record<Id, number>;
->Rec2 : Rec2
+>Rec2 : { [x: string & { __tag: "id "; }]: number; }
 
 type K1 = keyof Rec1;  // Id
 >K1 : Id
diff --git a/tests/baselines/reference/indexedAccessKeyofNestedSimplifiedSubstituteUnwrapped.types b/tests/baselines/reference/indexedAccessKeyofNestedSimplifiedSubstituteUnwrapped.types
index 8c4739cf4879b..b7a4e79d89a94 100644
--- a/tests/baselines/reference/indexedAccessKeyofNestedSimplifiedSubstituteUnwrapped.types
+++ b/tests/baselines/reference/indexedAccessKeyofNestedSimplifiedSubstituteUnwrapped.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/indexedAccessKeyofNestedSimplifiedSubstituteUnwrapped.ts ===
 type AnyFunction = (...args: any[]) => any;
->AnyFunction : AnyFunction
+>AnyFunction : (...args: any[]) => any
 >args : any[]
 
 type Params<T> = Parameters<Extract<T, AnyFunction>>;
diff --git a/tests/baselines/reference/indexedAccessRetainsIndexSignature.types b/tests/baselines/reference/indexedAccessRetainsIndexSignature.types
index 830ee6629fa8e..fa1dafca6dc0a 100644
--- a/tests/baselines/reference/indexedAccessRetainsIndexSignature.types
+++ b/tests/baselines/reference/indexedAccessRetainsIndexSignature.types
@@ -17,7 +17,7 @@ type Omit2<T, K extends keyof T> = {[P in Diff<keyof T, K>]: T[P]};
 >Omit2 : Omit2<T, K>
 
 type O = Omit<{ a: number, b: string }, 'a'>
->O : O
+>O : { b: string; }
 >a : number
 >b : string
 
diff --git a/tests/baselines/reference/indexerConstraints2.types b/tests/baselines/reference/indexerConstraints2.types
index 9c9222816379e..9a0e92d169932 100644
--- a/tests/baselines/reference/indexerConstraints2.types
+++ b/tests/baselines/reference/indexerConstraints2.types
@@ -83,7 +83,7 @@ interface N {
 }
 
 type IndexableUnion = "foo" | "bar";
->IndexableUnion : IndexableUnion
+>IndexableUnion : "foo" | "bar"
 
 interface O {
     [u: IndexableUnion]: A;
@@ -91,7 +91,7 @@ interface O {
 }
 
 type NonIndexableUnion = boolean | {};
->NonIndexableUnion : NonIndexableUnion
+>NonIndexableUnion : boolean | {}
 
 interface P {
     [u: NonIndexableUnion]: A;
@@ -99,7 +99,7 @@ interface P {
 }
 
 type NonIndexableUnion2 = string | number;
->NonIndexableUnion2 : NonIndexableUnion2
+>NonIndexableUnion2 : string | number
 
 interface Q {
     [u: NonIndexableUnion2]: A;
@@ -107,7 +107,7 @@ interface Q {
 }
 
 type NonIndexableUnion3 = "foo" | 42;
->NonIndexableUnion3 : NonIndexableUnion3
+>NonIndexableUnion3 : "foo" | 42
 
 interface R {
     [u: NonIndexableUnion3]: A;
diff --git a/tests/baselines/reference/indexingTypesWithNever.types b/tests/baselines/reference/indexingTypesWithNever.types
index dc0a535331875..84eefc13fab54 100644
--- a/tests/baselines/reference/indexingTypesWithNever.types
+++ b/tests/baselines/reference/indexingTypesWithNever.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/indexingTypesWithNever.ts ===
 type TestObj = {
->TestObj : TestObj
+>TestObj : { a: string; b: number; }
 
   a: string;
 >a : string
@@ -15,7 +15,7 @@ type Result1 = TestObj[never];
 >Result1 : never
 
 type EmptyObj = {};
->EmptyObj : EmptyObj
+>EmptyObj : {}
 
 // Should be never but without an error
 type Result2 = EmptyObj[keyof EmptyObj];
@@ -127,25 +127,25 @@ type ExpectType<Exp, Act> = Match<Exp, Act> extends "Match"
   : "Did not match";
 
 type P3 = { a: string; b: number; c?: boolean };
->P3 : P3
+>P3 : { a: string; b: number; c?: boolean | undefined; }
 >a : string
 >b : number
 >c : boolean | undefined
 
 type P2 = { a: string; c?: boolean };
->P2 : P2
+>P2 : { a: string; c?: boolean | undefined; }
 >a : string
 >c : boolean | undefined
 
 type P1 = { c?: boolean };
->P1 : P1
+>P1 : { c?: boolean | undefined; }
 >c : boolean | undefined
 
 type P0 = {};
->P0 : P0
+>P0 : {}
 
 type P3Names = RequiredPropNames<P3>; // expect 'a' | 'b'
->P3Names : P3Names
+>P3Names : "a" | "b"
 
 type P2Names = RequiredPropNames<P2>; // expect 'a'
 >P2Names : "a"
@@ -169,16 +169,16 @@ declare const p0NameTest: ExpectType<never, P0Names>;
 >p0NameTest : "Match"
 
 type P3Props = RequiredProps<P3>; // expect { a: string; b: number }
->P3Props : P3Props
+>P3Props : { a: string; b: number; }
 
 type P2Props = RequiredProps<P2>; // expect { a: string; }
->P2Props : P2Props
+>P2Props : { a: string; }
 
 type P1Props = RequiredProps<P1>; // expect {}
->P1Props : P1Props
+>P1Props : {}
 
 type P0Props = RequiredProps<P0>; // expect {}
->P0Props : P0Props
+>P0Props : {}
 
 declare const p3Test: ExpectType<{ a: string; b: number }, P3Props>;
 >p3Test : "Match"
@@ -196,25 +196,25 @@ declare const p0Test: ExpectType<{}, P0Props>;
 >p0Test : "Match"
 
 type O3 = { a?: string; b?: number; c: boolean };
->O3 : O3
+>O3 : { a?: string | undefined; b?: number | undefined; c: boolean; }
 >a : string | undefined
 >b : number | undefined
 >c : boolean
 
 type O2 = { a?: string; c: boolean };
->O2 : O2
+>O2 : { a?: string | undefined; c: boolean; }
 >a : string | undefined
 >c : boolean
 
 type O1 = { c: boolean };
->O1 : O1
+>O1 : { c: boolean; }
 >c : boolean
 
 type O0 = {};
->O0 : O0
+>O0 : {}
 
 type O3Names = OptionalPropNames<O3>; // expect 'a' | 'b'
->O3Names : O3Names
+>O3Names : "a" | "b"
 
 type O2Names = OptionalPropNames<O2>; // expect 'a'
 >O2Names : "a"
@@ -238,16 +238,16 @@ declare const o0NameTest: ExpectType<never, O0Names>;
 >o0NameTest : "Match"
 
 type O3Props = OptionalProps<O3>; // expect { a?: string | undefined; b?: number | undefined }
->O3Props : O3Props
+>O3Props : { a?: string | undefined; b?: number | undefined; }
 
 type O2Props = OptionalProps<O2>; // expect { a?: string | undefined; }
->O2Props : O2Props
+>O2Props : { a?: string | undefined; }
 
 type O1Props = OptionalProps<O1>; // expect {}
->O1Props : O1Props
+>O1Props : {}
 
 type O0Props = OptionalProps<O0>; // expect {}
->O0Props : O0Props
+>O0Props : {}
 
 declare const o3Test: ExpectType<{ a?: string; b?: number }, O3Props>;
 >o3Test : "Match"
diff --git a/tests/baselines/reference/indirectTypeParameterReferences.types b/tests/baselines/reference/indirectTypeParameterReferences.types
index f874fca104851..d8721c22b1aa0 100644
--- a/tests/baselines/reference/indirectTypeParameterReferences.types
+++ b/tests/baselines/reference/indirectTypeParameterReferences.types
@@ -2,7 +2,7 @@
 // Repro from #19043
 
 type B = {b: string}
->B : B
+>B : { b: string; }
 >b : string
 
 const flowtypes = <A>(b: B) => {
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
index 6eb2bbf32e681..dc1d4b32e9b45 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
@@ -172,7 +172,7 @@ export namespace DiagnosticSeverity {
 }
 
 export type DiagnosticSeverity = 1 | 2 | 3 | 4;
->DiagnosticSeverity : DiagnosticSeverity
+>DiagnosticSeverity : 1 | 2 | 3 | 4
 
 export interface Diagnostic {
 	severity?: DiagnosticSeverity;
@@ -294,7 +294,7 @@ declare function box<T>(value: T): Box<T>;
 >value : T
 
 type WinCondition =
->WinCondition : WinCondition
+>WinCondition : { type: 'win'; player: string; } | { type: 'draw'; }
 
     | { type: 'win', player: string }
 >type : "win"
@@ -312,7 +312,7 @@ let zz: Box<WinCondition> = box({ type: 'draw' });
 >'draw' : "draw"
 
 type WinType = 'win' | 'draw';
->WinType : WinType
+>WinType : "win" | "draw"
 
 let yy: Box<WinType> = box('draw');
 >yy : Box<WinType>
@@ -391,7 +391,7 @@ const a3: I[] = ['a', 'b'].map(name => {
 // Repro from https://www.memsql.com/blog/porting-30k-lines-of-code-from-flow-to-typescript/
 	
 type Player = {
->Player : Player
+>Player : { name: string; age: number; position: "STRIKER" | "GOALKEEPER"; }
 
     name: string;
 >name : string
@@ -405,7 +405,7 @@ type Player = {
 };
  
 type F = () => Promise<Array<Player>>;
->F : F
+>F : () => Promise<Array<Player>>
  
 const f1: F = () => {
 >f1 : F
@@ -477,7 +477,7 @@ enum State { A, B }
 >B : State.B
 
 type Foo = { state: State }
->Foo : Foo
+>Foo : { state: State; }
 >state : State
 
 declare function bar<T>(f: () => T[]): T[];
diff --git a/tests/baselines/reference/inferTInParentheses.types b/tests/baselines/reference/inferTInParentheses.types
index c95ebab700aef..1207c2f80f345 100644
--- a/tests/baselines/reference/inferTInParentheses.types
+++ b/tests/baselines/reference/inferTInParentheses.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/inferTInParentheses.ts ===
 type F1 = (num: [number]) => void;
->F1 : F1
+>F1 : (num: [number]) => void
 >num : [number]
 
 type IsNumber<T extends number> = T;
diff --git a/tests/baselines/reference/inferTypes1.types b/tests/baselines/reference/inferTypes1.types
index c7a609b3eaed2..964ae6c5c6bcd 100644
--- a/tests/baselines/reference/inferTypes1.types
+++ b/tests/baselines/reference/inferTypes1.types
@@ -335,7 +335,7 @@ type Jsonified<T> =
     : "what is this";
 
 type Example = {
->Example : Example
+>Example : { str: "literalstring"; fn: () => void; date: Date; customClass: MyClass; obj: {    prop: "property";    clz: MyClass;    nested: {        attr: Date;    };}; }
 
     str: "literalstring",
 >str : "literalstring"
diff --git a/tests/baselines/reference/inferenceUnionOfObjectsMappedContextualType.types b/tests/baselines/reference/inferenceUnionOfObjectsMappedContextualType.types
index 7a0dc327a499f..f017099d6126c 100644
--- a/tests/baselines/reference/inferenceUnionOfObjectsMappedContextualType.types
+++ b/tests/baselines/reference/inferenceUnionOfObjectsMappedContextualType.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/inferenceUnionOfObjectsMappedContextualType.ts ===
 type Entity = {
->Entity : Entity
+>Entity : { someDate: Date | null; } & ({ id: string; } | { id: number; })
 
     someDate: Date | null;
 >someDate : Date | null
diff --git a/tests/baselines/reference/inferrenceInfiniteLoopWithSubtyping.types b/tests/baselines/reference/inferrenceInfiniteLoopWithSubtyping.types
index e10562f57bcba..5d1ca14f1c257 100644
--- a/tests/baselines/reference/inferrenceInfiniteLoopWithSubtyping.types
+++ b/tests/baselines/reference/inferrenceInfiniteLoopWithSubtyping.types
@@ -7,7 +7,7 @@ export type Thunk<T> = (() => T) | T;
 >Thunk : Thunk<T>
 
 export type ComposeOutputTypeDefinition = Readonly<ObjectTypeComposer<any, any> | EnumTypeComposer>;
->ComposeOutputTypeDefinition : ComposeOutputTypeDefinition
+>ComposeOutputTypeDefinition : Readonly<ObjectTypeComposer<any, any>> | Readonly<EnumTypeComposer>
 
 export class EnumTypeComposer {
 >EnumTypeComposer : EnumTypeComposer
diff --git a/tests/baselines/reference/instantiateContextualTypes.types b/tests/baselines/reference/instantiateContextualTypes.types
index ff6154c78589c..72ea90d59533e 100644
--- a/tests/baselines/reference/instantiateContextualTypes.types
+++ b/tests/baselines/reference/instantiateContextualTypes.types
@@ -169,7 +169,7 @@ createReducer(
 // #25814
 
 type R = {
->R : R
+>R : { a: (x: number) => void; b: (x: string) => void; }
 
   a: (x: number) => void;
 >a : (x: number) => void
@@ -182,7 +182,7 @@ type R = {
 };
 
 type O = {
->O : O
+>O : { on<P extends keyof R>(x: P, callback: R[P]): void; }
 
   on<P extends keyof R>(x: P, callback: R[P]): void;
 >on : <P extends keyof R>(x: P, callback: R[P]) => void
@@ -329,7 +329,7 @@ passContentsToFunc(outerBoxOfString, box => box.value);
 // Repro from #32349
 
 type DooDad = 'SOMETHING' | 'ELSE' ;
->DooDad : DooDad
+>DooDad : "SOMETHING" | "ELSE"
 
 class Interesting {
 >Interesting : Interesting
diff --git a/tests/baselines/reference/instantiationExpressions.types b/tests/baselines/reference/instantiationExpressions.types
index 43a71f42d3ea5..bb35bc036a14a 100644
--- a/tests/baselines/reference/instantiationExpressions.types
+++ b/tests/baselines/reference/instantiationExpressions.types
@@ -409,14 +409,14 @@ type BoxFunc<T> = typeof makeBox<T>;  // (value: T) => { value: T }
 >makeBox : <T>(value: T) => { value: T; }
 
 type StringBoxFunc = BoxFunc<string>;  // (value: string) => { value: string }
->StringBoxFunc : StringBoxFunc
+>StringBoxFunc : (value: string) => { value: string; }
 
 type Box<T> = ReturnType<typeof makeBox<T>>;  // { value: T }
 >Box : { value: T; }
 >makeBox : <T>(value: T) => { value: T; }
 
 type StringBox = Box<string>;  // { value: string }
->StringBox : StringBox
+>StringBox : { value: string; }
 
 type A<U> = InstanceType<typeof Array<U>>;  // U[]
 >A : U[]
diff --git a/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.types b/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.types
index 6883034052e85..8a984980b2ad1 100644
--- a/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.types
+++ b/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.types
@@ -25,6 +25,6 @@ if (typeof x !== "string") {
 }
 
 type StringTree = string | StringTreeArray;
->StringTree : StringTree
+>StringTree : string | StringTreeArray
 
 interface StringTreeArray extends Array<StringTree> { }
diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.types b/tests/baselines/reference/interfaceExtendsObjectIntersection.types
index af63896907833..26ef179f45487 100644
--- a/tests/baselines/reference/interfaceExtendsObjectIntersection.types
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.types
@@ -1,27 +1,27 @@
 === tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersection.ts ===
 type T1 = { a: number };
->T1 : T1
+>T1 : { a: number; }
 >a : number
 
 type T2 = T1 & { b: number };
->T2 : T2
+>T2 : T1 & { b: number; }
 >b : number
 
 type T3 = () => void;
->T3 : T3
+>T3 : () => void
 
 type T4 = new () => { a: number };
->T4 : T4
+>T4 : new () => {    a: number;}
 >a : number
 
 type T5 = number[];
->T5 : T5
+>T5 : number[]
 
 type T6 = [string, number];
->T6 : T6
+>T6 : [string, number]
 
 type T7 = { [P in 'a' | 'b' | 'c']: string };
->T7 : T7
+>T7 : { a: string; b: string; c: string; }
 
 interface I1 extends T1 { x: string }
 >x : string
diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types
index 2fc15b5399411..651ce89bced13 100644
--- a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types
+++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types
@@ -1,20 +1,20 @@
 === tests/cases/conformance/interfaces/interfaceDeclarations/interfaceExtendsObjectIntersectionErrors.ts ===
 type T1 = { a: number };
->T1 : T1
+>T1 : { a: number; }
 >a : number
 
 type T2 = T1 & { b: number };
->T2 : T2
+>T2 : T1 & { b: number; }
 >b : number
 
 type T3 = number[];
->T3 : T3
+>T3 : number[]
 
 type T4 = [string, number];
->T4 : T4
+>T4 : [string, number]
 
 type T5 = { [P in 'a' | 'b' | 'c']: string };
->T5 : T5
+>T5 : { a: string; b: string; c: string; }
 
 interface I1 extends T1 { a: string }
 >a : string
@@ -130,7 +130,7 @@ interface I23 extends Identifiable<T1 & { b: number}> { a: string }
 >a : string
 
 type U = { a: number } | { b: string };
->U : U
+>U : { a: number; } | { b: string; }
 >a : number
 >b : string
 
diff --git a/tests/baselines/reference/intersectionAsWeakTypeSource.types b/tests/baselines/reference/intersectionAsWeakTypeSource.types
index 2362f7c92c17f..4c4f552e8cf5c 100644
--- a/tests/baselines/reference/intersectionAsWeakTypeSource.types
+++ b/tests/baselines/reference/intersectionAsWeakTypeSource.types
@@ -9,7 +9,7 @@ interface Z { z?: boolean }
 >z : boolean
 
 type XY = X & Y;
->XY : XY
+>XY : X & Y
 
 const xy: XY = {x: 'x', y: 10};
 >xy : XY
diff --git a/tests/baselines/reference/intersectionMemberOfUnionNarrowsCorrectly.types b/tests/baselines/reference/intersectionMemberOfUnionNarrowsCorrectly.types
index 77805ece13b11..73f063a571df3 100644
--- a/tests/baselines/reference/intersectionMemberOfUnionNarrowsCorrectly.types
+++ b/tests/baselines/reference/intersectionMemberOfUnionNarrowsCorrectly.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/intersection/intersectionMemberOfUnionNarrowsCorrectly.ts ===
 export type U = { kind?: 'A', a: string } | { kind?: 'B' } & { b: string };
->U : U
+>U : { kind?: 'A'; a: string; } | ({ kind?: 'B'; } & { b: string; })
 >kind : "A"
 >a : string
 >kind : "B"
diff --git a/tests/baselines/reference/intersectionOfUnionNarrowing.types b/tests/baselines/reference/intersectionOfUnionNarrowing.types
index 27dc8f3dc6c6c..5a9072bfa60bc 100644
--- a/tests/baselines/reference/intersectionOfUnionNarrowing.types
+++ b/tests/baselines/reference/intersectionOfUnionNarrowing.types
@@ -9,7 +9,7 @@ interface X {
 >bProp : string
 }
 type AorB = { a: object; b: undefined } | { a: undefined; b: object };
->AorB : AorB
+>AorB : { a: object; b: undefined; } | { a: undefined; b: object; }
 >a : object
 >b : undefined
 >a : undefined
diff --git a/tests/baselines/reference/intersectionReduction.types b/tests/baselines/reference/intersectionReduction.types
index 482e13483b8c5..4ecfe50e4271b 100644
--- a/tests/baselines/reference/intersectionReduction.types
+++ b/tests/baselines/reference/intersectionReduction.types
@@ -31,7 +31,7 @@ type T7 = string & 'a' & number & 10 & symbol & typeof sym1;  // never
 >sym1 : unique symbol
 
 type T10 = string & ('a' | 'b');  // 'a' | 'b'
->T10 : T10
+>T10 : "a" | "b"
 
 type T11 = (string | number) & ('a' | 10);  // 'a' | 10
 >T11 : "a" | 10
@@ -61,7 +61,7 @@ type N7 = void & string;
 >N7 : never
 
 type X = { x: string };
->X : X
+>X : { x: string; }
 >x : string
 
 type X1 = X | 'a' & 'b';
@@ -89,17 +89,17 @@ type X7 = X | void & string;
 >X7 : X
 
 type A = { kind: 'a', foo: string };
->A : A
+>A : { kind: 'a'; foo: string; }
 >kind : "a"
 >foo : string
 
 type B = { kind: 'b', foo: number };
->B : B
+>B : { kind: 'b'; foo: number; }
 >kind : "b"
 >foo : number
 
 type C = { kind: 'c', foo: number };
->C : C
+>C : { kind: 'c'; foo: number; }
 >kind : "c"
 >foo : number
 
@@ -143,7 +143,7 @@ type K1 = keyof (A & B);  // string | number | symbol
 >K1 : string | number | symbol
 
 type K2 = keyof A | keyof B;  // 'kind' | 'foo'
->K2 : K2
+>K2 : "kind" | "foo"
 
 type Merge1<T, U> = { [P in keyof (T & U)]: P extends keyof T ? T[P] : U[P & keyof U] }
 >Merge1 : Merge1<T, U>
@@ -159,26 +159,26 @@ type M1 = { a: 1, b: 2 } & { a: 2, c: 3 };  // never
 >c : 3
 
 type M2 = Merge1<{ a: 1, b: 2 }, { a: 2, c: 3 }>;  // {}
->M2 : M2
+>M2 : {}
 >a : 1
 >b : 2
 >a : 2
 >c : 3
 
 type M3 = Merge2<{ a: 1, b: 2 }, { a: 2, c: 3 }>;  // { a: 1, b: 2, c: 3 }
->M3 : M3
+>M3 : { a: 1; b: 2; c: 3; }
 >a : 1
 >b : 2
 >a : 2
 >c : 3
 
 type D = { kind: 'd', foo: unknown };
->D : D
+>D : { kind: 'd'; foo: unknown; }
 >kind : "d"
 >foo : unknown
 
 type E = { kind: 'e', foo: unknown };
->E : E
+>E : { kind: 'e'; foo: unknown; }
 >kind : "e"
 >foo : unknown
 
diff --git a/tests/baselines/reference/intersectionReductionStrict.types b/tests/baselines/reference/intersectionReductionStrict.types
index db47e9ada3fb7..0859d23785e63 100644
--- a/tests/baselines/reference/intersectionReductionStrict.types
+++ b/tests/baselines/reference/intersectionReductionStrict.types
@@ -31,7 +31,7 @@ type T7 = string & 'a' & number & 10 & symbol & typeof sym1;  // never
 >sym1 : unique symbol
 
 type T10 = string & ('a' | 'b');  // 'a' | 'b'
->T10 : T10
+>T10 : "a" | "b"
 
 type T11 = (string | number) & ('a' | 10);  // 'a' | 10
 >T11 : "a" | 10
@@ -61,7 +61,7 @@ type N7 = void & string;
 >N7 : never
 
 type X = { x: string };
->X : X
+>X : { x: string; }
 >x : string
 
 type X1 = X | 'a' & 'b';
@@ -89,17 +89,17 @@ type X7 = X | void & string;
 >X7 : X
 
 type A = { kind: 'a', foo: string };
->A : A
+>A : { kind: 'a'; foo: string; }
 >kind : "a"
 >foo : string
 
 type B = { kind: 'b', foo: number };
->B : B
+>B : { kind: 'b'; foo: number; }
 >kind : "b"
 >foo : number
 
 type C = { kind: 'c', foo: number };
->C : C
+>C : { kind: 'c'; foo: number; }
 >kind : "c"
 >foo : number
 
@@ -143,7 +143,7 @@ type K1 = keyof (A & B);  // string | number | symbol
 >K1 : string | number | symbol
 
 type K2 = keyof A | keyof B;  // 'kind' | 'foo'
->K2 : K2
+>K2 : "kind" | "foo"
 
 type Merge1<T, U> = { [P in keyof (T & U)]: P extends keyof T ? T[P] : U[P & keyof U] }
 >Merge1 : Merge1<T, U>
@@ -159,14 +159,14 @@ type M1 = { a: 1, b: 2 } & { a: 2, c: 3 };  // never
 >c : 3
 
 type M2 = Merge1<{ a: 1, b: 2 }, { a: 2, c: 3 }>;  // {}
->M2 : M2
+>M2 : {}
 >a : 1
 >b : 2
 >a : 2
 >c : 3
 
 type M3 = Merge2<{ a: 1, b: 2 }, { a: 2, c: 3 }>;  // { a: 1, b: 2, c: 3 }
->M3 : M3
+>M3 : { a: 1; b: 2; c: 3; }
 >a : 1
 >b : 2
 >a : 2
diff --git a/tests/baselines/reference/intersectionThisTypes.types b/tests/baselines/reference/intersectionThisTypes.types
index 5814099104365..36babb7bacefd 100644
--- a/tests/baselines/reference/intersectionThisTypes.types
+++ b/tests/baselines/reference/intersectionThisTypes.types
@@ -16,10 +16,10 @@ interface Thing2 {
 }
 
 type Thing3 = Thing1 & Thing2;
->Thing3 : Thing3
+>Thing3 : Thing1 & Thing2
 
 type Thing4 = Thing3 & string[];
->Thing4 : Thing4
+>Thing4 : Thing1 & Thing2 & string[]
 
 function f1(t: Thing3) {
 >f1 : (t: Thing3) => void
diff --git a/tests/baselines/reference/intersectionTypeInference3.types b/tests/baselines/reference/intersectionTypeInference3.types
index 173a882312776..27e65f7684ad6 100644
--- a/tests/baselines/reference/intersectionTypeInference3.types
+++ b/tests/baselines/reference/intersectionTypeInference3.types
@@ -13,7 +13,7 @@ type Nominal<Kind extends string, Type> = Type & {
 };
 
 type A = Nominal<'A', string>;
->A : A
+>A : string & { [Symbol.species]: "A"; }
 
 declare const a: Set<A>;
 >a : Set<A>
diff --git a/tests/baselines/reference/intersectionTypeMembers.types b/tests/baselines/reference/intersectionTypeMembers.types
index a48e05243d84e..9ff067f0b7fa0 100644
--- a/tests/baselines/reference/intersectionTypeMembers.types
+++ b/tests/baselines/reference/intersectionTypeMembers.types
@@ -75,11 +75,11 @@ xyz.x.c = "hello";
 >"hello" : "hello"
 
 type F1 = (x: string) => string;
->F1 : F1
+>F1 : (x: string) => string
 >x : string
 
 type F2 = (x: number) => number;
->F2 : F2
+>F2 : (x: number) => number
 >x : number
 
 var f: F1 & F2;
diff --git a/tests/baselines/reference/intersectionTypeNormalization.types b/tests/baselines/reference/intersectionTypeNormalization.types
index c6e5f6dbaf561..6f2f4e35cb13c 100644
--- a/tests/baselines/reference/intersectionTypeNormalization.types
+++ b/tests/baselines/reference/intersectionTypeNormalization.types
@@ -13,13 +13,13 @@ interface D { d: string }
 
 // Identical ways of writing the same type
 type X1 = (A | B) & (C | D);
->X1 : X1
+>X1 : (A | B) & (C | D)
 
 type X2 = A & (C | D) | B & (C | D)
->X2 : X2
+>X2 : (A & (C | D)) | (B & (C | D))
 
 type X3 = A & C | A & D | B & C | B & D;
->X3 : X3
+>X3 : (A & C) | (A & D) | (B & C) | (B & D)
 
 var x: X1;
 >x : X1
@@ -38,13 +38,13 @@ interface Y { y: string }
 
 // Identical ways of writing the same type
 type Y1 = (A | X & Y) & (C | D);
->Y1 : Y1
+>Y1 : (A | (X & Y)) & (C | D)
 
 type Y2 = A & (C | D) | X & Y & (C | D)
->Y2 : Y2
+>Y2 : (A & (C | D)) | (X & Y & (C | D))
 
 type Y3 = A & C | A & D | X & Y & C | X & Y & D;
->Y3 : Y3
+>Y3 : (A & C) | (A & D) | (X & Y & C) | (X & Y & D)
 
 var y: Y1;
 >y : Y1
@@ -63,16 +63,16 @@ interface N { n: string }
 
 // Identical ways of writing the same type
 type Z1 = (A | X & (M | N)) & (C | D);
->Z1 : Z1
+>Z1 : (A | (X & (M | N))) & (C | D)
 
 type Z2 = A & (C | D) | X & (M | N) & (C | D)
->Z2 : Z2
+>Z2 : (A & (C | D)) | (X & (M | N) & (C | D))
 
 type Z3 = A & C | A & D | X & (M | N) & C | X & (M | N) & D;
->Z3 : Z3
+>Z3 : (A & C) | (A & D) | (X & (M | N) & C) | (X & (M | N) & D)
 
 type Z4 = A & C | A & D | X & M & C | X & N & C | X & M & D | X & N & D;
->Z4 : Z4
+>Z4 : (A & C) | (A & D) | (X & M & C) | (X & M & D) | (X & N & C) | (X & N & D)
 
 var z: Z1;
 >z : Z1
@@ -89,14 +89,14 @@ var z: Z4;
 // Repro from #9919
 
 type ToString = {
->ToString : ToString
+>ToString : { toString(): string; }
 
     toString(): string;
 >toString : () => string
 }
 
 type BoxedValue = { kind: 'int',    num: number }
->BoxedValue : BoxedValue
+>BoxedValue : { kind: 'int'; num: number; } | { kind: 'string'; str: string; }
 >kind : "int"
 >num : number
 
@@ -105,10 +105,10 @@ type BoxedValue = { kind: 'int',    num: number }
 >str : string
 
 type IntersectionFail = BoxedValue & ToString
->IntersectionFail : IntersectionFail
+>IntersectionFail : BoxedValue & ToString
 
 type IntersectionInline = { kind: 'int',    num: number } & ToString
->IntersectionInline : IntersectionInline
+>IntersectionInline : ({ kind: 'int'; num: number; } & ToString) | ({ kind: 'string'; str: string; } & ToString)
 >kind : "int"
 >num : number
 
@@ -198,11 +198,11 @@ namespace enums {
 >c211 : C.c211
     }
     export type Genre = A | B | C;
->Genre : Genre
+>Genre : A | B | C
 }
 
 type Foo = {
->Foo : Foo
+>Foo : { genreId: enums.Genre; }
 
     genreId: enums.Genre;
 >genreId : enums.Genre
@@ -211,7 +211,7 @@ type Foo = {
 };
 
 type Bar = {
->Bar : Bar
+>Bar : { genreId: enums.Genre; }
 
     genreId: enums.Genre;
 >genreId : enums.Genre
@@ -220,7 +220,7 @@ type Bar = {
 };
 
 type FooBar = Foo & Bar;
->FooBar : FooBar
+>FooBar : Foo & Bar
 
 function foo(so: any) {
 >foo : (so: any) => enums.Genre
diff --git a/tests/baselines/reference/intersectionTypeOverloading.types b/tests/baselines/reference/intersectionTypeOverloading.types
index c906b38f5df43..dfaba566255d6 100644
--- a/tests/baselines/reference/intersectionTypeOverloading.types
+++ b/tests/baselines/reference/intersectionTypeOverloading.types
@@ -3,11 +3,11 @@
 // overload resolution
 
 type F = (s: string) => string;
->F : F
+>F : (s: string) => string
 >s : string
 
 type G = (x: any) => any;
->G : G
+>G : (x: any) => any
 >x : any
 
 var fg: F & G;
diff --git a/tests/baselines/reference/intersectionTypeWithLeadingOperator.types b/tests/baselines/reference/intersectionTypeWithLeadingOperator.types
index 826da4d8c51de..6f41770f483ef 100644
--- a/tests/baselines/reference/intersectionTypeWithLeadingOperator.types
+++ b/tests/baselines/reference/intersectionTypeWithLeadingOperator.types
@@ -3,7 +3,7 @@ type A = & string;
 >A : string
 
 type B =
->B : B
+>B : { foo: string; } & { bar: number; }
 
   & { foo: string }
 >foo : string
@@ -12,7 +12,7 @@ type B =
 >bar : number
 
 type C = [& { foo: 1 } & { bar: 2 }, & { foo: 3 } & { bar: 4 }];
->C : C
+>C : [{ foo: 1; } & { bar: 2; }, { foo: 3; } & { bar: 4; }]
 >foo : 1
 >bar : 2
 >foo : 3
diff --git a/tests/baselines/reference/intersectionWithIndexSignatures.types b/tests/baselines/reference/intersectionWithIndexSignatures.types
index c04a1c93bcbc7..21d2d72f0ca4d 100644
--- a/tests/baselines/reference/intersectionWithIndexSignatures.types
+++ b/tests/baselines/reference/intersectionWithIndexSignatures.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/types/intersection/intersectionWithIndexSignatures.ts ===
 type A = { a: string };
->A : A
+>A : { a: string; }
 >a : string
 
 type B = { b: string };
->B : B
+>B : { b: string; }
 >b : string
 
 declare let sa1: { x: A & B };
@@ -65,7 +65,7 @@ type constr<Source, Tgt> = { [K in keyof Source]: string } & Pick<Tgt, Exclude<k
 >constr : constr<Source, Tgt>
 
 type s = constr<{}, { [key: string]: { a: string } }>;
->s : s
+>s : {} & Pick<{ [key: string]: { a: string; }; }, string | number>
 >key : string
 >a : string
 
diff --git a/tests/baselines/reference/intersectionsAndEmptyObjects.types b/tests/baselines/reference/intersectionsAndEmptyObjects.types
index 1c73b23c07d5c..5459f614a89ed 100644
--- a/tests/baselines/reference/intersectionsAndEmptyObjects.types
+++ b/tests/baselines/reference/intersectionsAndEmptyObjects.types
@@ -3,15 +3,15 @@
 // that contain other object types
 
 type A = { a: number };
->A : A
+>A : { a: number; }
 >a : number
 
 type B = { b: string };
->B : B
+>B : { b: string; }
 >b : string
 
 type C = {};
->C : C
+>C : {}
 
 let x01: A & B;
 >x01 : A & B
@@ -61,7 +61,7 @@ let x14: A & B & C & D & E;
 // Repro from #20225
 
 type Dictionary = { [name: string]: string };
->Dictionary : Dictionary
+>Dictionary : { [name: string]: string; }
 >name : string
 
 const intersectDictionaries = <F1 extends Dictionary, F2 extends Dictionary>(
@@ -177,7 +177,7 @@ type choices<IChoiceList extends {
 };
 
 type IMyChoiceList = {
->IMyChoiceList : IMyChoiceList
+>IMyChoiceList : { car: true; }
 
     car: true
 >car : true
@@ -186,7 +186,7 @@ type IMyChoiceList = {
 };
 
 type IUnknownChoiceList = {};
->IUnknownChoiceList : IUnknownChoiceList
+>IUnknownChoiceList : {}
 
 var defaultChoices: choices<{}>;
 >defaultChoices : { shoes: boolean; food: boolean; }
@@ -209,12 +209,12 @@ var unknownChoicesAndEmpty: choices<IUnknownChoiceList & {}>;
 // Repro from #38672
 
 type Foo1 = { x: string } & { [x: number]: Foo1 };
->Foo1 : Foo1
+>Foo1 : { x: string; } & { [x: number]: Foo1; }
 >x : string
 >x : number
 
 type Foo2 = { x: string } & { [K in number]: Foo2 };
->Foo2 : Foo2
+>Foo2 : { x: string; } & { [x: number]: Foo2; }
 >x : string
 
 // Repro from #40239
diff --git a/tests/baselines/reference/intersectionsAndOptionalProperties.types b/tests/baselines/reference/intersectionsAndOptionalProperties.types
index 98bc85c7e4299..f00ab71e13f3c 100644
--- a/tests/baselines/reference/intersectionsAndOptionalProperties.types
+++ b/tests/baselines/reference/intersectionsAndOptionalProperties.types
@@ -37,7 +37,7 @@ interface To {
 }
 
 type From =  { field: null } & Omit<To, 'field'>;
->From : From
+>From : { field: null; } & Omit<To, "field">
 >field : null
 >null : null
 
diff --git a/tests/baselines/reference/intersectionsAndReadonlyProperties.types b/tests/baselines/reference/intersectionsAndReadonlyProperties.types
index a5130d48111b5..8e1bd8c16d22b 100644
--- a/tests/baselines/reference/intersectionsAndReadonlyProperties.types
+++ b/tests/baselines/reference/intersectionsAndReadonlyProperties.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/intersectionsAndReadonlyProperties.ts ===
 // readonly and non-readonly
 type Intersection1 = { readonly a: number } & { a: number };
->Intersection1 : Intersection1
+>Intersection1 : { readonly a: number; } & { a: number; }
 >a : number
 >a : number
 
@@ -17,7 +17,7 @@ i1.a = 2;
 
 // getter and setter
 type Intersection2 = { get a(): number } & { set a(v: number) };
->Intersection2 : Intersection2
+>Intersection2 : { readonly a: number; } & { a: number; }
 >a : number
 >a : number
 >v : number
@@ -34,7 +34,7 @@ i2.a = 2;
 
 // assignment to an all read-only property should still be disallowed
 type IntersectionAllReadonly = { readonly a: number } & { get a(): number };
->IntersectionAllReadonly : IntersectionAllReadonly
+>IntersectionAllReadonly : { readonly a: number; } & { readonly a: number; }
 >a : number
 >a : number
 
diff --git a/tests/baselines/reference/intraExpressionInferences.types b/tests/baselines/reference/intraExpressionInferences.types
index 50a99ac34fe11..afd3506665224 100644
--- a/tests/baselines/reference/intraExpressionInferences.types
+++ b/tests/baselines/reference/intraExpressionInferences.types
@@ -303,7 +303,7 @@ class Wrapper<T = any> {
 }
 
 type WrappedMap = Record<string, Wrapper>;
->WrappedMap : WrappedMap
+>WrappedMap : { [x: string]: Wrapper<any>; }
 
 type Unwrap<D extends WrappedMap> = {
 >Unwrap : Unwrap<D>
diff --git a/tests/baselines/reference/isomorphicMappedTypeInference.types b/tests/baselines/reference/isomorphicMappedTypeInference.types
index 800500764a5be..5d2a897899761 100644
--- a/tests/baselines/reference/isomorphicMappedTypeInference.types
+++ b/tests/baselines/reference/isomorphicMappedTypeInference.types
@@ -378,7 +378,7 @@ declare function validateAndClone<T>(obj: { readonly [P in keyof T]?: T[P] }): T
 >obj : { readonly [P in keyof T]?: T[P] | undefined; }
 
 type Foo = {
->Foo : Foo
+>Foo : { a?: number | undefined; readonly b: string; }
 
     a?: number;
 >a : number | undefined
diff --git a/tests/baselines/reference/jsDeclarationsWithDefaultAsNamespaceLikeMerge.types b/tests/baselines/reference/jsDeclarationsWithDefaultAsNamespaceLikeMerge.types
index 5a083f8e4e6e1..3ac3d722e4fdc 100644
--- a/tests/baselines/reference/jsDeclarationsWithDefaultAsNamespaceLikeMerge.types
+++ b/tests/baselines/reference/jsDeclarationsWithDefaultAsNamespaceLikeMerge.types
@@ -1,6 +1,6 @@
 === /helper.d.ts ===
 type Computed = () => any;
->Computed : Computed
+>Computed : () => any
 
 interface Mapper<R> {
     <Key extends string>(map: Key[]): { [K in Key]: R };
diff --git a/tests/baselines/reference/jsxCallElaborationCheckNoCrash1.types b/tests/baselines/reference/jsxCallElaborationCheckNoCrash1.types
index d3fb0d602549b..e4738eae0a0df 100644
--- a/tests/baselines/reference/jsxCallElaborationCheckNoCrash1.types
+++ b/tests/baselines/reference/jsxCallElaborationCheckNoCrash1.types
@@ -5,7 +5,7 @@ import * as React from "react";
 >React : typeof React
 
 type Tags = "span" | "div";
->Tags : Tags
+>Tags : "div" | "span"
 
 export const Hoc = <Tag extends Tags>(
 >Hoc : <Tag extends Tags>(TagElement: Tag) => React.SFC
diff --git a/tests/baselines/reference/jsxChildrenIndividualErrorElaborations.types b/tests/baselines/reference/jsxChildrenIndividualErrorElaborations.types
index 267e3a7027e57..1ebc32a29dc01 100644
--- a/tests/baselines/reference/jsxChildrenIndividualErrorElaborations.types
+++ b/tests/baselines/reference/jsxChildrenIndividualErrorElaborations.types
@@ -122,7 +122,7 @@ var a = <Blah2>
 >Blah2 : (props: PropsArr) => JSX.Element
 
 type Cb = (x: number) => string;
->Cb : Cb
+>Cb : (x: number) => string
 >x : number
 
 interface PropsMixed {
diff --git a/tests/baselines/reference/jsxChildrenSingleChildConfusableWithMultipleChildrenNoError.types b/tests/baselines/reference/jsxChildrenSingleChildConfusableWithMultipleChildrenNoError.types
index 59292bac60f0d..39de0a51e5a46 100644
--- a/tests/baselines/reference/jsxChildrenSingleChildConfusableWithMultipleChildrenNoError.types
+++ b/tests/baselines/reference/jsxChildrenSingleChildConfusableWithMultipleChildrenNoError.types
@@ -5,7 +5,7 @@ import * as React from 'react'
 >React : typeof React
 
 type Tab = [string, React.ReactNode]  // [tabName, tabContent]
->Tab : Tab
+>Tab : [string, React.ReactNode]
 >React : any
 
 interface Props {
diff --git a/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.types b/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.types
index ec5130e46a03a..9b0f793c10ab1 100644
--- a/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.types
+++ b/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.types
@@ -126,7 +126,7 @@ export type ValueComponentType<TValue = OptionValues> =  React.ComponentType<Val
 >React : any
 
 export type HandlerRendererResult = JSX.Element | null | false;
->HandlerRendererResult : HandlerRendererResult
+>HandlerRendererResult : false | JSX.Element | null
 >JSX : any
 >null : null
 >false : false
@@ -141,11 +141,11 @@ export type SelectValueHandler<TValue = OptionValues> = (option: Option<TValue>)
 >option : Option<TValue>
 
 export type ArrowRendererHandler = (props: ArrowRendererProps) => HandlerRendererResult;
->ArrowRendererHandler : ArrowRendererHandler
+>ArrowRendererHandler : (props: ArrowRendererProps) => HandlerRendererResult
 >props : ArrowRendererProps
 
 export type ClearRendererHandler = () => HandlerRendererResult;
->ClearRendererHandler : ClearRendererHandler
+>ClearRendererHandler : () => HandlerRendererResult
 
 export type FilterOptionHandler<TValue = OptionValues> = (option: Option<TValue>, filter: string) => boolean;
 >FilterOptionHandler : FilterOptionHandler<TValue>
@@ -159,7 +159,7 @@ export type FilterOptionsHandler<TValue = OptionValues> = (options: Options<TVal
 >currentValues : Options<TValue>
 
 export type InputRendererHandler = (props: { [key: string]: any }) => HandlerRendererResult;
->InputRendererHandler : InputRendererHandler
+>InputRendererHandler : (props: { [key: string]: any; }) => HandlerRendererResult
 >props : { [key: string]: any; }
 >key : string
 
@@ -168,28 +168,28 @@ export type MenuRendererHandler<TValue = OptionValues> = (props: MenuRendererPro
 >props : MenuRendererProps<TValue>
 
 export type OnCloseHandler = () => void;
->OnCloseHandler : OnCloseHandler
+>OnCloseHandler : () => void
 
 export type OnInputChangeHandler = (inputValue: string) => string;
->OnInputChangeHandler : OnInputChangeHandler
+>OnInputChangeHandler : (inputValue: string) => string
 >inputValue : string
 
 export type OnInputKeyDownHandler = React.KeyboardEventHandler<HTMLDivElement | HTMLInputElement>;
->OnInputKeyDownHandler : OnInputKeyDownHandler
+>OnInputKeyDownHandler : (event: React.KeyboardEvent<HTMLDivElement | HTMLInputElement>) => void
 >React : any
 
 export type OnMenuScrollToBottomHandler = () => void;
->OnMenuScrollToBottomHandler : OnMenuScrollToBottomHandler
+>OnMenuScrollToBottomHandler : () => void
 
 export type OnOpenHandler = () => void;
->OnOpenHandler : OnOpenHandler
+>OnOpenHandler : () => void
 
 export type OnFocusHandler = React.FocusEventHandler<HTMLDivElement | HTMLInputElement>;
->OnFocusHandler : OnFocusHandler
+>OnFocusHandler : (event: React.FocusEvent<HTMLDivElement | HTMLInputElement>) => void
 >React : any
 
 export type OnBlurHandler = React.FocusEventHandler<HTMLDivElement | HTMLInputElement>;
->OnBlurHandler : OnBlurHandler
+>OnBlurHandler : (event: React.FocusEvent<HTMLDivElement | HTMLInputElement>) => void
 >React : any
 
 export type OptionRendererHandler<TValue = OptionValues> = (option: Option<TValue>) => HandlerRendererResult;
@@ -216,7 +216,7 @@ export type IsOptionUniqueHandler<TValue = OptionValues> = (arg: { option: Optio
 >valueKey : string
 
 export type IsValidNewOptionHandler = (arg: { label: string }) => boolean;
->IsValidNewOptionHandler : IsValidNewOptionHandler
+>IsValidNewOptionHandler : (arg: {    label: string;}) => boolean
 >arg : { label: string; }
 >label : string
 
@@ -228,11 +228,11 @@ export type NewOptionCreatorHandler<TValue = OptionValues> = (arg: { label: stri
 >valueKey : string
 
 export type PromptTextCreatorHandler = (filterText: string) => string;
->PromptTextCreatorHandler : PromptTextCreatorHandler
+>PromptTextCreatorHandler : (filterText: string) => string
 >filterText : string
 
 export type ShouldKeyDownEventCreateNewOptionHandler = (arg: { keyCode: number }) => boolean;
->ShouldKeyDownEventCreateNewOptionHandler : ShouldKeyDownEventCreateNewOptionHandler
+>ShouldKeyDownEventCreateNewOptionHandler : (arg: {    keyCode: number;}) => boolean
 >arg : { keyCode: number; }
 >keyCode : number
 
@@ -314,7 +314,7 @@ export interface Option<TValue = OptionValues> {
 }
 
 export type OptionValues = string | number | boolean;
->OptionValues : OptionValues
+>OptionValues : string | number | boolean
 
 export interface MenuRendererProps<TValue = OptionValues> {
     /**
diff --git a/tests/baselines/reference/jsxFragmentFactoryNoUnusedLocals.types b/tests/baselines/reference/jsxFragmentFactoryNoUnusedLocals.types
index a83aca50051ea..a2a388c0bfb7a 100644
--- a/tests/baselines/reference/jsxFragmentFactoryNoUnusedLocals.types
+++ b/tests/baselines/reference/jsxFragmentFactoryNoUnusedLocals.types
@@ -5,7 +5,7 @@ import { Fragment, createElement } from "react"
 >createElement : { (type: "input", props?: import("react").InputHTMLAttributes<HTMLInputElement> & import("react").ClassAttributes<HTMLInputElement>, ...children: import("react").ReactNode[]): import("react").DetailedReactHTMLElement<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>; <P extends import("react").HTMLAttributes<T>, T extends HTMLElement>(type: keyof import("react").ReactHTML, props?: import("react").ClassAttributes<T> & P, ...children: import("react").ReactNode[]): import("react").DetailedReactHTMLElement<P, T>; <P extends import("react").SVGAttributes<T>, T extends SVGElement>(type: keyof import("react").ReactSVG, props?: import("react").ClassAttributes<T> & P, ...children: import("react").ReactNode[]): import("react").ReactSVGElement; <P extends import("react").DOMAttributes<T>, T extends Element>(type: string, props?: import("react").ClassAttributes<T> & P, ...children: import("react").ReactNode[]): import("react").DOMElement<P, T>; <P>(type: import("react").SFC<P>, props?: import("react").Attributes & P, ...children: import("react").ReactNode[]): import("react").SFCElement<P>; <P>(type: import("react").ClassType<P, import("react").ClassicComponent<P, any>, import("react").ClassicComponentClass<P>>, props?: import("react").ClassAttributes<import("react").ClassicComponent<P, any>> & P, ...children: import("react").ReactNode[]): import("react").CElement<P, import("react").ClassicComponent<P, any>>; <P, T extends import("react").Component<P, any, any>, C extends import("react").ComponentClass<P, any>>(type: import("react").ClassType<P, T, C>, props?: import("react").ClassAttributes<T> & P, ...children: import("react").ReactNode[]): import("react").CElement<P, T>; <P>(type: string | import("react").SFC<P> | import("react").ComponentClass<P, any>, props?: import("react").Attributes & P, ...children: import("react").ReactNode[]): import("react").ReactElement<P>; }
 
 type CounterProps = {
->CounterProps : CounterProps
+>CounterProps : { count?: number; }
 
     count?: number
 >count : number
diff --git a/tests/baselines/reference/jsxLibraryManagedAttributesUnusedGeneric.types b/tests/baselines/reference/jsxLibraryManagedAttributesUnusedGeneric.types
index 46f0e28a4b31a..8496f08aa4a52 100644
--- a/tests/baselines/reference/jsxLibraryManagedAttributesUnusedGeneric.types
+++ b/tests/baselines/reference/jsxLibraryManagedAttributesUnusedGeneric.types
@@ -18,7 +18,7 @@ namespace jsx {
         export interface IntrinsicAttributes {}
         export interface IntrinsicClassAttributes<T> {}
         export type IntrinsicElements = {
->IntrinsicElements : IntrinsicElements
+>IntrinsicElements : { div: {    className: string;}; }
 
             div: { className: string }
 >div : { className: string; }
diff --git a/tests/baselines/reference/jsxLocalNamespaceIndexSignatureNoCrash.types b/tests/baselines/reference/jsxLocalNamespaceIndexSignatureNoCrash.types
index f0841d84040c5..3d02da329b8b2 100644
--- a/tests/baselines/reference/jsxLocalNamespaceIndexSignatureNoCrash.types
+++ b/tests/baselines/reference/jsxLocalNamespaceIndexSignatureNoCrash.types
@@ -17,7 +17,7 @@ export class X {
 export namespace X {
     export namespace JSX {
         export type IntrinsicElements = {
->IntrinsicElements : IntrinsicElements
+>IntrinsicElements : { [other: string]: any; }
 
             [other: string]: any;
 >other : string
diff --git a/tests/baselines/reference/jsxNamespaceGlobalReexport.types b/tests/baselines/reference/jsxNamespaceGlobalReexport.types
index 85fc07e3497e3..12226ae9e13a1 100644
--- a/tests/baselines/reference/jsxNamespaceGlobalReexport.types
+++ b/tests/baselines/reference/jsxNamespaceGlobalReexport.types
@@ -51,16 +51,16 @@ export type ComponentType<T = {}> = {};
 >ComponentType : ComponentType<T>
 
 export type ComponentChild = {};
->ComponentChild : ComponentChild
+>ComponentChild : {}
 
 export type ComponentChildren = {};
->ComponentChildren : ComponentChildren
+>ComponentChildren : {}
 
 export type VNode<T = {}> = {};
 >VNode : VNode<T>
 
 export type Attributes = {};
->Attributes : Attributes
+>Attributes : {}
 
 export type Component<T = {}, U = {}> = {};
 >Component : Component<T, U>
diff --git a/tests/baselines/reference/jsxNamespaceGlobalReexportMissingAliasTarget.types b/tests/baselines/reference/jsxNamespaceGlobalReexportMissingAliasTarget.types
index 7cc6f7937322c..2e27ccbfa7433 100644
--- a/tests/baselines/reference/jsxNamespaceGlobalReexportMissingAliasTarget.types
+++ b/tests/baselines/reference/jsxNamespaceGlobalReexportMissingAliasTarget.types
@@ -51,16 +51,16 @@ export type ComponentType<T = {}> = {};
 >ComponentType : ComponentType<T>
 
 export type ComponentChild = {};
->ComponentChild : ComponentChild
+>ComponentChild : {}
 
 export type ComponentChildren = {};
->ComponentChildren : ComponentChildren
+>ComponentChildren : {}
 
 export type VNode<T = {}> = {};
 >VNode : VNode<T>
 
 export type Attributes = {};
->Attributes : Attributes
+>Attributes : {}
 
 export type Component<T = {}, U = {}> = {};
 >Component : Component<T, U>
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespace.types b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespace.types
index 8869f10731bb5..a8d93e63512eb 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespace.types
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespace.types
@@ -51,16 +51,16 @@ export type ComponentType<T = {}> = {};
 >ComponentType : ComponentType<T>
 
 export type ComponentChild = {};
->ComponentChild : ComponentChild
+>ComponentChild : {}
 
 export type ComponentChildren = {};
->ComponentChildren : ComponentChildren
+>ComponentChildren : {}
 
 export type VNode<T = {}> = {};
 >VNode : VNode<T>
 
 export type Attributes = {};
->Attributes : Attributes
+>Attributes : {}
 
 export type Component<T = {}, U = {}> = {};
 >Component : Component<T, U>
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).types b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).types
index 56cc97e6cea9a..1709e564272f9 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).types
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=preserve).types
@@ -92,7 +92,7 @@ export namespace EmotionJSX {
     extends ReactJSXIntrinsicClassAttributes<T> {}
 
   type IntrinsicElements = {
->IntrinsicElements : IntrinsicElements
+>IntrinsicElements : { div: { css?: string | undefined; }; }
 
     [K in keyof ReactJSXIntrinsicElements]: ReactJSXIntrinsicElements[K] & {
       css?: string
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).types b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).types
index 56cc97e6cea9a..1709e564272f9 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).types
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromConfigPickedOverGlobalOne(jsx=react-jsx).types
@@ -92,7 +92,7 @@ export namespace EmotionJSX {
     extends ReactJSXIntrinsicClassAttributes<T> {}
 
   type IntrinsicElements = {
->IntrinsicElements : IntrinsicElements
+>IntrinsicElements : { div: { css?: string | undefined; }; }
 
     [K in keyof ReactJSXIntrinsicElements]: ReactJSXIntrinsicElements[K] & {
       css?: string
diff --git a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.types b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.types
index eec34dc7517e7..e51abfb5825aa 100644
--- a/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.types
+++ b/tests/baselines/reference/jsxNamespaceImplicitImportJSXNamespaceFromPragmaPickedOverGlobalOne.types
@@ -92,7 +92,7 @@ export namespace EmotionJSX {
         extends ReactJSXIntrinsicClassAttributes<T> { }
 
     type IntrinsicElements = {
->IntrinsicElements : IntrinsicElements
+>IntrinsicElements : { div: { css?: string | undefined; }; }
 
         [K in keyof ReactJSXIntrinsicElements]: ReactJSXIntrinsicElements[K] & {
             css?: string
diff --git a/tests/baselines/reference/jsxSpreadFirstUnionNoErrors.types b/tests/baselines/reference/jsxSpreadFirstUnionNoErrors.types
index d1823d7997978..493526b9fc7d2 100644
--- a/tests/baselines/reference/jsxSpreadFirstUnionNoErrors.types
+++ b/tests/baselines/reference/jsxSpreadFirstUnionNoErrors.types
@@ -3,7 +3,7 @@ import React from "react";
 >React : typeof React
 
 type InfoProps =
->InfoProps : InfoProps
+>InfoProps : { status: "hidden"; } | { status: "visible"; content: string; }
 
 | { status: "hidden" }
 >status : "hidden"
diff --git a/tests/baselines/reference/keyRemappingKeyofResult.types b/tests/baselines/reference/keyRemappingKeyofResult.types
index 5d8aef034be42..c0a4ea4fefb82 100644
--- a/tests/baselines/reference/keyRemappingKeyofResult.types
+++ b/tests/baselines/reference/keyRemappingKeyofResult.types
@@ -6,19 +6,19 @@ const sym = Symbol("")
 >"" : ""
 
 type Orig = { [k: string]: any, str: any, [sym]: any }
->Orig : Orig
+>Orig : { [k: string]: any; str: any; [sym]: any; }
 >k : string
 >str : any
 >[sym] : any
 >sym : unique symbol
 
 type Okay = Exclude<keyof Orig, never>
->Okay : Okay
+>Okay : string | number | unique symbol
 
 // type Okay = string | number | typeof sym
 
 type Remapped = { [K in keyof Orig as {} extends Record<K, any> ? never : K]: any }
->Remapped : Remapped
+>Remapped : { str: any; [sym]: any; }
 
 /* type Remapped = {
     str: any;
@@ -27,7 +27,7 @@ type Remapped = { [K in keyof Orig as {} extends Record<K, any> ? never : K]: an
 // no string index signature, right?
 
 type Oops = Exclude<keyof Remapped, never>
->Oops : Oops
+>Oops : unique symbol | "str"
 
 declare let x: Oops;
 >x : Oops
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index 0c8af36f1ac79..fc4603b997ff7 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess.types
@@ -125,7 +125,7 @@ type NAME = "name";
 >NAME : "name"
 
 type WIDTH_OR_HEIGHT = "width" | "height";
->WIDTH_OR_HEIGHT : WIDTH_OR_HEIGHT
+>WIDTH_OR_HEIGHT : "width" | "height"
 
 type Q10 = Shape["name"];  // string
 >Q10 : string
@@ -134,7 +134,7 @@ type Q11 = Shape["width" | "height"];  // number
 >Q11 : number
 
 type Q12 = Shape["name" | "visible"];  // string | boolean
->Q12 : Q12
+>Q12 : string | boolean
 
 type Q20 = Shape[NAME];  // string
 >Q20 : string
@@ -1196,7 +1196,7 @@ class C1 {
 }
 
 type S2 = {
->S2 : S2
+>S2 : { a: string; b: string; }
 
     a: string;
 >a : string
@@ -1448,7 +1448,7 @@ function path(obj: any, ...keys: (string | number)[]): any {
 }
 
 type Thing = {
->Thing : Thing
+>Thing : { a: {    x: number;    y: string;}; b: boolean; }
 
     a: { x: number, y: string },
 >a : { x: number; y: string; }
@@ -1646,7 +1646,7 @@ function f<K extends keyof R>(p: K) {
 // Repro from #12651
 
 type MethodDescriptor = {
->MethodDescriptor : MethodDescriptor
+>MethodDescriptor : { name: string; args: any[]; returnValue: any; }
 
 	name: string;
 >name : string
@@ -1664,7 +1664,7 @@ declare function dispatchMethod<M extends MethodDescriptor>(name: M['name'], arg
 >args : M["args"]
 
 type SomeMethodDescriptor = {
->SomeMethodDescriptor : SomeMethodDescriptor
+>SomeMethodDescriptor : { name: "someMethod"; args: [string, number]; returnValue: string[]; }
 
 	name: "someMethod";
 >name : "someMethod"
@@ -1688,7 +1688,7 @@ let result = dispatchMethod<SomeMethodDescriptor>("someMethod", ["hello", 35]);
 // Repro from #13073
 
 type KeyTypes = "a" | "b"
->KeyTypes : KeyTypes
+>KeyTypes : "a" | "b"
 
 let MyThingy: { [key in KeyTypes]: string[] };
 >MyThingy : { a: string[]; b: string[]; }
diff --git a/tests/baselines/reference/keyofAndIndexedAccess2.types b/tests/baselines/reference/keyofAndIndexedAccess2.types
index 9fa1ac46783bb..d82644efd53c4 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess2.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess2.types
@@ -228,7 +228,7 @@ function f4<K extends string>(a: { [key: string]: number }[K], b: number) {
 }
 
 type Item = { a: string, b: number };
->Item : Item
+>Item : { a: string; b: number; }
 >a : string
 >b : number
 
@@ -270,7 +270,7 @@ function f10<T extends Item, K extends keyof T>(obj: T, k1: string, k2: keyof It
 }
 
 type Dict = Record<string, number>;
->Dict : Dict
+>Dict : { [x: string]: number; }
 
 function f11<K extends keyof Dict>(obj: Dict, k1: keyof Dict, k2: K) {
 >f11 : <K extends string>(obj: Dict, k1: keyof Dict, k2: K) => void
diff --git a/tests/baselines/reference/keyofAndIndexedAccessErrors.types b/tests/baselines/reference/keyofAndIndexedAccessErrors.types
index 6fb2b69bfad91..ed449ab1e3ec4 100644
--- a/tests/baselines/reference/keyofAndIndexedAccessErrors.types
+++ b/tests/baselines/reference/keyofAndIndexedAccessErrors.types
@@ -421,7 +421,7 @@ type UndefinedKeys<T extends Record<string, any>> = {
 };
 
 type MyType = {a: string, b: string | undefined}
->MyType : MyType
+>MyType : { a: string; b: string | undefined; }
 >a : string
 >b : string
 
diff --git a/tests/baselines/reference/keyofDoesntContainSymbols.types b/tests/baselines/reference/keyofDoesntContainSymbols.types
index 00ccad59caa36..5971064fa36c5 100644
--- a/tests/baselines/reference/keyofDoesntContainSymbols.types
+++ b/tests/baselines/reference/keyofDoesntContainSymbols.types
@@ -85,6 +85,6 @@ type Values<T> = T[keyof T];
 >Values : Values<T>
 
 type ValuesOfObj = Values<typeof obj>;
->ValuesOfObj : ValuesOfObj
+>ValuesOfObj : string | number
 >obj : { num: number; str: string; 0: 0; [sym]: symbol; }
 
diff --git a/tests/baselines/reference/keyofIntersection.types b/tests/baselines/reference/keyofIntersection.types
index f6d636f6a2b4c..b667a08dbe9af 100644
--- a/tests/baselines/reference/keyofIntersection.types
+++ b/tests/baselines/reference/keyofIntersection.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/types/keyof/keyofIntersection.ts ===
 type A = { a: string };
->A : A
+>A : { a: string; }
 >a : string
 
 type B = { b: string };
->B : B
+>B : { b: string; }
 >b : string
 
 type T01 = keyof (A & B);  // "a" | "b"
@@ -20,13 +20,13 @@ type T04<T, U> = keyof (T & U);  // keyof T | keyof U
 >T04 : keyof T | keyof U
 
 type T05 = T02<A>;  // "a" | "b"
->T05 : T05
+>T05 : "b" | "a"
 
 type T06 = T03<B>;  // "a" | "b"
->T06 : T06
+>T06 : "b" | "a"
 
 type T07 = T04<A, B>;  // "a" | "b"
->T07 : T07
+>T07 : "b" | "a"
 
 // Repros from #22291
 
@@ -34,7 +34,7 @@ type Example1<T extends string, U extends string> = keyof (Record<T, any> & Reco
 >Example1 : T | U
 
 type Result1 = Example1<'x', 'y'>;  // "x" | "y"
->Result1 : Result1
+>Result1 : "x" | "y"
 
 type Result2 = keyof (Record<'x', any> & Record<'y', any>);  // "x" | "y"
 >Result2 : "x" | "y"
@@ -55,5 +55,5 @@ type Example5<T, U> = keyof (T & U);
 >Example5 : keyof T | keyof U
 
 type Result5 = Example5<Record<'x', any>, Record<'y', any>>;  // "x" | "y"
->Result5 : Result5
+>Result5 : "x" | "y"
 
diff --git a/tests/baselines/reference/lambdaParameterWithTupleArgsHasCorrectAssignability.types b/tests/baselines/reference/lambdaParameterWithTupleArgsHasCorrectAssignability.types
index 435bdc4c4cf93..539326ab1c791 100644
--- a/tests/baselines/reference/lambdaParameterWithTupleArgsHasCorrectAssignability.types
+++ b/tests/baselines/reference/lambdaParameterWithTupleArgsHasCorrectAssignability.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/lambdaParameterWithTupleArgsHasCorrectAssignability.ts ===
 type MyTupleItem = {};
->MyTupleItem : MyTupleItem
+>MyTupleItem : {}
 
 type MyTuple = [MyTupleItem, ...MyTupleItem[]];
->MyTuple : MyTuple
+>MyTuple : [MyTupleItem, ...MyTupleItem[]]
 
 type GenericFunction<T extends MyTuple> = (...fromArgs: T) => void;
 >GenericFunction : GenericFunction<T>
diff --git a/tests/baselines/reference/lateBoundConstraintTypeChecksCorrectly.types b/tests/baselines/reference/lateBoundConstraintTypeChecksCorrectly.types
index 6cde47ff0dc04..fa806eda9641c 100644
--- a/tests/baselines/reference/lateBoundConstraintTypeChecksCorrectly.types
+++ b/tests/baselines/reference/lateBoundConstraintTypeChecksCorrectly.types
@@ -6,7 +6,7 @@ declare const barProp: unique symbol;
 >barProp : unique symbol
 
 type BothProps = typeof fooProp | typeof barProp;
->BothProps : BothProps
+>BothProps : unique symbol | unique symbol
 >fooProp : unique symbol
 >barProp : unique symbol
 
diff --git a/tests/baselines/reference/literalTypeWidening.types b/tests/baselines/reference/literalTypeWidening.types
index 6ba61a8072605..f40f9d1229821 100644
--- a/tests/baselines/reference/literalTypeWidening.types
+++ b/tests/baselines/reference/literalTypeWidening.types
@@ -343,7 +343,7 @@ if (isSuccess(result)) {
 // Repro from #10898
 
 type TestEvent = "onmouseover" | "onmouseout";
->TestEvent : TestEvent
+>TestEvent : "onmouseover" | "onmouseout"
 
 function onMouseOver(): TestEvent { return "onmouseover"; }
 >onMouseOver : () => TestEvent
@@ -398,7 +398,7 @@ export function keys<K extends string, V>(obj: Record<K, V>): K[] {
 }
 
 type Obj = { code: LangCode }
->Obj : Obj
+>Obj : { code: LangCode; }
 >code : "fr" | "en" | "es" | "it" | "nl"
 
 const langCodeSet = Set('fr', 'en', 'es', 'it', 'nl')
diff --git a/tests/baselines/reference/literalTypes1.types b/tests/baselines/reference/literalTypes1.types
index f2f25599ae99e..3456663ab0483 100644
--- a/tests/baselines/reference/literalTypes1.types
+++ b/tests/baselines/reference/literalTypes1.types
@@ -78,7 +78,7 @@ function f2(x: 0 | 1 | 2) {
 }
 
 type Falsy = false | 0 | "" | null | undefined;
->Falsy : Falsy
+>Falsy : false | "" | 0 | null | undefined
 >false : false
 >null : null
 
diff --git a/tests/baselines/reference/literalTypes2.types b/tests/baselines/reference/literalTypes2.types
index 09d4cc3d2189e..6194083b77f74 100644
--- a/tests/baselines/reference/literalTypes2.types
+++ b/tests/baselines/reference/literalTypes2.types
@@ -756,7 +756,7 @@ function append<T>(a: T[], x: T): T[] {
 }
 
 type Bit = 0 | 1;
->Bit : Bit
+>Bit : 0 | 1
 
 let aa = makeArray<Bit>(0);
 >aa : Bit[]
diff --git a/tests/baselines/reference/localTypeParameterInferencePriority.types b/tests/baselines/reference/localTypeParameterInferencePriority.types
index 3297fc40a6f1f..9834da9c9d92a 100644
--- a/tests/baselines/reference/localTypeParameterInferencePriority.types
+++ b/tests/baselines/reference/localTypeParameterInferencePriority.types
@@ -7,7 +7,7 @@ export type UnrollOnHover<O extends object> = O extends object ?
 
 
 export type Schema = Record<string, unknown>;
->Schema : Schema
+>Schema : { [x: string]: unknown; }
 
 class Table<S extends Schema>  {
 >Table : Table<S>
diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types
index 3f443a735cbe3..5e345f3ccf677 100644
--- a/tests/baselines/reference/mapOnTupleTypes02.types
+++ b/tests/baselines/reference/mapOnTupleTypes02.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/mapOnTupleTypes02.ts ===
 export type Point = [number, number];
->Point : Point
+>Point : [number, number]
 
 export function increment(point: Point) {
 >increment : (point: Point) => number[]
diff --git a/tests/baselines/reference/mappedTypeAsClauses.types b/tests/baselines/reference/mappedTypeAsClauses.types
index f77042a71e5c1..de951157933a3 100644
--- a/tests/baselines/reference/mappedTypeAsClauses.types
+++ b/tests/baselines/reference/mappedTypeAsClauses.types
@@ -5,7 +5,7 @@ type Getters<T> = { [P in keyof T & string as `get${Capitalize<P>}`]: () => T[P]
 >Getters : Getters<T>
 
 type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>;
->TG1 : TG1
+>TG1 : { getFoo: () => string; getBar: () => number; getBaz: () => { z: boolean; }; }
 >foo : string
 >bar : number
 >baz : { z: boolean; }
@@ -22,7 +22,7 @@ type TypeFromDefs<T extends PropDef<keyof any, any>> = { [P in T as P['name']]:
 >TypeFromDefs : TypeFromDefs<T>
 
 type TP1 = TypeFromDefs<{ name: 'a', type: string } | { name: 'b', type: number } | { name: 'a', type: boolean }>;
->TP1 : TP1
+>TP1 : { a: string | boolean; b: number; }
 >name : "a"
 >type : string
 >name : "b"
@@ -33,10 +33,10 @@ type TP1 = TypeFromDefs<{ name: 'a', type: string } | { name: 'b', type: number
 // No array or tuple type mapping when 'as N' clause present
 
 type TA1 = Getters<string[]>;
->TA1 : TA1
+>TA1 : { getConcat: () => { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }; getIndexOf: () => (searchElement: string, fromIndex?: number | undefined) => number; getLastIndexOf: () => (searchElement: string, fromIndex?: number | undefined) => number; getSlice: () => (start?: number | undefined, end?: number | undefined) => string[]; getLength: () => number; getToString: () => () => string; getToLocaleString: () => () => string; getPop: () => () => string | undefined; getPush: () => (...items: string[]) => number; getJoin: () => (separator?: string | undefined) => string; getReverse: () => () => string[]; getShift: () => () => string | undefined; getSort: () => (compareFn?: ((a: string, b: string) => number) | undefined) => string[]; getSplice: () => { (start: number, deleteCount?: number | undefined): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; }; getUnshift: () => (...items: string[]) => number; getEvery: () => { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean; }; getSome: () => (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any) => boolean; getForEach: () => (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void; getMap: () => <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]; getFilter: () => { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[]; }; getReduce: () => { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }; getReduceRight: () => { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }; }
 
 type TA2 = Getters<[number, boolean]>;
->TA2 : TA2
+>TA2 : { getConcat: () => { (...items: ConcatArray<number | boolean>[]): (number | boolean)[]; (...items: (number | boolean | ConcatArray<number | boolean>)[]): (number | boolean)[]; }; getIndexOf: () => (searchElement: number | boolean, fromIndex?: number | undefined) => number; getLastIndexOf: () => (searchElement: number | boolean, fromIndex?: number | undefined) => number; getSlice: () => (start?: number | undefined, end?: number | undefined) => (number | boolean)[]; getLength: () => 2; getToString: () => () => string; getToLocaleString: () => () => string; getPop: () => () => number | boolean | undefined; getPush: () => (...items: (number | boolean)[]) => number; getJoin: () => (separator?: string | undefined) => string; getReverse: () => () => (number | boolean)[]; getShift: () => () => number | boolean | undefined; getSort: () => (compareFn?: ((a: number | boolean, b: number | boolean) => number) | undefined) => [number, boolean]; getSplice: () => { (start: number, deleteCount?: number | undefined): (number | boolean)[]; (start: number, deleteCount: number, ...items: (number | boolean)[]): (number | boolean)[]; }; getUnshift: () => (...items: (number | boolean)[]) => number; getEvery: () => { <S extends number | boolean>(predicate: (value: number | boolean, index: number, array: (number | boolean)[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number | boolean, index: number, array: (number | boolean)[]) => unknown, thisArg?: any): boolean; }; getSome: () => (predicate: (value: number | boolean, index: number, array: (number | boolean)[]) => unknown, thisArg?: any) => boolean; getForEach: () => (callbackfn: (value: number | boolean, index: number, array: (number | boolean)[]) => void, thisArg?: any) => void; getMap: () => <U>(callbackfn: (value: number | boolean, index: number, array: (number | boolean)[]) => U, thisArg?: any) => U[]; getFilter: () => { <S extends number | boolean>(predicate: (value: number | boolean, index: number, array: (number | boolean)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | boolean, index: number, array: (number | boolean)[]) => unknown, thisArg?: any): (number | boolean)[]; }; getReduce: () => { (callbackfn: (previousValue: number | boolean, currentValue: number | boolean, currentIndex: number, array: (number | boolean)[]) => number | boolean): number | boolean; (callbackfn: (previousValue: number | boolean, currentValue: number | boolean, currentIndex: number, array: (number | boolean)[]) => number | boolean, initialValue: number | boolean): number | boolean; <U>(callbackfn: (previousValue: U, currentValue: number | boolean, currentIndex: number, array: (number | boolean)[]) => U, initialValue: U): U; }; getReduceRight: () => { (callbackfn: (previousValue: number | boolean, currentValue: number | boolean, currentIndex: number, array: (number | boolean)[]) => number | boolean): number | boolean; (callbackfn: (previousValue: number | boolean, currentValue: number | boolean, currentIndex: number, array: (number | boolean)[]) => number | boolean, initialValue: number | boolean): number | boolean; <U>(callbackfn: (previousValue: U, currentValue: number | boolean, currentIndex: number, array: (number | boolean)[]) => U, initialValue: U): U; }; get0: () => number; get1: () => boolean; }
 
 // Filtering using 'as N' clause
 
@@ -56,7 +56,7 @@ type DoubleProp<T> = { [P in keyof T & string as `${P}1` | `${P}2`]: T[P] }
 >DoubleProp : DoubleProp<T>
 
 type TD1 = DoubleProp<{ a: string, b: number }>;  // { a1: string, a2: string, b1: number, b2: number }
->TD1 : TD1
+>TD1 : { a1: string; a2: string; b1: number; b2: number; }
 >a : string
 >b : number
 
@@ -91,7 +91,7 @@ type LazyPerson = Lazyify<Person>;
 // Repro from #40833
 
 type Example = {foo: string, bar: number};
->Example : Example
+>Example : { foo: string; bar: number; }
 >foo : string
 >bar : number
 
@@ -153,7 +153,7 @@ interface Wheel {
 }
 
 type Primitive = string | number | boolean;
->Primitive : Primitive
+>Primitive : string | number | boolean
 
 type OnlyPrimitives<T> = { [K in keyof T as T[K] extends Primitive ? K : never]: T[K] };
 >OnlyPrimitives : OnlyPrimitives<T>
@@ -192,7 +192,7 @@ type GetObjWithIf<S, V> = { [TP in keyof S as If<Equal<S[TP], V>, TP, never>]: a
 >GetObjWithIf : GetObjWithIf<S, V>
 
 type Task = {
->Task : Task
+>Task : { isDone: boolean; }
 
   isDone: boolean;
 >isDone : boolean
@@ -200,7 +200,7 @@ type Task = {
 };
 
 type Schema = {
->Schema : Schema
+>Schema : { root: {    title: string;    task: Task;}; Task: Task; }
 
   root: {
 >root : { title: string; task: Task; }
@@ -252,7 +252,7 @@ f("a");  // Error, should allow only "b"
 >"a" : "a"
 
 type NameMap = { 'a': 'x', 'b': 'y', 'c': 'z' };
->NameMap : NameMap
+>NameMap : { a: 'x'; b: 'y'; c: 'z'; }
 >'a' : "x"
 >'b' : "y"
 >'c' : "z"
diff --git a/tests/baselines/reference/mappedTypeConstraints.types b/tests/baselines/reference/mappedTypeConstraints.types
index 86d62eb40c56c..86099d594d59f 100644
--- a/tests/baselines/reference/mappedTypeConstraints.types
+++ b/tests/baselines/reference/mappedTypeConstraints.types
@@ -81,7 +81,7 @@ function f4<T extends { a: string, b: string }>(obj: Record<Exclude<keyof T, 'b'
 // Repro from #28821
 
 type TargetProps = {
->TargetProps : TargetProps
+>TargetProps : { foo: string; bar: string; }
 
     foo: string,
 >foo : string
diff --git a/tests/baselines/reference/mappedTypeContextualTypesApplied.types b/tests/baselines/reference/mappedTypeContextualTypesApplied.types
index fc539785d1b0e..dde424dab5d7b 100644
--- a/tests/baselines/reference/mappedTypeContextualTypesApplied.types
+++ b/tests/baselines/reference/mappedTypeContextualTypesApplied.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/mappedTypeContextualTypesApplied.ts ===
 type TakeString = (s: string) => any;
->TakeString : TakeString
+>TakeString : (s: string) => any
 >s : string
 
 // Various functions accepting an object whose properties are TakeString functions.
diff --git a/tests/baselines/reference/mappedTypeErrors.types b/tests/baselines/reference/mappedTypeErrors.types
index 3f25f247d2e34..d7d683313aeb7 100644
--- a/tests/baselines/reference/mappedTypeErrors.types
+++ b/tests/baselines/reference/mappedTypeErrors.types
@@ -29,37 +29,37 @@ interface Point {
 // Constraint checking
 
 type T00 = { [P in P]: string };  // Error
->T00 : T00
+>T00 : { [x: string]: string; }
 
 type T01 = { [P in number]: string };  // Error
->T01 : T01
+>T01 : { [x: number]: string; }
 
 type T02 = { [P in Date]: number };  // Error
->T02 : T02
+>T02 : {}
 
 type T03 = Record<Date, number>;  // Error
->T03 : T03
+>T03 : {}
 
 type T10 = Pick<Shape, "name">;
->T10 : T10
+>T10 : { name: string; }
 
 type T11 = Pick<Shape, "foo">;  // Error
->T11 : T11
+>T11 : { foo: unknown; }
 
 type T12 = Pick<Shape, "name" | "foo">;  // Error
->T12 : T12
+>T12 : { name: string; foo: unknown; }
 
 type T13 = Pick<Shape, keyof Named>;
->T13 : T13
+>T13 : { name: string; }
 
 type T14 = Pick<Shape, keyof Point>;  // Error
->T14 : T14
+>T14 : { x: unknown; y: unknown; }
 
 type T15 = Pick<Shape, never>;
->T15 : T15
+>T15 : {}
 
 type T16 = Pick<Shape, undefined>;  // Error
->T16 : T16
+>T16 : {}
 
 function f1<T>(x: T) {
 >f1 : <T>(x: T) => void
@@ -434,7 +434,7 @@ c.setState({ c: true });  // Error
 >true : true
 
 type T2 = { a?: number, [key: string]: any };
->T2 : T2
+>T2 : { [key: string]: any; a?: number | undefined; }
 >a : number | undefined
 >key : string
 
@@ -469,7 +469,7 @@ type Foo2<T, F extends keyof T> = {
 
 };
 type O = {x: number, y: boolean};
->O : O
+>O : { x: number; y: boolean; }
 >x : number
 >y : boolean
 
diff --git a/tests/baselines/reference/mappedTypeErrors2.types b/tests/baselines/reference/mappedTypeErrors2.types
index 303cf31061ac9..91b38ae100948 100644
--- a/tests/baselines/reference/mappedTypeErrors2.types
+++ b/tests/baselines/reference/mappedTypeErrors2.types
@@ -2,7 +2,7 @@
 // Repros from #17238
 
 type AB = {
->AB : AB
+>AB : { a: 'a'; b: 'a'; }
 
     a: 'a'
 >a : "a"
@@ -23,7 +23,7 @@ type R = AB[keyof AB]; // "a"
 >R : "a"
 
 type T3 = { [key in R]: true };
->T3 : T3
+>T3 : { a: true; }
 >true : true
 
 type T4<K extends 'a'|'b'> = T3[K] // Error
diff --git a/tests/baselines/reference/mappedTypeIndexedAccess.types b/tests/baselines/reference/mappedTypeIndexedAccess.types
index c145f925bde48..57d446e6dcf1d 100644
--- a/tests/baselines/reference/mappedTypeIndexedAccess.types
+++ b/tests/baselines/reference/mappedTypeIndexedAccess.types
@@ -18,7 +18,7 @@ type Pair<T> = Pairs<T>[keyof T];
 >Pair : Pair<T>
 
 type FooBar = {
->FooBar : FooBar
+>FooBar : { foo: string; bar: number; }
 
     foo: string;
 >foo : string
diff --git a/tests/baselines/reference/mappedTypeInferenceCircularity.types b/tests/baselines/reference/mappedTypeInferenceCircularity.types
index 51f1f69f04cf1..591b4fa066052 100644
--- a/tests/baselines/reference/mappedTypeInferenceCircularity.types
+++ b/tests/baselines/reference/mappedTypeInferenceCircularity.types
@@ -2,7 +2,7 @@
 // Repro from #12511
 
 type HTML = { [K in 'div']: Block<HTML> };
->HTML : HTML
+>HTML : { div: Block<HTML>; }
 
 type Block<P> = <T>(func: HTML) => {};
 >Block : Block<P>
diff --git a/tests/baselines/reference/mappedTypeModifiers.types b/tests/baselines/reference/mappedTypeModifiers.types
index 317c3fd052412..dac3cc264120a 100644
--- a/tests/baselines/reference/mappedTypeModifiers.types
+++ b/tests/baselines/reference/mappedTypeModifiers.types
@@ -1,21 +1,21 @@
 === tests/cases/conformance/types/mapped/mappedTypeModifiers.ts ===
 type T = { a: number, b: string };
->T : T
+>T : { a: number; b: string; }
 >a : number
 >b : string
 
 type TP = { a?: number, b?: string };
->TP : TP
+>TP : { a?: number | undefined; b?: string | undefined; }
 >a : number | undefined
 >b : string | undefined
 
 type TR = { readonly a: number, readonly b: string };
->TR : TR
+>TR : { readonly a: number; readonly b: string; }
 >a : number
 >b : string
 
 type TPR = { readonly a?: number, readonly b?: string };
->TPR : TPR
+>TPR : { readonly a?: number | undefined; readonly b?: string | undefined; }
 >a : number | undefined
 >b : string | undefined
 
@@ -105,28 +105,28 @@ type Boxified<T> = { [P in keyof T]: { x: T[P] } };
 >x : T[P]
 
 type B = { a: { x: number }, b: { x: string } };
->B : B
+>B : { a: {    x: number;}; b: {    x: string;}; }
 >a : { x: number; }
 >x : number
 >b : { x: string; }
 >x : string
 
 type BP = { a?: { x: number }, b?: { x: string } };
->BP : BP
+>BP : { a?: { x: number; } | undefined; b?: { x: string; } | undefined; }
 >a : { x: number; } | undefined
 >x : number
 >b : { x: string; } | undefined
 >x : string
 
 type BR = { readonly a: { x: number }, readonly b: { x: string } };
->BR : BR
+>BR : { readonly a: {    x: number;}; readonly b: {    x: string;}; }
 >a : { x: number; }
 >x : number
 >b : { x: string; }
 >x : string
 
 type BPR = { readonly a?: { x: number }, readonly b?: { x: string } };
->BPR : BPR
+>BPR : { readonly a?: { x: number; } | undefined; readonly b?: { x: string; } | undefined; }
 >a : { x: number; } | undefined
 >x : number
 >b : { x: string; } | undefined
@@ -214,7 +214,7 @@ var b04: Pick<BPR, keyof BPR>;
 >b04 : BPR
 
 type Foo = { prop: number, [x: string]: number };
->Foo : Foo
+>Foo : { [x: string]: number; prop: number; }
 >prop : number
 >x : string
 
diff --git a/tests/baselines/reference/mappedTypeOverlappingStringEnumKeys.types b/tests/baselines/reference/mappedTypeOverlappingStringEnumKeys.types
index ae58d3f12ddc3..21db5f8a35b09 100644
--- a/tests/baselines/reference/mappedTypeOverlappingStringEnumKeys.types
+++ b/tests/baselines/reference/mappedTypeOverlappingStringEnumKeys.types
@@ -24,7 +24,7 @@ enum AlienAnimalTypes {
 };
 
 type AnimalTypes = TerrestrialAnimalTypes | AlienAnimalTypes;
->AnimalTypes : AnimalTypes
+>AnimalTypes : TerrestrialAnimalTypes | AlienAnimalTypes
 
 interface TerrestrialCat {
   type: TerrestrialAnimalTypes.CAT;
@@ -45,10 +45,10 @@ interface AlienCat {
 }
 
 type Cats = TerrestrialCat | AlienCat;
->Cats : Cats
+>Cats : TerrestrialCat | AlienCat
 
 type CatMap = {
->CatMap : CatMap
+>CatMap : { cat: (TerrestrialCat | AlienCat)[]; dog: never[]; }
 
   [V in AnimalTypes]: Extract<Cats, { type: V }>[]
 >type : V
diff --git a/tests/baselines/reference/mappedTypeProperties.types b/tests/baselines/reference/mappedTypeProperties.types
index bb40340eacb37..0a75c228660f3 100644
--- a/tests/baselines/reference/mappedTypeProperties.types
+++ b/tests/baselines/reference/mappedTypeProperties.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/types/mapped/mappedTypeProperties.ts ===
 export type PlaceType = 'openSky' | 'roofed' | 'garage'
->PlaceType : PlaceType
+>PlaceType : "openSky" | "roofed" | "garage"
 
 type Before = {
->Before : Before
+>Before : { model: 'hour' | 'day'; }
 
     model: 'hour' | 'day';
 >model : "hour" | "day"
@@ -16,7 +16,7 @@ type Before = {
 }
 
 type After = {
->After : After
+>After : { openSky: void; roofed: void; garage: void; }
 
     [placeType in PlaceType]: void;
     model: 'hour' | 'day'
@@ -24,14 +24,14 @@ type After = {
 }
 
 type AfterQuestion = {
->AfterQuestion : AfterQuestion
+>AfterQuestion : { openSky?: void; roofed?: void; garage?: void; }
 
     [placeType in PlaceType]?: void;
     model: 'hour' | 'day';
 >model : "hour" | "day"
 }
 type AfterMethod = {
->AfterMethod : AfterMethod
+>AfterMethod : { openSky?: void; roofed?: void; garage?: void; }
 
     [placeType in PlaceType]?: void;
     model(duration: number): 'hour' | 'day';
@@ -40,14 +40,14 @@ type AfterMethod = {
 }
 
 type AfterImplicit = {
->AfterImplicit : AfterImplicit
+>AfterImplicit : { openSky: any; roofed: any; garage: any; }
 
     [placeType in PlaceType]
     model: 'hour' | 'day';
 >model : "hour" | "day"
 }
 type AfterImplicitQ = {
->AfterImplicitQ : AfterImplicitQ
+>AfterImplicitQ : { openSky?: any; roofed?: any; garage?: any; }
 
     [placeType in PlaceType]?
     model: 'hour' | 'day'
diff --git a/tests/baselines/reference/mappedTypeRelationships.types b/tests/baselines/reference/mappedTypeRelationships.types
index f138f86e521f7..7d93248e8f021 100644
--- a/tests/baselines/reference/mappedTypeRelationships.types
+++ b/tests/baselines/reference/mappedTypeRelationships.types
@@ -322,7 +322,7 @@ function f23<T, U extends T, K extends keyof T>(x: T, y: Readonly<U>, k: K) {
 }
 
 type Thing = { a: string, b: string };
->Thing : Thing
+>Thing : { a: string; b: string; }
 >a : string
 >b : string
 
@@ -391,14 +391,14 @@ function f41<T extends Thing>(x: Readonly<Thing>, y: Readonly<T>) {
 }
 
 type Item = {
->Item : Item
+>Item : { name: string; }
 
     name: string;
 >name : string
 }
 
 type ItemMap = {
->ItemMap : ItemMap
+>ItemMap : { [x: string]: Item; }
 
     [x: string]: Item;
 >x : string
diff --git a/tests/baselines/reference/mappedTypeWithAny.types b/tests/baselines/reference/mappedTypeWithAny.types
index 773984fa576d6..983ea1acc7113 100644
--- a/tests/baselines/reference/mappedTypeWithAny.types
+++ b/tests/baselines/reference/mappedTypeWithAny.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/mapped/mappedTypeWithAny.ts ===
 type Item = { value: string };
->Item : Item
+>Item : { value: string; }
 >value : string
 
 type ItemMap<T> = { [P in keyof T]: Item };
@@ -24,7 +24,7 @@ declare let x4: ItemMap<any>;
 // Repro from #19152
 
 type Data = {
->Data : Data
+>Data : { value: string; }
 
   value: string;
 >value : string
diff --git a/tests/baselines/reference/mappedTypes1.types b/tests/baselines/reference/mappedTypes1.types
index 9c33653214b54..4dac0fa8c47b0 100644
--- a/tests/baselines/reference/mappedTypes1.types
+++ b/tests/baselines/reference/mappedTypes1.types
@@ -1,80 +1,80 @@
 === tests/cases/conformance/types/mapped/mappedTypes1.ts ===
 type Item = { a: string, b: number, c: boolean };
->Item : Item
+>Item : { a: string; b: number; c: boolean; }
 >a : string
 >b : number
 >c : boolean
 
 type T00 = { [P in "x" | "y"]: number };
->T00 : T00
+>T00 : { x: number; y: number; }
 
 type T01 = { [P in "x" | "y"]: P };
->T01 : T01
+>T01 : { x: "x"; y: "y"; }
 
 type T02 = { [P in "a" | "b"]: Item[P]; }
->T02 : T02
+>T02 : { a: string; b: number; }
 
 type T03 = { [P in keyof Item]: Date };
->T03 : T03
+>T03 : { a: Date; b: Date; c: Date; }
 
 type T10 = { [P in keyof Item]: Item[P] };
->T10 : T10
+>T10 : { a: string; b: number; c: boolean; }
 
 type T11 = { [P in keyof Item]?: Item[P] };
->T11 : T11
+>T11 : { a?: string | undefined; b?: number | undefined; c?: boolean | undefined; }
 
 type T12 = { readonly [P in keyof Item]: Item[P] };
->T12 : T12
+>T12 : { readonly a: string; readonly b: number; readonly c: boolean; }
 
 type T13 = { readonly [P in keyof Item]?: Item[P] };
->T13 : T13
+>T13 : { readonly a?: string | undefined; readonly b?: number | undefined; readonly c?: boolean | undefined; }
 
 type T20 = { [P in keyof Item]: Item[P] | null };
->T20 : T20
+>T20 : { a: string | null; b: number | null; c: boolean | null; }
 >null : null
 
 type T21 = { [P in keyof Item]: Array<Item[P]> };
->T21 : T21
+>T21 : { a: string[]; b: number[]; c: boolean[]; }
 
 type T30 = { [P in keyof any]: void };
->T30 : T30
+>T30 : { [x: string]: void; }
 
 type T31 = { [P in keyof string]: void };
->T31 : T31
+>T31 : { [x: number]: void; toString: void; charAt: void; charCodeAt: void; concat: void; indexOf: void; lastIndexOf: void; localeCompare: void; match: void; replace: void; search: void; slice: void; split: void; substring: void; toLowerCase: void; toLocaleLowerCase: void; toUpperCase: void; toLocaleUpperCase: void; trim: void; readonly length: void; substr: void; valueOf: void; }
 
 type T32 = { [P in keyof number]: void };
->T32 : T32
+>T32 : { toString: void; toFixed: void; toExponential: void; toPrecision: void; valueOf: void; toLocaleString: void; }
 
 type T33 = { [P in keyof boolean]: void };
->T33 : T33
+>T33 : { valueOf: void; }
 
 type T34 = { [P in keyof undefined]: void };
->T34 : T34
+>T34 : {}
 
 type T35 = { [P in keyof null]: void };
->T35 : T35
+>T35 : {}
 >null : null
 
 type T36 = { [P in keyof void]: void };
->T36 : T36
+>T36 : {}
 
 type T37 = { [P in keyof symbol]: void };
->T37 : T37
+>T37 : { toString: void; valueOf: void; }
 
 type T38 = { [P in keyof never]: void };
->T38 : T38
+>T38 : {}
 
 type T40 = { [P in string]: void };
->T40 : T40
+>T40 : { [x: string]: void; }
 
 type T43 = { [P in "a" | "b"]: void };
->T43 : T43
+>T43 : { a: void; b: void; }
 
 type T44 = { [P in "a" | "b" | "0" | "1"]: void };
->T44 : T44
+>T44 : { a: void; b: void; 0: void; 1: void; }
 
 type T47 = { [P in string | "a" | "b" | "0" | "1"]: void };
->T47 : T47
+>T47 : { [x: string]: void; }
 
 declare function f1<T1>(): { [P in keyof T1]: void };
 >f1 : <T1>() => { [P in keyof T1]: void; }
diff --git a/tests/baselines/reference/mappedTypes4.types b/tests/baselines/reference/mappedTypes4.types
index 7f7c36fc85c55..85e714a4f0043 100644
--- a/tests/baselines/reference/mappedTypes4.types
+++ b/tests/baselines/reference/mappedTypes4.types
@@ -49,15 +49,15 @@ function boxify<T>(obj: T): Boxified<T> {
 }
 
 type A = { a: string };
->A : A
+>A : { a: string; }
 >a : string
 
 type B = { b: string };
->B : B
+>B : { b: string; }
 >b : string
 
 type C = { c: string };
->C : C
+>C : { c: string; }
 >c : string
 
 function f1(x: A | B | C | undefined) {
@@ -71,25 +71,25 @@ function f1(x: A | B | C | undefined) {
 }
 
 type T00 = Partial<A | B | C>;
->T00 : T00
+>T00 : Partial<A> | Partial<B> | Partial<C>
 
 type T01 = Readonly<A | B | C | null | undefined>;
->T01 : T01
+>T01 : Readonly<A> | Readonly<B> | Readonly<C> | null | undefined
 >null : null
 
 type T02 = Boxified<A | B[] | C | string>
->T02 : T02
+>T02 : string | Boxified<A> | Boxified<C> | Box<B>[]
 
 type T03 = Readonly<string | number | boolean | null | undefined | void>;
->T03 : T03
+>T03 : string | number | boolean | void | null | undefined
 >null : null
 
 type T04 = Boxified<string | number | boolean | null | undefined | void>;
->T04 : T04
+>T04 : string | number | boolean | void | null | undefined
 >null : null
 
 type T05 = Partial<"hello" | "world" | 42>;
->T05 : T05
+>T05 : "hello" | "world" | 42
 
 type BoxifiedWithSentinel<T, U> = {
 >BoxifiedWithSentinel : BoxifiedWithSentinel<T, U>
@@ -98,11 +98,11 @@ type BoxifiedWithSentinel<T, U> = {
 }
 
 type T10 = BoxifiedWithSentinel<A | B | C, null>;
->T10 : T10
+>T10 : BoxifiedWithSentinel<A, null> | BoxifiedWithSentinel<B, null> | BoxifiedWithSentinel<C, null>
 >null : null
 
 type T11 = BoxifiedWithSentinel<A | B | C, undefined>;
->T11 : T11
+>T11 : BoxifiedWithSentinel<A, undefined> | BoxifiedWithSentinel<B, undefined> | BoxifiedWithSentinel<C, undefined>
 
 type T12 = BoxifiedWithSentinel<string, undefined>;
 >T12 : string
@@ -114,7 +114,7 @@ type DeepReadonly<T> = {
 };
 
 type Foo = {
->Foo : Foo
+>Foo : { x: number; y: {    a: string;    b: number;}; z: boolean; }
 
     x: number;
 >x : number
@@ -130,7 +130,7 @@ type Foo = {
 };
 
 type DeepReadonlyFoo = {
->DeepReadonlyFoo : DeepReadonlyFoo
+>DeepReadonlyFoo : { readonly x: number; readonly y: {    readonly a: string;    readonly b: number;}; readonly z: boolean; }
 
     readonly x: number;
 >x : number
@@ -154,7 +154,7 @@ var x1: DeepReadonlyFoo;
 // Repro from #13232
 
 type Z = { a: number };
->Z : Z
+>Z : { a: number; }
 >a : number
 
 type Clone<T> = {
diff --git a/tests/baselines/reference/mappedTypes5.types b/tests/baselines/reference/mappedTypes5.types
index 587f0b0e3ddd3..ba6b43f7a44bf 100644
--- a/tests/baselines/reference/mappedTypes5.types
+++ b/tests/baselines/reference/mappedTypes5.types
@@ -74,7 +74,7 @@ function f<T>(p: Partial<T>, r: Readonly<T>, pr: Partial<Readonly<T>>, rp: Reado
 // Repro from #17682
 
 type State = {
->State : State
+>State : { [key: string]: string | number | boolean | null; }
 
     [key: string]: string | boolean | number | null;
 >key : string
@@ -137,12 +137,12 @@ function doit<T extends State>() {
 }
 
 type State2 = { foo: number, bar: string };
->State2 : State2
+>State2 : { foo: number; bar: string; }
 >foo : number
 >bar : string
 
 type Args3 = {
->Args3 : Args3
+>Args3 : { readonly previous: Readonly<Partial<State2>>; readonly current: Readonly<Partial<State2>>; }
 
     readonly previous: Readonly<Partial<State2>>;
 >previous : Readonly<Partial<State2>>
@@ -153,7 +153,7 @@ type Args3 = {
 };
 
 type Args4 = {
->Args4 : Args4
+>Args4 : { readonly previous: Partial<Readonly<State2>>; readonly current: Partial<Readonly<State2>>; }
 
     readonly previous: Partial<Readonly<State2>>;
 >previous : Partial<Readonly<State2>>
diff --git a/tests/baselines/reference/mappedTypes6.types b/tests/baselines/reference/mappedTypes6.types
index 9c8d5e8a3d7fa..871f6867612bc 100644
--- a/tests/baselines/reference/mappedTypes6.types
+++ b/tests/baselines/reference/mappedTypes6.types
@@ -278,7 +278,7 @@ function f10<T>(x: Readonly<T>, y: T, z: Readwrite<T>) {
 }
 
 type Foo = {
->Foo : Foo
+>Foo : { a: number; b: number | undefined; c?: number | undefined; d?: number | undefined; }
 
     a: number;
 >a : number
@@ -420,7 +420,7 @@ x2 = { a: 1, b: 1, c: 1, d: 1 };
 >1 : 1
 
 type Bar = {
->Bar : Bar
+>Bar : { a: number; readonly b: number; }
 
     a: number;
 >a : number
diff --git a/tests/baselines/reference/mappedTypesArraysTuples.types b/tests/baselines/reference/mappedTypesArraysTuples.types
index 082890b009713..dbd83076d3b2a 100644
--- a/tests/baselines/reference/mappedTypesArraysTuples.types
+++ b/tests/baselines/reference/mappedTypesArraysTuples.types
@@ -58,15 +58,15 @@ type T31 = Partial<Boxified<string[]>>;
 >T31 : (Box<string> | undefined)[]
 
 type A = { a: string };
->A : A
+>A : { a: string; }
 >a : string
 
 type B = { b: string };
->B : B
+>B : { b: string; }
 >b : string
 
 type T40 = Boxified<A | A[] | ReadonlyArray<A> | [A, B] | string | string[]>;
->T40 : T40
+>T40 : string | Box<string>[] | Boxified<A> | readonly Box<A>[] | [Box<A>, Box<B>] | Box<A>[]
 
 type ReadWrite<T> = { -readonly [P in keyof T] : T[P] };
 >ReadWrite : ReadWrite<T>
diff --git a/tests/baselines/reference/mixinAccessModifiers.types b/tests/baselines/reference/mixinAccessModifiers.types
index 9b4cb432ab2e2..c104bfa23570b 100644
--- a/tests/baselines/reference/mixinAccessModifiers.types
+++ b/tests/baselines/reference/mixinAccessModifiers.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/classes/mixinAccessModifiers.ts ===
 type Constructable = new (...args: any[]) => object;
->Constructable : Constructable
+>Constructable : new (...args: any[]) => object
 >args : any[]
 
 class Private {
diff --git a/tests/baselines/reference/namedTupleMembers.types b/tests/baselines/reference/namedTupleMembers.types
index 100eeb0679e85..224c928c5f281 100644
--- a/tests/baselines/reference/namedTupleMembers.types
+++ b/tests/baselines/reference/namedTupleMembers.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/types/tuple/named/namedTupleMembers.ts ===
 export type Segment = [length: number, count: number];
->Segment : Segment
+>Segment : [length: number, count: number]
 
 export type SegmentAnnotated = [
->SegmentAnnotated : SegmentAnnotated
+>SegmentAnnotated : [length: number, count: number]
 
     /** 
      * Size of message buffer segment handles
@@ -88,7 +88,7 @@ d = c;
 >c : [number, number]
 
 export type WithOptAndRest = [first: number, second?: number, ...rest: string[]];
->WithOptAndRest : WithOptAndRest
+>WithOptAndRest : [first: number, second?: number, ...rest: string[]]
 
 export type Func<T extends any[]> = (...x: T) => void;
 >Func : Func<T>
@@ -112,7 +112,7 @@ export function useState<T>(initial: T): [value: T, setter: (T) => void] {
 
 
 export type Iter = Func<[step: number, iterations: number]>;
->Iter : Iter
+>Iter : (step: number, iterations: number) => void
 
 export function readSegment([length, count]: [number, number]) {}
 >readSegment : ([length, count]: [number, number]) => void
@@ -128,10 +128,10 @@ export const val = null as any as Parameters<typeof readSegment>[0];
 >readSegment : ([length, count]: [number, number]) => void
 
 export type RecursiveTupleA = [initial: string, next: RecursiveTupleA];
->RecursiveTupleA : RecursiveTupleA
+>RecursiveTupleA : [initial: string, next: RecursiveTupleA]
 
 export type RecursiveTupleB = [first: string, ptr: RecursiveTupleB];
->RecursiveTupleB : RecursiveTupleB
+>RecursiveTupleB : [first: string, ptr: RecursiveTupleB]
 
 declare var q: RecursiveTupleA;
 >q : RecursiveTupleA
@@ -150,10 +150,10 @@ r = q;
 >q : RecursiveTupleA
 
 export type RecusiveRest = [first: string, ...rest: RecusiveRest[]];
->RecusiveRest : RecusiveRest
+>RecusiveRest : [first: string, ...rest: RecusiveRest[]]
 
 export type RecusiveRest2 = [string, ...RecusiveRest2[]];
->RecusiveRest2 : RecusiveRest2
+>RecusiveRest2 : [string, ...RecusiveRest2[]]
 
 declare var x: RecusiveRest;
 >x : RecusiveRest
diff --git a/tests/baselines/reference/namedTupleMembersErrors.types b/tests/baselines/reference/namedTupleMembersErrors.types
index 0ae16d3b68353..a191b57a718dc 100644
--- a/tests/baselines/reference/namedTupleMembersErrors.types
+++ b/tests/baselines/reference/namedTupleMembersErrors.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts ===
 export type Segment1 = [length: number, number]; // partially named, disallowed
->Segment1 : Segment1
+>Segment1 : [number, number]
 
 export type Segment2 = [number, size: number]; // partially named, disallowed
->Segment2 : Segment2
+>Segment2 : [number, number]
 
 export type List = [item: any, ...any];  // partially named, disallowed
 >List : [any, ...any[]]
@@ -12,22 +12,22 @@ export type List2 = [any, ...remainder: any];  // partially named, disallowed
 >List2 : [any, ...any[]]
 
 export type Pair = [item: any, any?];  // partially named, disallowed
->Pair : Pair
+>Pair : [any, any?]
 
 export type Pair2 = [any, last?: any];  // partially named, disallowed
->Pair2 : Pair2
+>Pair2 : [any, any?]
 
 export type Opt = [element: string?]; // question mark on element disallowed
->Opt : Opt
+>Opt : [element: string]
 
 export type Trailing = [first: string, rest: ...string[]]; // dots on element disallowed
->Trailing : Trailing
+>Trailing : [first: string, rest: string]
 
 export type OptTrailing = [first: string, rest: ...string[]?]; // dots+question on element disallowed
->OptTrailing : OptTrailing
+>OptTrailing : [first: string, rest: string[]]
 
 export type OptRest = [first: string, ...rest?: string[]]; // rest+optional disallowed
->OptRest : OptRest
+>OptRest : [first: string, rest?: string]
 
 export type NonArrayRest = [first: string, ...rest: number]; // non-arraylike rest, disallowed
 >NonArrayRest : [first: string, ...rest: any[]]
diff --git a/tests/baselines/reference/namespaceDisambiguationInUnion.types b/tests/baselines/reference/namespaceDisambiguationInUnion.types
index a7852beebd22f..0c0761699ad12 100644
--- a/tests/baselines/reference/namespaceDisambiguationInUnion.types
+++ b/tests/baselines/reference/namespaceDisambiguationInUnion.types
@@ -1,13 +1,13 @@
 === tests/cases/compiler/namespaceDisambiguationInUnion.ts ===
 namespace Foo {
   export type Yep = { type: "foo.yep" };
->Yep : Yep
+>Yep : { type: "foo.yep"; }
 >type : "foo.yep"
 }
 
 namespace Bar {
   export type Yep = { type: "bar.yep" };
->Yep : Yep
+>Yep : { type: "bar.yep"; }
 >type : "bar.yep"
 }
 
diff --git a/tests/baselines/reference/namespaceMergedWithImportAliasNoCrash.types b/tests/baselines/reference/namespaceMergedWithImportAliasNoCrash.types
index 06f5ecaca0fd5..e470490a32f99 100644
--- a/tests/baselines/reference/namespaceMergedWithImportAliasNoCrash.types
+++ b/tests/baselines/reference/namespaceMergedWithImportAliasNoCrash.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/file1.ts ===
 export namespace Library {
     export type Bar = { a: number };
->Bar : Bar
+>Bar : { a: number; }
 >a : number
 }
 var x: Library.Bar; // should work
diff --git a/tests/baselines/reference/narrowTypeByInstanceof.types b/tests/baselines/reference/narrowTypeByInstanceof.types
index 65b706eea76cd..57427f90fa210 100644
--- a/tests/baselines/reference/narrowTypeByInstanceof.types
+++ b/tests/baselines/reference/narrowTypeByInstanceof.types
@@ -22,7 +22,7 @@
     }
 
 type FileMatchOrMatch = FileMatch | Match;
->FileMatchOrMatch : FileMatchOrMatch
+>FileMatchOrMatch : Match | FileMatch
 
 
 let elementA: FileMatchOrMatch, elementB: FileMatchOrMatch;
diff --git a/tests/baselines/reference/narrowingByDiscriminantInLoop.types b/tests/baselines/reference/narrowingByDiscriminantInLoop.types
index 34c68000850eb..db7a2a59e2532 100644
--- a/tests/baselines/reference/narrowingByDiscriminantInLoop.types
+++ b/tests/baselines/reference/narrowingByDiscriminantInLoop.types
@@ -2,7 +2,7 @@
 // Repro from #9977
 
 type IDLMemberTypes = OperationMemberType | ConstantMemberType;
->IDLMemberTypes : IDLMemberTypes
+>IDLMemberTypes : OperationMemberType | ConstantMemberType
 
 interface IDLTypeDescription {
     origin: string;
diff --git a/tests/baselines/reference/narrowingByTypeofInSwitch.types b/tests/baselines/reference/narrowingByTypeofInSwitch.types
index 2b028aad6bd16..96897cd71de20 100644
--- a/tests/baselines/reference/narrowingByTypeofInSwitch.types
+++ b/tests/baselines/reference/narrowingByTypeofInSwitch.types
@@ -97,7 +97,7 @@ function assertBooleanOrObject(x: boolean | object) {
 }
 
 type Basic = number | boolean | string | symbol | object | Function | undefined;
->Basic : Basic
+>Basic : string | number | boolean | symbol | object | Function | undefined
 
 function testUnion(x: Basic) {
 >testUnion : (x: Basic) => void
@@ -431,11 +431,11 @@ function testExtendsImplicitDefault<T extends Basic>(x: T) {
 }
 
 type L = (x: number) => string;
->L : L
+>L : (x: number) => string
 >x : number
 
 type R = { x: string, y: number }
->R : R
+>R : { x: string; y: number; }
 >x : string
 >y : number
 
diff --git a/tests/baselines/reference/narrowingDestructuring.types b/tests/baselines/reference/narrowingDestructuring.types
index a942e163da860..24ff38a297d56 100644
--- a/tests/baselines/reference/narrowingDestructuring.types
+++ b/tests/baselines/reference/narrowingDestructuring.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/narrowingDestructuring.ts ===
 type X = { kind: "a", a: string } | { kind: "b", b: string }
->X : X
+>X : { kind: "a"; a: string; } | { kind: "b"; b: string; }
 >kind : "a"
 >a : string
 >kind : "b"
@@ -39,7 +39,7 @@ function func<T extends X>(value: T) {
 }
 
 type Z = { kind: "f", f: { a: number, b: string, c: number } }
->Z : Z
+>Z : { kind: "f"; f: {    a: number;    b: string;    c: number;}; } | { kind: "g"; g: {    a: string;    b: number;    c: string;}; }
 >kind : "f"
 >f : { a: number; b: string; c: number; }
 >a : number
diff --git a/tests/baselines/reference/narrowingIntersection.types b/tests/baselines/reference/narrowingIntersection.types
index ba44c888c803b..c6f229e39698d 100644
--- a/tests/baselines/reference/narrowingIntersection.types
+++ b/tests/baselines/reference/narrowingIntersection.types
@@ -1,12 +1,12 @@
 === tests/cases/compiler/narrowingIntersection.ts ===
 // Somehow this being an intersection matters.
 type FooAndBaz = { foo: unknown } & { baz: unknown };
->FooAndBaz : FooAndBaz
+>FooAndBaz : { foo: unknown; } & { baz: unknown; }
 >foo : unknown
 >baz : unknown
 
 type Disjoint =
->Disjoint : Disjoint
+>Disjoint : { readonly value: string; readonly err?: never; } | { readonly value?: never; readonly err: FooAndBaz; }
 
  | { readonly value: string; readonly err?: never; }
 >value : string
@@ -38,7 +38,7 @@ function test1(result: Disjoint): string {
 }
 
 type TrivialIntersection = { a: 1 } & { a: 1 };
->TrivialIntersection : TrivialIntersection
+>TrivialIntersection : { a: 1; } & { a: 1; }
 >a : 1
 >a : 1
 
diff --git a/tests/baselines/reference/narrowingOfQualifiedNames.types b/tests/baselines/reference/narrowingOfQualifiedNames.types
index 59349ce8e18eb..d95620a6dda35 100644
--- a/tests/baselines/reference/narrowingOfQualifiedNames.types
+++ b/tests/baselines/reference/narrowingOfQualifiedNames.types
@@ -261,19 +261,19 @@ function init2(foo: DeepOptional) {
 // Repro from #48289
 
 type Fish = { type: 'fish', hasFins: true }
->Fish : Fish
+>Fish : { type: 'fish'; hasFins: true; }
 >type : "fish"
 >hasFins : true
 >true : true
 
 type Dog = { type: 'dog', saysWoof: true }
->Dog : Dog
+>Dog : { type: 'dog'; saysWoof: true; }
 >type : "dog"
 >saysWoof : true
 >true : true
 
 type Pet = Fish | Dog;
->Pet : Pet
+>Pet : Fish | Dog
 
 function handleDogBroken<PetType extends Pet>(pet: PetType) {
 >handleDogBroken : <PetType extends Pet>(pet: PetType) => void
diff --git a/tests/baselines/reference/narrowingTypeofFunction.types b/tests/baselines/reference/narrowingTypeofFunction.types
index 9342585ddd54e..6290fe95c3782 100644
--- a/tests/baselines/reference/narrowingTypeofFunction.types
+++ b/tests/baselines/reference/narrowingTypeofFunction.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/narrowingTypeofFunction.ts ===
 type Meta = { foo: string }
->Meta : Meta
+>Meta : { foo: string; }
 >foo : string
 
 interface F { (): string }
diff --git a/tests/baselines/reference/nearbyIdenticalGenericLambdasAssignable.types b/tests/baselines/reference/nearbyIdenticalGenericLambdasAssignable.types
index 74b907ee4adad..55fa9e45cdf51 100644
--- a/tests/baselines/reference/nearbyIdenticalGenericLambdasAssignable.types
+++ b/tests/baselines/reference/nearbyIdenticalGenericLambdasAssignable.types
@@ -41,7 +41,7 @@ type TC = typeof fC;
 >fC : <T>() => { v: T; }
 
 type TL = <T>() => { v: T }; 
->TL : TL
+>TL : <T>() => { v: T; }
 >v : T
 
 declare function accA(x: TA): void;
diff --git a/tests/baselines/reference/nestedRecursiveArraysOrObjectsError01.types b/tests/baselines/reference/nestedRecursiveArraysOrObjectsError01.types
index 8b5f5df29012d..26630884d1883 100644
--- a/tests/baselines/reference/nestedRecursiveArraysOrObjectsError01.types
+++ b/tests/baselines/reference/nestedRecursiveArraysOrObjectsError01.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/nestedRecursiveArraysOrObjectsError01.ts ===
 type Style = StyleBase | StyleArray;
->Style : Style
+>Style : StyleBase | StyleArray
 
 interface StyleArray extends Array<Style> {}
 interface StyleBase {
diff --git a/tests/baselines/reference/neverUnionIntersection.types b/tests/baselines/reference/neverUnionIntersection.types
index 4f578052e9c23..5d9085e72e60f 100644
--- a/tests/baselines/reference/neverUnionIntersection.types
+++ b/tests/baselines/reference/neverUnionIntersection.types
@@ -6,7 +6,7 @@ type T02 = string & never;
 >T02 : never
 
 type T03 = string | number | never;
->T03 : T03
+>T03 : string | number
 
 type T04 = string & number & never;
 >T04 : never
diff --git a/tests/baselines/reference/noAsConstNameLookup.types b/tests/baselines/reference/noAsConstNameLookup.types
index 42a06c8530fb2..c90c1e69055f8 100644
--- a/tests/baselines/reference/noAsConstNameLookup.types
+++ b/tests/baselines/reference/noAsConstNameLookup.types
@@ -2,11 +2,11 @@
 // Repros from #44292
 
 type Store = { a: 123 }
->Store : Store
+>Store : { a: 123; }
 >a : 123
 
 export type Cleaner = <W extends Store>(runner: FeatureRunner<W>) => Promise<any>
->Cleaner : Cleaner
+>Cleaner : <W extends Store>(runner: FeatureRunner<W>) => Promise<any>
 >runner : FeatureRunner<W>
 
 export class FeatureRunner<W extends Store> {
diff --git a/tests/baselines/reference/noCrashUMDMergedWithGlobalValue.types b/tests/baselines/reference/noCrashUMDMergedWithGlobalValue.types
index f01fad2560eee..b922f42aaa5a8 100644
--- a/tests/baselines/reference/noCrashUMDMergedWithGlobalValue.types
+++ b/tests/baselines/reference/noCrashUMDMergedWithGlobalValue.types
@@ -3,7 +3,7 @@ export as namespace SomeInterface;
 >SomeInterface : typeof import("/other")
 
 export type Action = "PUSH" | "POP" | "REPLACE";
->Action : Action
+>Action : "PUSH" | "POP" | "REPLACE"
 
 === /main.ts ===
 interface SomeInterface {
diff --git a/tests/baselines/reference/noErrorTruncation.types b/tests/baselines/reference/noErrorTruncation.types
index 53735c04db73d..e1a52900bc589 100644
--- a/tests/baselines/reference/noErrorTruncation.types
+++ b/tests/baselines/reference/noErrorTruncation.types
@@ -2,27 +2,27 @@
 // @noErrorTruncation
 
 type SomeLongOptionA = { someLongOptionA: string }
->SomeLongOptionA : SomeLongOptionA
+>SomeLongOptionA : { someLongOptionA: string; }
 >someLongOptionA : string
 
 type SomeLongOptionB = { someLongOptionB: string }
->SomeLongOptionB : SomeLongOptionB
+>SomeLongOptionB : { someLongOptionB: string; }
 >someLongOptionB : string
 
 type SomeLongOptionC = { someLongOptionC: string }
->SomeLongOptionC : SomeLongOptionC
+>SomeLongOptionC : { someLongOptionC: string; }
 >someLongOptionC : string
 
 type SomeLongOptionD = { someLongOptionD: string }
->SomeLongOptionD : SomeLongOptionD
+>SomeLongOptionD : { someLongOptionD: string; }
 >someLongOptionD : string
 
 type SomeLongOptionE = { someLongOptionE: string }
->SomeLongOptionE : SomeLongOptionE
+>SomeLongOptionE : { someLongOptionE: string; }
 >someLongOptionE : string
 
 type SomeLongOptionF = { someLongOptionF: string }
->SomeLongOptionF : SomeLongOptionF
+>SomeLongOptionF : { someLongOptionF: string; }
 >someLongOptionF : string
 
 const x: SomeLongOptionA
diff --git a/tests/baselines/reference/noImplicitAnyDestructuringInPrivateMethod.types b/tests/baselines/reference/noImplicitAnyDestructuringInPrivateMethod.types
index d2589cb1a46b7..4cf1662402c72 100644
--- a/tests/baselines/reference/noImplicitAnyDestructuringInPrivateMethod.types
+++ b/tests/baselines/reference/noImplicitAnyDestructuringInPrivateMethod.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/noImplicitAnyDestructuringInPrivateMethod.ts ===
 type Arg = {
->Arg : Arg
+>Arg : { a: number; }
 
     a: number;
 >a : number
diff --git a/tests/baselines/reference/noImplicitSymbolToString.types b/tests/baselines/reference/noImplicitSymbolToString.types
index 7111542c4a318..009361a565495 100644
--- a/tests/baselines/reference/noImplicitSymbolToString.types
+++ b/tests/baselines/reference/noImplicitSymbolToString.types
@@ -40,7 +40,7 @@ const templateStrUnion = `union with number ${symbolUnionNumber} and union with
 // Fix #44462
 
 type StringOrSymbol = string | symbol;
->StringOrSymbol : StringOrSymbol
+>StringOrSymbol : string | symbol
 
 function getKey<S extends StringOrSymbol>(key: S) {
 >getKey : <S extends StringOrSymbol>(key: S) => string
diff --git a/tests/baselines/reference/noMappedGetSet.types b/tests/baselines/reference/noMappedGetSet.types
index 1f46980e4b1eb..b22fe1cd742fb 100644
--- a/tests/baselines/reference/noMappedGetSet.types
+++ b/tests/baselines/reference/noMappedGetSet.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/noMappedGetSet.ts ===
 type OH_NO = {
->OH_NO : OH_NO
+>OH_NO : {}
 
     get [K in WAT](): string
 >[K in WAT] : string
diff --git a/tests/baselines/reference/noStrictGenericChecks.types b/tests/baselines/reference/noStrictGenericChecks.types
index a7e09f302b947..ec3a3b118ec5d 100644
--- a/tests/baselines/reference/noStrictGenericChecks.types
+++ b/tests/baselines/reference/noStrictGenericChecks.types
@@ -1,11 +1,11 @@
 === tests/cases/compiler/noStrictGenericChecks.ts ===
 type A = <T, U>(x: T, y: U) => [T, U];
->A : A
+>A : <T, U>(x: T, y: U) => [T, U]
 >x : T
 >y : U
 
 type B = <S>(x: S, y: S) => [S, S];
->B : B
+>B : <S>(x: S, y: S) => [S, S]
 >x : S
 >y : S
 
diff --git a/tests/baselines/reference/noUnusedLocals_selfReference.types b/tests/baselines/reference/noUnusedLocals_selfReference.types
index 6ef7930b4f07a..819ea0743d1c4 100644
--- a/tests/baselines/reference/noUnusedLocals_selfReference.types
+++ b/tests/baselines/reference/noUnusedLocals_selfReference.types
@@ -34,7 +34,7 @@ interface I { x: I };
 >x : I
 
 type T = { x: T };
->T : T
+>T : { x: T; }
 >x : T
 
 namespace N { N; }
diff --git a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmit1(module=node12).types b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmit1(module=node12).types
index 82a46bf9b274c..520761d1b0a01 100644
--- a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmit1(module=node12).types
+++ b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmit1(module=node12).types
@@ -1,6 +1,6 @@
 === /index.ts ===
 export type LocalInterface =
->LocalInterface : LocalInterface
+>LocalInterface : import("/node_modules/pkg/require").RequireInterface & import("/node_modules/pkg/import").ImportInterface
 
     & import("pkg", { assert: {"resolution-mode": "require"} }).RequireInterface
     & import("pkg", { assert: {"resolution-mode": "import"} }).ImportInterface;
diff --git a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmit1(module=nodenext).types b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmit1(module=nodenext).types
index 82a46bf9b274c..520761d1b0a01 100644
--- a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmit1(module=nodenext).types
+++ b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmit1(module=nodenext).types
@@ -1,6 +1,6 @@
 === /index.ts ===
 export type LocalInterface =
->LocalInterface : LocalInterface
+>LocalInterface : import("/node_modules/pkg/require").RequireInterface & import("/node_modules/pkg/import").ImportInterface
 
     & import("pkg", { assert: {"resolution-mode": "require"} }).RequireInterface
     & import("pkg", { assert: {"resolution-mode": "import"} }).ImportInterface;
diff --git a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=node12).types b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=node12).types
index 096b9fe9ee3c5..1b75c0fff241a 100644
--- a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=node12).types
+++ b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=node12).types
@@ -4,7 +4,7 @@ No type information for this code.=== /node_modules/pkg/require.d.ts ===
 export interface RequireInterface {}
 No type information for this code.=== /index.ts ===
 export type LocalInterface =
->LocalInterface : LocalInterface
+>LocalInterface : import("/node_modules/pkg/require").RequireInterface & import("/node_modules/pkg/import").ImportInterface
 
     & import("pkg", { assert: {"resolution-mode": "foobar"} }).RequireInterface
     & import("pkg", { assert: {"resolution-mode": "import"} }).ImportInterface;
@@ -128,12 +128,12 @@ export const b = (null as any as import("pkg", [ {"resolution-mode": "import"} ]
 === /other4.ts ===
 // Indirected assertion objecty-thing - not allowed
 type Asserts1 = { assert: {"resolution-mode": "require"} };
->Asserts1 : Asserts1
+>Asserts1 : { assert: {    "resolution-mode": "require";}; }
 >assert : { "resolution-mode": "require"; }
 >"resolution-mode" : "require"
 
 type Asserts2 = { assert: {"resolution-mode": "import"} };
->Asserts2 : Asserts2
+>Asserts2 : { assert: {    "resolution-mode": "import";}; }
 >assert : { "resolution-mode": "import"; }
 >"resolution-mode" : "import"
 
diff --git a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=nodenext).types b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=nodenext).types
index 096b9fe9ee3c5..1b75c0fff241a 100644
--- a/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=nodenext).types
+++ b/tests/baselines/reference/nodeModulesImportTypeModeDeclarationEmitErrors1(module=nodenext).types
@@ -4,7 +4,7 @@ No type information for this code.=== /node_modules/pkg/require.d.ts ===
 export interface RequireInterface {}
 No type information for this code.=== /index.ts ===
 export type LocalInterface =
->LocalInterface : LocalInterface
+>LocalInterface : import("/node_modules/pkg/require").RequireInterface & import("/node_modules/pkg/import").ImportInterface
 
     & import("pkg", { assert: {"resolution-mode": "foobar"} }).RequireInterface
     & import("pkg", { assert: {"resolution-mode": "import"} }).ImportInterface;
@@ -128,12 +128,12 @@ export const b = (null as any as import("pkg", [ {"resolution-mode": "import"} ]
 === /other4.ts ===
 // Indirected assertion objecty-thing - not allowed
 type Asserts1 = { assert: {"resolution-mode": "require"} };
->Asserts1 : Asserts1
+>Asserts1 : { assert: {    "resolution-mode": "require";}; }
 >assert : { "resolution-mode": "require"; }
 >"resolution-mode" : "require"
 
 type Asserts2 = { assert: {"resolution-mode": "import"} };
->Asserts2 : Asserts2
+>Asserts2 : { assert: {    "resolution-mode": "import";}; }
 >assert : { "resolution-mode": "import"; }
 >"resolution-mode" : "import"
 
diff --git a/tests/baselines/reference/nonGenericTypeReferenceWithTypeArguments.types b/tests/baselines/reference/nonGenericTypeReferenceWithTypeArguments.types
index 6b51828900195..13818f4c99cc3 100644
--- a/tests/baselines/reference/nonGenericTypeReferenceWithTypeArguments.types
+++ b/tests/baselines/reference/nonGenericTypeReferenceWithTypeArguments.types
@@ -9,7 +9,7 @@ enum E { }
 >E : E
 
 type T = { };
->T : T
+>T : {}
 
 var v1: C<string>;
 >v1 : any
diff --git a/tests/baselines/reference/nonNullReferenceMatching.types b/tests/baselines/reference/nonNullReferenceMatching.types
index 03ef70177c07f..04790d328aa05 100644
--- a/tests/baselines/reference/nonNullReferenceMatching.types
+++ b/tests/baselines/reference/nonNullReferenceMatching.types
@@ -1,18 +1,18 @@
 === tests/cases/compiler/nonNullReferenceMatching.ts ===
 type ElementRef = (element: HTMLElement | null) => void;
->ElementRef : ElementRef
+>ElementRef : (element: HTMLElement | null) => void
 >element : HTMLElement | null
 >null : null
 
 type ThumbProps = {
->ThumbProps : ThumbProps
+>ThumbProps : { elementRef?: ElementRef | undefined; }
 
     elementRef?: ElementRef;
 >elementRef : ElementRef | undefined
 }
 
 type ComponentProps = {
->ComponentProps : ComponentProps
+>ComponentProps : { thumbYProps?: ThumbProps | undefined; thumbXProps: ThumbProps; }
 
     thumbYProps?: ThumbProps;
 >thumbYProps : ThumbProps | undefined
diff --git a/tests/baselines/reference/numericEnumMappedType.types b/tests/baselines/reference/numericEnumMappedType.types
index bffec2ed8ca18..ca9d19890a512 100644
--- a/tests/baselines/reference/numericEnumMappedType.types
+++ b/tests/baselines/reference/numericEnumMappedType.types
@@ -14,10 +14,10 @@ declare enum E2 { ONE, TWO, THREE }
 >THREE : E2
 
 type Bins1 = { [k in E1]?: string; }
->Bins1 : Bins1
+>Bins1 : { 0?: string | undefined; 1?: string | undefined; 2?: string | undefined; }
 
 type Bins2 = { [k in E2]?: string; }
->Bins2 : Bins2
+>Bins2 : { [x: number]: string | undefined; }
 
 const b1: Bins1 = {};
 >b1 : Bins1
@@ -91,7 +91,7 @@ enum N2 { C = val(), D = val() }
 >val : () => number
 
 type T1 = { [K in N1 | N2]: K };
->T1 : T1
+>T1 : { [x: number]: N1 | N2; }
 
 // Enum types with string valued members are always literal enum types and therefore
 // ONE and TWO below are not computed members but rather just numerically valued members
diff --git a/tests/baselines/reference/numericLiteralTypes1.types b/tests/baselines/reference/numericLiteralTypes1.types
index 721265816bce7..92eed3cee2a6d 100644
--- a/tests/baselines/reference/numericLiteralTypes1.types
+++ b/tests/baselines/reference/numericLiteralTypes1.types
@@ -39,17 +39,17 @@ function f1() {
 }
 
 type B1 = -1 | 0 | 1;
->B1 : B1
+>B1 : 0 | 1 | -1
 >-1 : -1
 >1 : 1
 
 type B2 = 1 | 0 | -1;
->B2 : B2
+>B2 : 0 | 1 | -1
 >-1 : -1
 >1 : 1
 
 type B3 = 0 | -1 | 1;
->B3 : B3
+>B3 : 0 | 1 | -1
 >-1 : -1
 >1 : 1
 
@@ -260,7 +260,7 @@ function assertNever(x: never): never {
 }
 
 type Tag = 0 | 1 | 2;
->Tag : Tag
+>Tag : 0 | 1 | 2
 
 function f10(x: Tag) {
 >f10 : (x: Tag) => "a" | "b" | "c"
@@ -406,7 +406,7 @@ function f15(x: 0 | false, y: 1 | "one") {
 }
 
 type Item =
->Item : Item
+>Item : { kind: 0; a: string; } | { kind: 1; b: string; } | { kind: 2; c: string; }
 
     { kind: 0, a: string } |
 >kind : 0
diff --git a/tests/baselines/reference/numericLiteralTypes2.types b/tests/baselines/reference/numericLiteralTypes2.types
index 331fe0d43de6e..8842d63a26a61 100644
--- a/tests/baselines/reference/numericLiteralTypes2.types
+++ b/tests/baselines/reference/numericLiteralTypes2.types
@@ -39,17 +39,17 @@ function f1() {
 }
 
 type B1 = -1 | 0 | 1;
->B1 : B1
+>B1 : 0 | 1 | -1
 >-1 : -1
 >1 : 1
 
 type B2 = 1 | 0 | -1;
->B2 : B2
+>B2 : 0 | 1 | -1
 >-1 : -1
 >1 : 1
 
 type B3 = 0 | -1 | 1;
->B3 : B3
+>B3 : 0 | 1 | -1
 >-1 : -1
 >1 : 1
 
@@ -260,7 +260,7 @@ function assertNever(x: never): never {
 }
 
 type Tag = 0 | 1 | 2;
->Tag : Tag
+>Tag : 0 | 1 | 2
 
 function f10(x: Tag) {
 >f10 : (x: Tag) => "a" | "b" | "c"
@@ -406,7 +406,7 @@ function f15(x: 0 | false, y: 1 | "one") {
 }
 
 type Item =
->Item : Item
+>Item : { kind: 0; a: string; } | { kind: 1; b: string; } | { kind: 2; c: string; }
 
     { kind: 0, a: string } |
 >kind : 0
diff --git a/tests/baselines/reference/numericLiteralTypes3.types b/tests/baselines/reference/numericLiteralTypes3.types
index cf545192a27b9..ed2f8dfce077a 100644
--- a/tests/baselines/reference/numericLiteralTypes3.types
+++ b/tests/baselines/reference/numericLiteralTypes3.types
@@ -3,13 +3,13 @@ type A = 1;
 >A : 1
 
 type B = 2 | 3;
->B : B
+>B : 2 | 3
 
 type C = 1 | 2 | 3;
->C : C
+>C : 2 | 3 | 1
 
 type D = 0 | 1 | 2;
->D : D
+>D : 0 | 2 | 1
 
 function f1(a: A, b: B, c: C, d: D) {
 >f1 : (a: A, b: B, c: C, d: D) => void
diff --git a/tests/baselines/reference/objectInstantiationFromUnionSpread.types b/tests/baselines/reference/objectInstantiationFromUnionSpread.types
index 3061622551c3f..d9b83cdad64ea 100644
--- a/tests/baselines/reference/objectInstantiationFromUnionSpread.types
+++ b/tests/baselines/reference/objectInstantiationFromUnionSpread.types
@@ -14,7 +14,7 @@ interface Fail {
 }
 
 type Item = Success | Fail;
->Item : Item
+>Item : Success | Fail
 
 function f1(a: Item[]) {
 >f1 : (a: Item[]) => void
diff --git a/tests/baselines/reference/objectLiteralEnumPropertyNames.types b/tests/baselines/reference/objectLiteralEnumPropertyNames.types
index f3efed1488468..785b9cdbc0c11 100644
--- a/tests/baselines/reference/objectLiteralEnumPropertyNames.types
+++ b/tests/baselines/reference/objectLiteralEnumPropertyNames.types
@@ -12,7 +12,7 @@ enum Strs {
 >'b' : "b"
 }
 type TestStrs = { [key in Strs]: string }
->TestStrs : TestStrs
+>TestStrs : { a: string; b: string; }
 
 const x: TestStrs = {
 >x : TestStrs
@@ -111,7 +111,7 @@ enum Nums {
 >B : Nums.B
 }
 type TestNums = { 0: number, 1: number }
->TestNums : TestNums
+>TestNums : { 0: number; 1: number; }
 >0 : number
 >1 : number
 
diff --git a/tests/baselines/reference/objectRestReadonly.types b/tests/baselines/reference/objectRestReadonly.types
index 5f015aeb1e5f5..12fbb268326bb 100644
--- a/tests/baselines/reference/objectRestReadonly.types
+++ b/tests/baselines/reference/objectRestReadonly.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/rest/objectRestReadonly.ts ===
 // #23734
 type ObjType = {
->ObjType : ObjType
+>ObjType : { foo: string; baz: string; quux: string; }
 
   foo: string
 >foo : string
diff --git a/tests/baselines/reference/objectSpread.types b/tests/baselines/reference/objectSpread.types
index 7fd7675d1d73d..6f81f24c40d9e 100644
--- a/tests/baselines/reference/objectSpread.types
+++ b/tests/baselines/reference/objectSpread.types
@@ -168,7 +168,7 @@ let spreadFunc = { ...(function () { }) };
 >function () { } : () => void
 
 type Header = { head: string, body: string, authToken: string }
->Header : Header
+>Header : { head: string; body: string; authToken: string; }
 >head : string
 >body : string
 >authToken : string
diff --git a/tests/baselines/reference/objectSpreadStrictNull.types b/tests/baselines/reference/objectSpreadStrictNull.types
index 05e50a2145861..fb433b4b1abfa 100644
--- a/tests/baselines/reference/objectSpreadStrictNull.types
+++ b/tests/baselines/reference/objectSpreadStrictNull.types
@@ -86,7 +86,7 @@ function f(
 }
 
 type Movie = {
->Movie : Movie
+>Movie : { title: string; yearReleased: number; }
 
     title: string;
 >title : string
diff --git a/tests/baselines/reference/objectTypeWithStringAndNumberIndexSignatureToAny.types b/tests/baselines/reference/objectTypeWithStringAndNumberIndexSignatureToAny.types
index 5c2efdc2bc007..144f552bca3aa 100644
--- a/tests/baselines/reference/objectTypeWithStringAndNumberIndexSignatureToAny.types
+++ b/tests/baselines/reference/objectTypeWithStringAndNumberIndexSignatureToAny.types
@@ -176,7 +176,7 @@ function f2(sToAny: StringTo<any>, nToAny: NumberTo<any>, bothToAny: StringTo<an
 }
 
 type NumberToNumber = NumberTo<number>;
->NumberToNumber : NumberToNumber
+>NumberToNumber : NumberTo<number>
 
 interface StringToAnyNumberToNumber extends StringTo<any>, NumberToNumber {
 }
diff --git a/tests/baselines/reference/omitTypeHelperModifiers01.types b/tests/baselines/reference/omitTypeHelperModifiers01.types
index b1962065e4b8c..e956f06352f64 100644
--- a/tests/baselines/reference/omitTypeHelperModifiers01.types
+++ b/tests/baselines/reference/omitTypeHelperModifiers01.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/omitTypeHelperModifiers01.ts ===
 type A = {
->A : A
+>A : { a: number; b?: string | undefined; readonly c: boolean; d: unknown; }
 
     a: number;
 >a : number
@@ -17,7 +17,7 @@ type A = {
 };
 
 type B = Omit<A, 'a'>;
->B : B
+>B : { b?: string | undefined; readonly c: boolean; d: unknown; }
 
 function f(x: B) {
 >f : (x: B) => void
diff --git a/tests/baselines/reference/omitTypeTestErrors01.types b/tests/baselines/reference/omitTypeTestErrors01.types
index b6758505eff96..f341e33cc0640 100644
--- a/tests/baselines/reference/omitTypeTestErrors01.types
+++ b/tests/baselines/reference/omitTypeTestErrors01.types
@@ -11,10 +11,10 @@ interface Foo {
 }
 
 export type Bar = Omit<Foo, "c">;
->Bar : Bar
+>Bar : { a: string; b: number; }
 
 export type Baz = Omit<Foo, "b" | "c">;
->Baz : Baz
+>Baz : { a: string; }
 
 export function getBarC(bar: Bar) {
 >getBarC : (bar: Bar) => any
diff --git a/tests/baselines/reference/omitTypeTests01.types b/tests/baselines/reference/omitTypeTests01.types
index 10feea46871c3..6a270844af5b5 100644
--- a/tests/baselines/reference/omitTypeTests01.types
+++ b/tests/baselines/reference/omitTypeTests01.types
@@ -11,10 +11,10 @@ interface Foo {
 }
 
 export type Bar = Omit<Foo, "c">;
->Bar : Bar
+>Bar : { a: string; b: number; }
 
 export type Baz = Omit<Foo, "b" | "c">;
->Baz : Baz
+>Baz : { a: string; }
 
 export function getBarA(bar: Bar) {
 >getBarA : (bar: Bar) => string
diff --git a/tests/baselines/reference/operatorsAndIntersectionTypes.types b/tests/baselines/reference/operatorsAndIntersectionTypes.types
index 5e5765d66f7ce..4be6d56e137c8 100644
--- a/tests/baselines/reference/operatorsAndIntersectionTypes.types
+++ b/tests/baselines/reference/operatorsAndIntersectionTypes.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/types/intersection/operatorsAndIntersectionTypes.ts ===
 type Guid = string & { $Guid };          // Tagged string type
->Guid : Guid
+>Guid : string & { $Guid: any; }
 >$Guid : any
 
 type SerialNo = number & { $SerialNo };  // Tagged number type
->SerialNo : SerialNo
+>SerialNo : number & { $SerialNo: any; }
 >$SerialNo : any
 
 function createGuid() {
diff --git a/tests/baselines/reference/optionalTupleElements1.types b/tests/baselines/reference/optionalTupleElements1.types
index b784bf72e5843..9b811bfe3a554 100644
--- a/tests/baselines/reference/optionalTupleElements1.types
+++ b/tests/baselines/reference/optionalTupleElements1.types
@@ -1,15 +1,15 @@
 === tests/cases/conformance/types/tuple/optionalTupleElements1.ts ===
 type T1 = [number, string, boolean];
->T1 : T1
+>T1 : [number, string, boolean]
 
 type T2 = [number, string, boolean?];
->T2 : T2
+>T2 : [number, string, (boolean | undefined)?]
 
 type T3 = [number, string?, boolean?];
->T3 : T3
+>T3 : [number, (string | undefined)?, (boolean | undefined)?]
 
 type T4 = [number?, string?, boolean?];
->T4 : T4
+>T4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
 
 type L1 = T1["length"];
 >L1 : 3
@@ -24,7 +24,7 @@ type L4 = T4["length"];
 >L4 : 0 | 3 | 2 | 1
 
 type T5 = [number, string?, boolean];  // Error
->T5 : T5
+>T5 : [number, (string | undefined)?, boolean]
 
 function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
 >f1 : (t1: T1, t2: T2, t3: T3, t4: T4) => void
diff --git a/tests/baselines/reference/override19.types b/tests/baselines/reference/override19.types
index 6bf2567393d79..9868b696cb7d9 100644
--- a/tests/baselines/reference/override19.types
+++ b/tests/baselines/reference/override19.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/override/override19.ts ===
 type Foo = abstract new(...args: any) => any;
->Foo : Foo
+>Foo : abstract new (...args: any) => any
 >args : any
 
 declare function CreateMixin<C extends Foo, T extends Foo>(Context: C, Base: T): T & {
diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.types b/tests/baselines/reference/parenthesizedContexualTyping1.types
index 30c8dab626240..95f8a42f51fd0 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping1.types
+++ b/tests/baselines/reference/parenthesizedContexualTyping1.types
@@ -240,7 +240,7 @@ var lambda2: (x: number) => number = (x => x);
 >x : number
 
 type ObjType = { x: (p: number) => string; y: (p: string) => number };
->ObjType : ObjType
+>ObjType : { x: (p: number) => string; y: (p: string) => number; }
 >x : (p: number) => string
 >p : number
 >y : (p: string) => number
diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.types b/tests/baselines/reference/parenthesizedContexualTyping2.types
index d8927c336d09d..96f41e54af74b 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping2.types
+++ b/tests/baselines/reference/parenthesizedContexualTyping2.types
@@ -6,7 +6,7 @@
 // back if contextual typing is not taking effect.
 
 type FuncType = (x: <T>(p: T) => T) => typeof x;
->FuncType : FuncType
+>FuncType : (x: <T>(p: T) => T) => <T>(p: T) => T
 >x : <T>(p: T) => T
 >p : T
 >x : <T>(p: T) => T
@@ -303,7 +303,7 @@ var lambda2: FuncType = (x => { x<number>(undefined); return x; });
 >x : <T>(p: T) => T
 
 type ObjType = { x: (p: number) => string; y: (p: string) => number };
->ObjType : ObjType
+>ObjType : { x: (p: number) => string; y: (p: string) => number; }
 >x : (p: number) => string
 >p : number
 >y : (p: string) => number
diff --git a/tests/baselines/reference/parseErrorIncorrectReturnToken.types b/tests/baselines/reference/parseErrorIncorrectReturnToken.types
index 90734ed68ced5..d29fc4ae6cfd6 100644
--- a/tests/baselines/reference/parseErrorIncorrectReturnToken.types
+++ b/tests/baselines/reference/parseErrorIncorrectReturnToken.types
@@ -1,12 +1,12 @@
 === tests/cases/compiler/parseErrorIncorrectReturnToken.ts ===
 type F1 = {
->F1 : F1
+>F1 : (n: number) => string
 
     (n: number) => string; // should be : not =>
 >n : number
 }
 type F2 = (n: number): string; // should be => not :
->F2 : F2
+>F2 : (n: number) => any
 >n : number
 >string : any
 
diff --git a/tests/baselines/reference/partialDiscriminatedUnionMemberHasGoodError.types b/tests/baselines/reference/partialDiscriminatedUnionMemberHasGoodError.types
index 5b1277374e464..466ed724fea32 100644
--- a/tests/baselines/reference/partialDiscriminatedUnionMemberHasGoodError.types
+++ b/tests/baselines/reference/partialDiscriminatedUnionMemberHasGoodError.types
@@ -16,7 +16,7 @@ interface TypeB {
 }
 
 type ValidType = TypeA | TypeB;
->ValidType : ValidType
+>ValidType : TypeA | TypeB
 
 interface Wrapper {
     types: ValidType[];
diff --git a/tests/baselines/reference/partialTypeNarrowedToByTypeGuard.types b/tests/baselines/reference/partialTypeNarrowedToByTypeGuard.types
index bbf8f96904b8a..eeea96cc13722 100644
--- a/tests/baselines/reference/partialTypeNarrowedToByTypeGuard.types
+++ b/tests/baselines/reference/partialTypeNarrowedToByTypeGuard.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/partialTypeNarrowedToByTypeGuard.ts ===
 type Obj = {} | undefined;
->Obj : Obj
+>Obj : {} | undefined
 
 type User = {
->User : User
+>User : { email: string; name: string; }
 
     email: string;
 >email : string
diff --git a/tests/baselines/reference/partiallyDiscriminantedUnions.types b/tests/baselines/reference/partiallyDiscriminantedUnions.types
index f1d44249c0eb2..bc2ee1bf23586 100644
--- a/tests/baselines/reference/partiallyDiscriminantedUnions.types
+++ b/tests/baselines/reference/partiallyDiscriminantedUnions.types
@@ -26,7 +26,7 @@ interface B {
 }
 
 type AB = A1 | A2 | B;
->AB : AB
+>AB : A1 | A2 | B
 
 const ab: AB = <AB>{};
 >ab : AB
@@ -65,10 +65,10 @@ class Circle { kind: "circle"; }
 >kind : "circle"
 
 type Shape = Circle | Square;
->Shape : Shape
+>Shape : Square | Circle
 
 type Shapes = Shape | Array<Shape>;
->Shapes : Shapes
+>Shapes : Shape | Shape[]
 
 function isShape(s : Shapes): s is Shape {
 >isShape : (s: Shapes) => s is Shape
diff --git a/tests/baselines/reference/preserveUnusedImports.types b/tests/baselines/reference/preserveUnusedImports.types
index e4e32ebb27ebb..83816ebf24600 100644
--- a/tests/baselines/reference/preserveUnusedImports.types
+++ b/tests/baselines/reference/preserveUnusedImports.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/a.ts ===
 export type A = {};
->A : A
+>A : {}
 
 === tests/cases/compiler/b.ts ===
 export class B {}
diff --git a/tests/baselines/reference/preserveValueImports_errors(isolatedmodules=false).types b/tests/baselines/reference/preserveValueImports_errors(isolatedmodules=false).types
index 1e8a912ed7ced..15803ab5c919f 100644
--- a/tests/baselines/reference/preserveValueImports_errors(isolatedmodules=false).types
+++ b/tests/baselines/reference/preserveValueImports_errors(isolatedmodules=false).types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/externalModules/typeOnly/a.ts ===
 export type A = {};
->A : A
+>A : {}
 
 export type { A as default };
 >A : any
diff --git a/tests/baselines/reference/preserveValueImports_errors(isolatedmodules=true).types b/tests/baselines/reference/preserveValueImports_errors(isolatedmodules=true).types
index 1e8a912ed7ced..15803ab5c919f 100644
--- a/tests/baselines/reference/preserveValueImports_errors(isolatedmodules=true).types
+++ b/tests/baselines/reference/preserveValueImports_errors(isolatedmodules=true).types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/externalModules/typeOnly/a.ts ===
 export type A = {};
->A : A
+>A : {}
 
 export type { A as default };
 >A : any
diff --git a/tests/baselines/reference/primitiveUnionDetection.types b/tests/baselines/reference/primitiveUnionDetection.types
index ac2243d80d4aa..03e1ed19884f4 100644
--- a/tests/baselines/reference/primitiveUnionDetection.types
+++ b/tests/baselines/reference/primitiveUnionDetection.types
@@ -2,7 +2,7 @@
 // Repro from #46624
 
 type Kind = "one" | "two" | "three";
->Kind : Kind
+>Kind : "one" | "two" | "three"
 
 declare function getInterfaceFromString<T extends Kind>(options?: { type?: T } & { type?: Kind }): T;
 >getInterfaceFromString : <T extends Kind>(options?: ({ type?: T | undefined; } & { type?: Kind | undefined; }) | undefined) => T
diff --git a/tests/baselines/reference/privateNameAndPropertySignature.types b/tests/baselines/reference/privateNameAndPropertySignature.types
index 3ff962d53e007..9e15556d098f9 100644
--- a/tests/baselines/reference/privateNameAndPropertySignature.types
+++ b/tests/baselines/reference/privateNameAndPropertySignature.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/classes/members/privateNames/privateNameAndPropertySignature.ts ===
 type A = {
->A : A
+>A : {}
 
     #foo: string;
 >#foo : string
diff --git a/tests/baselines/reference/privatePropertyInUnion.types b/tests/baselines/reference/privatePropertyInUnion.types
index 8a618b09e063a..1bc4ea394773a 100644
--- a/tests/baselines/reference/privatePropertyInUnion.types
+++ b/tests/baselines/reference/privatePropertyInUnion.types
@@ -2,7 +2,7 @@
 // Repro from #38236
 
 type Type = string | object;
->Type : Type
+>Type : string | object
 
 class SyncableObject {
 >SyncableObject : SyncableObject
diff --git a/tests/baselines/reference/propTypeValidatorInference.types b/tests/baselines/reference/propTypeValidatorInference.types
index be23e8eecb6cc..ed705dbd73061 100644
--- a/tests/baselines/reference/propTypeValidatorInference.types
+++ b/tests/baselines/reference/propTypeValidatorInference.types
@@ -275,12 +275,12 @@ const propTypesWithoutAnnotation = {
 };
 
 type ExtractedProps = PropTypes.InferProps<typeof propTypes>;
->ExtractedProps : ExtractedProps
+>ExtractedProps : PropTypes.InferPropsInner<Pick<PropTypes.ValidationMap<Props>, PropTypes.RequiredKeys<PropTypes.ValidationMap<Props>>>> & Partial<PropTypes.InferPropsInner<Pick<PropTypes.ValidationMap<Props>, "any">>>
 >PropTypes : any
 >propTypes : PropTypes.ValidationMap<Props>
 
 type ExtractedPropsWithoutAnnotation = PropTypes.InferProps<typeof propTypesWithoutAnnotation>;
->ExtractedPropsWithoutAnnotation : ExtractedPropsWithoutAnnotation
+>ExtractedPropsWithoutAnnotation : PropTypes.InferPropsInner<Pick<{ any: PropTypes.Requireable<any>; array: PropTypes.Validator<any[]>; bool: PropTypes.Validator<boolean>; shape: PropTypes.Validator<PropTypes.InferProps<{ foo: PropTypes.Validator<string>; bar: PropTypes.Requireable<boolean>; baz: PropTypes.Requireable<any>; }>>; oneOfType: PropTypes.Validator<string | boolean | PropTypes.InferProps<{ foo: PropTypes.Requireable<string>; bar: PropTypes.Validator<number>; }>>; }, PropTypes.RequiredKeys<{ any: PropTypes.Requireable<any>; array: PropTypes.Validator<any[]>; bool: PropTypes.Validator<boolean>; shape: PropTypes.Validator<PropTypes.InferProps<{ foo: PropTypes.Validator<string>; bar: PropTypes.Requireable<boolean>; baz: PropTypes.Requireable<any>; }>>; oneOfType: PropTypes.Validator<string | boolean | PropTypes.InferProps<{ foo: PropTypes.Requireable<string>; bar: PropTypes.Validator<number>; }>>; }>>> & Partial<PropTypes.InferPropsInner<Pick<{ any: PropTypes.Requireable<any>; array: PropTypes.Validator<any[]>; bool: PropTypes.Validator<boolean>; shape: PropTypes.Validator<PropTypes.InferProps<{ foo: PropTypes.Validator<string>; bar: PropTypes.Requireable<boolean>; baz: PropTypes.Requireable<any>; }>>; oneOfType: PropTypes.Validator<string | boolean | PropTypes.InferProps<{ foo: PropTypes.Requireable<string>; bar: PropTypes.Validator<number>; }>>; }, "any">>>
 >PropTypes : any
 >propTypesWithoutAnnotation : { any: PropTypes.Requireable<any>; array: PropTypes.Validator<any[]>; bool: PropTypes.Validator<boolean>; shape: PropTypes.Validator<PropTypes.InferProps<{ foo: PropTypes.Validator<string>; bar: PropTypes.Requireable<boolean>; baz: PropTypes.Requireable<any>; }>>; oneOfType: PropTypes.Validator<string | boolean | PropTypes.InferProps<{ foo: PropTypes.Requireable<string>; bar: PropTypes.Validator<number>; }>>; }
 
diff --git a/tests/baselines/reference/quickinfoTypeAtReturnPositionsInaccurate.types b/tests/baselines/reference/quickinfoTypeAtReturnPositionsInaccurate.types
index 1782050b8f261..e0d62f6f5324c 100644
--- a/tests/baselines/reference/quickinfoTypeAtReturnPositionsInaccurate.types
+++ b/tests/baselines/reference/quickinfoTypeAtReturnPositionsInaccurate.types
@@ -102,7 +102,7 @@ class SimpleStore<Entries extends { [index: string]: NumClass<number> | StrClass
 }
 
 type Slice = {
->Slice : Slice
+>Slice : { [index: string]: NumClass<number> | StrClass<string>; }
 
     [index: string]: NumClass<number> | StrClass<string>
 >index : string
diff --git a/tests/baselines/reference/ramdaToolsNoInfinite.types b/tests/baselines/reference/ramdaToolsNoInfinite.types
index f655e100c3009..36d923f338ae0 100644
--- a/tests/baselines/reference/ramdaToolsNoInfinite.types
+++ b/tests/baselines/reference/ramdaToolsNoInfinite.types
@@ -143,7 +143,7 @@ declare namespace Tools {
 
 declare namespace R {
     export type Placeholder = { __placeholder: void };
->Placeholder : Placeholder
+>Placeholder : { __placeholder: void; }
 >__placeholder : void
 }
 
diff --git a/tests/baselines/reference/ramdaToolsNoInfinite2.types b/tests/baselines/reference/ramdaToolsNoInfinite2.types
index b61d0ef3754fa..82a6a3cd6f245 100644
--- a/tests/baselines/reference/ramdaToolsNoInfinite2.types
+++ b/tests/baselines/reference/ramdaToolsNoInfinite2.types
@@ -99,7 +99,7 @@ declare module "Boolean/Boolean" {
 >"Boolean/Boolean" : typeof import("Boolean/Boolean")
 
     export type Boolean = True | False;
->Boolean : Boolean
+>Boolean : 0 | 1
 
     export type True = 1;
 >True : 1
@@ -161,7 +161,7 @@ declare module "Any/_Internal" {
 >_NumberOf : any
 
     export type Match = 'default' | 'implements->' | '<-implements' | 'extends->' | '<-extends' | 'equals';
->Match : Match
+>Match : "default" | "implements->" | "<-implements" | "extends->" | "<-extends" | "equals"
 
     export type NumberOf<N extends any> = N extends number ? _NumberOf<N> : N;
 >NumberOf : NumberOf<N>
@@ -179,7 +179,7 @@ declare module "Any/Key" {
 >"Any/Key" : typeof import("Any/Key")
 
     export type Key = string | number | symbol;
->Key : Key
+>Key : string | number | symbol
 }
 declare module "Union/Keys" {
 >"Union/Keys" : typeof import("Union/Keys")
@@ -409,19 +409,19 @@ declare module "Number/_Internal" {
 >Format : any
 
     export type Formats = 'b' | 'n' | 's';
->Formats : Formats
+>Formats : "n" | "s" | "b"
 
     type KnownIterationMapKeys = '-40' | '-39' | '-38' | '-37' | '-36' | '-35' | '-34' | '-33' | '-32' | '-31' | '-30' | '-29' | '-28' | '-27' | '-26' | '-25' | '-24' | '-23' | '-22' | '-21' | '-20' | '-19' | '-18' | '-17' | '-16' | '-15' | '-14' | '-13' | '-12' | '-11' | '-10' | '-9' | '-8' | '-7' | '-6' | '-5' | '-4' | '-3' | '-2' | '-1' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '13' | '14' | '15' | '16' | '17' | '18' | '19' | '20' | '21' | '22' | '23' | '24' | '25' | '26' | '27' | '28' | '29' | '30' | '31' | '32' | '33' | '34' | '35' | '36' | '37' | '38' | '39' | '40';
->KnownIterationMapKeys : KnownIterationMapKeys
+>KnownIterationMapKeys : "-40" | "-39" | "-38" | "-37" | "-36" | "-35" | "-34" | "-33" | "-32" | "-31" | "-30" | "-29" | "-28" | "-27" | "-26" | "-25" | "-24" | "-23" | "-22" | "-21" | "-20" | "-19" | "-18" | "-17" | "-16" | "-15" | "-14" | "-13" | "-12" | "-11" | "-10" | "-9" | "-8" | "-7" | "-6" | "-5" | "-4" | "-3" | "-2" | "-1" | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "22" | "23" | "24" | "25" | "26" | "27" | "28" | "29" | "30" | "31" | "32" | "33" | "34" | "35" | "36" | "37" | "38" | "39" | "40"
 
     type PositiveIterationKeys = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '13' | '14' | '15' | '16' | '17' | '18' | '19' | '20' | '21' | '22' | '23' | '24' | '25' | '26' | '27' | '28' | '29' | '30' | '31' | '32' | '33' | '34' | '35' | '36' | '37' | '38' | '39' | '40';
->PositiveIterationKeys : PositiveIterationKeys
+>PositiveIterationKeys : "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "22" | "23" | "24" | "25" | "26" | "27" | "28" | "29" | "30" | "31" | "32" | "33" | "34" | "35" | "36" | "37" | "38" | "39" | "40"
 
     type NegativeIterationKeys = '-40' | '-39' | '-38' | '-37' | '-36' | '-35' | '-34' | '-33' | '-32' | '-31' | '-30' | '-29' | '-28' | '-27' | '-26' | '-25' | '-24' | '-23' | '-22' | '-21' | '-20' | '-19' | '-18' | '-17' | '-16' | '-15' | '-14' | '-13' | '-12' | '-11' | '-10' | '-9' | '-8' | '-7' | '-6' | '-5' | '-4' | '-3' | '-2' | '-1';
->NegativeIterationKeys : NegativeIterationKeys
+>NegativeIterationKeys : "-40" | "-39" | "-38" | "-37" | "-36" | "-35" | "-34" | "-33" | "-32" | "-31" | "-30" | "-29" | "-28" | "-27" | "-26" | "-25" | "-24" | "-23" | "-22" | "-21" | "-20" | "-19" | "-18" | "-17" | "-16" | "-15" | "-14" | "-13" | "-12" | "-11" | "-10" | "-9" | "-8" | "-7" | "-6" | "-5" | "-4" | "-3" | "-2" | "-1"
 
     export type Numbers = {
->Numbers : Numbers
+>Numbers : { string: {    'all': Format<IterationMap[KnownIterationMapKeys], 's'>;    '+': Format<IterationMap[PositiveIterationKeys], 's'>;    '-': Format<IterationMap[NegativeIterationKeys], 's'>;    '0': Format<IterationMap['0'], 's'>;}; number: {    'all': Format<IterationMap[KnownIterationMapKeys], 'n'>;    '+': Format<IterationMap[PositiveIterationKeys], 'n'>;    '-': Format<IterationMap[NegativeIterationKeys], 'n'>;    '0': Format<IterationMap['0'], 'n'>;}; }
 
         'string': {
 >'string' : { all: Format<IterationMap[KnownIterationMapKeys], 's'>; '+': Format<IterationMap[PositiveIterationKeys], 's'>; '-': Format<IterationMap[NegativeIterationKeys], 's'>; '0': Format<IterationMap['0'], 's'>; }
@@ -467,10 +467,10 @@ declare module "Iteration/_Internal" {
 >"Iteration/_Internal" : typeof import("Iteration/_Internal")
 
     export type Formats = 'n' | 's';
->Formats : Formats
+>Formats : "n" | "s"
 
     export type Way = '->' | '<-';
->Way : Way
+>Way : "->" | "<-"
 }
 declare module "List/Prepend" {
 >"List/Prepend" : typeof import("List/Prepend")
@@ -801,10 +801,10 @@ declare module "Object/_Internal" {
 >"Object/_Internal" : typeof import("Object/_Internal")
 
     export type Modx = ['?' | '!', 'W' | 'R'];
->Modx : Modx
+>Modx : ["?" | "!", "W" | "R"]
 
     export type Depth = 'flat' | 'deep';
->Depth : Depth
+>Depth : "flat" | "deep"
 
     export type Empty<O extends object> = {
 >Empty : Empty<O>
@@ -819,7 +819,7 @@ declare module "Iteration/IterationOf" {
 >Number : any
 
     export type IterationMap = {
->IterationMap : IterationMap
+>IterationMap : { '-40': ['__', '-39', '-40', -40, '-']; '-39': ['-40', '-38', '-39', -39, '-']; '-38': ['-39', '-37', '-38', -38, '-']; '-37': ['-38', '-36', '-37', -37, '-']; '-36': ['-37', '-35', '-36', -36, '-']; '-35': ['-36', '-34', '-35', -35, '-']; '-34': ['-35', '-33', '-34', -34, '-']; '-33': ['-34', '-32', '-33', -33, '-']; '-32': ['-33', '-31', '-32', -32, '-']; '-31': ['-32', '-30', '-31', -31, '-']; '-30': ['-31', '-29', '-30', -30, '-']; '-29': ['-30', '-28', '-29', -29, '-']; '-28': ['-29', '-27', '-28', -28, '-']; '-27': ['-28', '-26', '-27', -27, '-']; '-26': ['-27', '-25', '-26', -26, '-']; '-25': ['-26', '-24', '-25', -25, '-']; '-24': ['-25', '-23', '-24', -24, '-']; '-23': ['-24', '-22', '-23', -23, '-']; '-22': ['-23', '-21', '-22', -22, '-']; '-21': ['-22', '-20', '-21', -21, '-']; '-20': ['-21', '-19', '-20', -20, '-']; '-19': ['-20', '-18', '-19', -19, '-']; '-18': ['-19', '-17', '-18', -18, '-']; '-17': ['-18', '-16', '-17', -17, '-']; '-16': ['-17', '-15', '-16', -16, '-']; '-15': ['-16', '-14', '-15', -15, '-']; '-14': ['-15', '-13', '-14', -14, '-']; '-13': ['-14', '-12', '-13', -13, '-']; '-12': ['-13', '-11', '-12', -12, '-']; '-11': ['-12', '-10', '-11', -11, '-']; '-10': ['-11', '-9', '-10', -10, '-']; '-9': ['-10', '-8', '-9', -9, '-']; '-8': ['-9', '-7', '-8', -8, '-']; '-7': ['-8', '-6', '-7', -7, '-']; '-6': ['-7', '-5', '-6', -6, '-']; '-5': ['-6', '-4', '-5', -5, '-']; '-4': ['-5', '-3', '-4', -4, '-']; '-3': ['-4', '-2', '-3', -3, '-']; '-2': ['-3', '-1', '-2', -2, '-']; '-1': ['-2', '0', '-1', -1, '-']; '0': ['-1', '1', '0', 0, '0']; '1': ['0', '2', '1', 1, '+']; '2': ['1', '3', '2', 2, '+']; '3': ['2', '4', '3', 3, '+']; '4': ['3', '5', '4', 4, '+']; '5': ['4', '6', '5', 5, '+']; '6': ['5', '7', '6', 6, '+']; '7': ['6', '8', '7', 7, '+']; '8': ['7', '9', '8', 8, '+']; '9': ['8', '10', '9', 9, '+']; '10': ['9', '11', '10', 10, '+']; '11': ['10', '12', '11', 11, '+']; '12': ['11', '13', '12', 12, '+']; '13': ['12', '14', '13', 13, '+']; '14': ['13', '15', '14', 14, '+']; '15': ['14', '16', '15', 15, '+']; '16': ['15', '17', '16', 16, '+']; '17': ['16', '18', '17', 17, '+']; '18': ['17', '19', '18', 18, '+']; '19': ['18', '20', '19', 19, '+']; '20': ['19', '21', '20', 20, '+']; '21': ['20', '22', '21', 21, '+']; '22': ['21', '23', '22', 22, '+']; '23': ['22', '24', '23', 23, '+']; '24': ['23', '25', '24', 24, '+']; '25': ['24', '26', '25', 25, '+']; '26': ['25', '27', '26', 26, '+']; '27': ['26', '28', '27', 27, '+']; '28': ['27', '29', '28', 28, '+']; '29': ['28', '30', '29', 29, '+']; '30': ['29', '31', '30', 30, '+']; '31': ['30', '32', '31', 31, '+']; '32': ['31', '33', '32', 32, '+']; '33': ['32', '34', '33', 33, '+']; '34': ['33', '35', '34', 34, '+']; '35': ['34', '36', '35', 35, '+']; '36': ['35', '37', '36', 36, '+']; '37': ['36', '38', '37', 37, '+']; '38': ['37', '39', '38', 38, '+']; '39': ['38', '40', '39', 39, '+']; '40': ['39', '__', '40', 40, '+']; __: ['__', '__', string, number, '-' | '0' | '+']; }
 
         '-40': ['__', '-39', '-40', -40, '-'];
 >'-40' : ["__", "-39", "-40", -40, "-"]
@@ -1159,7 +1159,7 @@ declare module "Iteration/Iteration" {
 >IterationMap : any
 
     export type Iteration = [keyof IterationMap, keyof IterationMap, string, number, '-' | '0' | '+'];
->Iteration : Iteration
+>Iteration : [keyof IterationMap, keyof IterationMap, string, number, "0" | "-" | "+"]
 }
 declare module "Iteration/Key" {
 >"Iteration/Key" : typeof import("Iteration/Key")
diff --git a/tests/baselines/reference/reachabilityChecks4.types b/tests/baselines/reference/reachabilityChecks4.types
index 27051b3550d9e..30b7cb9f0bd5d 100644
--- a/tests/baselines/reference/reachabilityChecks4.types
+++ b/tests/baselines/reference/reachabilityChecks4.types
@@ -70,10 +70,10 @@ function f1(x: 0 | 1 | 2) {
 // Repro from #34021
 
 type Behavior = 'SLIDE' | 'SLIDE_OUT'
->Behavior : Behavior
+>Behavior : "SLIDE" | "SLIDE_OUT"
 
 type Direction = 'LEFT' | 'RIGHT' | 'TOP' | 'BOTTOM'
->Direction : Direction
+>Direction : "LEFT" | "RIGHT" | "TOP" | "BOTTOM"
 
 interface Transition {
   behavior: Behavior
diff --git a/tests/baselines/reference/readonlyArraysAndTuples.types b/tests/baselines/reference/readonlyArraysAndTuples.types
index 1f443c702f0ff..5075319ef9550 100644
--- a/tests/baselines/reference/readonlyArraysAndTuples.types
+++ b/tests/baselines/reference/readonlyArraysAndTuples.types
@@ -1,21 +1,21 @@
 === tests/cases/conformance/types/tuple/readonlyArraysAndTuples.ts ===
 type T10 = string[];
->T10 : T10
+>T10 : string[]
 
 type T11 = Array<string>;
->T11 : T11
+>T11 : string[]
 
 type T12 = readonly string[];
->T12 : T12
+>T12 : readonly string[]
 
 type T13 = ReadonlyArray<string>;
->T13 : T13
+>T13 : readonly string[]
 
 type T20 = [number, number];
->T20 : T20
+>T20 : [number, number]
 
 type T21 = readonly [number, number];
->T21 : T21
+>T21 : readonly [number, number]
 
 type T30 = readonly string;  // Error
 >T30 : string
@@ -24,10 +24,10 @@ type T31<T> = readonly T;  // Error
 >T31 : T
 
 type T32 = readonly readonly string[];  // Error
->T32 : T32
+>T32 : readonly string[]
 
 type T33 = readonly Array<string>;  // Error
->T33 : T33
+>T33 : string[]
 
 function f1(ma: string[], ra: readonly string[], mt: [string, string], rt: readonly [string, string]) {
 >f1 : (ma: string[], ra: readonly string[], mt: [string, string], rt: readonly [string, string]) => void
diff --git a/tests/baselines/reference/readonlyArraysAndTuples2.types b/tests/baselines/reference/readonlyArraysAndTuples2.types
index 21872ad63d221..9e49820fdbea4 100644
--- a/tests/baselines/reference/readonlyArraysAndTuples2.types
+++ b/tests/baselines/reference/readonlyArraysAndTuples2.types
@@ -1,21 +1,21 @@
 === tests/cases/conformance/types/tuple/readonlyArraysAndTuples2.ts ===
 type T10 = string[];
->T10 : T10
+>T10 : string[]
 
 type T11 = Array<string>;
->T11 : T11
+>T11 : string[]
 
 type T12 = readonly string[];
->T12 : T12
+>T12 : readonly string[]
 
 type T13 = ReadonlyArray<string>;
->T13 : T13
+>T13 : readonly string[]
 
 type T20 = [number, number];
->T20 : T20
+>T20 : [number, number]
 
 type T21 = readonly [number, number];
->T21 : T21
+>T21 : readonly [number, number]
 
 declare function f1(ma: string[], ra: readonly string[], mt: [string, string], rt: readonly [string, string]): readonly [string, string];
 >f1 : (ma: string[], ra: readonly string[], mt: [string, string], rt: readonly [string, string]) => readonly [string, string]
diff --git a/tests/baselines/reference/recursiveArrayNotCircular.types b/tests/baselines/reference/recursiveArrayNotCircular.types
index 1d0c76523af42..4aa4fc2530fc2 100644
--- a/tests/baselines/reference/recursiveArrayNotCircular.types
+++ b/tests/baselines/reference/recursiveArrayNotCircular.types
@@ -22,7 +22,7 @@ enum ActionType {
 }
 
 type ReducerAction =
->ReducerAction : ReducerAction
+>ReducerAction : { type: ActionType.Bar; payload: number; } | { type: ActionType.Baz; payload: false; } | { type: ActionType.Baz; payload: true; } | { type: ActionType.Foo; payload: string; } | { type: ActionType.Batch; payload: ReducerAction[]; }
 
   | Action<ActionType.Bar, number>
 >ActionType : any
diff --git a/tests/baselines/reference/recursiveConditionalTypes.types b/tests/baselines/reference/recursiveConditionalTypes.types
index 2291ce8b5eb35..a72af8cb4ffa2 100644
--- a/tests/baselines/reference/recursiveConditionalTypes.types
+++ b/tests/baselines/reference/recursiveConditionalTypes.types
@@ -76,7 +76,7 @@ type B0 = Flatten<string[][][]>;
 >B0 : string[]
 
 type B1 = Flatten<string[][] | readonly (number[] | boolean[][])[]>;
->B1 : B1
+>B1 : string[] | readonly (number | boolean)[]
 
 type B2 = Flatten<InfiniteArray<string>>;
 >B2 : any[]
@@ -96,7 +96,7 @@ type TT0 = TupleOf<string, 4>;
 >TT0 : [string, string, string, string]
 
 type TT1 = TupleOf<number, 0 | 2 | 4>;
->TT1 : TT1
+>TT1 : [] | [number, number] | [number, number, number, number]
 
 type TT2 = TupleOf<number, number>;
 >TT2 : number[]
@@ -154,22 +154,22 @@ declare function unbox<T>(box: RecBox<T>): T
 >box : RecBox<T>
 
 type T1 = Box<string>;
->T1 : T1
+>T1 : Box<string>
 
 type T2 = Box<T1>;
->T2 : T2
+>T2 : Box<T1>
 
 type T3 = Box<T2>;
->T3 : T3
+>T3 : Box<T2>
 
 type T4 = Box<T3>;
->T4 : T4
+>T4 : Box<T3>
 
 type T5 = Box<T4>;
->T5 : T5
+>T5 : Box<T4>
 
 type T6 = Box<T5>;
->T6 : T6
+>T6 : Box<T5>
 
 declare let b1: Box<Box<Box<Box<Box<Box<string>>>>>>;
 >b1 : Box<Box<Box<Box<Box<Box<string>>>>>>
diff --git a/tests/baselines/reference/recursiveExcessPropertyChecks.types b/tests/baselines/reference/recursiveExcessPropertyChecks.types
index 04b78367460b5..19f27b3af715d 100644
--- a/tests/baselines/reference/recursiveExcessPropertyChecks.types
+++ b/tests/baselines/reference/recursiveExcessPropertyChecks.types
@@ -7,7 +7,7 @@ interface ITreeItem {
 }
 
 type NodeWithId = ITreeItem & { Id?: number };
->NodeWithId : NodeWithId
+>NodeWithId : ITreeItem & { Id?: number | undefined; }
 >Id : number | undefined
 
 function getMaxId(items: NodeWithId[]) {
diff --git a/tests/baselines/reference/recursiveGenericUnionType1.types b/tests/baselines/reference/recursiveGenericUnionType1.types
index c4580adf453c8..37cc988279b88 100644
--- a/tests/baselines/reference/recursiveGenericUnionType1.types
+++ b/tests/baselines/reference/recursiveGenericUnionType1.types
@@ -8,7 +8,7 @@ declare module Test1 {
 
     };
     export type IStringContainer = Container<string>;
->IStringContainer : IStringContainer
+>IStringContainer : string | { [i: string]: Container<string>; }
 }
 
 declare module Test2 {
@@ -20,7 +20,7 @@ declare module Test2 {
 
     };
     export type IStringContainer = Container<string>;
->IStringContainer : IStringContainer
+>IStringContainer : string | { [i: string]: Container<string>; }
 }
 
 var x: Test1.Container<number>;
diff --git a/tests/baselines/reference/recursiveGenericUnionType2.types b/tests/baselines/reference/recursiveGenericUnionType2.types
index dbc4a03b6d02f..8f97bc24881c0 100644
--- a/tests/baselines/reference/recursiveGenericUnionType2.types
+++ b/tests/baselines/reference/recursiveGenericUnionType2.types
@@ -8,7 +8,7 @@ declare module Test1 {
 
     };
     export type IStringContainer = Container<string>;
->IStringContainer : IStringContainer
+>IStringContainer : string | { [i: string]: Container<string>[]; }
 }
 
 declare module Test2 {
@@ -20,7 +20,7 @@ declare module Test2 {
 
     };
     export type IStringContainer = Container<string>;
->IStringContainer : IStringContainer
+>IStringContainer : string | { [i: string]: Container<string>[]; }
 }
 
 var x: Test1.Container<number>;
diff --git a/tests/baselines/reference/recursiveMappedTypes.types b/tests/baselines/reference/recursiveMappedTypes.types
index c5888a1c2317f..14c2167f189d6 100644
--- a/tests/baselines/reference/recursiveMappedTypes.types
+++ b/tests/baselines/reference/recursiveMappedTypes.types
@@ -25,7 +25,7 @@ export type Circular<T> = {[P in keyof T]: Circular<T>};
 >Circular : Circular<T>
 
 type tup = [number, number, number, number];
->tup : tup
+>tup : [number, number, number, number]
 
 function foo(arg: Circular<tup>): tup {
 >foo : (arg: any) => tup
@@ -44,10 +44,10 @@ type DeepMap<T extends unknown[], R> = {
 };
 
 type tpl = [string, [string, [string]]];
->tpl : tpl
+>tpl : [string, [string, [string]]]
 
 type arr = string[][];
->arr : arr
+>arr : string[][]
 
 type t1 = DeepMap<tpl, number>;  // [number, [number, [number]]]
 >t1 : [number, [number, [number]]]
@@ -123,7 +123,7 @@ export interface ListWidget {
 }
 
 type ListChild = Child<ListWidget>
->ListChild : ListChild
+>ListChild : { [x: string]: any; }
 
 declare let x: ListChild;
 >x : ListChild
diff --git a/tests/baselines/reference/recursiveTupleTypeInference.types b/tests/baselines/reference/recursiveTupleTypeInference.types
index bc2c5373dcf1b..050a4bd3135ef 100644
--- a/tests/baselines/reference/recursiveTupleTypeInference.types
+++ b/tests/baselines/reference/recursiveTupleTypeInference.types
@@ -2,7 +2,7 @@
 // Repro from #37475
 
 export type A = "number" | "null" | A[];
->A : A
+>A : "number" | "null" | A[]
 
 export type F<T> = null extends T
 >F : F<T>
diff --git a/tests/baselines/reference/recursiveTypeReferences1.types b/tests/baselines/reference/recursiveTypeReferences1.types
index 8259f392c5ba8..bbdcdfeb82708 100644
--- a/tests/baselines/reference/recursiveTypeReferences1.types
+++ b/tests/baselines/reference/recursiveTypeReferences1.types
@@ -22,7 +22,7 @@ const a1: ValueOrArray<number> = [1, [2, 3], [4, [5, [6, 7]]]];
 >7 : 7
 
 type HypertextNode = string | [string, { [key: string]: unknown }, ...HypertextNode[]];
->HypertextNode : HypertextNode
+>HypertextNode : string | [string, { [key: string]: unknown; }, ...HypertextNode[]]
 >key : string
 
 const hypertextNode: HypertextNode =
@@ -54,7 +54,7 @@ const hypertextNode: HypertextNode =
     ];
 
 type Json = string | number | boolean | null | Json[] | { [key: string]: Json };
->Json : Json
+>Json : string | number | boolean | Json[] | { [key: string]: Json; } | null
 >null : null
 >key : string
 
@@ -89,13 +89,13 @@ interface Box<T> { value: T };
 >value : T
 
 type T1 = Box<T1>;
->T1 : T1
+>T1 : Box<T1>
 
 type T2 = Box<Box<T2>>;
->T2 : T2
+>T2 : Box<Box<T2>>
 
 type T3 = Box<Box<Box<T3>>>;
->T3 : T3
+>T3 : Box<Box<Box<T3>>>
 
 function f1(t1: T1, t2: T2, t3: T3) {
 >f1 : (t1: T1, t2: T2, t3: T3) => void
@@ -135,7 +135,7 @@ function f1(t1: T1, t2: T2, t3: T3) {
 }
 
 type Box1 = Box<Box1> | number;
->Box1 : Box1
+>Box1 : number | Box<Box1>
 
 const b10: Box1 = 42;
 >b10 : Box1
@@ -158,7 +158,7 @@ const b12: Box1 = { value: { value: { value: 42 }}};
 >42 : 42
 
 type Box2 = Box<Box2 | number>;
->Box2 : Box2
+>Box2 : Box<number | Box2>
 
 const b20: Box2 = 42;  // Error
 >b20 : Box2
@@ -344,19 +344,19 @@ flat2([1, ['a']]);  // Error
 >'a' : "a"
 
 type T10 = T10[];
->T10 : T10
+>T10 : T10[]
 
 type T11 = readonly T11[];
->T11 : T11
+>T11 : readonly T11[]
 
 type T12 = (T12)[];
->T12 : T12
+>T12 : T12[]
 
 type T13 = T13[] | string;
->T13 : T13
+>T13 : string | T13[]
 
 type T14 = T14[] & { x: string };
->T14 : T14
+>T14 : T14[] & { x: string; }
 >x : string
 
 type T15<X> = X extends string ? T15<X>[] : never;
@@ -403,7 +403,7 @@ let x2 = foo2(ra2);  // Boom!
 // Repro from #33617 (errors are expected)
 
 type Tree = [HTMLHeadingElement, Tree][];
->Tree : Tree
+>Tree : [HTMLHeadingElement, Tree][]
 
 function parse(node: Tree, index: number[] = []): HTMLUListElement {
 >parse : (node: Tree, index?: number[]) => HTMLUListElement
diff --git a/tests/baselines/reference/restTupleElements1.types b/tests/baselines/reference/restTupleElements1.types
index b74d0c20df841..149ad77a9fa6e 100644
--- a/tests/baselines/reference/restTupleElements1.types
+++ b/tests/baselines/reference/restTupleElements1.types
@@ -1,27 +1,27 @@
 === tests/cases/conformance/types/tuple/restTupleElements1.ts ===
 type T00 = [string?];
->T00 : T00
+>T00 : [(string | undefined)?]
 
 type T01 = [string, string?];
->T01 : T01
+>T01 : [string, (string | undefined)?]
 
 type T02 = [string?, string];  // Error
->T02 : T02
+>T02 : [(string | undefined)?, string]
 
 type T03 = [...string[]];
->T03 : T03
+>T03 : string[]
 
 type T04 = [...[...string[]]];
->T04 : T04
+>T04 : string[]
 
 type T05 = [...[...[...string[]]]];
->T05 : T05
+>T05 : string[]
 
 type T06 = [string, ...string[]];
->T06 : T06
+>T06 : [string, ...string[]]
 
 type T07 = [...string[], string];  // Error
->T07 : T07
+>T07 : [...string[], string]
 
 type T08 = [...string];  // Error
 >T08 : any[]
@@ -30,13 +30,13 @@ type T09 = [...string?];  // Error
 >T09 : any[]
 
 type T10 = [string, ...[...string[]]];
->T10 : T10
+>T10 : [string, ...string[]]
 
 type T11 = [string, ...[...[...string[]]]];
->T11 : T11
+>T11 : [string, ...string[]]
 
 type T15 = [boolean, number, ...string[]];
->T15 : T15
+>T15 : [boolean, number, ...string[]]
 
 type L15 = T15["length"];  // number
 >L15 : number
@@ -101,25 +101,25 @@ assign<[number, ...number[]], [number, number, number, string]>();  // Error
 >assign : <T, S extends T>() => void
 
 type T20 = [number, string, ...boolean[]];
->T20 : T20
+>T20 : [number, string, ...boolean[]]
 
 type T21 = T20[0];
 >T21 : number
 
 type T22 = T20[0 | 1];
->T22 : T22
+>T22 : string | number
 
 type T23 = T20[0 | 1 | 2];
->T23 : T23
+>T23 : string | number | boolean
 
 type T24 = T20[0 | 1 | 2 | 3];
->T24 : T24
+>T24 : string | number | boolean
 
 type T25 = T20[1 | 2 | 3];
->T25 : T25
+>T25 : string | boolean
 
 type T26 = T20[2 | 3];
->T26 : T26
+>T26 : boolean
 
 type T27 = T20[3];
 >T27 : boolean
diff --git a/tests/baselines/reference/restTuplesFromContextualTypes.types b/tests/baselines/reference/restTuplesFromContextualTypes.types
index b62045eba3166..6bbc92095d073 100644
--- a/tests/baselines/reference/restTuplesFromContextualTypes.types
+++ b/tests/baselines/reference/restTuplesFromContextualTypes.types
@@ -501,10 +501,10 @@ take(function(...rest){});
 // Repro from #29833
 
 type ArgsUnion = [number, string] | [number, Error];
->ArgsUnion : ArgsUnion
+>ArgsUnion : [number, string] | [number, Error]
 
 type TupleUnionFunc = (...params: ArgsUnion) => number;
->TupleUnionFunc : TupleUnionFunc
+>TupleUnionFunc : (...params: ArgsUnion) => number
 >params : ArgsUnion
 
 const funcUnionTupleNoRest: TupleUnionFunc = (num, strOrErr) => {
diff --git a/tests/baselines/reference/returnTypeInferenceNotTooBroad.types b/tests/baselines/reference/returnTypeInferenceNotTooBroad.types
index a95d7012d1700..a17ce9534c33a 100644
--- a/tests/baselines/reference/returnTypeInferenceNotTooBroad.types
+++ b/tests/baselines/reference/returnTypeInferenceNotTooBroad.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/returnTypeInferenceNotTooBroad.ts ===
 type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; };
->Signs : Signs
+>Signs : { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }
 >kind : "a"
 >a : 3
 >kind : "b"
diff --git a/tests/baselines/reference/reverseMappedTypeAssignableToIndex.types b/tests/baselines/reference/reverseMappedTypeAssignableToIndex.types
index 589e9ff3477a3..f8e272ed48334 100644
--- a/tests/baselines/reference/reverseMappedTypeAssignableToIndex.types
+++ b/tests/baselines/reference/reverseMappedTypeAssignableToIndex.types
@@ -10,7 +10,7 @@ type InferFromMapped<T> = T extends Mapped<infer R> ? R : never;
 // Object literal type and associated mapped type
 // Note that in the real code we don't have a direct reference to LiteralType
 type LiteralType = {
->LiteralType : LiteralType
+>LiteralType : { first: "first"; second: "second"; }
 
 	first: "first";
 >first : "first"
@@ -19,7 +19,7 @@ type LiteralType = {
 >second : "second"
 }
 type MappedLiteralType = {
->MappedLiteralType : MappedLiteralType
+>MappedLiteralType : { first: {    name: "first";}; second: {    name: "second";}; }
 
 	first: { name: "first" },
 >first : { name: "first"; }
diff --git a/tests/baselines/reference/selfReferencingTypeReferenceInference.types b/tests/baselines/reference/selfReferencingTypeReferenceInference.types
index a33b3d9ceb75f..17ab0ee787fdf 100644
--- a/tests/baselines/reference/selfReferencingTypeReferenceInference.types
+++ b/tests/baselines/reference/selfReferencingTypeReferenceInference.types
@@ -15,7 +15,7 @@ type InferRecursive<T> = T extends Recursive<infer R> ? R : "never!"
 
 // the type we are testing with
 type t1 = Box<string | Box<number | boolean>>
->t1 : t1
+>t1 : Box<string | Box<number | boolean>>
 
 type t2 = InferRecursive<t1>
 >t2 : string | number | boolean
diff --git a/tests/baselines/reference/silentNeverPropagation.types b/tests/baselines/reference/silentNeverPropagation.types
index c64dfc61f6e96..018f59630842a 100644
--- a/tests/baselines/reference/silentNeverPropagation.types
+++ b/tests/baselines/reference/silentNeverPropagation.types
@@ -10,7 +10,7 @@ type ModuleWithState<TState> = {
 };
 
 type State = {
->State : State
+>State : { a: number; }
 
     a: number;
 >a : number
@@ -18,7 +18,7 @@ type State = {
 };
 
 type MoreState = {
->MoreState : MoreState
+>MoreState : { z: string; }
 
     z: string;
 >z : string
diff --git a/tests/baselines/reference/singletonLabeledTuple.types b/tests/baselines/reference/singletonLabeledTuple.types
index 44ca6b978d1bd..654741d2123b4 100644
--- a/tests/baselines/reference/singletonLabeledTuple.types
+++ b/tests/baselines/reference/singletonLabeledTuple.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/singletonLabeledTuple.ts ===
 type AliasOptional = [p?: number]
->AliasOptional : AliasOptional
+>AliasOptional : [p?: number]
 
 // literal type vs type alias
 type Literal = [p?: number] extends [unknown] ? true : false // Expect `Literal` to be `false`
@@ -26,7 +26,7 @@ type Normal = [number?] extends [unknown] ? true : false       // Expect `Normal
 
 
 type AliasRest = [...p: number[]];
->AliasRest : AliasRest
+>AliasRest : number[]
 
 type LiteralRest = [...p: number[]] extends [unknown] ? true : false; // Expect `LiteralRest` to be `false`
 >LiteralRest : false
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern.types b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern.types
index eff8a93096310..9cf260ffd343a 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 let robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern2.types
index bfa1757d616ba..296e6a5b3607e 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern2.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern2.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 let robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.types b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.types
index 2dab0c1cd6b83..9f5f07b533cdd 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, string[]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, string[]]
 
 let robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.types b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.types
index aa06efe39657d..bbe23b1c3f367 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 let robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern.types b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern.types
index f38bc8330ef75..36710552499c4 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 let robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types
index 92797377d3a49..d08d463ece8de 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 let robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.types b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.types
index cab4cc5ba07be..0ccac5ac7c1e7 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 let robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types
index 14e0bbaa33580..2e6f39f639eab 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 let robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types
index ff955abe34bfe..1ee8ebd1887eb 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types
@@ -7,7 +7,7 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 var robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types
index aa1dc644b08d6..50d9ad00e750a 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types
@@ -7,7 +7,7 @@ declare var console: {
 >msg : any
 }
 type Robot = [string, [string, string]];
->Robot : Robot
+>Robot : [string, [string, string]]
 
 var robotA: Robot = ["trimmer", ["trimming", "edging"]];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types
index 94106255a1290..dfadbc9f867d1 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types
@@ -7,7 +7,7 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 var robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types
index 8fd8a82fa6939..07545582f1c6c 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types
@@ -7,7 +7,7 @@ declare var console: {
 >msg : any
 }
 type Robot = [string, string[]];
->Robot : Robot
+>Robot : [string, string[]]
 
 var robotA: Robot = ["trimmer", ["trimming", "edging"]];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.types
index 61e7f7ab3e2e9..04586760989e2 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.types
@@ -7,7 +7,7 @@ declare var console: {
 >msg : string
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 var robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.types
index 899d2c1872ae0..02041b4aeb5ed 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.types
@@ -7,7 +7,7 @@ declare var console: {
 >msg : string
 }
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]];
 >multiRobotA : MultiSkilledRobot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.types
index a1e735ea691e5..8ef9960df1b15 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, [string, string]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, [string, string]]
 
 var robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.types
index 0bdf495f09efc..2d9245a65989e 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.types
@@ -7,7 +7,7 @@ declare var console: {
 >msg : string
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 var robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.types
index ff88713b0db43..f00d3251e41cd 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.types
@@ -7,7 +7,7 @@ declare var console: {
 >msg : string
 }
 type MultiSkilledRobot = [string, string[]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, string[]]
 
 var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]];
 >multiRobotA : MultiSkilledRobot
diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.types
index eaa8c33d7c0b3..163f23be381b5 100644
--- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.types
+++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.types
@@ -7,10 +7,10 @@ declare var console: {
 >msg : any
 }
 type Robot = [number, string, string];
->Robot : Robot
+>Robot : [number, string, string]
 
 type MultiSkilledRobot = [string, string[]];
->MultiSkilledRobot : MultiSkilledRobot
+>MultiSkilledRobot : [string, string[]]
 
 var robotA: Robot = [1, "mower", "mowing"];
 >robotA : Robot
diff --git a/tests/baselines/reference/spreadBooleanRespectsFreshness.types b/tests/baselines/reference/spreadBooleanRespectsFreshness.types
index cd20dc31944b6..3ccc42b24e3ce 100644
--- a/tests/baselines/reference/spreadBooleanRespectsFreshness.types
+++ b/tests/baselines/reference/spreadBooleanRespectsFreshness.types
@@ -1,13 +1,13 @@
 === tests/cases/compiler/spreadBooleanRespectsFreshness.ts ===
 type Foo = FooBase | FooArray;
->Foo : Foo
+>Foo : FooBase | FooArray
 
 type FooBase = string | false;
->FooBase : FooBase
+>FooBase : string | false
 >false : false
 
 type FooArray = FooBase[];
->FooArray : FooArray
+>FooArray : FooBase[]
 
 declare let foo1: Foo;
 >foo1 : Foo
diff --git a/tests/baselines/reference/spreadExcessProperty.types b/tests/baselines/reference/spreadExcessProperty.types
index 015c7cc85aad6..66b337bdb0b69 100644
--- a/tests/baselines/reference/spreadExcessProperty.types
+++ b/tests/baselines/reference/spreadExcessProperty.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/spread/spreadExcessProperty.ts ===
 type A = { a: string, b: string };
->A : A
+>A : { a: string; b: string; }
 >a : string
 >b : string
 
diff --git a/tests/baselines/reference/staticIndexSignature5.types b/tests/baselines/reference/staticIndexSignature5.types
index 92360a7fde388..2f3ea91f8cfc2 100644
--- a/tests/baselines/reference/staticIndexSignature5.types
+++ b/tests/baselines/reference/staticIndexSignature5.types
@@ -38,16 +38,16 @@ type TE = keyof typeof B;
 >B : typeof B
 
 type TF = Pick<typeof B, number>
->TF : TF
+>TF : { [x: number]: 42 | 233; }
 >B : typeof B
 
 type TFI = Pick<I, number>
->TFI : TFI
+>TFI : { [x: number]: 42 | 233; }
 
 type TG = Omit<typeof B, number>
->TG : TG
+>TG : { [x: string]: number; }
 >B : typeof B
 
 type TGI = Omit<I, number>
->TGI : TGI
+>TGI : { [x: string]: number; }
 
diff --git a/tests/baselines/reference/strictOptionalProperties1.types b/tests/baselines/reference/strictOptionalProperties1.types
index 86e2e6e5c1259..ba14aedfd1846 100644
--- a/tests/baselines/reference/strictOptionalProperties1.types
+++ b/tests/baselines/reference/strictOptionalProperties1.types
@@ -414,7 +414,7 @@ function f6() {
 // Example from #13195
 
 type Props = {
->Props : Props
+>Props : { foo: string; bar: string; }
 
     foo: string;
 >foo : string
@@ -424,7 +424,7 @@ type Props = {
 }
 
 type InputProps = {
->InputProps : InputProps
+>InputProps : { foo?: string; bar: string; }
 
     foo?: string;
 >foo : string | undefined
@@ -793,7 +793,7 @@ interface PropsFromMaterialUI {
 }
 
 type TheTypeFromMaterialUI = PropsFromReact & PropsFromMaterialUI;
->TheTypeFromMaterialUI : TheTypeFromMaterialUI
+>TheTypeFromMaterialUI : PropsFromReact & PropsFromMaterialUI
 
 interface NavBottomListItem extends TheTypeFromMaterialUI {
     value: string;
diff --git a/tests/baselines/reference/stringEnumLiteralTypes1.types b/tests/baselines/reference/stringEnumLiteralTypes1.types
index 0c09694228e2a..41b3f7b6514f3 100644
--- a/tests/baselines/reference/stringEnumLiteralTypes1.types
+++ b/tests/baselines/reference/stringEnumLiteralTypes1.types
@@ -9,17 +9,17 @@ const enum Choice { Unknown = "", Yes = "yes", No = "no" };
 >"no" : "no"
 
 type YesNo = Choice.Yes | Choice.No;
->YesNo : YesNo
+>YesNo : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type NoYes = Choice.No | Choice.Yes;
->NoYes : NoYes
+>NoYes : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
->UnknownYesNo : UnknownYesNo
+>UnknownYesNo : Choice
 >Choice : any
 >Choice : any
 >Choice : any
@@ -280,7 +280,7 @@ function f13(x: UnknownYesNo) {
 }
 
 type Item =
->Item : Item
+>Item : { kind: Choice.Yes; a: string; } | { kind: Choice.No; b: string; }
 
     { kind: Choice.Yes, a: string } |
 >kind : Choice.Yes
diff --git a/tests/baselines/reference/stringEnumLiteralTypes2.types b/tests/baselines/reference/stringEnumLiteralTypes2.types
index f4dd211517ade..e44e24c55fa16 100644
--- a/tests/baselines/reference/stringEnumLiteralTypes2.types
+++ b/tests/baselines/reference/stringEnumLiteralTypes2.types
@@ -9,17 +9,17 @@ const enum Choice { Unknown = "", Yes = "yes", No = "no" };
 >"no" : "no"
 
 type YesNo = Choice.Yes | Choice.No;
->YesNo : YesNo
+>YesNo : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type NoYes = Choice.No | Choice.Yes;
->NoYes : NoYes
+>NoYes : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
->UnknownYesNo : UnknownYesNo
+>UnknownYesNo : Choice
 >Choice : any
 >Choice : any
 >Choice : any
@@ -280,7 +280,7 @@ function f13(x: UnknownYesNo) {
 }
 
 type Item =
->Item : Item
+>Item : { kind: Choice.Yes; a: string; } | { kind: Choice.No; b: string; }
 
     { kind: Choice.Yes, a: string } |
 >kind : Choice.Yes
diff --git a/tests/baselines/reference/stringEnumLiteralTypes3.types b/tests/baselines/reference/stringEnumLiteralTypes3.types
index c3c1fb30e2a07..c286680e4245f 100644
--- a/tests/baselines/reference/stringEnumLiteralTypes3.types
+++ b/tests/baselines/reference/stringEnumLiteralTypes3.types
@@ -13,17 +13,17 @@ type Yes = Choice.Yes;
 >Choice : any
 
 type YesNo = Choice.Yes | Choice.No;
->YesNo : YesNo
+>YesNo : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type NoYes = Choice.No | Choice.Yes;
->NoYes : NoYes
+>NoYes : Choice.Yes | Choice.No
 >Choice : any
 >Choice : any
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
->UnknownYesNo : UnknownYesNo
+>UnknownYesNo : Choice
 >Choice : any
 >Choice : any
 >Choice : any
diff --git a/tests/baselines/reference/stringLiteralCheckedInIf01.types b/tests/baselines/reference/stringLiteralCheckedInIf01.types
index b63fadb8076ef..c6e83c0af7baa 100644
--- a/tests/baselines/reference/stringLiteralCheckedInIf01.types
+++ b/tests/baselines/reference/stringLiteralCheckedInIf01.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf01.ts ===
 type S = "a" | "b";
->S : S
+>S : "a" | "b"
 
 type T = S[] | S;
->T : T
+>T : S | S[]
 
 function f(foo: T) {
 >f : (foo: T) => S
diff --git a/tests/baselines/reference/stringLiteralCheckedInIf02.types b/tests/baselines/reference/stringLiteralCheckedInIf02.types
index 8056c2dd43a27..760e48d24f850 100644
--- a/tests/baselines/reference/stringLiteralCheckedInIf02.types
+++ b/tests/baselines/reference/stringLiteralCheckedInIf02.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralCheckedInIf02.ts ===
 type S = "a" | "b";
->S : S
+>S : "a" | "b"
 
 type T = S[] | S;
->T : T
+>T : S | S[]
 
 function isS(t: T): t is S {
 >isS : (t: T) => t is S
diff --git a/tests/baselines/reference/stringLiteralMatchedInSwitch01.types b/tests/baselines/reference/stringLiteralMatchedInSwitch01.types
index 144550eaa0eb9..44775223596c6 100644
--- a/tests/baselines/reference/stringLiteralMatchedInSwitch01.types
+++ b/tests/baselines/reference/stringLiteralMatchedInSwitch01.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralMatchedInSwitch01.ts ===
 type S = "a" | "b";
->S : S
+>S : "a" | "b"
 
 type T = S[] | S;
->T : T
+>T : S | S[]
 
 var foo: T;
 >foo : T
diff --git a/tests/baselines/reference/stringLiteralTypeAssertion01.types b/tests/baselines/reference/stringLiteralTypeAssertion01.types
index 9aba3b1aa9b6a..590d273087b4d 100644
--- a/tests/baselines/reference/stringLiteralTypeAssertion01.types
+++ b/tests/baselines/reference/stringLiteralTypeAssertion01.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypeAssertion01.ts ===
 type S = "a" | "b";
->S : S
+>S : "a" | "b"
 
 type T = S[] | S;
->T : T
+>T : S | S[]
 
 var s: S;
 >s : S
diff --git a/tests/baselines/reference/stringLiteralTypesAndTuples01.types b/tests/baselines/reference/stringLiteralTypesAndTuples01.types
index a3e3fc5bd7ae1..24e0a732165f2 100644
--- a/tests/baselines/reference/stringLiteralTypesAndTuples01.types
+++ b/tests/baselines/reference/stringLiteralTypesAndTuples01.types
@@ -12,7 +12,7 @@ let [hello, brave, newish, world] = ["Hello", "Brave", "New", "World"];
 >"World" : "World"
 
 type RexOrRaptor = "t-rex" | "raptor"
->RexOrRaptor : RexOrRaptor
+>RexOrRaptor : "t-rex" | "raptor"
 
 let [im, a, dinosaur]: ["I'm", "a", RexOrRaptor] = ['I\'m', 'a', 't-rex'];
 >im : "I'm"
diff --git a/tests/baselines/reference/stringLiteralTypesAsTags01.types b/tests/baselines/reference/stringLiteralTypesAsTags01.types
index 8a101a7a00ead..f7666d65ea6f5 100644
--- a/tests/baselines/reference/stringLiteralTypesAsTags01.types
+++ b/tests/baselines/reference/stringLiteralTypesAsTags01.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts ===
 type Kind = "A" | "B"
->Kind : Kind
+>Kind : "A" | "B"
 
 interface Entity {
     kind: Kind;
diff --git a/tests/baselines/reference/stringLiteralTypesAsTags02.types b/tests/baselines/reference/stringLiteralTypesAsTags02.types
index d6c183c67a465..544e3f75455c9 100644
--- a/tests/baselines/reference/stringLiteralTypesAsTags02.types
+++ b/tests/baselines/reference/stringLiteralTypesAsTags02.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags02.ts ===
 type Kind = "A" | "B"
->Kind : Kind
+>Kind : "A" | "B"
 
 interface Entity {
     kind: Kind;
diff --git a/tests/baselines/reference/stringLiteralTypesAsTags03.types b/tests/baselines/reference/stringLiteralTypesAsTags03.types
index 517eaab297403..f5583ebdca9f4 100644
--- a/tests/baselines/reference/stringLiteralTypesAsTags03.types
+++ b/tests/baselines/reference/stringLiteralTypesAsTags03.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags03.ts ===
 type Kind = "A" | "B"
->Kind : Kind
+>Kind : "A" | "B"
 
 interface Entity {
     kind: Kind;
diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types
index a4d08a8d43b38..d06714e837fce 100644
--- a/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types
+++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes01.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes01.ts ===
 type T = "foo" | "bar" | "baz";
->T : T
+>T : "foo" | "bar" | "baz"
 
 var x: "foo" | "bar" | "baz" = undefined;
 >x : "foo" | "bar" | "baz"
diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types
index fb79356ad2a57..7db889fc0b0a0 100644
--- a/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types
+++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes03.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes03.ts ===
 type T = number | "foo" | "bar";
->T : T
+>T : number | "foo" | "bar"
 
 var x: "foo" | "bar" | number;
 >x : number | "foo" | "bar"
diff --git a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types
index 030b55c5e99f0..723c89ec3bdc6 100644
--- a/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types
+++ b/tests/baselines/reference/stringLiteralTypesInUnionTypes04.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypesInUnionTypes04.ts ===
 type T = "" | "foo";
->T : T
+>T : "" | "foo"
 
 let x: T = undefined;
 >x : T
diff --git a/tests/baselines/reference/stringLiteralTypesOverloads01.types b/tests/baselines/reference/stringLiteralTypesOverloads01.types
index 67437fc122ee4..c8ba27fb6824e 100644
--- a/tests/baselines/reference/stringLiteralTypesOverloads01.types
+++ b/tests/baselines/reference/stringLiteralTypesOverloads01.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts ===
 type PrimitiveName = 'string' | 'number' | 'boolean';
->PrimitiveName : PrimitiveName
+>PrimitiveName : "string" | "number" | "boolean"
 
 function getFalsyPrimitive(x: "string"): string;
 >getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "string" | "boolean"): string | boolean; (x: "number" | "boolean"): number | boolean; (x: "string" | "number"): string | number; (x: "string" | "number" | "boolean"): string | number | boolean; }
diff --git a/tests/baselines/reference/stringLiteralTypesTypePredicates01.types b/tests/baselines/reference/stringLiteralTypesTypePredicates01.types
index 918679081a6d8..488491554c61e 100644
--- a/tests/baselines/reference/stringLiteralTypesTypePredicates01.types
+++ b/tests/baselines/reference/stringLiteralTypesTypePredicates01.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/stringLiteral/stringLiteralTypesTypePredicates01.ts ===
 type Kind = "A" | "B"
->Kind : Kind
+>Kind : "A" | "B"
 
 function kindIs(kind: Kind, is: "A"): kind is "A";
 >kindIs : { (kind: Kind, is: "A"): kind is "A"; (kind: Kind, is: "B"): kind is "B"; }
diff --git a/tests/baselines/reference/stringLiteralsAssertionsInEqualityComparisons02.types b/tests/baselines/reference/stringLiteralsAssertionsInEqualityComparisons02.types
index b52ee123bb5e0..ddc068551f750 100644
--- a/tests/baselines/reference/stringLiteralsAssertionsInEqualityComparisons02.types
+++ b/tests/baselines/reference/stringLiteralsAssertionsInEqualityComparisons02.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/literal/stringLiteralsAssertionsInEqualityComparisons02.ts ===
 type EnhancedString = string & { enhancements: any };
->EnhancedString : EnhancedString
+>EnhancedString : string & { enhancements: any; }
 >enhancements : any
 
 var a = "foo" === "bar" as "baz";
diff --git a/tests/baselines/reference/styledComponentsInstantiaionLimitNotReached.types b/tests/baselines/reference/styledComponentsInstantiaionLimitNotReached.types
index 9d7221f7587dd..efce2c28ffdf4 100644
--- a/tests/baselines/reference/styledComponentsInstantiaionLimitNotReached.types
+++ b/tests/baselines/reference/styledComponentsInstantiaionLimitNotReached.types
@@ -156,7 +156,7 @@ type NonReactStatics<
     };
 
 export type AnyStyledComponent = StyledComponent<any, any, any, any> | StyledComponent<any, any, any>;
->AnyStyledComponent : AnyStyledComponent
+>AnyStyledComponent : StyledComponent<any, any, any, any> | StyledComponent<any, any, any, never>
 
 export type StyledComponent<
 >StyledComponent : StyledComponent<C, T, O, A>
diff --git a/tests/baselines/reference/substituteReturnTypeSatisfiesConstraint.types b/tests/baselines/reference/substituteReturnTypeSatisfiesConstraint.types
index 51f69b9fb22e7..f8d1b43eb017b 100644
--- a/tests/baselines/reference/substituteReturnTypeSatisfiesConstraint.types
+++ b/tests/baselines/reference/substituteReturnTypeSatisfiesConstraint.types
@@ -1,10 +1,10 @@
 === tests/cases/compiler/substituteReturnTypeSatisfiesConstraint.ts ===
 type M = { p: string };
->M : M
+>M : { p: string; }
 >p : string
 
 type O = { m: () => M };
->O : O
+>O : { m: () => M; }
 >m : () => M
 
 type X<T extends M> = T;
diff --git a/tests/baselines/reference/substitutionTypesCompareCorrectlyInRestrictiveInstances.types b/tests/baselines/reference/substitutionTypesCompareCorrectlyInRestrictiveInstances.types
index 87cea0ef45018..f930d8eca9bca 100644
--- a/tests/baselines/reference/substitutionTypesCompareCorrectlyInRestrictiveInstances.types
+++ b/tests/baselines/reference/substitutionTypesCompareCorrectlyInRestrictiveInstances.types
@@ -9,12 +9,12 @@ type Bug<TAll> =  BugHelper<TAll, TAll>
 >Bug : Bug<TAll>
 
 type Q = UnionKeys<{ a : any } | { b: any }>    // should be "a" | "b"
->Q : Q
+>Q : "a" | "b"
 >a : any
 >b : any
 
 type R = Bug<{ a : any } | { b: any }>          // should be "a" | "b"
->R : R
+>R : "a" | "b"
 >a : any
 >b : any
 
diff --git a/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.types b/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.types
index df7e4af01e618..a0df1acaa22df 100644
--- a/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.types
+++ b/tests/baselines/reference/substitutionTypesInIndexedAccessTypes.types
@@ -2,7 +2,7 @@
 // Repro from #31086
 
 type UserArgs = {
->UserArgs : UserArgs
+>UserArgs : { select?: boolean | undefined; }
 
   select?: boolean
 >select : boolean | undefined
diff --git a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types
index 9a5df469be818..8ce93eeca0143 100644
--- a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types
+++ b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNames.types
@@ -3,7 +3,7 @@ import { Constructor } from "@loopback/context";
 >Constructor : any
 
 export type ControllerClass = Constructor<any>;
->ControllerClass : ControllerClass
+>ControllerClass : (...args: any[]) => any
 
 === tests/cases/compiler/monorepo/core/src/usage.ts ===
 import { ControllerClass } from './application';
diff --git a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types
index f858acad1ac57..65d13ba0473d1 100644
--- a/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types
+++ b/tests/baselines/reference/symbolLinkDeclarationEmitModuleNamesRootDir.types
@@ -27,7 +27,7 @@ import { Constructor } from "@loopback/context";
 >Constructor : any
 
 export type ControllerClass = Constructor<any>;
->ControllerClass : ControllerClass
+>ControllerClass : (...args: any[]) => any
 
 === tests/cases/compiler/monorepo/core/src/usage.ts ===
 import { ControllerClass } from './application';
diff --git a/tests/baselines/reference/symbolMergeValueAndImportedType.types b/tests/baselines/reference/symbolMergeValueAndImportedType.types
index 2c6e728ac1e0d..b588605962475 100644
--- a/tests/baselines/reference/symbolMergeValueAndImportedType.types
+++ b/tests/baselines/reference/symbolMergeValueAndImportedType.types
@@ -17,5 +17,5 @@ console.log('X is ' + X);
 
 === tests/cases/compiler/other.ts ===
 export type X = {};
->X : X
+>X : {}
 
diff --git a/tests/baselines/reference/taggedPrimitiveNarrowing.types b/tests/baselines/reference/taggedPrimitiveNarrowing.types
index c26e4174b593d..fb9d6053997c8 100644
--- a/tests/baselines/reference/taggedPrimitiveNarrowing.types
+++ b/tests/baselines/reference/taggedPrimitiveNarrowing.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/taggedPrimitiveNarrowing.ts ===
 type Hash = string & { __hash: true };
->Hash : Hash
+>Hash : string & { __hash: true; }
 >__hash : true
 >true : true
 
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.types b/tests/baselines/reference/taggedTemplateContextualTyping1.types
index 84af70b5b88cd..1d196fd5155e6 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping1.types
+++ b/tests/baselines/reference/taggedTemplateContextualTyping1.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts ===
 type FuncType = (x: <T>(p: T) => T) => typeof x;
->FuncType : FuncType
+>FuncType : (x: <T>(p: T) => T) => <T>(p: T) => T
 >x : <T>(p: T) => T
 >p : T
 >x : <T>(p: T) => T
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.types b/tests/baselines/reference/taggedTemplateContextualTyping2.types
index d182bb526a882..46e4332e208b6 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping2.types
+++ b/tests/baselines/reference/taggedTemplateContextualTyping2.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping2.ts ===
 type FuncType1 = (x: <T>(p: T) => T) => typeof x;
->FuncType1 : FuncType1
+>FuncType1 : (x: <T>(p: T) => T) => <T>(p: T) => T
 >x : <T>(p: T) => T
 >p : T
 >x : <T>(p: T) => T
 
 type FuncType2 = (x: <S, T>(p: T) => T) => typeof x;
->FuncType2 : FuncType2
+>FuncType2 : (x: <S, T>(p: T) => T) => <S, T>(p: T) => T
 >x : <S, T>(p: T) => T
 >p : T
 >x : <S, T>(p: T) => T
diff --git a/tests/baselines/reference/templateLiteralIntersection.types b/tests/baselines/reference/templateLiteralIntersection.types
index d675ad0e0eb74..b305f6677740f 100644
--- a/tests/baselines/reference/templateLiteralIntersection.types
+++ b/tests/baselines/reference/templateLiteralIntersection.types
@@ -9,7 +9,7 @@ type A = typeof a
 >a : "a"
 
 type MixA = A & {foo: string}
->MixA : MixA
+>MixA : "a" & { foo: string; }
 >foo : string
 
 type OriginA1 = `${A}`
@@ -23,7 +23,7 @@ type B = `${typeof a}`
 >a : "a"
 
 type MixB = B & { foo: string }
->MixB : MixB
+>MixB : "a" & { foo: string; }
 >foo : string
 
 type OriginB1 = `${B}`
@@ -33,7 +33,7 @@ type OriginB2 = `${MixB}`
 >OriginB2 : "a"
 
 type MixC = { foo: string } & A
->MixC : MixC
+>MixC : { foo: string; } & "a"
 >foo : string
 
 type OriginC = `${MixC}`
@@ -54,7 +54,7 @@ type E = `${A & {}}`;
 >E : "a"
 
 type MixE = E & {}
->MixE : MixE
+>MixE : "a" & {}
 
 type OriginE = `${MixE}`
 >OriginE : "a"
diff --git a/tests/baselines/reference/templateLiteralTypes1.types b/tests/baselines/reference/templateLiteralTypes1.types
index d143dc764ca09..fed8939ea7605 100644
--- a/tests/baselines/reference/templateLiteralTypes1.types
+++ b/tests/baselines/reference/templateLiteralTypes1.types
@@ -197,7 +197,7 @@ type T27 = FirstTwoAndRest<'a'>;  // unknown
 >T27 : unknown
 
 type HexDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |'8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f';
->HexDigit : HexDigit
+>HexDigit : "0" | "4" | "1" | "2" | "a" | "b" | "3" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "c" | "d" | "e" | "f"
 
 type HexColor<S extends string> =
 >HexColor : HexColor<S>
@@ -436,7 +436,7 @@ type A = any;
 >A : any
 
 type U1 = {a1:A} | {b1:A} | {c1:A} | {d1:A} | {e1:A} | {f1:A} | {g1:A} | {h1:A} | {i1:A} | {j1:A};
->U1 : U1
+>U1 : { a1: A; } | { b1: A; } | { c1: A; } | { d1: A; } | { e1: A; } | { f1: A; } | { g1: A; } | { h1: A; } | { i1: A; } | { j1: A; }
 >a1 : any
 >b1 : any
 >c1 : any
@@ -449,7 +449,7 @@ type U1 = {a1:A} | {b1:A} | {c1:A} | {d1:A} | {e1:A} | {f1:A} | {g1:A} | {h1:A}
 >j1 : any
 
 type U2 = {a2:A} | {b2:A} | {c2:A} | {d2:A} | {e2:A} | {f2:A} | {g2:A} | {h2:A} | {i2:A} | {j2:A};
->U2 : U2
+>U2 : { a2: A; } | { b2: A; } | { c2: A; } | { d2: A; } | { e2: A; } | { f2: A; } | { g2: A; } | { h2: A; } | { i2: A; } | { j2: A; }
 >a2 : any
 >b2 : any
 >c2 : any
@@ -462,7 +462,7 @@ type U2 = {a2:A} | {b2:A} | {c2:A} | {d2:A} | {e2:A} | {f2:A} | {g2:A} | {h2:A}
 >j2 : any
 
 type U3 = {a3:A} | {b3:A} | {c3:A} | {d3:A} | {e3:A} | {f3:A} | {g3:A} | {h3:A} | {i3:A} | {j3:A};
->U3 : U3
+>U3 : { a3: A; } | { b3: A; } | { c3: A; } | { d3: A; } | { e3: A; } | { f3: A; } | { g3: A; } | { h3: A; } | { i3: A; } | { j3: A; }
 >a3 : any
 >b3 : any
 >c3 : any
@@ -475,7 +475,7 @@ type U3 = {a3:A} | {b3:A} | {c3:A} | {d3:A} | {e3:A} | {f3:A} | {g3:A} | {h3:A}
 >j3 : any
 
 type U4 = {a4:A} | {b4:A} | {c4:A} | {d4:A} | {e4:A} | {f4:A} | {g4:A} | {h4:A} | {i4:A} | {j4:A};
->U4 : U4
+>U4 : { a4: A; } | { b4: A; } | { c4: A; } | { d4: A; } | { e4: A; } | { f4: A; } | { g4: A; } | { h4: A; } | { i4: A; } | { j4: A; }
 >a4 : any
 >b4 : any
 >c4 : any
@@ -488,7 +488,7 @@ type U4 = {a4:A} | {b4:A} | {c4:A} | {d4:A} | {e4:A} | {f4:A} | {g4:A} | {h4:A}
 >j4 : any
 
 type U5 = {a5:A} | {b5:A} | {c5:A} | {d5:A} | {e5:A} | {f5:A} | {g5:A} | {h5:A} | {i5:A} | {j5:A};
->U5 : U5
+>U5 : { a5: A; } | { b5: A; } | { c5: A; } | { d5: A; } | { e5: A; } | { f5: A; } | { g5: A; } | { h5: A; } | { i5: A; } | { j5: A; }
 >a5 : any
 >b5 : any
 >c5 : any
@@ -504,13 +504,13 @@ type U100000 = U1 & U2 & U3 & U4 & U5;  // Error
 >U100000 : any
 
 type Digits = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
->Digits : Digits
+>Digits : 0 | 1 | 4 | 2 | 3 | 6 | 5 | 7 | 8 | 9
 
 type D100000 = `${Digits}${Digits}${Digits}${Digits}${Digits}`;  // Error
 >D100000 : any
 
 type TDigits = [0] | [1] | [2] | [3] | [4] | [5] | [6] | [7] | [8] | [9];
->TDigits : TDigits
+>TDigits : [4] | [0] | [1] | [2] | [3] | [5] | [6] | [7] | [8] | [9]
 
 type T100000 = [...TDigits, ...TDigits, ...TDigits, ...TDigits, ...TDigits];  // Error
 >T100000 : any
@@ -597,7 +597,7 @@ let make = getProp2(obj2, 'cars.1.make');  // 'Trabant'
 // Repro from #46480
 
 export type Spacing =
->Spacing : Spacing
+>Spacing : "0" | `${number}px` | `${number}rem` | "s1" | "s4" | "s2" | "s3" | "s6" | "s5" | "s7" | "s8" | "s18" | "s9" | "s10" | "s11" | "s12" | "s13" | "s14" | "s15" | "s16" | "s17" | "s19" | "s20"
 
     | `0`
     | `${number}px`
diff --git a/tests/baselines/reference/templateLiteralTypes3.types b/tests/baselines/reference/templateLiteralTypes3.types
index 27d780c7e22ac..66a36048f07af 100644
--- a/tests/baselines/reference/templateLiteralTypes3.types
+++ b/tests/baselines/reference/templateLiteralTypes3.types
@@ -32,10 +32,10 @@ type T09 = Foo1<`**${string}**${string}**`>;
 >T09 : `*${string}**${string}*`
 
 type T10 = Foo1<`**${'a' | 'b' | 'c'}**`>;
->T10 : T10
+>T10 : "*a*" | "*b*" | "*c*"
 
 type T11 = Foo1<`**${boolean}**${boolean}**`>;
->T11 : T11
+>T11 : "*false**false*" | "*false**true*" | "*true**false*" | "*true**true*"
 
 declare function foo1<V extends string>(arg: `*${V}*`): V;
 >foo1 : <V extends string>(arg: `*${V}*`) => V
@@ -366,10 +366,10 @@ const templated2: Templated = `${value2} abc` as const;
 // Repro from #43620
 
 type Prefixes = "foo" | "bar";
->Prefixes : Prefixes
+>Prefixes : "foo" | "bar"
 
 type AllPrefixData = "foo:baz" | "bar:baz";
->AllPrefixData : AllPrefixData
+>AllPrefixData : "foo:baz" | "bar:baz"
 
 type PrefixData<P extends Prefixes> = `${P}:baz`;
 >PrefixData : `${P}:baz`
@@ -382,7 +382,7 @@ interface ITest<P extends Prefixes, E extends AllPrefixData = PrefixData<P>> {
 // Repro from #45906
 
 type Schema = { a: { b: { c: number } } };
->Schema : Schema
+>Schema : { a: {    b: {        c: number;    };}; }
 >a : { b: {    c: number;}; }
 >b : { c: number; }
 >c : number
@@ -481,7 +481,7 @@ function ff4(x: string, y: `foo-${string}`) {
 // Repro from #46045
 
 type Action =
->Action : Action
+>Action : { type: `${string}_REQUEST`; } | { type: `${string}_SUCCESS`; response: string; }
 
     | { type: `${string}_REQUEST` }
 >type : `${string}_REQUEST`
diff --git a/tests/baselines/reference/thisTypeInObjectLiterals2.types b/tests/baselines/reference/thisTypeInObjectLiterals2.types
index 227be40f79f39..3777ded41acaf 100644
--- a/tests/baselines/reference/thisTypeInObjectLiterals2.types
+++ b/tests/baselines/reference/thisTypeInObjectLiterals2.types
@@ -72,7 +72,7 @@ let obj1 = {
 // contextual type.
 
 type Point = {
->Point : Point
+>Point : { x: number; y: number; z?: number | undefined; moveBy(dx: number, dy: number, dz?: number | undefined): void; }
 
     x: number;
 >x : number
diff --git a/tests/baselines/reference/tryCatchFinallyControlFlow.types b/tests/baselines/reference/tryCatchFinallyControlFlow.types
index b5fb0cf95cc8c..ab2bae77befc2 100644
--- a/tests/baselines/reference/tryCatchFinallyControlFlow.types
+++ b/tests/baselines/reference/tryCatchFinallyControlFlow.types
@@ -592,7 +592,7 @@ function t1() {
 // Repro from #39043
 
 type State = { tag: "one" } | { tag: "two" } | { tag: "three" };
->State : State
+>State : { tag: "one"; } | { tag: "two"; } | { tag: "three"; }
 >tag : "one"
 >tag : "two"
 >tag : "three"
diff --git a/tests/baselines/reference/tsxAttributeResolution16.types b/tests/baselines/reference/tsxAttributeResolution16.types
index cd7ffb467683e..16e84687bbf11 100644
--- a/tests/baselines/reference/tsxAttributeResolution16.types
+++ b/tests/baselines/reference/tsxAttributeResolution16.types
@@ -21,7 +21,7 @@ interface AmericanAddress extends Address {
 }
 
 type Properties = CanadianAddress | AmericanAddress;
->Properties : Properties
+>Properties : CanadianAddress | AmericanAddress
 
 export class AddressComp extends React.Component<Properties, void> {
 >AddressComp : AddressComp
diff --git a/tests/baselines/reference/tsxAttributesHasInferrableIndex.types b/tests/baselines/reference/tsxAttributesHasInferrableIndex.types
index 25e76e39628ac..81e88424a5478 100644
--- a/tests/baselines/reference/tsxAttributesHasInferrableIndex.types
+++ b/tests/baselines/reference/tsxAttributesHasInferrableIndex.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/tsxAttributesHasInferrableIndex.tsx ===
 type AttributeValue = number | string | Date | boolean;
->AttributeValue : AttributeValue
+>AttributeValue : string | number | boolean | Date
 
 interface Attributes {
     [key: string]: AttributeValue;
diff --git a/tests/baselines/reference/tsxDiscriminantPropertyInference.types b/tests/baselines/reference/tsxDiscriminantPropertyInference.types
index 63932bd18d963..0bd5fcd52890a 100644
--- a/tests/baselines/reference/tsxDiscriminantPropertyInference.types
+++ b/tests/baselines/reference/tsxDiscriminantPropertyInference.types
@@ -5,7 +5,7 @@ namespace JSX {
 }
 
 type DiscriminatorTrue = {
->DiscriminatorTrue : DiscriminatorTrue
+>DiscriminatorTrue : { disc: true; cb: (x: string) => void; }
 
     disc: true;
 >disc : true
@@ -17,7 +17,7 @@ type DiscriminatorTrue = {
 }
 
 type DiscriminatorFalse = {
->DiscriminatorFalse : DiscriminatorFalse
+>DiscriminatorFalse : { disc?: false | undefined; cb: (x: number) => void; }
 
     disc?: false;
 >disc : false | undefined
@@ -29,7 +29,7 @@ type DiscriminatorFalse = {
 }
 
 type Props = DiscriminatorTrue | DiscriminatorFalse;
->Props : Props
+>Props : DiscriminatorTrue | DiscriminatorFalse
 
 declare function Comp(props: DiscriminatorTrue | DiscriminatorFalse): JSX.Element;
 >Comp : (props: DiscriminatorTrue | DiscriminatorFalse) => JSX.Element
diff --git a/tests/baselines/reference/tsxLibraryManagedAttributes.types b/tests/baselines/reference/tsxLibraryManagedAttributes.types
index b6e54f2be01c1..10a67a7dbec09 100644
--- a/tests/baselines/reference/tsxLibraryManagedAttributes.types
+++ b/tests/baselines/reference/tsxLibraryManagedAttributes.types
@@ -48,7 +48,7 @@ declare namespace PropTypes {
 }
 
 type ReactNode = string | number | ReactComponent<{}, {}>;
->ReactNode : ReactNode
+>ReactNode : string | number | ReactComponent<{}, {}>
 
 declare class ReactComponent<P={}, S={}> {
 >ReactComponent : ReactComponent<P, S>
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution6.types b/tests/baselines/reference/tsxSpreadAttributesResolution6.types
index f8abfc34b2301..e2ab1cfd1464f 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution6.types
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution6.types
@@ -3,7 +3,7 @@ import React = require('react');
 >React : typeof React
 
 type TextProps = { editable: false }
->TextProps : TextProps
+>TextProps : { editable: false; } | { editable: true; onEdit: (newText: string) => void; }
 >editable : false
 >false : false
 
diff --git a/tests/baselines/reference/tsxSpreadAttributesResolution7.types b/tests/baselines/reference/tsxSpreadAttributesResolution7.types
index 532a6a73b494e..f2a94ac6b71a0 100644
--- a/tests/baselines/reference/tsxSpreadAttributesResolution7.types
+++ b/tests/baselines/reference/tsxSpreadAttributesResolution7.types
@@ -3,7 +3,7 @@ import React = require('react');
 >React : typeof React
 
 type TextProps = { editable: false }
->TextProps : TextProps
+>TextProps : { editable: false; } | { editable: true; onEdit: (newText: string) => void; }
 >editable : false
 >false : false
 
diff --git a/tests/baselines/reference/tsxTypeArgumentsJsxPreserveOutput.types b/tests/baselines/reference/tsxTypeArgumentsJsxPreserveOutput.types
index a03c907d3bbf2..4db5e2ee6faaa 100644
--- a/tests/baselines/reference/tsxTypeArgumentsJsxPreserveOutput.types
+++ b/tests/baselines/reference/tsxTypeArgumentsJsxPreserveOutput.types
@@ -3,7 +3,7 @@ import React = require('react');
 >React : typeof React
 
 type TypeProps = { foo?: boolean; };
->TypeProps : TypeProps
+>TypeProps : { foo?: boolean; }
 >foo : boolean
 
 interface InterfaceProps { foo?: boolean; }
diff --git a/tests/baselines/reference/tsxUnionSpread.types b/tests/baselines/reference/tsxUnionSpread.types
index f03fef7837730..def68a2e87682 100644
--- a/tests/baselines/reference/tsxUnionSpread.types
+++ b/tests/baselines/reference/tsxUnionSpread.types
@@ -4,16 +4,16 @@ namespace JSX {
 }
 
 export type CatInfo = { type: 'Cat'; subType: string; };
->CatInfo : CatInfo
+>CatInfo : { type: 'Cat'; subType: string; }
 >type : "Cat"
 >subType : string
 
 export type DogInfo = { type: 'Dog'; };
->DogInfo : DogInfo
+>DogInfo : { type: 'Dog'; }
 >type : "Dog"
 
 export type AnimalInfo = CatInfo | DogInfo;
->AnimalInfo : AnimalInfo
+>AnimalInfo : CatInfo | DogInfo
 
 function AnimalComponent(info: AnimalInfo): JSX.Element {
 >AnimalComponent : (info: AnimalInfo) => JSX.Element
diff --git a/tests/baselines/reference/tsxUnionTypeComponent2.types b/tests/baselines/reference/tsxUnionTypeComponent2.types
index e8ca5d6af5505..f03c9bf35986d 100644
--- a/tests/baselines/reference/tsxUnionTypeComponent2.types
+++ b/tests/baselines/reference/tsxUnionTypeComponent2.types
@@ -3,7 +3,7 @@ import React = require('react');
 >React : typeof React
 
 type Invalid1 = React.ComponentClass<any> | number;
->Invalid1 : Invalid1
+>Invalid1 : number | React.ComponentClass<any>
 >React : any
 
 const X: Invalid1 = 1;
diff --git a/tests/baselines/reference/tupleTypes.types b/tests/baselines/reference/tupleTypes.types
index a1b0a345f00f1..ba2654609c181 100644
--- a/tests/baselines/reference/tupleTypes.types
+++ b/tests/baselines/reference/tupleTypes.types
@@ -227,7 +227,7 @@ a3 = a2;
 >a2 : [number, number]
 
 type B = Pick<[number], 'length'>;
->B : B
+>B : { length: 1; }
 
 declare const b: B;
 >b : B
diff --git a/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.types b/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.types
index 76d0aa9a96bda..532fef8e8cf47 100644
--- a/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.types
+++ b/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.types
@@ -2,7 +2,7 @@
 declare module m {
     // type alias declaration here shouldnt make the module declaration instantiated
     type Selector = string| string[] |Function;
->Selector : Selector
+>Selector : string | Function | string[]
 
     export interface IStatic {
         (selector: any /* Selector */): IInstance;
diff --git a/tests/baselines/reference/typeAliasFunctionTypeSharedSymbol.types b/tests/baselines/reference/typeAliasFunctionTypeSharedSymbol.types
index 454ae1513e117..e028a8c4c0869 100644
--- a/tests/baselines/reference/typeAliasFunctionTypeSharedSymbol.types
+++ b/tests/baselines/reference/typeAliasFunctionTypeSharedSymbol.types
@@ -22,5 +22,5 @@ type ReturnTypeOf<V> = V extends (...args: any[])=>infer R ? R : never;
 >args : any[]
 
 type Crashes = number & Mixin;
->Crashes : Crashes
+>Crashes : number & { new (...args: any[]): Mixin<new (...args: any[]) => {}>.(Anonymous class); prototype: Mixin<any>.(Anonymous class); } & (new (...args: any[]) => {})
 
diff --git a/tests/baselines/reference/typeAliases.types b/tests/baselines/reference/typeAliases.types
index e884529260e97..be734e51a0b2d 100644
--- a/tests/baselines/reference/typeAliases.types
+++ b/tests/baselines/reference/typeAliases.types
@@ -72,7 +72,7 @@ var x7: T7;
 >x7 : C7
 
 type T8 = string | boolean;
->T8 : T8
+>T8 : string | boolean
 
 var x8: string | boolean;
 >x8 : string | boolean
@@ -81,7 +81,7 @@ var x8: T8;
 >x8 : string | boolean
 
 type T9 = () => string;
->T9 : T9
+>T9 : () => string
 
 var x9: () => string;
 >x9 : () => string
@@ -90,7 +90,7 @@ var x9: T9;
 >x9 : () => string
 
 type T10 = { x: number };
->T10 : T10
+>T10 : { x: number; }
 >x : number
 
 var x10: { x: number };
@@ -101,7 +101,7 @@ var x10: T10;
 >x10 : { x: number; }
 
 type T11 = { new(): boolean };
->T11 : T11
+>T11 : new () => boolean
 
 var x11: { new(): boolean };
 >x11 : new () => boolean
@@ -183,7 +183,7 @@ f15(E.x).toLowerCase();
 >toLowerCase : () => string
 
 type StringAndBoolean = [string, boolean]
->StringAndBoolean : StringAndBoolean
+>StringAndBoolean : [string, boolean]
 
 declare function f16(s: StringAndBoolean): string;
 >f16 : (s: StringAndBoolean) => string
diff --git a/tests/baselines/reference/typeAliasesForObjectTypes.types b/tests/baselines/reference/typeAliasesForObjectTypes.types
index b18b3159fe064..bbc5433da327c 100644
--- a/tests/baselines/reference/typeAliasesForObjectTypes.types
+++ b/tests/baselines/reference/typeAliasesForObjectTypes.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/typeAliases/typeAliasesForObjectTypes.ts ===
 type T1 = { x: string }
->T1 : T1
+>T1 : { x: string; }
 >x : string
 
 // An interface can be named in an extends or implements clause, but a type alias for an object type literal cannot.
@@ -16,7 +16,7 @@ class C1 implements T1 {
 
 // An interface can have multiple merged declarations, but a type alias for an object type literal cannot.
 type T2 = { x: string }
->T2 : T2
+>T2 : { x: string; }
 >x : string
 
 type T2 = { y: number }
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
index 2c1279b6170f5..62af144e81cd5 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts ===
 type TreeNode = {
->TreeNode : TreeNode
+>TreeNode : { name: string; parent: TreeNode; }
 
     name: string;
 >name : string
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
index 5a0765560b2ec..597064010c0e5 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts ===
 type TreeNode = {
->TreeNode : TreeNode
+>TreeNode : { name: string; parent: TreeNode; }
 
     name: string;
 >name : string
@@ -10,7 +10,7 @@ type TreeNode = {
 }
 
 type TreeNodeMiddleman = {
->TreeNodeMiddleman : TreeNodeMiddleman
+>TreeNodeMiddleman : { name: string; parent: TreeNode; }
 
     name: string;
 >name : string
diff --git a/tests/baselines/reference/typeGuardFunctionErrors.types b/tests/baselines/reference/typeGuardFunctionErrors.types
index 53fd02acdc707..dd0d8929c1eda 100644
--- a/tests/baselines/reference/typeGuardFunctionErrors.types
+++ b/tests/baselines/reference/typeGuardFunctionErrors.types
@@ -343,7 +343,7 @@ if (hasMissingParameter()) {
 // repro #17297
 
 type Keys = 'a'|'b'|'c'
->Keys : Keys
+>Keys : "a" | "b" | "c"
 
 type KeySet<T extends Keys> = { [k in T]: true }
 >KeySet : KeySet<T>
@@ -355,11 +355,11 @@ declare function hasKey<T extends Keys>(x: KeySet<T>): x is KeySet<T|'d'>;
 >x : KeySet<T>
 
 type Foo = { 'a': string; }
->Foo : Foo
+>Foo : { a: string; }
 >'a' : string
 
 type Bar = { 'a': number; }
->Bar : Bar
+>Bar : { a: number; }
 >'a' : number
 
 interface NeedsFoo<T extends Foo> {
diff --git a/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty1.types b/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty1.types
index ee4fc6c2ec9c8..0e66a773604be 100644
--- a/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty1.types
+++ b/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty1.types
@@ -28,7 +28,7 @@ interface Square {
 >radius : number
 }
  type Shape = Square | Rectangle | Circle;
->Shape : Shape
+>Shape : Square | Rectangle | Circle
 
 interface Subshape {
     "0": {
@@ -208,16 +208,16 @@ interface Y {
 }
 
 type A = ["aa", number];
->A : A
+>A : ["aa", number]
 
 type B = ["bb", string];
->B : B
+>B : ["bb", string]
 
 type Z = X | Y;
->Z : Z
+>Z : X | Y
 
 type C = A | B;
->C : C
+>C : A | B
 
 function check(z: Z, c: C) {
 >check : (z: Z, c: C) => void
diff --git a/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty3.types b/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty3.types
index b4c751d074398..4052ca4ac5ba9 100644
--- a/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty3.types
+++ b/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty3.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/typeGuardNarrowsIndexedAccessOfKnownProperty3.ts ===
 type Foo = (number | undefined)[] | undefined;
->Foo : Foo
+>Foo : (number | undefined)[] | undefined
 
 const foo: Foo = [1, 2, 3];
 >foo : Foo
diff --git a/tests/baselines/reference/typeGuardNarrowsPrimitiveIntersection.types b/tests/baselines/reference/typeGuardNarrowsPrimitiveIntersection.types
index 0a9ae9c4cf1b5..544134e72e6e5 100644
--- a/tests/baselines/reference/typeGuardNarrowsPrimitiveIntersection.types
+++ b/tests/baselines/reference/typeGuardNarrowsPrimitiveIntersection.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/expressions/typeGuards/typeGuardNarrowsPrimitiveIntersection.ts ===
 type Tag = {__tag: any};
->Tag : Tag
+>Tag : { __tag: any; }
 >__tag : any
 
 declare function isNonBlank(value: string) : value is (string & Tag);
diff --git a/tests/baselines/reference/typeInferenceLiteralUnion.types b/tests/baselines/reference/typeInferenceLiteralUnion.types
index c8718f7515eb8..3b44e2424c310 100644
--- a/tests/baselines/reference/typeInferenceLiteralUnion.types
+++ b/tests/baselines/reference/typeInferenceLiteralUnion.types
@@ -4,7 +4,7 @@
  * Administrivia: JavaScript primitive types and Date
  */
 export type Primitive = number | string | boolean | Date;
->Primitive : Primitive
+>Primitive : string | number | boolean | Date
 
 /**
  * Administrivia: anything with a valueOf(): number method is comparable, so we allow it in numeric operations
diff --git a/tests/baselines/reference/typeOfThisInstanceMemberNarrowedWithLoopAntecedent.types b/tests/baselines/reference/typeOfThisInstanceMemberNarrowedWithLoopAntecedent.types
index 7938c5ec6e14c..336c3daa9effb 100644
--- a/tests/baselines/reference/typeOfThisInstanceMemberNarrowedWithLoopAntecedent.types
+++ b/tests/baselines/reference/typeOfThisInstanceMemberNarrowedWithLoopAntecedent.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInstanceMemberNarrowedWithLoopAntecedent.ts ===
 // #31995
 type State = {
->State : State
+>State : { type: "numberVariant"; data: number; } | { type: "stringVariant"; data: string; }
 
     type: "numberVariant";
 >type : "numberVariant"
diff --git a/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.types b/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.types
index ba87f02355e51..008f1c3164362 100644
--- a/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.types
+++ b/tests/baselines/reference/typeParameterExtendsUnionConstraintDistributed.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/jsdoc/typeParameterExtendsUnionConstraintDistributed.ts ===
 type A = 1 | 2;
->A : A
+>A : 1 | 2
 
 function f<T extends A>(a: T): A & T { return a; } // Shouldn't error
 >f : <T extends A>(a: T) => A & T
@@ -8,7 +8,7 @@ function f<T extends A>(a: T): A & T { return a; } // Shouldn't error
 >a : T
 
 type B = 2 | 3;
->B : B
+>B : 2 | 3
 
 function f2<T extends A, U extends B>(ab: T & U): (A | B) & T & U { return ab; } // Also shouldn't error
 >f2 : <T extends A, U extends B>(ab: T & U) => (A | B) & T & U
diff --git a/tests/baselines/reference/typeParameterLeak.types b/tests/baselines/reference/typeParameterLeak.types
index f7d14ea165ecc..d4e281a119a82 100644
--- a/tests/baselines/reference/typeParameterLeak.types
+++ b/tests/baselines/reference/typeParameterLeak.types
@@ -5,7 +5,7 @@ interface Box<T> { data: T }
 >data : T
 
 type BoxTypes = Box<{ x: string }> | Box<{ y: string }>;
->BoxTypes : BoxTypes
+>BoxTypes : Box<{ x: string; }> | Box<{ y: string; }>
 >x : string
 >y : string
 
diff --git a/tests/baselines/reference/typePredicateStructuralMatch.types b/tests/baselines/reference/typePredicateStructuralMatch.types
index 4d0b371b1071d..ae7238400c6f2 100644
--- a/tests/baselines/reference/typePredicateStructuralMatch.types
+++ b/tests/baselines/reference/typePredicateStructuralMatch.types
@@ -26,11 +26,11 @@ getResults2({data: []});
 >[] : undefined[]
 
 type Result = { value: string };
->Result : Result
+>Result : { value: string; }
 >value : string
 
 type Results = Result[];
->Results : Results
+>Results : Result[]
 
 function isResponseInData<T>(value: T | { data: T}): value is { data: T } {
 >isResponseInData : <T>(value: T | {    data: T;}) => value is { data: T; }
diff --git a/tests/baselines/reference/typePredicatesInUnion.types b/tests/baselines/reference/typePredicatesInUnion.types
index 23d22fa598ee3..5cc8ffb6f3d2f 100644
--- a/tests/baselines/reference/typePredicatesInUnion.types
+++ b/tests/baselines/reference/typePredicatesInUnion.types
@@ -11,7 +11,7 @@ interface B {
 }
 
 type Or = A | B;
->Or : Or
+>Or : A | B
 
 function f(o: Or, x: {}) {
 >f : (o: Or, x: {}) => void
diff --git a/tests/baselines/reference/typePredicatesInUnion_noMatch.types b/tests/baselines/reference/typePredicatesInUnion_noMatch.types
index 2dacc990817f0..8f63b31061121 100644
--- a/tests/baselines/reference/typePredicatesInUnion_noMatch.types
+++ b/tests/baselines/reference/typePredicatesInUnion_noMatch.types
@@ -13,7 +13,7 @@ interface B {
 }
 
 type Or = A | B;
->Or : Or
+>Or : A | B
 
 function f(o: Or, x: {}, y: {}) {
 >f : (o: Or, x: {}, y: {}) => void
diff --git a/tests/baselines/reference/typeUsedAsTypeLiteralIndex.types b/tests/baselines/reference/typeUsedAsTypeLiteralIndex.types
index 3b95394188538..8ce6282d13b6c 100644
--- a/tests/baselines/reference/typeUsedAsTypeLiteralIndex.types
+++ b/tests/baselines/reference/typeUsedAsTypeLiteralIndex.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/typeUsedAsTypeLiteralIndex.ts ===
 type K = number | string;
->K : K
+>K : string | number
 
 type T = {
->T : T
+>T : {}
 
     [K]: number;  // Did you mean to use 'P in K'?
 >[K] : number
@@ -16,7 +16,7 @@ const K1 = Symbol();
 >Symbol : SymbolConstructor
 
 type T1 = {
->T1 : T1
+>T1 : { [K1]: number; }
 
     [K1]: number;
 >[K1] : number
@@ -24,10 +24,10 @@ type T1 = {
 }
 
 type K2 = "x" | "y";
->K2 : K2
+>K2 : "x" | "y"
 
 type T2 = {
->T2 : T2
+>T2 : {}
 
     [K2]: number;  // Did you mean to use 'K in K2'?
 >[K2] : number
@@ -35,10 +35,10 @@ type T2 = {
 }
 
 type K3 = number | string;
->K3 : K3
+>K3 : string | number
 
 type T3 = {
->T3 : T3
+>T3 : {}
 
     [K3]: number; // Did you mean to use 'K in K3'?
 >[K3] : number
@@ -46,10 +46,10 @@ type T3 = {
 }
 
 type K4 = number | string;
->K4 : K4
+>K4 : string | number
 
 type T4 = {
->T4 : T4
+>T4 : { k4: string; }
 
     [K4]: number;
 >[K4] : number
diff --git a/tests/baselines/reference/typeUsedAsValueError.types b/tests/baselines/reference/typeUsedAsValueError.types
index 7fb9b0e6921a4..cdac54e117c95 100644
--- a/tests/baselines/reference/typeUsedAsValueError.types
+++ b/tests/baselines/reference/typeUsedAsValueError.types
@@ -12,7 +12,7 @@ type TypeAliasForSomeClass = SomeClass;
 >TypeAliasForSomeClass : SomeClass
 
 type someType = { x: number };
->someType : someType
+>someType : { x: number; }
 >x : number
 
 function acceptsSomeType(a: someType) {
diff --git a/tests/baselines/reference/typeVariableTypeGuards.types b/tests/baselines/reference/typeVariableTypeGuards.types
index 063f6bbc96d55..9f6f45935a7a9 100644
--- a/tests/baselines/reference/typeVariableTypeGuards.types
+++ b/tests/baselines/reference/typeVariableTypeGuards.types
@@ -90,7 +90,7 @@ class BigMonkey extends Monkey<BigBanana> {
 // Another repro
 
 type Item = {
->Item : Item
+>Item : { (): string; x: string; }
 
     (): string;
     x: string;
diff --git a/tests/baselines/reference/typeofStripsFreshness.types b/tests/baselines/reference/typeofStripsFreshness.types
index 48c68bc749588..152050af563fa 100644
--- a/tests/baselines/reference/typeofStripsFreshness.types
+++ b/tests/baselines/reference/typeofStripsFreshness.types
@@ -31,7 +31,7 @@ type Another = typeof ANOTHER;
 >ANOTHER : "another"
 
 type Both = Another | All;
->Both : Both
+>Both : "all" | "another"
 
 const result2: Collection<Both> = new Collection();
 >result2 : Collection<Both>
diff --git a/tests/baselines/reference/typeofUsedBeforeBlockScoped.types b/tests/baselines/reference/typeofUsedBeforeBlockScoped.types
index ec8e30bb135a6..b56f1bee2ceb3 100644
--- a/tests/baselines/reference/typeofUsedBeforeBlockScoped.types
+++ b/tests/baselines/reference/typeofUsedBeforeBlockScoped.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/typeofUsedBeforeBlockScoped.ts ===
 type T = typeof C & typeof C.s & typeof o & typeof o.n;
->T : T
+>T : typeof C & number & { n: number; }
 >C : typeof C
 >C.s : number
 >C : typeof C
diff --git a/tests/baselines/reference/unionErrorMessageOnMatchingDiscriminant.types b/tests/baselines/reference/unionErrorMessageOnMatchingDiscriminant.types
index 4a02a5a5b88db..e4cb822394075 100644
--- a/tests/baselines/reference/unionErrorMessageOnMatchingDiscriminant.types
+++ b/tests/baselines/reference/unionErrorMessageOnMatchingDiscriminant.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/unionErrorMessageOnMatchingDiscriminant.ts ===
 type A = {
->A : A
+>A : { type: 'a'; data: {    a: string;}; }
 
     type: 'a',
 >type : "a"
@@ -12,7 +12,7 @@ type A = {
 };
 
 type B = {
->B : B
+>B : { type: 'b'; data: null; }
 
     type: 'b',
 >type : "b"
@@ -24,7 +24,7 @@ type B = {
 };
 
 type C = {
->C : C
+>C : { type: 'c'; payload: string; }
 
     type: 'c',
 >type : "c"
@@ -35,7 +35,7 @@ type C = {
 };
 
 type Union = A | B | C;
->Union : Union
+>Union : A | B | C
 
 // error
 const foo: Union = {
diff --git a/tests/baselines/reference/unionPropertyExistence.types b/tests/baselines/reference/unionPropertyExistence.types
index a57ce2fcfa671..3450a2a408794 100644
--- a/tests/baselines/reference/unionPropertyExistence.types
+++ b/tests/baselines/reference/unionPropertyExistence.types
@@ -30,10 +30,10 @@ interface C {
 }
 
 type AB = A | B;
->AB : AB
+>AB : A | B
 
 type ABC = C | AB;
->ABC : ABC
+>ABC : C | AB
 
 var ab: AB;
 >ab : AB
diff --git a/tests/baselines/reference/unionTypeCallSignatures4.types b/tests/baselines/reference/unionTypeCallSignatures4.types
index a5628129dbe5c..f9a5c5f259eb1 100644
--- a/tests/baselines/reference/unionTypeCallSignatures4.types
+++ b/tests/baselines/reference/unionTypeCallSignatures4.types
@@ -1,28 +1,28 @@
 === tests/cases/conformance/types/union/unionTypeCallSignatures4.ts ===
 type F1 = (a: string, b?: string) => void;
->F1 : F1
+>F1 : (a: string, b?: string) => void
 >a : string
 >b : string
 
 type F2 = (a: string, b?: string, c?: string) => void;
->F2 : F2
+>F2 : (a: string, b?: string, c?: string) => void
 >a : string
 >b : string
 >c : string
 
 type F3 = (a: string, ...rest: string[]) => void;
->F3 : F3
+>F3 : (a: string, ...rest: string[]) => void
 >a : string
 >rest : string[]
 
 type F4 = (a: string, b?: string, ...rest: string[]) => void;
->F4 : F4
+>F4 : (a: string, b?: string, ...rest: string[]) => void
 >a : string
 >b : string
 >rest : string[]
 
 type F5 = (a: string, b: string) => void;
->F5 : F5
+>F5 : (a: string, b: string) => void
 >a : string
 >b : string
 
diff --git a/tests/baselines/reference/unionTypeCallSignatures6.types b/tests/baselines/reference/unionTypeCallSignatures6.types
index fbb6dda54fb9c..a023a1fa0d60c 100644
--- a/tests/baselines/reference/unionTypeCallSignatures6.types
+++ b/tests/baselines/reference/unionTypeCallSignatures6.types
@@ -1,30 +1,30 @@
 === tests/cases/conformance/types/union/unionTypeCallSignatures6.ts ===
 type A = { a: string };
->A : A
+>A : { a: string; }
 >a : string
 
 type B = { b: number };
->B : B
+>B : { b: number; }
 >b : number
 
 type C = { c: string };
->C : C
+>C : { c: string; }
 >c : string
 
 type D = { d: number };
->D : D
+>D : { d: number; }
 >d : number
 
 type F0 = () => void;
->F0 : F0
+>F0 : () => void
 
 // #31547
 type F1 = (this: A) => void;
->F1 : F1
+>F1 : (this: A) => void
 >this : A
 
 type F2 = (this: B) => void;
->F2 : F2
+>F2 : (this: B) => void
 >this : B
 
 declare var f1: F1 | F2;
@@ -124,7 +124,7 @@ x2.f4();
 >f4 : F3 | F5
 
 type F6 = (this: A & B) => void;
->F6 : F6
+>F6 : (this: A & B) => void
 >this : A & B
 
 declare var f3: F1 | F6;
diff --git a/tests/baselines/reference/unionTypeReduction2.types b/tests/baselines/reference/unionTypeReduction2.types
index 740ee28910069..f4f724e6dcdb0 100644
--- a/tests/baselines/reference/unionTypeReduction2.types
+++ b/tests/baselines/reference/unionTypeReduction2.types
@@ -166,14 +166,14 @@ function f6(x: (x: 'hello' | undefined) => void, y: (x?: string) => void) {
 }
 
 type A = {
->A : A
+>A : { f(): void; }
 
     f(): void;
 >f : () => void
 }
 
 type B = {
->B : B
+>B : { f(x?: string | undefined): void; g(): void; }
 
     f(x?: string): void;
 >f : (x?: string | undefined) => void
diff --git a/tests/baselines/reference/unionTypeWithIndexSignature.types b/tests/baselines/reference/unionTypeWithIndexSignature.types
index 417d62e706e9a..6392f8846bac5 100644
--- a/tests/baselines/reference/unionTypeWithIndexSignature.types
+++ b/tests/baselines/reference/unionTypeWithIndexSignature.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/union/unionTypeWithIndexSignature.ts ===
 type Two = { foo: { bar: true }, baz: true } | { [s: string]: string };
->Two : Two
+>Two : { foo: {    bar: true;}; baz: true; } | { [s: string]: string; }
 >foo : { bar: true; }
 >bar : true
 >true : true
@@ -26,7 +26,7 @@ u.baz = 'hi'
 >'hi' : "hi"
 
 type Three = { foo: number } | { [s: string]: string } | { [s: string]: boolean };
->Three : Three
+>Three : { foo: number; } | { [s: string]: string; } | { [s: string]: boolean; }
 >foo : number
 >s : string
 >s : string
@@ -42,7 +42,7 @@ v.foo = false
 >false : false
 
 type Missing = { foo: number, bar: true } | { [s: string]: string } | { foo: boolean }
->Missing : Missing
+>Missing : { foo: number; bar: true; } | { [s: string]: string; } | { foo: boolean; }
 >foo : number
 >bar : true
 >true : true
@@ -65,7 +65,7 @@ m.bar
 >bar : any
 
 type RO = { foo: number } | { readonly [s: string]: string }
->RO : RO
+>RO : { foo: number; } | { readonly [s: string]: string; }
 >foo : number
 >s : string
 
@@ -80,7 +80,7 @@ ro.foo = 'not allowed'
 >'not allowed' : "not allowed"
 
 type Num = { '0': string } | { [n: number]: number }
->Num : Num
+>Num : { '0': string; } | { [n: number]: number; }
 >'0' : string
 >n : number
 
@@ -107,7 +107,7 @@ const sym = Symbol()
 >Symbol : SymbolConstructor
 
 type Both = { s: number, '0': number, [sym]: boolean } | { [n: number]: number, [s: string]: string | number }
->Both : Both
+>Both : { s: number; '0': number; [sym]: boolean; } | { [n: number]: number; [s: string]: string | number; }
 >s : number
 >'0' : number
 >[sym] : boolean
diff --git a/tests/baselines/reference/unionTypeWithIndexedLiteralType.types b/tests/baselines/reference/unionTypeWithIndexedLiteralType.types
index 47d1d6832e183..37d9f9d3de4fc 100644
--- a/tests/baselines/reference/unionTypeWithIndexedLiteralType.types
+++ b/tests/baselines/reference/unionTypeWithIndexedLiteralType.types
@@ -6,7 +6,7 @@ interface Idx { [index: string]: U; }
 >index : string
 
 type U = Idx | I | "lit";
->U : U
+>U : I | Idx | "lit"
 
 const u: U = { x: "lit" };
 >u : U
diff --git a/tests/baselines/reference/unionTypeWithLeadingOperator.types b/tests/baselines/reference/unionTypeWithLeadingOperator.types
index 63d2e7c018d5f..5f3c74e011f6b 100644
--- a/tests/baselines/reference/unionTypeWithLeadingOperator.types
+++ b/tests/baselines/reference/unionTypeWithLeadingOperator.types
@@ -3,7 +3,7 @@ type A = | string;
 >A : string
 
 type B =
->B : B
+>B : { type: "INCREMENT"; } | { type: "DECREMENT"; }
 
   | { type: "INCREMENT" }
 >type : "INCREMENT"
@@ -12,10 +12,10 @@ type B =
 >type : "DECREMENT"
 
 type C = [| 0 | 1, | "foo" | "bar"];
->C : C
+>C : [0 | 1, "foo" | "bar"]
 
 export type D = 
->D : D
+>D : 1 | 2
 
   /*leading0*/
   | /*leading1*/ 1 /*trailing1*/ 
diff --git a/tests/baselines/reference/unionWithIndexSignature.types b/tests/baselines/reference/unionWithIndexSignature.types
index 60eba708cec19..5acb5391f814f 100644
--- a/tests/baselines/reference/unionWithIndexSignature.types
+++ b/tests/baselines/reference/unionWithIndexSignature.types
@@ -28,7 +28,7 @@ export function foo<T extends NumList | StrList>(arr: T & (NumList | StrList)) {
 // Repro from #38102
 
 export type TypedArray = Int32Array | Uint8Array;
->TypedArray : TypedArray
+>TypedArray : Int32Array | Uint8Array
 
 export function isTypedArray(a: {}): a is Int32Array | Uint8Array {
 >isTypedArray : (a: {}) => a is Int32Array | Uint8Array
diff --git a/tests/baselines/reference/unionsOfTupleTypes1.types b/tests/baselines/reference/unionsOfTupleTypes1.types
index f1142821d2850..45ad08eeeb3e4 100644
--- a/tests/baselines/reference/unionsOfTupleTypes1.types
+++ b/tests/baselines/reference/unionsOfTupleTypes1.types
@@ -1,15 +1,15 @@
 === tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts ===
 type T1 = [string, number];
->T1 : T1
+>T1 : [string, number]
 
 type T2 = [boolean] | [string, number];
->T2 : T2
+>T2 : [boolean] | [string, number]
 
 type T3 = [string, ...number[]];
->T3 : T3
+>T3 : [string, ...number[]]
 
 type T4 = [boolean] | [string, ...number[]];
->T4 : T4
+>T4 : [boolean] | [string, ...number[]]
 
 type T10 = T1[0];  // string
 >T10 : string
@@ -251,7 +251,7 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) {
 // Repro from #27543
 
 type Unioned = [string] | [string, number];
->Unioned : Unioned
+>Unioned : [string, number] | [string]
 
 const ex: Unioned = ["hi"] as Unioned;
 >ex : Unioned
diff --git a/tests/baselines/reference/uniqueSymbols.types b/tests/baselines/reference/uniqueSymbols.types
index 4a89412efae38..aa956c4045ca8 100644
--- a/tests/baselines/reference/uniqueSymbols.types
+++ b/tests/baselines/reference/uniqueSymbols.types
@@ -331,7 +331,7 @@ const constInitToIReadonlyTypeWithIndexedAccess: I["readonlyType"] = i.readonlyT
 
 // type literals
 type L = {
->L : L
+>L : { readonly readonlyType: unique symbol; nested: {    readonly readonlyNestedType: unique symbol;}; }
 
     readonly readonlyType: unique symbol;
 >readonlyType : unique symbol
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.types b/tests/baselines/reference/uniqueSymbolsDeclarations.types
index 56ab89dea9cf1..018b6d50ad79c 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarations.types
+++ b/tests/baselines/reference/uniqueSymbolsDeclarations.types
@@ -324,7 +324,7 @@ const constInitToIReadonlyTypeWithIndexedAccess: I["readonlyType"] = i.readonlyT
 
 // type literals
 type L = {
->L : L
+>L : { readonly readonlyType: unique symbol; nested: {    readonly readonlyNestedType: unique symbol;}; }
 
     readonly readonlyType: unique symbol;
 >readonlyType : unique symbol
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.types b/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.types
index dc135a10d10e8..402d82eda3f29 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.types
+++ b/tests/baselines/reference/uniqueSymbolsDeclarationsErrors.types
@@ -76,7 +76,7 @@ export interface InterfaceWithPrivateNamedMethods {
 }
 
 export type TypeLiteralWithPrivateNamedProperties = {
->TypeLiteralWithPrivateNamedProperties : TypeLiteralWithPrivateNamedProperties
+>TypeLiteralWithPrivateNamedProperties : { [s]: any; }
 
     [s]: any;
 >[s] : any
@@ -84,7 +84,7 @@ export type TypeLiteralWithPrivateNamedProperties = {
 }
 
 export type TypeLiteralWithPrivateNamedMethods = {
->TypeLiteralWithPrivateNamedMethods : TypeLiteralWithPrivateNamedMethods
+>TypeLiteralWithPrivateNamedMethods : { [s](): any; }
 
     [s](): any;
 >[s] : () => any
diff --git a/tests/baselines/reference/uniqueSymbolsErrors.types b/tests/baselines/reference/uniqueSymbolsErrors.types
index 09f03a8ee11ea..6422ec64129d8 100644
--- a/tests/baselines/reference/uniqueSymbolsErrors.types
+++ b/tests/baselines/reference/uniqueSymbolsErrors.types
@@ -150,7 +150,7 @@ interface InvalidInterface {
 
 // type literals
 type InvalidTypeLiteral = {
->InvalidTypeLiteral : InvalidTypeLiteral
+>InvalidTypeLiteral : { invalidPropertyType: unique symbol; invalidArgType(arg: unique symbol): void; invalidRestArgType(...args: (unique symbol)[]): void; invalidReturnType(): unique symbol; invalidThisType(this: unique symbol): any; invalidTypePredicate(n: any): n is symbol; invalidTypeParameterConstraint<T extends symbol>(): void; invalidTypeParameterDefault<T = symbol>(): void; }
 
     invalidPropertyType: unique symbol;
 >invalidPropertyType : symbol
diff --git a/tests/baselines/reference/unknownType1.types b/tests/baselines/reference/unknownType1.types
index 09bd22fde04c5..c6911e0bf3bdd 100644
--- a/tests/baselines/reference/unknownType1.types
+++ b/tests/baselines/reference/unknownType1.types
@@ -91,7 +91,7 @@ type T35<T> = T extends unknown ? { x: T } : false;
 >false : false
 
 type T36 = T35<string | number>;  // { x: string } | { x: number }
->T36 : T36
+>T36 : { x: string; } | { x: number; }
 
 type T37 = T35<any>;  // { x: any }
 >T37 : { x: any; }
diff --git a/tests/baselines/reference/unknownType2.types b/tests/baselines/reference/unknownType2.types
index 72122f043d0c0..cbb9269c76304 100644
--- a/tests/baselines/reference/unknownType2.types
+++ b/tests/baselines/reference/unknownType2.types
@@ -9,7 +9,7 @@ type isTrue<T extends true> = T;
 >true : true
 
 type SomeResponse = 'yes' | 'no' | 'idk';
->SomeResponse : SomeResponse
+>SomeResponse : "yes" | "no" | "idk"
 
 let validate: (x: unknown) => SomeResponse = x => (x === 'yes' || x === 'no') ? x : 'idk'; // No error
 >validate : (x: unknown) => SomeResponse
diff --git a/tests/baselines/reference/unparenthesizedConstructorTypeInUnionOrIntersection.types b/tests/baselines/reference/unparenthesizedConstructorTypeInUnionOrIntersection.types
index bc133b3fe8218..0179b1129ea41 100644
--- a/tests/baselines/reference/unparenthesizedConstructorTypeInUnionOrIntersection.types
+++ b/tests/baselines/reference/unparenthesizedConstructorTypeInUnionOrIntersection.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/unparenthesizedConstructorTypeInUnionOrIntersection.ts ===
 type U1 = string | new () => void;
->U1 : U1
+>U1 : string | (new () => void)
 
 type U2 = string | new (foo: number) => void
->U2 : U2
+>U2 : string | (new (foo: number) => void)
 >foo : number
 
 type U3 = | new () => number
@@ -14,12 +14,12 @@ type U4 = | new (foo?: number) => void;
 >foo : number
 
 type U5 = string | new (number: number, foo?: string) => void | number;
->U5 : U5
+>U5 : string | (new (number: number, foo?: string) => void | number)
 >number : number
 >foo : string
 
 type U6 =
->U6 : U6
+>U6 : string | (new (...args: any[]) => void | number)
 
   | string
   | new (...args: any[]) => void
@@ -28,10 +28,10 @@ type U6 =
   | number;
 
 type I1 = string & new () => void;
->I1 : I1
+>I1 : string & (new () => void)
 
 type I2 = string & new (...foo: number[]) => void;
->I2 : I2
+>I2 : string & (new (...foo: number[]) => void)
 >foo : number[]
 
 type I3 = & new () => boolean
@@ -42,19 +42,19 @@ type I4 = & new () => boolean & null;
 >null : null
 
 type I5 = string & new (any: any, any2: any) => any & any;
->I5 : I5
+>I5 : string & (new (any: any, any2: any) => any & any)
 >any : any
 >any2 : any
 
 type I6 =
->I6 : I6
+>I6 : string & (new (foo: any) => void)
 
   & string
   & new (foo: any) => void;
 >foo : any
 
 type M1 = string | number & string | new () => number;
->M1 : M1
+>M1 : string | (new () => number)
 
 type M2 = any & string | any & new () => void;
 >M2 : any
@@ -64,8 +64,8 @@ type M3 = any & new (foo: any) => void | new () => void & any;
 >foo : any
 
 type OK1 = string | (new ()=> void);
->OK1 : OK1
+>OK1 : string | (new () => void)
 
 type OK2 = string | (new ()=> string | number);
->OK2 : OK2
+>OK2 : string | (new () => string | number)
 
diff --git a/tests/baselines/reference/unparenthesizedFunctionTypeInUnionOrIntersection.types b/tests/baselines/reference/unparenthesizedFunctionTypeInUnionOrIntersection.types
index 3a98c892d27be..876d3614b9710 100644
--- a/tests/baselines/reference/unparenthesizedFunctionTypeInUnionOrIntersection.types
+++ b/tests/baselines/reference/unparenthesizedFunctionTypeInUnionOrIntersection.types
@@ -1,9 +1,9 @@
 === tests/cases/compiler/unparenthesizedFunctionTypeInUnionOrIntersection.ts ===
 type U1 = string | () => void;
->U1 : U1
+>U1 : string | (() => void)
 
 type U2 = string | (foo: number) => void
->U2 : U2
+>U2 : string | ((foo: number) => void)
 >foo : number
 
 type U3 = | () => number
@@ -14,12 +14,12 @@ type U4 = | (foo?: number) => void;
 >foo : number
 
 type U5 = string | (number: number, foo?: string) => void | number;
->U5 : U5
+>U5 : string | ((number: number, foo?: string) => void | number)
 >number : number
 >foo : string
 
 type U6 =
->U6 : U6
+>U6 : string | ((...args: any[]) => void | number)
 
   | string
   | (...args: any[]) => void
@@ -28,10 +28,10 @@ type U6 =
   | number;
 
 type I1 = string & () => void;
->I1 : I1
+>I1 : string & (() => void)
 
 type I2 = string & (...foo: number[]) => void;
->I2 : I2
+>I2 : string & ((...foo: number[]) => void)
 >foo : number[]
 
 type I3 = & () => boolean
@@ -42,19 +42,19 @@ type I4 = & () => boolean & null;
 >null : null
 
 type I5 = string & (any: any, any2: any) => any & any;
->I5 : I5
+>I5 : string & ((any: any, any2: any) => any & any)
 >any : any
 >any2 : any
 
 type I6 =
->I6 : I6
+>I6 : string & ((foo: any) => void)
 
   & string
   & (foo: any) => void;
 >foo : any
 
 type M1 = string | number & string | () => number;
->M1 : M1
+>M1 : string | (() => number)
 
 type M2 = any & string | any & () => void;
 >M2 : any
@@ -64,14 +64,14 @@ type M3 = any & (foo: any) => void | () => void & any;
 >foo : any
 
 type OK1 = string | (number);
->OK1 : OK1
+>OK1 : string | number
 
 type OK2 = string | ((number));
->OK2 : OK2
+>OK2 : string | number
 
 type OK3 = string | (()=> void);
->OK3 : OK3
+>OK3 : string | (() => void)
 
 type OK4 = string | (()=> string | number);
->OK4 : OK4
+>OK4 : string | (() => string | number)
 
diff --git a/tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types b/tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types
index ff73539d3862a..da65ef518a7cd 100644
--- a/tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types
+++ b/tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/unusedLocalsAndParametersTypeAliases.ts ===
 // used in a declaration
 type handler1 = () => void;
->handler1 : handler1
+>handler1 : () => void
 
 export interface I1 {
     getHandler: handler1;
@@ -10,11 +10,11 @@ export interface I1 {
 
 // exported
 export type handler2 = () => void;
->handler2 : handler2
+>handler2 : () => void
 
 // used in extends clause
 type handler3 = () => void;
->handler3 : handler3
+>handler3 : () => void
 
 export interface I3<T extends handler3> {
     getHandler: T;
@@ -23,10 +23,10 @@ export interface I3<T extends handler3> {
 
 // used in another type alias declaration
 type handler4 = () => void;
->handler4 : handler4
+>handler4 : () => void
 
 type handler5 = handler4 | (()=>number);
->handler5 : handler5
+>handler5 : handler4 | (() => number)
 
 var x: handler5;
 >x : handler5
@@ -37,7 +37,7 @@ x();
 
 // used as type argument
 type handler6 = () => void;
->handler6 : handler6
+>handler6 : () => void
 
 var y: Array<handler6>;
 >y : handler6[]
diff --git a/tests/baselines/reference/unusedLocalsAndParametersTypeAliases2.types b/tests/baselines/reference/unusedLocalsAndParametersTypeAliases2.types
index 182cbc614a82f..3ad121bedf49e 100644
--- a/tests/baselines/reference/unusedLocalsAndParametersTypeAliases2.types
+++ b/tests/baselines/reference/unusedLocalsAndParametersTypeAliases2.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/unusedLocalsAndParametersTypeAliases2.ts ===
 // unused
 type handler1 = () => void;
->handler1 : handler1
+>handler1 : () => void
 
 
 function foo() {
diff --git a/tests/baselines/reference/varRequireFromTypescript.types b/tests/baselines/reference/varRequireFromTypescript.types
index 931f95e9bd5a2..72c4e7827c708 100644
--- a/tests/baselines/reference/varRequireFromTypescript.types
+++ b/tests/baselines/reference/varRequireFromTypescript.types
@@ -43,7 +43,7 @@ function f(greatest, wrap) {
 
 === tests/cases/conformance/salsa/ex.d.ts ===
 export type Greatest = { day: 1 }
->Greatest : Greatest
+>Greatest : { day: 1; }
 >day : 1
 
 export class Crunch {
diff --git a/tests/baselines/reference/variadicTuples1.types b/tests/baselines/reference/variadicTuples1.types
index 3bb6d7d6d65c2..3aa03e67b84b9 100644
--- a/tests/baselines/reference/variadicTuples1.types
+++ b/tests/baselines/reference/variadicTuples1.types
@@ -1390,7 +1390,7 @@ callApi(getOrgUser);
 // Repro from #40235
 
 type Numbers = number[];
->Numbers : Numbers
+>Numbers : number[]
 
 type Unbounded = [...Numbers, boolean];
 >Unbounded : [...number[], boolean]
diff --git a/tests/baselines/reference/variadicTuples2.types b/tests/baselines/reference/variadicTuples2.types
index b60c45bc727f6..f4c199cfc9c06 100644
--- a/tests/baselines/reference/variadicTuples2.types
+++ b/tests/baselines/reference/variadicTuples2.types
@@ -2,22 +2,22 @@
 // Declarations
 
 type V00 = [number, ...string[]];
->V00 : V00
+>V00 : [number, ...string[]]
 
 type V01 = [...string[], number];
->V01 : V01
+>V01 : [...string[], number]
 
 type V03 = [number, ...string[], number];
->V03 : V03
+>V03 : [number, ...string[], number]
 
 type V10 = [number, ...string[], ...boolean[]];  // Error
->V10 : V10
+>V10 : [number, ...string[], ...boolean[]]
 
 type V11 = [number, ...string[], boolean?];  // Error
->V11 : V11
+>V11 : [number, ...string[], (boolean | undefined)?]
 
 type V12 = [number, string?, boolean];  // Error
->V12 : V12
+>V12 : [number, (string | undefined)?, boolean]
 
 // Normalization
 
diff --git a/tests/baselines/reference/varianceCallbacksAndIndexedAccesses.types b/tests/baselines/reference/varianceCallbacksAndIndexedAccesses.types
index 6b4d90767b69d..b72eb2d1e28f8 100644
--- a/tests/baselines/reference/varianceCallbacksAndIndexedAccesses.types
+++ b/tests/baselines/reference/varianceCallbacksAndIndexedAccesses.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/varianceCallbacksAndIndexedAccesses.ts ===
 type Source = {
->Source : Source
+>Source : { <K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; }
 
     <K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
 >type : K
@@ -57,7 +57,7 @@ interface WindowLike<T> extends PostMessageObject<T> {
 >handler : Action1<any>
 }
 type Target = {
->Target : Target
+>Target : { (type: "message", handler: Action1<MessageEventLike<any>>): void; (type: string, handler: Action1<any>): void; }
 
     (type: "message", handler: Action1<MessageEventLike<any>>): void;
 >type : "message"
diff --git a/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.types b/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.types
index c46df5c0f5aef..45d50307daef3 100644
--- a/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.types
+++ b/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.types
@@ -142,7 +142,7 @@ type NeededInfo<MyNamespaceSchema = {}> = {
 };
 
 export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
->MyInfo : MyInfo
+>MyInfo : { ASchema: ToA<ToB<{ initialize: any; }>>; }
 >initialize : any
 
 const tmp1: MyInfo = null!;
diff --git a/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.types b/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.types
index 8218ca02dd59c..85cecc1423f0c 100644
--- a/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.types
+++ b/tests/baselines/reference/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.types
@@ -142,7 +142,7 @@ type NeededInfo<MyNamespaceSchema = {}> = {
 };
 
 export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
->MyInfo : MyInfo
+>MyInfo : { ASchema: ToA<ToB<{ initialize: any; }>>; }
 >initialize : any
 
 const tmp1: MyInfo = null!;
diff --git a/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.types b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.types
index 950ae7c336c39..6765e14f49e4e 100644
--- a/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.types
+++ b/tests/baselines/reference/varianceRepeatedlyPropegatesWithUnreliableFlag.types
@@ -1,10 +1,10 @@
 === tests/cases/compiler/varianceRepeatedlyPropegatesWithUnreliableFlag.ts ===
 type A = { a: number };
->A : A
+>A : { a: number; }
 >a : number
 
 type B = { b: number };
->B : B
+>B : { b: number; }
 >b : number
 
 type X<T> = ({ [K in keyof T]: T[K] } & Record<string, void>)[keyof T];
diff --git a/tests/baselines/reference/weakType.types b/tests/baselines/reference/weakType.types
index d2256478521e5..c85847c9889bf 100644
--- a/tests/baselines/reference/weakType.types
+++ b/tests/baselines/reference/weakType.types
@@ -64,15 +64,15 @@ doSomething(false);
 // this is an oddly popular way of defining settings
 // this example is from services/textChanges.ts
 type ConfigurableStart = { useStart?: boolean }
->ConfigurableStart : ConfigurableStart
+>ConfigurableStart : { useStart?: boolean; }
 >useStart : boolean
 
 type ConfigurableEnd = { useEnd?: boolean }
->ConfigurableEnd : ConfigurableEnd
+>ConfigurableEnd : { useEnd?: boolean; }
 >useEnd : boolean
 
 type ConfigurableStartEnd = ConfigurableStart & ConfigurableEnd
->ConfigurableStartEnd : ConfigurableStartEnd
+>ConfigurableStartEnd : ConfigurableStart & ConfigurableEnd
 
 interface InsertOptions {
     prefix?: string
@@ -82,7 +82,7 @@ interface InsertOptions {
 >suffix : string
 }
 type ChangeOptions = ConfigurableStartEnd & InsertOptions;
->ChangeOptions : ChangeOptions
+>ChangeOptions : ConfigurableStart & ConfigurableEnd & InsertOptions
 
 function del(options: ConfigurableStartEnd = {},
 >del : (options?: ConfigurableStartEnd, error?: {    error?: number;}) => void
@@ -131,11 +131,11 @@ let ctor: Ctor = K
 >K : typeof K
 
 type Spoiler = { nope?: string }
->Spoiler : Spoiler
+>Spoiler : { nope?: string; }
 >nope : string
 
 type Weak = {
->Weak : Weak
+>Weak : { a?: number; properties?: {    b?: number;}; }
 
     a?: number
 >a : number