@types/hubot

constructor(robot: Robot<Adapter>);

close: () => void;

emote: (envelope: Envelope, ...strings: string[]) => void;

http: (url: string) => ScopedClient;

play: (envelope: Envelope, ...strings: string[]) => void;

receive: (message: Message) => void;

reply: (envelope: Envelope, ...strings: string[]) => void;

run: () => void;

send: (envelope: Envelope, ...strings: string[]) => void;

topic: (envelope: Envelope, ...strings: string[]) => void;

userForId: (id: string, options?: {}) => User;

userForName: (name: string) => User;

users: () => User[];

usersForFuzzyName: (fuzzyName: string) => User[];

usersForRawFuzzyName: (fuzzyName: string) => User[];

constructor(robot: Robot<A>);

close: () => void;

get: (key: string) => any;

mergeData: (data: {}) => void;

remove: (key: string) => this;

resetSaveInterval: (seconds: number) => void;

save: () => void;

set: (key: string, value: any) => this;

setAutoSave: (enabled: boolean) => void;

userForId: (id: string, options?: {}) => User;

userForName: (name: string) => User;

users: () => User[];

usersForFuzzyName: (fuzzyName: string) => User[];

usersForRawFuzzyName: (fuzzyName: string) => User[];

constructor(message: Message);

message: Message;

constructor(robot: Robot<Adapter>);

get: (key: string) => Promise<any>;

getObject: (key: string, objectKey: string) => Promise<any>;

set: (key: string, value: any) => Promise<void>;

setArray: (key: string, value: any) => Promise<void>;

setObject: (key: string, objectKey: string, value: any) => Promise<void>;

text: null;

text: null;

constructor(user: User, done?: boolean);

id: string;

room: string;

text: string;

user: User;

finish: () => void;

constructor(robot: Robot<T>);

stack: MiddlewareHandler<T>[];

execute: (
    context: MiddlewareContext<T>,
    next: NextFunction,
    done: DoneFunction
) => void;

register: (middleware: MiddlewareHandler<T>) => void;

constructor(robot: Robot<A>, message: Message, match: RegExpMatchArray);

envelope: Envelope;

match: RegExpMatchArray;

message: Message;

emote: (...strings: string[]) => void;

finish: () => void;

http: (url: string, options?: HttpOptions) => ScopedClient;

locked: (...strings: string[]) => void;

play: (...strings: string[]) => void;

random: <T>(items: T[]) => T;

reply: (...strings: string[]) => void;

send: (...strings: string[]) => void;

topic: (...strings: string[]) => void;

constructor(
    adapterPath: string,
    adapter: string,
    httpd: boolean,
    name: string,
    alias?: string
);

readonly adapter: Adapter;

readonly adapterName: string;

readonly adapterPath: string;

readonly alias: string;

readonly brain: Brain<A>;

readonly commands: [];

readonly datastore: DataStore;

readonly errorHandlers: [];

readonly events: EventEmitter;

readonly globalHttpOptions: HttpOptions;

readonly logger: Log;

readonly middleware: {
    listener: Middleware<A>;
    response: Middleware<A>;
    receive: Middleware<A>;
};

readonly name: string;

readonly onUncaughtException: (err: Error) => void;

readonly pingIntervalId: any;

readonly router: Express;

readonly server?: any;

readonly version: string;

catchAll: {
    (callback: ListenerCallback<A, CatchAllMessage>): void;
    (options: {}, callback: ListenerCallback<A, CatchAllMessage>): void;
};

emit: (event: string | symbol, ...args: unknown[]) => void;

enter: {
    (callback: ListenerCallback<A, EnterMessage>): void;
    (options: {}, callback: ListenerCallback<A, EnterMessage>): void;
};

error: (cb: (error: Error) => void) => void;

hear: {
    (regex: RegExp, callback: ListenerCallback<A, TextMessage>): void;
    (
        regex: RegExp,
        options: {},
        callback: ListenerCallback<A, TextMessage>
    ): void;
};

helpCommands: () => string[];

http: (url: string, options?: HttpOptions) => ScopedClient;

leave: {
    (callback: ListenerCallback<A, LeaveMessage>): void;
    (options: {}, callback: ListenerCallback<A, LeaveMessage>): void;
};

listen: {
    (
        matcher: (message: Message) => boolean,
        callback: ListenerCallback<A>
    ): void;
    (
        matcher: (message: Message) => boolean,
        options: {},
        callback: ListenerCallback<A, Message>
    ): void;
};

listenerMiddleware: (middleware: MiddlewareHandler<A>) => void;

loadExternalScripts: (packages: string[]) => void;

loadFile: (directory: string, fileName: string) => void;

loadHubotScripts: (path: string, scripts: string[]) => void;

messageRoom: (room: string, ...strings: string[]) => void;

on: (event: string | symbol, listener: (...args: unknown[]) => void) => this;

receive: (message: Message, cb?: () => void) => void;

receiveMiddleware: (middleware: MiddlewareHandler<A>) => void;

reply: (envelope: Envelope, ...strings: string[]) => void;

respond: {
    (regex: RegExp, callback: ListenerCallback<A, TextMessage>): void;
    (
        regex: RegExp,
        options: {},
        callback: ListenerCallback<A, TextMessage>
    ): void;
};

respondPattern: (regex: RegExp) => RegExp;

responseMiddleware: (middleware: MiddlewareHandler<A>) => void;

run: () => void;

send: (envelope: Envelope, ...strings: string[]) => void;

shutdown: () => void;

topic: {
    (callback: ListenerCallback<A, TopicMessage>): void;
    (options: {}, callback: ListenerCallback<A, TopicMessage>): void;
};

constructor(user: User, text: string, id: string);

text: string;

match: (regex: RegExp) => RegExpMatchArray;

toString: () => string;

text: string;

constructor(id: string, options?: {});

id: string;

name: string;

get: (key: string) => any;

set: (key: string, value: any) => this;

message: Message;

room: string;

user: User;

debug: LogLevel;

error: LogLevel;

info: LogLevel;

notice: LogLevel;

warning: LogLevel;

get: (namespace: string) => Log;

(...messages: any[]): void;

disable: () => void;

enable: () => void;

(...messages: any[]): void;

response?: Response<T> | undefined;

[key: string]: unknown;