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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
=== tests/cases/compiler/express.d.ts ===
declare module Express {
export interface Request { }
export interface Response { }
export interface Application { }
}
declare module "express" {
>"express" : typeof import("express")
function e(): e.Express;
>e : typeof import("tests/cases/compiler/express.d.ts")
>e : any
namespace e {
>e : typeof import("tests/cases/compiler/express.d.ts")
interface IRoute {
all(...handler: RequestHandler[]): IRoute;
>all : (...handler: RequestHandler[]) => IRoute
>handler : RequestHandler[]
}
interface IRouterMatcher<T> {
(name: string|RegExp, ...handlers: RequestHandler[]): T;
>name : string | RegExp
>handlers : RequestHandler[]
}
interface IRouter<T> extends RequestHandler {
route(path: string): IRoute;
>route : (path: string) => IRoute
>path : string
}
export function Router(options?: any): Router;
>Router : (options?: any) => Router
>options : any
export interface Router extends IRouter<Router> {}
interface Errback { (err: Error): void; }
>err : Error
interface Request extends Express.Request {
>Express : any
get (name: string): string;
>get : (name: string) => string
>name : string
}
interface Response extends Express.Response {
>Express : any
charset: string;
>charset : string
}
interface ErrorRequestHandler {
(err: any, req: Request, res: Response, next: Function): any;
>err : any
>req : Request
>res : Response
>next : Function
}
interface RequestHandler {
(req: Request, res: Response, next: Function): any;
>req : Request
>res : Response
>next : Function
}
interface Handler extends RequestHandler {}
interface RequestParamHandler {
(req: Request, res: Response, next: Function, param: any): any;
>req : Request
>res : Response
>next : Function
>param : any
}
interface Application extends IRouter<Application>, Express.Application {
>Express : any
routes: any;
>routes : any
}
interface Express extends Application {
createApplication(): Application;
>createApplication : () => Application
}
var static: any;
>static : any
}
export = e;
>e : typeof e
}
=== tests/cases/compiler/augmentation.ts ===
/// <reference path="express.d.ts"/>
import * as e from "express";
>e : typeof e
declare module "express" {
>"express" : typeof e
interface Request {
id: number;
>id : number
}
}
=== tests/cases/compiler/consumer.ts ===
import { Request } from "express";
>Request : any
import "./augmentation";
let x: Request;
>x : Request
const y = x.id;
>y : number
>x.id : number
>x : Request
>id : number
|
