probot

constructor

constructor(event: WebhookEvent<E>, octokit: any, log: Logger);

property id

id: string;

property isBot

readonly isBot: boolean;

• Returns a boolean if the actor on the event was a bot. {boolean}

property log

log: Logger;

property name

name: WebhookEvents;

property octokit

octokit: any;

property payload

payload: WebhookEvent<E>;

method config

config: <T>(
    fileName: string,
    defaultConfig?: T,
    deepMergeOptions?: merge.Options
) => Promise<T | null>;

• Reads the app configuration from the given YAML file in the .github directory of the repository.

  For example, given a file named .github/config.yml:

  close: true
  comment: Check the specs on the rotary girder.

  Your app can read that file from the target repository:

  // Load config from .github/config.yml in the repository
  const config = await context.config('config.yml')
  
  if (config.close) {
    context.octokit.issues.comment(context.issue({body: config.comment}))
    context.octokit.issues.edit(context.issue({state: 'closed'}))
  }

  You can also use a defaultConfig object:

  // Load config from .github/config.yml in the repository and combine with default config
  const config = await context.config('config.yml', {comment: 'Make sure to check all the specs.'})
  
  if (config.close) {
    context.octokit.issues.comment(context.issue({body: config.comment}));
    context.octokit.issues.edit(context.issue({state: 'closed'}))
  }

  Config files can also specify a base that they extend. deepMergeOptions can be used to configure how the target config, extended base, and default configs are merged.

  For security reasons, configuration is only loaded from the repository's default branch, changes made in pull requests from different branches or forks are ignored.

  If you need more lower-level control over reading and merging configuration files, you can context.octokit.config.get(options), see https://github.com/probot/octokit-plugin-config.

  Parameter fileName

  Name of the YAML file in the .github directory

  Parameter defaultConfig

  An object of default config options

  Parameter deepMergeOptions

  Controls merging configs (from the [deepmerge](https://github.com/TehShrike/deepmerge) module) Configuration object read from the file

method issue

issue: <T>(
    object?: T
) => RepoResultType<E> & { issue_number: RepoIssueNumberType<E> } & T;

• Return the owner, repo, and issue_number params for making API requests against an issue. The object passed in will be merged with the repo params.

  const params = context.issue({body: 'Hello World!'})
  // Returns: {owner: 'username', repo: 'reponame', issue_number: 123, body: 'Hello World!'}

  Parameter object

  Params to be merged with the issue params.

method pullRequest

pullRequest: <T>(
    object?: T
) => RepoResultType<E> & { pull_number: RepoIssueNumberType<E> } & T;

• Return the owner, repo, and pull_number params for making API requests against a pull request. The object passed in will be merged with the repo params.

  const params = context.pullRequest({body: 'Hello World!'})
  // Returns: {owner: 'username', repo: 'reponame', pull_number: 123, body: 'Hello World!'}

  Parameter object

  Params to be merged with the pull request params.

method repo

repo: <T>(object?: T) => RepoResultType<E> & T;

• Return the owner and repo params for making API requests against a repository.

  const params = context.repo({path: '.github/config.yml'})
  // Returns: {owner: 'username', repo: 'reponame', path: '.github/config.yml'}

  Parameter object

  Params to be merged with the repo params.

constructor

constructor(options?: Options);

property auth

auth: (installationId?: number, log?: Logger) => Promise<ProbotOctokit>;

property log

log: Logger;

property on

on: Webhooks<SimplifiedObject>;

property onAny

onAny: Webhooks<SimplifiedObject>;

property onError

onError: Webhooks<SimplifiedObject>;

property version

static version: string;

property version

version: string;

property webhookPath

webhookPath: string;

property webhooks

webhooks: Webhooks<SimplifiedObject>;

method defaults

static defaults: <S extends Constructor<any>>(
    this: S,
    defaults: Options
) => (new (...args: any[]) => { [x: string]: any }) & S;

method load

load: (
    appFn: ApplicationFunction | ApplicationFunction[],
    options?: ApplicationFunctionOptions
) => Promise<void>;

method receive

receive: (event: WebhookEvent) => Promise<void>;

constructor

constructor(options?: ServerOptions);

property expressApp

expressApp: Application;

property log

log: Logger;

property probotApp

probotApp: Probot;

property version

static version: string;

property version

version: string;

method load

load: (appFn: ApplicationFunction) => Promise<void>;

method router

router: (path?: string) => any;

method start

start: () => Promise<
    HttpServer<
        typeof import('http').IncomingMessage,
        typeof import('http').ServerResponse
    >
>;

method stop

stop: () => Promise<unknown>;

property appId

appId?: number | string;

property baseUrl

baseUrl?: string;

property githubToken

githubToken?: string;

property host

host?: string;

property log

log?: Logger;

property logLevel

logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';

property logMessageKey

logMessageKey?: string;

property Octokit

Octokit?: typeof ProbotOctokit;

property port

port?: number;

property privateKey

privateKey?: string;

property redisConfig

redisConfig?: RedisOptions | string;

property request

request?: RequestRequestOptions;

property secret

secret?: string;

property webhookPath

webhookPath?: string;