@types/hubot

Version 11.3.0
Published 9 months ago
12.4 kB
3 dependencies
MIT license

Install

npm i @types/hubot

yarn add @types/hubot

pnpm add @types/hubot

Overview

TypeScript definitions for hubot

Index

Classes

class Adapter

class Adapter extends EventEmitter {}

constructor

constructor(robot: Robot<Adapter>);

property robot

robot: Robot<Adapter>;

method emote

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

method http

http: (url: string) => ScopedClient;

method play

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

method receive

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

method reply

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

method run

run: () => Promise<void>;

method send

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

method topic

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

method userForId

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

method userForName

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

method users

users: () => User[];

Returns
an object containing all the users with property names that are the user id and with the value set as the User. You can iterate over them all with for (const id in users())
Deprecated
Use @robot.brain

method usersForFuzzyName

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

method usersForRawFuzzyName

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

class Brain

class Brain<A extends Adapter> extends EventEmitter {}

constructor

constructor(robot: Robot<A>);

method close

close: () => void;

method get

get: (key: string) => any;

method mergeData

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

method remove

remove: (key: string) => this;

method resetSaveInterval

resetSaveInterval: (seconds: number) => void;

method save

save: () => void;

method set

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

method setAutoSave

setAutoSave: (enabled: boolean) => void;

method userForId

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

method userForName

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

method users

users: () => User[];

Returns
an object containing all the users with property names that are the user id and with the value set as the User. You can iterate over them all with for (const id in users())

method usersForFuzzyName

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

method usersForRawFuzzyName

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

class CatchAllMessage

class CatchAllMessage extends Message {}

constructor

constructor(message: Message);

property message

message: Message;

class DataStore

class DataStore {}

constructor

constructor(robot: Robot<Adapter>);

method get

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

method getObject

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

method set

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

method setArray

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

method setObject

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

class DataStoreUnavailable

class DataStoreUnavailable extends Error {}

class EnterMessage

class EnterMessage extends Message {}

class LeaveMessage

class LeaveMessage extends Message {}

class Listener

class Listener<A extends Adapter = Adapter> {}

constructor

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

property matcher

matcher: ListenerMatcher;

property options

options: {};

property robot

robot: Robot<A>;

method call

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

class Message

class Message {}

constructor

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

property done

done: boolean;

property id

id: string;

property room

room: string;

property text

text?: string;

property user

user: User;

method finish

finish: () => void;

class Middleware

class Middleware<A extends Adapter = Adapter> {}

constructor

constructor(robot: Robot<A>);

property stack

stack: MiddlewareHandler<A, Message>[];

method execute

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

method register

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

class Response

class Response<
    A extends Adapter = Adapter,
    M extends Message = Message,
    R extends RegExpMatchArray | { [key: string]: string } = RegExpMatchArray
> {}

constructor

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

property envelope

envelope: Envelope;

property match

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

property message

message: Message;

property robot

robot: Robot<A>;

method emote

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

method finish

finish: () => void;

method http

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

method locked

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

method play

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

method random

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

method reply

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

method send

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

method topic

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

class Robot

class Robot<A extends Adapter = Adapter> {}

constructor

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

property adapter

readonly adapter: Adapter;

property adapterName

readonly adapterName: string;

property alias

readonly alias: string;

property brain

readonly brain: Brain<A>;

property commands

readonly commands: string[];

property datastore

readonly datastore: DataStore;

property errorHandlers

readonly errorHandlers: [];

property events

readonly events: EventEmitter;

property globalHttpOptions

readonly globalHttpOptions: HttpOptions;

property listeners

readonly listeners: Listener<A>[];

property logger

readonly logger: Log;

property middleware

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

property name

readonly name: string;

property pingIntervalId

readonly pingIntervalId: any;

property router

readonly router: Express;

property server

readonly server?: any;

property shouldEnableHttpd

readonly shouldEnableHttpd: boolean;

property version

readonly version: string;

method catchAll

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

method emit

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

method enter

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

method error

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

method hear

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

method helpCommands

helpCommands: () => string[];

method http

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

method leave

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

method listen

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

method listenerMiddleware

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

method load

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

method loadAdapter

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

method loadExternalScripts

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

method loadFile

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

method messageRoom

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

method on

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

method parseVersion

parseVersion: () => string;

method receive

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

method receiveMiddleware

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

method reply

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

method respond

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

method respondPattern

respondPattern: (regex: RegExp) => RegExp;

method responseMiddleware

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

method run

run: () => Promise<any>;

method send

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

method shutdown

shutdown: () => void;

method topic

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

class TextListener

class TextListener<A extends Adapter> extends Listener<A> {}

constructor

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

class TextMessage

class TextMessage extends Message {}

constructor

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

method match

match: (regex: RegExp) => RegExpMatchArray;

method toString

toString: () => string;

class TopicMessage

class TopicMessage extends TextMessage {}

class User

class User {}

constructor

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

property id

id: string;

property name

name: string;

method get

get: (key: string) => any;

method set

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

Interfaces

interface Envelope

interface Envelope {}

property message

message: Message;

property room

room: string;

property user

user: User;

interface Log

interface Log {}

property debug

debug: LogLevel;

property error

error: LogLevel;

property info

info: LogLevel;

property notice

notice: LogLevel;

property warn

warn: LogLevel;

method get

get: (namespace: string) => Log;

call signature

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

interface LogLevel

interface LogLevel {}

method disable

disable: () => void;

method enable

enable: () => void;

call signature

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

interface MiddlewareContext

interface MiddlewareContext<
    A extends Adapter = Adapter,
    M extends Message = Message
> {}

property listener

listener?: Listener<A>;

property method

method?: string;

property plaintext

plaintext?: boolean;

property response

response: Response<A, M>;

index signature

[key: string]: unknown;

Type Aliases

type ListenerCallback

type ListenerCallback<A extends Adapter = Adapter, M extends Message = Message> = (
    response: Response<A, M>
) => Promise<void>;

type ListenerMatcher

type ListenerMatcher = (message: Message) => boolean;

type MiddlewareHandler

type MiddlewareHandler<A extends Adapter = Adapter, M extends Message = Message> = (
    context: MiddlewareContext<A, M>
) => Promise<boolean>;

Package Files (1)

index.d.ts

Dependencies (3)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/hubot.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/hubot)

HTML

<a href="https://www.jsdocs.io/package/@types/hubot"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 9 months ago.
Package analyzed in 4313 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/hubot

Install

Overview

Index

Classes

Interfaces

Type Aliases

Classes

class Adapter

property robot

method emote

method http

method play

method receive

method reply

method run

method send

method topic

method userForId

method userForName

method users

Returns

Deprecated

method usersForFuzzyName

method usersForRawFuzzyName

class Brain

method close

method get

method mergeData

method remove

method resetSaveInterval

method save

method set

method setAutoSave

method userForId

method userForName

method users

Returns

method usersForFuzzyName

method usersForRawFuzzyName

class CatchAllMessage

property message

class DataStore

method get

method getObject

method set

method setArray

method setObject

class DataStoreUnavailable

class EnterMessage

class LeaveMessage

class Listener

property matcher

property options

property robot

method call

class Message

property done

property id

property room

property text

property user

method finish

class Middleware

property stack

method execute

method register

class Response

property envelope

property match

property message

property robot

method emote

method finish

method http

method locked

method play

method random

method reply

method send