@types/hubot

  • Version 3.3.2
  • Published
  • 11.8 kB
  • 2 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>);

      method close

      close: () => void;

        method emote

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

          method http

          http: (url: string) => ScopedClient;

            method play

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

              method receive

              receive: (message: Message) => void;

                method reply

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

                  method run

                  run: () => void;

                    method send

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

                      method topic

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

                        method userForId

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

                          method userForName

                          userForName: (name: string) => User;

                            method users

                            users: () => User[];

                              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;

                                                          method users

                                                          users: () => User[];

                                                            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 {}

                                                                                        property text

                                                                                        text: null;

                                                                                          class LeaveMessage

                                                                                          class LeaveMessage extends Message {}

                                                                                            property text

                                                                                            text: null;

                                                                                              class Message

                                                                                              class Message {}

                                                                                                constructor

                                                                                                constructor(user: User, 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<T extends Adapter = Adapter> {}

                                                                                                              constructor

                                                                                                              constructor(robot: Robot<T>);

                                                                                                                property stack

                                                                                                                stack: MiddlewareHandler<T>[];

                                                                                                                  method execute

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

                                                                                                                    method register

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

                                                                                                                      class Response

                                                                                                                      class Response<A extends Adapter = Adapter, M extends Message = Message> {}

                                                                                                                        constructor

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

                                                                                                                          property envelope

                                                                                                                          envelope: Envelope;

                                                                                                                            property match

                                                                                                                            match: RegExpMatchArray;

                                                                                                                              property message

                                                                                                                              message: Message;

                                                                                                                                method emote

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

                                                                                                                                  method finish

                                                                                                                                  finish: () => void;

                                                                                                                                    method http

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

                                                                                                                                      method locked

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

                                                                                                                                        method play

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

                                                                                                                                          method random

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

                                                                                                                                            method reply

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

                                                                                                                                              method send

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

                                                                                                                                                method topic

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

                                                                                                                                                  class Robot

                                                                                                                                                  class Robot<A extends Adapter = Adapter> {}

                                                                                                                                                    constructor

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

                                                                                                                                                      property adapter

                                                                                                                                                      readonly adapter: Adapter;

                                                                                                                                                        property adapterName

                                                                                                                                                        readonly adapterName: string;

                                                                                                                                                          property adapterPath

                                                                                                                                                          readonly adapterPath: string;

                                                                                                                                                            property alias

                                                                                                                                                            readonly alias: string;

                                                                                                                                                              property brain

                                                                                                                                                              readonly brain: Brain<A>;

                                                                                                                                                                property commands

                                                                                                                                                                readonly commands: [];

                                                                                                                                                                  property datastore

                                                                                                                                                                  readonly datastore: DataStore;

                                                                                                                                                                    property errorHandlers

                                                                                                                                                                    readonly errorHandlers: [];

                                                                                                                                                                      property events

                                                                                                                                                                      readonly events: EventEmitter;

                                                                                                                                                                        property globalHttpOptions

                                                                                                                                                                        readonly globalHttpOptions: HttpOptions;

                                                                                                                                                                          property logger

                                                                                                                                                                          readonly logger: Log;

                                                                                                                                                                            property middleware

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

                                                                                                                                                                              property name

                                                                                                                                                                              readonly name: string;

                                                                                                                                                                                property onUncaughtException

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

                                                                                                                                                                                  property pingIntervalId

                                                                                                                                                                                  readonly pingIntervalId: any;

                                                                                                                                                                                    property router

                                                                                                                                                                                    readonly router: Express;

                                                                                                                                                                                      property server

                                                                                                                                                                                      readonly server?: any;

                                                                                                                                                                                        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 loadExternalScripts

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

                                                                                                                                                                                                                method loadFile

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

                                                                                                                                                                                                                  method loadHubotScripts

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

                                                                                                                                                                                                                    method messageRoom

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

                                                                                                                                                                                                                      method on

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

                                                                                                                                                                                                                        method receive

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

                                                                                                                                                                                                                          method receiveMiddleware

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

                                                                                                                                                                                                                            method reply

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

                                                                                                                                                                                                                              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>) => void;

                                                                                                                                                                                                                                    method run

                                                                                                                                                                                                                                    run: () => void;

                                                                                                                                                                                                                                      method send

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

                                                                                                                                                                                                                                        method shutdown

                                                                                                                                                                                                                                        shutdown: () => void;

                                                                                                                                                                                                                                          method topic

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

                                                                                                                                                                                                                                            class TextMessage

                                                                                                                                                                                                                                            class TextMessage extends Message {}

                                                                                                                                                                                                                                              constructor

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

                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                text: string;

                                                                                                                                                                                                                                                  method match

                                                                                                                                                                                                                                                  match: (regex: RegExp) => RegExpMatchArray;

                                                                                                                                                                                                                                                    method toString

                                                                                                                                                                                                                                                    toString: () => string;

                                                                                                                                                                                                                                                      class TopicMessage

                                                                                                                                                                                                                                                      class TopicMessage extends TextMessage {}

                                                                                                                                                                                                                                                        property text

                                                                                                                                                                                                                                                        text: string;

                                                                                                                                                                                                                                                          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 warning

                                                                                                                                                                                                                                                                                        warning: 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<T extends Adapter = Adapter> {}

                                                                                                                                                                                                                                                                                                        property response

                                                                                                                                                                                                                                                                                                        response?: Response<T> | undefined;

                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                          [key: string]: unknown;

                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                            type DoneFunction

                                                                                                                                                                                                                                                                                                            type DoneFunction = () => void;

                                                                                                                                                                                                                                                                                                              type ListenerCallback

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

                                                                                                                                                                                                                                                                                                                type MiddlewareHandler

                                                                                                                                                                                                                                                                                                                type MiddlewareHandler<T extends Adapter = Adapter> = (
                                                                                                                                                                                                                                                                                                                context: MiddlewareContext<T>,
                                                                                                                                                                                                                                                                                                                next: NextFunction,
                                                                                                                                                                                                                                                                                                                done: DoneFunction
                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                  type NextFunction

                                                                                                                                                                                                                                                                                                                  type NextFunction = (done: DoneFunction) => void;

                                                                                                                                                                                                                                                                                                                    Package Files (1)

                                                                                                                                                                                                                                                                                                                    Dependencies (2)

                                                                                                                                                                                                                                                                                                                    Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                    No dev dependencies.

                                                                                                                                                                                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                    No peer dependencies.

                                                                                                                                                                                                                                                                                                                    Badge

                                                                                                                                                                                                                                                                                                                    To add a badge like this onejsDocs.io badgeto 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>