TypeScript/tests/baselines/reference/exportImportAlias.types

=== tests/cases/conformance/internalModules/importDeclarations/exportImportAlias.ts ===
// expect no errors here

module A {
>A : typeof A

    export var x = 'hello world'
>x : string

    export class Point {
>Point : Point

        constructor(public x: number, public y: number) { }
>x : number
>y : number
    }
    export module B {
>B : unknown

        export interface Id {
>Id : Id

            name: string;
>name : string
        }
    }
}

module C {
>C : typeof C

    export import a = A;
>a : typeof a
>A : typeof a
}

var a: string = C.a.x;
>a : string
>C.a.x : string
>C.a : typeof A
>C : typeof C
>a : typeof A
>x : string

var b: { x: number; y: number; } = new C.a.Point(0, 0);
>b : { x: number; y: number; }
>x : number
>y : number
>new C.a.Point(0, 0) : A.Point
>C.a.Point : typeof A.Point
>C.a : typeof A
>C : typeof C
>a : typeof A
>Point : typeof A.Point

var c: { name: string };
>c : { name: string; }
>name : string

var c: C.a.B.Id;
>c : { name: string; }
>C : unknown
>a : unknown
>B : unknown
>Id : A.B.Id

module X {
>X : typeof X

    export function Y() {
>Y : typeof Y

        return 42;
    }

    export module Y {
>Y : typeof Y

        export class Point {
>Point : Point

            constructor(public x: number, public y: number) { }
>x : number
>y : number
        }
    }
}

module Z {
>Z : typeof Z

    // 'y' should be a fundule here
    export import y = X.Y;
>y : typeof y
>X : typeof X
>Y : typeof y
}

var m: number = Z.y();
>m : number
>Z.y() : number
>Z.y : typeof X.Y
>Z : typeof Z
>y : typeof X.Y

var n: { x: number; y: number; } = new Z.y.Point(0, 0);
>n : { x: number; y: number; }
>x : number
>y : number
>new Z.y.Point(0, 0) : X.Y.Point
>Z.y.Point : typeof X.Y.Point
>Z.y : typeof X.Y
>Z : typeof Z
>y : typeof X.Y
>Point : typeof X.Y.Point

module K {
>K : typeof K

    export class L {
>L : L

        constructor(public name: string) { }
>name : string
    }

    export module L {
>L : typeof L

        export var y = 12;
>y : number

        export interface Point {
>Point : Point

            x: number;
>x : number

            y: number;
>y : number
        }
    }
}

module M {
>M : typeof M

    export import D = K.L;
>D : typeof D
>K : typeof K
>L : D
}

var o: { name: string };
>o : { name: string; }
>name : string

var o = new M.D('Hello');
>o : { name: string; }
>new M.D('Hello') : K.L
>M.D : typeof K.L
>M : typeof M
>D : typeof K.L

var p: { x: number; y: number; }
>p : { x: number; y: number; }
>x : number
>y : number

var p: M.D.Point;
>p : { x: number; y: number; }
>M : unknown
>D : unknown
>Point : K.L.Point