1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 | import { EventEmitter } from 'events';
|
11 | import { Options as HttpOptions, ScopedClient } from 'scoped-http-client';
|
12 | import { Server } from 'http';
|
13 | import { Express } from 'express';
|
14 |
|
15 | declare namespace Hubot {
|
16 | class Adapter extends EventEmitter {
|
17 | constructor(robot: Robot);
|
18 |
|
19 | send(envelope: Envelope, ...strings: string[]): void;
|
20 | emote(envelope: Envelope, ...strings: string[]): void;
|
21 | reply(envelope: Envelope, ...strings: string[]): void;
|
22 | topic(envelope: Envelope, ...strings: string[]): void;
|
23 | play(envelope: Envelope, ...strings: string[]): void;
|
24 |
|
25 | run(): void;
|
26 | close(): void;
|
27 |
|
28 | receive(message: Message): void;
|
29 | http(url: string): ScopedClient;
|
30 |
|
31 | users(): User[];
|
32 | userForId(id: string, options?: {}): User;
|
33 | userForName(name: string): User | null;
|
34 | usersForRawFuzzyName(fuzzyName: string): User[];
|
35 | usersForFuzzyName(fuzzyName: string): User[];
|
36 | }
|
37 |
|
38 | class DataStore {
|
39 | constructor(robot: Robot);
|
40 | set(key: string, value: any): Promise<void>;
|
41 | setObject(key: string, objectKey: string, value: any): Promise<void>;
|
42 | setArray(key: string, value: any): Promise<void>;
|
43 | get(key: string): Promise<any>;
|
44 | getObject(key: string, objectKey: string): Promise<any>;
|
45 | }
|
46 |
|
47 | class DataStoreUnavailable extends Error {}
|
48 |
|
49 | class Middleware<T extends Adapter = Adapter> {
|
50 | stack: Array<MiddlewareHandler<T>>;
|
51 | constructor(robot: Robot<T>);
|
52 | execute(context: MiddlewareContext<T>, next: NextFunction, done: DoneFunction): void;
|
53 | register(middleware: MiddlewareHandler<T>): void;
|
54 | }
|
55 |
|
56 | class Brain<A extends Adapter> extends EventEmitter {
|
57 | constructor(robot: Robot<A>);
|
58 | set(key: string, value: any): this;
|
59 | get(key: string): any;
|
60 | remove(key: string): this;
|
61 | save(): void;
|
62 | close(): void;
|
63 | setAutoSave(enabled: boolean): void;
|
64 | resetSaveInterval(seconds: number): void;
|
65 | mergeData(data: {}): void;
|
66 | users(): User[];
|
67 | userForId(id: string, options?: {}): User;
|
68 | userForName(name: string): User | null;
|
69 | usersForRawFuzzyName(fuzzyName: string): User[];
|
70 | usersForFuzzyName(fuzzyName: string): User[];
|
71 | }
|
72 |
|
73 | class User {
|
74 | constructor(id: string, options?: {});
|
75 | id: string;
|
76 | name: string;
|
77 | set(key: string, value: any): this;
|
78 | get(key: string): any;
|
79 | [property: string]: unknown;
|
80 | }
|
81 |
|
82 | class Message {
|
83 | constructor(user: User, done?: boolean);
|
84 | id: string;
|
85 | user: User;
|
86 | text: string | null;
|
87 | room: string;
|
88 | finish(): void;
|
89 | }
|
90 |
|
91 | class TextMessage extends Message {
|
92 | text: string;
|
93 |
|
94 | constructor(user: User, text: string, id: string);
|
95 |
|
96 | match(regex: RegExp): RegExpMatchArray;
|
97 | toString(): string;
|
98 | }
|
99 |
|
100 | class EnterMessage extends Message {
|
101 | text: null;
|
102 | }
|
103 |
|
104 | class LeaveMessage extends Message {
|
105 | text: null;
|
106 | }
|
107 |
|
108 | class TopicMessage extends TextMessage {
|
109 | text: string;
|
110 | }
|
111 |
|
112 | class CatchAllMessage extends Message {
|
113 | message: Message;
|
114 |
|
115 | constructor(message: Message);
|
116 | }
|
117 |
|
118 | interface Envelope {
|
119 | room: string;
|
120 | user: User;
|
121 | message: Message;
|
122 | }
|
123 |
|
124 | class Response<A extends Adapter = Adapter, M extends Message = Message> {
|
125 | match: RegExpMatchArray;
|
126 | message: Message;
|
127 | envelope: Envelope;
|
128 |
|
129 | constructor(robot: Robot<A>, message: Message, match: RegExpMatchArray);
|
130 | send(...strings: string[]): void;
|
131 | emote(...strings: string[]): void;
|
132 | reply(...strings: string[]): void;
|
133 | topic(...strings: string[]): void;
|
134 | play(...strings: string[]): void;
|
135 | locked(...strings: string[]): void;
|
136 | random<T>(items: T[]): T;
|
137 | finish(): void;
|
138 | http(url: string, options?: HttpOptions): ScopedClient;
|
139 | }
|
140 |
|
141 | type ListenerCallback<A extends Adapter = Adapter, M extends Message = Message> = (
|
142 | response: Response<A, M>,
|
143 | ) => void;
|
144 | type DoneFunction = () => void;
|
145 | type NextFunction = (done: DoneFunction) => void;
|
146 | interface MiddlewareContext<T extends Adapter = Adapter> {
|
147 | response?: Response<T> | undefined;
|
148 | [key: string]: unknown;
|
149 | }
|
150 | type MiddlewareHandler<T extends Adapter = Adapter> = (
|
151 | context: MiddlewareContext<T>,
|
152 | next: NextFunction,
|
153 | done: DoneFunction,
|
154 | ) => void;
|
155 |
|
156 | interface LogLevel {
|
157 | (...messages: any[]): void;
|
158 | disable(): void;
|
159 | enable(): void;
|
160 | }
|
161 |
|
162 | interface Log {
|
163 | (...messages: any[]): void;
|
164 | get(namespace: string): Log;
|
165 | debug: LogLevel;
|
166 | info: LogLevel;
|
167 | notice: LogLevel;
|
168 | warning: LogLevel;
|
169 | error: LogLevel;
|
170 | }
|
171 |
|
172 | class Robot<A extends Adapter = Adapter> {
|
173 | readonly name: string;
|
174 | readonly events: EventEmitter;
|
175 | readonly brain: Brain<A>;
|
176 | readonly alias: string;
|
177 | readonly adapterPath: string;
|
178 | readonly adapterName: string;
|
179 | readonly adapter: A;
|
180 | readonly errorHandlers: [];
|
181 | readonly onUncaughtException: (err: Error) => void;
|
182 | readonly datastore: null | DataStore;
|
183 | readonly commands: [];
|
184 | readonly middleware: {
|
185 | listener: Middleware<A>;
|
186 | response: Middleware<A>;
|
187 | receive: Middleware<A>;
|
188 | };
|
189 | readonly logger: Log;
|
190 | readonly pingIntervalId: null | NodeJS.Timeout;
|
191 | readonly globalHttpOptions: HttpOptions;
|
192 | readonly version: string;
|
193 | readonly server?: Server | undefined;
|
194 | readonly router: Express;
|
195 |
|
196 | constructor(adapterPath: string, adapter: string, httpd: boolean, name: string, alias?: string);
|
197 | catchAll(callback: ListenerCallback<A, CatchAllMessage>): void;
|
198 | catchAll(options: {}, callback: ListenerCallback<A, CatchAllMessage>): void;
|
199 | emit(event: string | symbol, ...args: unknown[]): void;
|
200 | enter(callback: ListenerCallback<A, EnterMessage>): void;
|
201 | enter(options: {}, callback: ListenerCallback<A, EnterMessage>): void;
|
202 | error(cb: (error: Error) => void): void;
|
203 | hear(regex: RegExp, callback: ListenerCallback<A, TextMessage>): void;
|
204 | hear(regex: RegExp, options: {}, callback: ListenerCallback<A, TextMessage>): void;
|
205 | helpCommands(): string[];
|
206 | http(url: string, options?: HttpOptions): ScopedClient;
|
207 | leave(callback: ListenerCallback<A, LeaveMessage>): void;
|
208 | leave(options: {}, callback: ListenerCallback<A, LeaveMessage>): void;
|
209 | listen(matcher: (message: Message) => boolean, callback: ListenerCallback<A>): void;
|
210 | listen(matcher: (message: Message) => boolean, options: {}, callback: ListenerCallback<A>): void;
|
211 | listenerMiddleware(middleware: MiddlewareHandler<A>): void;
|
212 | loadExternalScripts(packages: string[]): void;
|
213 | loadFile(directory: string, fileName: string): void;
|
214 | loadHubotScripts(path: string, scripts: string[]): void;
|
215 | messageRoom(room: string, ...strings: string[]): void;
|
216 | on(event: string | symbol, listener: (...args: unknown[]) => void): this;
|
217 | receive(message: Message, cb?: () => void): void;
|
218 | receiveMiddleware(middleware: MiddlewareHandler<A>): void;
|
219 | reply(envelope: Envelope, ...strings: string[]): void;
|
220 | respond(regex: RegExp, callback: ListenerCallback<A, TextMessage>): void;
|
221 | respond(regex: RegExp, options: {}, callback: ListenerCallback<A, TextMessage>): void;
|
222 | respondPattern(regex: RegExp): RegExp;
|
223 | responseMiddleware(middleware: MiddlewareHandler<A>): void;
|
224 | run(): void;
|
225 | send(envelope: Envelope, ...strings: string[]): void;
|
226 | shutdown(): void;
|
227 | topic(callback: ListenerCallback<A, TopicMessage>): void;
|
228 | topic(options: {}, callback: ListenerCallback<A, TopicMessage>): void;
|
229 | }
|
230 | }
|
231 |
|
232 | // Compatibility with CommonJS syntax exported by Hubot's CoffeeScript.
|
233 | // eslint-disable-next-line export-just-namespace
|
234 | export = Hubot;
|
235 | export as namespace Hubot;
|