@types/hubot

constructor(robot: Robot<Adapter>);

robot: Robot<Adapter>;

emote: (envelope: Envelope, ...strings: string[]) => Promise<any>;

http: (url: string) => ScopedClient;

play: (envelope: Envelope, ...strings: string[]) => Promise<any>;

receive: (message: Message) => Promise<any>;

reply: (envelope: Envelope, ...strings: string[]) => Promise<any>;

run: () => Promise<void>;

send: (envelope: Envelope, ...strings: string[]) => Promise<any>;

topic: (envelope: Envelope, ...strings: string[]) => Promise<any>;

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

userForName: (name: string) => User | null;

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 | null;

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>;

constructor(
    robot: Robot<A>,
    matcher: ListenerMatcher,
    options: {},
    callback: ListenerCallback<A, Message>
);

matcher: ListenerMatcher;

options: {};

robot: Robot<A>;

call: (message: Message, middleware: Middleware<A>) => Promise<any>;

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

done: boolean;

id: string;

room: string;

text?: string;

user: User;

finish: () => void;

constructor(robot: Robot<A>);

stack: MiddlewareHandler<A, Message>[];

execute: (context: MiddlewareContext<A>) => Promise<boolean>;

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

constructor(
    robot: Robot<A>,
    message: Message,
    match: RegExpMatchArray | { [key: string]: string }
);

envelope: Envelope;

match: RegExpMatchArray | { [key: string]: string };

message: Message;

robot: Robot<A>;

emote: (...strings: string[]) => Promise<any>;

finish: () => void;

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

locked: (...strings: string[]) => Promise<any>;

play: (...strings: string[]) => Promise<any>;

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

reply: (...strings: string[]) => Promise<any>;

send: (...strings: string[]) => Promise<any>;

topic: (...strings: string[]) => Promise<any>;

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

readonly adapter: Adapter;

readonly adapterName: string;

readonly alias: string;

readonly brain: Brain<A>;

readonly commands: string[];

readonly datastore: DataStore;

readonly errorHandlers: [];

readonly events: EventEmitter;

readonly globalHttpOptions: HttpOptions;

readonly listeners: Listener<A>[];

readonly logger: Log;

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

readonly name: string;

readonly pingIntervalId: any;

readonly router: Express;

readonly server?: any;

readonly shouldEnableHttpd: boolean;

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;

load: (path: string) => Promise<void>;

loadAdapter: { (): Promise<void>; (adapterPath: string): Promise<void> };

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

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

messageRoom: (room: string, ...strings: string[]) => Promise<any>;

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

parseVersion: () => string;

receive: (message: Message) => Promise<any>;

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

reply: (envelope: Envelope, ...strings: string[]) => Promise<any>;

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

respondPattern: (regex: RegExp) => RegExp;

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

run: () => Promise<any>;

send: (envelope: Envelope, ...strings: string[]) => Promise<any>;

shutdown: () => void;

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

constructor(
    robot: Robot<A>,
    regex: RegExp,
    options: {},
    callback: ListenerCallback<A, TextMessage>
);

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

match: (regex: RegExp) => RegExpMatchArray;

toString: () => 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;

warn: LogLevel;

get: (namespace: string) => Log;

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

disable: () => void;

enable: () => void;

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

listener?: Listener<A>;

method?: string;

plaintext?: boolean;

response: Response<A, M>;

[key: string]: unknown;