1 | import net = require('net');
|
2 | import tls = require('tls');
|
3 | import https = require('https');
|
4 | import http = require('http');
|
5 | import events = require('events');
|
6 | import Stream = require('stream');
|
7 | import WebSocket = require('isomorphic-ws');
|
8 | import * as connect from 'connect';
|
9 |
|
10 | type ConstructorOf<Proto, CtorArgs extends any[]> = {
|
11 | (...args: CtorArgs): Proto;
|
12 | new(...args: CtorArgs): Proto;
|
13 | prototype: Proto;
|
14 | }
|
15 |
|
16 | export interface UtilsJSONParseOptions {
|
17 | reviver?: Function;
|
18 | }
|
19 |
|
20 | export interface UtilsJSONStringifyOptions {
|
21 | replacer?: Function;
|
22 | }
|
23 |
|
24 | export interface GenerateRequestOptions {
|
25 | version?: number;
|
26 | notificationIdNull?: boolean;
|
27 | generator?: IDGenerator;
|
28 | }
|
29 |
|
30 | export declare class Utils {
|
31 |
|
32 | static request(method: string, params: RequestParamsLike, options?: GenerateRequestOptions): JSONRPCRequest;
|
33 | static request(method: string, params: RequestParamsLike, id?: JSONRPCIDLike | null | undefined, options?: GenerateRequestOptions): JSONRPCRequest;
|
34 |
|
35 | static response(error: JSONRPCError | undefined | null, result: JSONRPCResultLike | undefined | null, id: JSONRPCIDLike | null | undefined, version?: number): JSONRPCVersionTwoRequest;
|
36 | static response(error: JSONRPCError | undefined | null, result: JSONRPCResultLike | undefined | null, id: JSONRPCIDLike | null | undefined, version:2): JSONRPCVersionTwoRequest;
|
37 | static response(error: JSONRPCError | undefined | null, result: JSONRPCResultLike | undefined | null, id: JSONRPCIDLike | null | undefined, version:1): JSONRPCVersionOneRequest;
|
38 |
|
39 | static generateId(): string;
|
40 |
|
41 | static merge(...objs: object[]): object;
|
42 |
|
43 | static parseStream(stream:Stream, options:UtilsJSONParseOptions, onRequest: (err?:Error, data?:any) => void): void;
|
44 |
|
45 | static parseBody(stream:Stream, options:UtilsJSONParseOptions, callback: (err?:Error, obj?:any) => void): void;
|
46 |
|
47 | static getHttpListener(self:http.Server, server:Server): Function;
|
48 |
|
49 | static isContentType(request:http.IncomingMessage, typ:string): boolean;
|
50 |
|
51 | static isMethod(request:http.IncomingMessage, method:string): boolean;
|
52 |
|
53 | static walk(obj:object, key:string, fn: (key:string, value:any) => any): object;
|
54 |
|
55 | static JSON: UtilsJSON;
|
56 |
|
57 | static Request: UtilsRequest;
|
58 |
|
59 | static Response: UtilsResponse;
|
60 |
|
61 | }
|
62 |
|
63 |
|
64 | export declare class utils extends Utils {
|
65 | }
|
66 |
|
67 | type UtilsJSON = {
|
68 | parse(str:string, options:UtilsJSONParseOptions | null | undefined, callback: (err?:Error, obj?:object) => void):void;
|
69 | stringify(obj:object, options:UtilsJSONStringifyOptions | null | undefined, callback: (err?:Error, str?:string) => void):void;
|
70 | }
|
71 |
|
72 | type UtilsRequest = {
|
73 | isBatch(request:any): boolean;
|
74 | isNotification(request:any): boolean;
|
75 | isValidVersionTwoRequest(request:any): boolean;
|
76 | isValidVersionOneRequest(request:any): boolean;
|
77 | isValidRequest(request:any, version?:number): boolean;
|
78 | }
|
79 |
|
80 | type UtilsResponse = {
|
81 | isValidError(error:any, version?:number): boolean;
|
82 | isValidResponse(response:any, version?:number): boolean;
|
83 | }
|
84 |
|
85 | export type RequestParamsLike = Array<any> | object | undefined;
|
86 |
|
87 | export interface JSONRPCError {
|
88 | code: number;
|
89 | message: string;
|
90 | data?: object;
|
91 | }
|
92 |
|
93 | export type JSONRPCErrorLike = Error | JSONRPCError;
|
94 |
|
95 | export interface JSONRPCVersionOneRequest {
|
96 | method: string;
|
97 | params: Array<any>;
|
98 | id: JSONRPCIDLike;
|
99 | }
|
100 |
|
101 | export interface JSONRPCVersionTwoRequest {
|
102 | jsonrpc: string;
|
103 | method: string;
|
104 | params: RequestParamsLike;
|
105 | id?: JSONRPCIDLike | null;
|
106 | }
|
107 |
|
108 | export type JSONRPCRequest = JSONRPCVersionOneRequest | JSONRPCVersionTwoRequest;
|
109 |
|
110 | export interface JSONRPCVersionOneResponseWithResult {
|
111 | result: any;
|
112 | error: null;
|
113 | id: any;
|
114 | }
|
115 |
|
116 | export interface JSONRPCVersionOneResponseWithError {
|
117 | result: null;
|
118 | error: object;
|
119 | id: any;
|
120 | }
|
121 |
|
122 | export type JSONRPCVersionOneResponse = JSONRPCVersionOneResponseWithError | JSONRPCVersionOneResponseWithResult;
|
123 |
|
124 | export interface JSONRPCVersionTwoResponseWithResult {
|
125 | jsonrpc: string;
|
126 | result: any;
|
127 | id: JSONRPCIDLike | null;
|
128 | }
|
129 |
|
130 | export interface JSONRPCVersionTwoResponseWithError {
|
131 | jsonrpc: string;
|
132 | error: JSONRPCError;
|
133 | id: JSONRPCIDLike | null;
|
134 | }
|
135 |
|
136 | export type JSONRPCVersionTwoResponse = JSONRPCVersionTwoResponseWithResult | JSONRPCVersionTwoResponseWithError;
|
137 |
|
138 | export type JSONRPCResponseWithError = JSONRPCVersionOneResponseWithError | JSONRPCVersionTwoResponseWithError;
|
139 | export type JSONRPCResponseWithResult = JSONRPCVersionOneResponseWithResult | JSONRPCVersionTwoResponseWithResult;
|
140 | export type JSONRPCResponse = JSONRPCVersionOneResponse | JSONRPCVersionTwoResponse;
|
141 |
|
142 | export type JSONRPCIDLike = number | string;
|
143 |
|
144 | export type JSONRPCRequestLike = JSONRPCRequest | string;
|
145 |
|
146 | export type JSONRPCResultLike = any;
|
147 |
|
148 | export interface JSONRPCCallbackTypePlain {
|
149 | (err?: JSONRPCErrorLike | null, result?: JSONRPCResultLike): void
|
150 | }
|
151 |
|
152 | export interface JSONRPCCallbackTypeSugared {
|
153 | (err?: Error | null, error?: JSONRPCErrorLike, result?: JSONRPCResultLike): void
|
154 | }
|
155 |
|
156 | type JSONRPCCallbackType = JSONRPCCallbackTypePlain | JSONRPCCallbackTypeSugared;
|
157 |
|
158 | export interface JSONRPCCallbackTypeBatchPlain {
|
159 | (err: JSONRPCErrorLike, results?: Array<JSONRPCResultLike>): void
|
160 | }
|
161 |
|
162 | export interface JSONRPCCallbackTypeBatchSugared {
|
163 | (err: Error, errors?: Array<JSONRPCErrorLike>, results?: Array<JSONRPCResultLike>): void
|
164 | }
|
165 |
|
166 | type JSONRPCCallbackTypeBatch = JSONRPCCallbackTypeBatchPlain | JSONRPCCallbackTypeBatchSugared;
|
167 |
|
168 | export interface MethodHandler {
|
169 | (this:Server, args:RequestParamsLike, callback:JSONRPCCallbackTypePlain): void;
|
170 | }
|
171 |
|
172 | export interface MethodHandlerContext {
|
173 | (this:Server, args:RequestParamsLike, context:object, callback:JSONRPCCallbackTypePlain): void;
|
174 | }
|
175 |
|
176 | export type MethodHandlerType = MethodHandlerContext | MethodHandler;
|
177 | export type MethodOptionsParamsLike = Array<any> | Object | object;
|
178 |
|
179 | export interface MethodOptions {
|
180 | handler?: MethodHandlerType;
|
181 | useContext?: boolean;
|
182 | params?: MethodOptionsParamsLike;
|
183 | }
|
184 |
|
185 | export type MethodExecuteCallbackType = {
|
186 | (err?: Error | null, result?: JSONRPCResultLike): void
|
187 | }
|
188 |
|
189 | type MethodConstructor = ConstructorOf<Method, [options: MethodOptions] | [handler?: MethodHandlerType, options?: MethodOptions]>;
|
190 |
|
191 | export interface Method {
|
192 | getHandler(): MethodHandlerType;
|
193 | setHandler(handler: MethodHandlerType): void;
|
194 | execute(server: Server, requestParams: RequestParamsLike, callback: MethodExecuteCallbackType): any | Promise<any>;
|
195 | execute(server: Server, requestParams: RequestParamsLike, context:object, callback: MethodExecuteCallbackType): any | Promise<any>;
|
196 | }
|
197 |
|
198 | export declare const Method: MethodConstructor;
|
199 |
|
200 |
|
201 | export type method = Method;
|
202 | export declare const method: MethodConstructor;
|
203 |
|
204 | export type MethodLike = Function | Method | Client;
|
205 |
|
206 | export type ServerRouterFunction = (this: Server, method: string, params: RequestParamsLike) => MethodLike;
|
207 |
|
208 | export interface ServerOptions {
|
209 | useContext?: boolean;
|
210 | params?: MethodOptionsParamsLike;
|
211 | version?: number;
|
212 | reviver?: JSONParseReviver;
|
213 | replacer?: JSONStringifyReplacer;
|
214 | encoding?: string;
|
215 | router?: ServerRouterFunction;
|
216 | methodConstructor?: Function;
|
217 | }
|
218 |
|
219 | export type ServerCallCallbackType = {
|
220 | (err?: JSONRPCResponseWithError | null, result?: JSONRPCResponseWithResult): void
|
221 | }
|
222 |
|
223 | export interface MethodMap { [methodName:string]: Method }
|
224 |
|
225 | type ServerConstructor = ConstructorOf<Server, [methods?: {[methodName: string]: MethodLike}, options?: ServerOptions]> & {
|
226 | errors: {[errorName: string]: number};
|
227 | errorMessages: {[errorMessage: string]: string};
|
228 | interfaces: {[interfaces: string]: Function};
|
229 | }
|
230 |
|
231 | export interface Server extends events.EventEmitter {
|
232 | _methods: MethodMap;
|
233 | options: ServerOptions;
|
234 | errorMessages: {[errorMessage: string]: string};
|
235 |
|
236 | http(options?: HttpServerOptions): HttpServer;
|
237 | https(options?: HttpsServerOptions): HttpsServer;
|
238 | tcp(options?: TcpServerOptions): TcpServer;
|
239 | tls(options?: TlsServerOptions): TlsServer;
|
240 | websocket(options?: WebsocketServerOptions): WebsocketServer;
|
241 | middleware(options?: MiddlewareServerOptions): connect.HandleFunction;
|
242 |
|
243 | method(name: string, definition: MethodLike): void;
|
244 | methods(methods: {[methodName: string]: MethodLike}): void;
|
245 | hasMethod(name: string): boolean;
|
246 | removeMethod(name: string): void;
|
247 | getMethod(name: string): MethodLike;
|
248 | error(code?: number, message?: string, data?: object): JSONRPCError;
|
249 | call(request: JSONRPCRequestLike | Array<JSONRPCRequestLike>, originalCallback?: ServerCallCallbackType): void;
|
250 | call(request: JSONRPCRequestLike | Array<JSONRPCRequestLike>, context: object, originalCallback?: ServerCallCallbackType): void;
|
251 | callp(request: JSONRPCRequestLike | Array<JSONRPCRequestLike>, context?: object): Promise<JSONRPCResultLike>;
|
252 | }
|
253 |
|
254 | export declare const Server: ServerConstructor;
|
255 |
|
256 |
|
257 | export type server = Server;
|
258 | export declare const server: ServerConstructor;
|
259 |
|
260 | export interface MiddlewareServerOptions extends ServerOptions {
|
261 | end?: boolean;
|
262 | }
|
263 |
|
264 | export interface HttpServerOptions extends ServerOptions {
|
265 | }
|
266 |
|
267 | declare class HttpServer extends http.Server {
|
268 | constructor(server: Server, options?: HttpServerOptions);
|
269 | }
|
270 |
|
271 | export interface HttpsServerOptions extends ServerOptions, https.ServerOptions {
|
272 | }
|
273 |
|
274 | declare class HttpsServer extends https.Server {
|
275 | constructor(server: Server, options?: HttpsServerOptions);
|
276 | }
|
277 |
|
278 | export interface TcpServerOptions extends ServerOptions {
|
279 | }
|
280 |
|
281 | declare class TcpServer extends net.Server {
|
282 | constructor(server: Server, options?: TcpServerOptions);
|
283 | }
|
284 |
|
285 | export interface TlsServerOptions extends tls.TlsOptions {
|
286 | }
|
287 |
|
288 | declare class TlsServer extends tls.Server {
|
289 | constructor(server: Server, options?: TlsServerOptions);
|
290 | }
|
291 |
|
292 | export interface WebsocketServerOptions extends ServerOptions, WebSocket.ServerOptions {
|
293 | wss?: WebSocket.Server;
|
294 | }
|
295 |
|
296 | declare class WebsocketServer {
|
297 | constructor(server: Server, options?: WebsocketServerOptions);
|
298 | }
|
299 |
|
300 | type JSONParseReviver = (key: string, value: any) => any;
|
301 | type JSONStringifyReplacer = (key: string, value: any) => any;
|
302 |
|
303 | type IDGenerator = () => JSONRPCIDLike;
|
304 |
|
305 | export interface ClientOptions {
|
306 | version?: number;
|
307 | reviver?: JSONParseReviver;
|
308 | replacer?: JSONStringifyReplacer;
|
309 | generator?: IDGenerator;
|
310 | notificationIdNull?: boolean;
|
311 | }
|
312 |
|
313 | export interface HttpClientOptions extends ClientOptions, http.RequestOptions {
|
314 | }
|
315 |
|
316 | declare class HttpClient extends Client {
|
317 | constructor(options?: HttpClientOptions);
|
318 | }
|
319 |
|
320 | export interface TlsClientOptions extends ClientOptions, tls.ConnectionOptions {
|
321 | }
|
322 |
|
323 | declare class TlsClient extends Client {
|
324 | constructor(options?: TlsClientOptions);
|
325 | }
|
326 |
|
327 | export interface TcpClientOptions extends ClientOptions, net.TcpSocketConnectOpts {
|
328 | }
|
329 |
|
330 | declare class TcpClient extends Client {
|
331 | constructor(options?: TcpClientOptions);
|
332 | }
|
333 |
|
334 | export interface HttpsClientOptions extends ClientOptions, https.RequestOptions {
|
335 | }
|
336 |
|
337 | declare class HttpsClient extends Client {
|
338 | constructor(options?: HttpsClientOptions);
|
339 | }
|
340 |
|
341 | export interface WebsocketClientOptions extends ClientOptions {
|
342 | url?: string;
|
343 | ws?: WebSocket;
|
344 | timeout?: number;
|
345 | }
|
346 |
|
347 | declare class WebsocketClient extends Client {
|
348 | constructor(options?: WebsocketClientOptions);
|
349 | }
|
350 |
|
351 | type ClientConstructor = ConstructorOf<Client, [options: ClientOptions] | [server: Server, options?: ClientOptions]> & {
|
352 | http(options?: HttpClientOptions): HttpClient;
|
353 | https(options?: HttpsClientOptions): HttpsClient;
|
354 | tcp(options?: TcpClientOptions): TcpClient;
|
355 | tls(options?: TlsClientOptions): TlsClient;
|
356 | websocket(options?: WebsocketClientOptions): WebsocketClient;
|
357 | }
|
358 |
|
359 | export interface Client extends events.EventEmitter {
|
360 | request(method: string, params: RequestParamsLike, id?: string | null, callback?: JSONRPCCallbackType): JSONRPCRequest;
|
361 | request(method: string, params: RequestParamsLike, callback?: JSONRPCCallbackType): JSONRPCRequest;
|
362 | request(method: Array<JSONRPCRequestLike>, callback: JSONRPCCallbackTypeBatch): Array<JSONRPCRequest>;
|
363 | }
|
364 |
|
365 | export declare const Client: ClientConstructor;
|
366 |
|
367 |
|
368 | export type client = Client;
|
369 | export declare const client: ClientConstructor
|