danger

  • Version 10.6.6
  • Published
  • 1.29 MB
  • 36 dependencies
  • MIT license

Install

npm i danger
yarn add danger
pnpm add danger

Overview

Unit tests for Team Culture

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable danger

const danger: DangerDSLType;
  • The root Danger object. This contains all of the metadata you will be looking for in order to generate useful rules.

variable peril

const peril: PerilDSL;
  • When Peril is running your Dangerfile, the Danger DSL is extended with additional options.

variable results

const results: DangerRuntimeContainer;
  • The current results of a Danger run, this can be useful if you are wanting to introspect on whether a build has already failed.

Functions

function fail

fail: (message: MarkdownString, file?: string, line?: number) => void;
  • Fails a build, outputting a specific reason for failing into a HTML table.

    Parameter message

    the String to output

    Parameter file

    a file which this message should be attached to

    Parameter line

    the line which this message should be attached to

function markdown

markdown: (message: MarkdownString, file?: string, line?: number) => void;
  • Adds raw markdown into the Danger comment, under the table

    Parameter message

    the String to output

    Parameter file

    a file which this message should be attached to

    Parameter line

    the line which this message should be attached to

function message

message: {
(message: MarkdownString, file?: string, line?: number): void;
(message: string, opts?: { file?: string; line?: number; icon?: string }): void;
};
  • Adds a message to the Danger table, the only difference between this and warn is the emoji which shows in the table.

    Parameter message

    the String to output

    Parameter file

    a file which this message should be attached to

    Parameter line

    the line which this message should be attached to

  • Adds a message to the Danger table, the only difference between this and warn is the default emoji which shows in the table. You can also specifiy a custom emoji to show in the table for each message

    Parameter message

    the String to output

    Parameter opts

    Parameter

    opts.file a file which this message should be attached to

    Parameter

    opts.line the line which this message should be attached to

    Parameter

    opts.icon icon string or image to show in table, take care not to break table formatting

function schedule

schedule: (asyncFunction: Scheduleable) => void;
  • A Dangerfile, in Peril, is evaluated as a script, and so async code does not work out of the box. By using the schedule function you can now register a section of code to evaluate across multiple tick cycles.

    schedule currently handles two types of arguments, either a promise or a function with a resolve arg.

    Parameter asyncFunction

    the function to run asynchronously

function warn

warn: (message: MarkdownString, file?: string, line?: number) => void;
  • Highlights low-priority issues, but does not fail the build. Message is shown inside a HTML table.

    Parameter message

    the String to output

    Parameter file

    a file which this message should be attached to

    Parameter line

    the line which this message should be attached to

Interfaces

interface BitBucketCloudCommit

interface BitBucketCloudCommit {}
  • A BitBucketCloud specific implementation of a git commit.

property author

author: {
/** Format: `Foo Bar <foo@bar.com>` */
raw: string;
user: BitBucketCloudUser;
};
  • The author of the commit, assumed to be the person who wrote the code.

property date

date: string;
  • When the commit was committed to the project, in ISO 8601 format

property hash

hash: string;
  • The SHA for the commit

links: BitBucketCloudLinks<'html'>;
  • The commit's links

property message

message: string;
  • The commit's message

property parents

parents: {
/** The full SHA */
hash: string;
}[];
  • The commit's parents

interface BitBucketCloudContent

interface BitBucketCloudContent {}

    property html

    html: string;

      property markup

      markup: string;

        property raw

        raw: string;

          property type

          type: 'rendered';

            interface BitBucketCloudDSL

            interface BitBucketCloudDSL extends BitBucketCloudJSONDSL {}

              interface BitBucketCloudJSONDSL

              interface BitBucketCloudJSONDSL {}

                property activities

                activities: BitBucketCloudPRActivity[];
                • The activities such as OPENING, CLOSING, MERGING or UPDATING a pull request

                property comments

                comments: BitBucketCloudPRComment[];
                • The comments on the pull request

                property commits

                commits: BitBucketCloudCommit[];
                • The commits associated with the pull request

                property metadata

                metadata: RepoMetaData;
                • The pull request and repository metadata

                property pr

                pr: BitBucketCloudPRDSL;
                • The PR metadata

                interface BitBucketCloudMergeRef

                interface BitBucketCloudMergeRef {}

                  property branch

                  branch: {
                  name: string;
                  };

                    property commit

                    commit: {
                    hash: string;
                    };

                      property repository

                      repository: BitBucketCloudRepo;

                        interface BitBucketCloudPagedResponse

                        interface BitBucketCloudPagedResponse<T> {}

                          property next

                          next: string | undefined;

                            property page

                            page: number;

                              property pagelen

                              pagelen: number;

                                property previous

                                previous: string | undefined;

                                  property size

                                  size: number;

                                    property values

                                    values: T[];

                                      interface BitBucketCloudPRActivity

                                      interface BitBucketCloudPRActivity {}

                                        property comment

                                        comment?: BitBucketCloudPRComment;

                                          property pull_request

                                          pull_request: {
                                          id: number;
                                          title: string;
                                          };

                                            interface BitBucketCloudPRComment

                                            interface BitBucketCloudPRComment {}

                                              property content

                                              content: BitBucketCloudContent;

                                                property created_on

                                                created_on: string;
                                                • When the comment was created, in ISO 8601 format

                                                property deleted

                                                deleted: boolean;

                                                  property id

                                                  id: number;

                                                    property inline

                                                    inline?: {
                                                    to: number | null;
                                                    from: number;
                                                    path: string;
                                                    };
                                                      links: BitBucketCloudLinks<'self' | 'html'>;

                                                        property pullrequest

                                                        pullrequest: {
                                                        id: number;
                                                        links: BitBucketCloudLinks<'self' | 'html'>;
                                                        title: string;
                                                        };

                                                          property type

                                                          type: string;

                                                            property updated_on

                                                            updated_on: string;
                                                            • When the comment was updated, in ISO 8601 format

                                                            property user

                                                            user: BitBucketCloudUser;

                                                              interface BitBucketCloudPRDSL

                                                              interface BitBucketCloudPRDSL {}

                                                                property author

                                                                author: BitBucketCloudUser;
                                                                • The creator of the PR

                                                                property created_on

                                                                created_on: string;
                                                                • When the pr was created, in ISO 8601 format

                                                                property description

                                                                description: string;
                                                                • The text describing the PR

                                                                property destination

                                                                destination: BitBucketCloudMergeRef;
                                                                • The PR's destination

                                                                property id

                                                                id: number;
                                                                • The PR's ID

                                                                links: BitBucketCloudLinks<
                                                                | 'decline'
                                                                | 'commits'
                                                                | 'self'
                                                                | 'comments'
                                                                | 'merge'
                                                                | 'html'
                                                                | 'activity'
                                                                | 'diff'
                                                                | 'approve'
                                                                | 'statuses'
                                                                >;
                                                                • Misc links for hypermedia conformance

                                                                property participants

                                                                participants: BitBucketCloudPRParticipant[];
                                                                • People who have participated in the PR

                                                                property reviewers

                                                                reviewers: BitBucketCloudUser[];
                                                                • People requested as reviewers

                                                                property source

                                                                source: BitBucketCloudMergeRef;
                                                                • The PR's source, The repo Danger is running on

                                                                property state

                                                                state: 'OPEN' | 'MERGED' | 'DECLINED' | 'SUPERSEDED';
                                                                • The pull request's current status.

                                                                property title

                                                                title: string;
                                                                • Title of the pull request.

                                                                property updated_on

                                                                updated_on: string;
                                                                • When the pr was updated, in ISO 8601 format

                                                                interface BitBucketCloudPRParticipant

                                                                interface BitBucketCloudPRParticipant {}

                                                                  property approved

                                                                  approved: boolean;
                                                                  • Did they approve of the PR?

                                                                  property role

                                                                  role: 'REVIEWER' | 'PARTICIPANT';
                                                                  • How did they contribute

                                                                  property user

                                                                  user: BitBucketCloudUser;

                                                                    interface BitBucketCloudRepo

                                                                    interface BitBucketCloudRepo {}

                                                                      property full_name

                                                                      full_name: string;

                                                                        property name

                                                                        name: string;

                                                                          property uuid

                                                                          uuid: string;

                                                                            interface BitBucketCloudUser

                                                                            interface BitBucketCloudUser {}

                                                                              property account_id

                                                                              account_id: string;
                                                                              • The acount id of the commit author

                                                                              property display_name

                                                                              display_name: string;
                                                                              • The display name of the commit author

                                                                              property nickname

                                                                              nickname: string;
                                                                              • The nick name of the commit author

                                                                              property uuid

                                                                              uuid: string;
                                                                              • The uuid of the commit author

                                                                              interface BitBucketServerAPIDSL

                                                                              interface BitBucketServerAPIDSL {}

                                                                                method delete

                                                                                delete: (path: string, headers: any, body: any) => Promise<any>;
                                                                                • Make a delete call against the bitbucket server API

                                                                                method get

                                                                                get: (path: string, headers: any, suppressErrors?: boolean) => Promise<any>;
                                                                                • Make a get call against the bitbucket server API

                                                                                method getFileContents

                                                                                getFileContents: (
                                                                                filePath: string,
                                                                                repoSlug?: string,
                                                                                refspec?: string
                                                                                ) => Promise<string>;
                                                                                • Gets the contents of a file from a repo (defaults to yours)

                                                                                method post

                                                                                post: (
                                                                                path: string,
                                                                                headers: any,
                                                                                body: any,
                                                                                suppressErrors?: boolean
                                                                                ) => Promise<any>;
                                                                                • Make a post call against the bitbucket server API

                                                                                method put

                                                                                put: (path: string, headers: any, body: any) => Promise<any>;
                                                                                • Make a put call against the bitbucket server API

                                                                                interface BitBucketServerChangesValueAddCopyModifyDelete

                                                                                interface BitBucketServerChangesValueAddCopyModifyDelete {}

                                                                                  property path

                                                                                  path: {
                                                                                  toString: string;
                                                                                  };

                                                                                    property type

                                                                                    type: 'ADD' | 'COPY' | 'MODIFY' | 'DELETE' | 'UNKNOWN';

                                                                                      interface BitBucketServerChangesValueMove

                                                                                      interface BitBucketServerChangesValueMove {}

                                                                                        property path

                                                                                        path: {
                                                                                        toString: string;
                                                                                        };

                                                                                          property srcPath

                                                                                          srcPath: {
                                                                                          toString: string;
                                                                                          };

                                                                                            property type

                                                                                            type: 'MOVE';

                                                                                              interface BitBucketServerCommit

                                                                                              interface BitBucketServerCommit {}
                                                                                              • A BitBucketServer specific implementation of a git commit.

                                                                                              property author

                                                                                              author: {
                                                                                              /** The id of the commit author */
                                                                                              name: string;
                                                                                              /** The display name of the commit author */
                                                                                              displayName: string;
                                                                                              /** The email of the commit author */
                                                                                              emailAddress: string;
                                                                                              };
                                                                                              • The author of the commit, assumed to be the person who wrote the code.

                                                                                              property authorTimestamp

                                                                                              authorTimestamp: number;
                                                                                              • The UNIX timestamp for when the commit was authored

                                                                                              property committer

                                                                                              committer: {
                                                                                              /** The id of the commit committer */
                                                                                              name: string;
                                                                                              /** The display name of the commit committer */
                                                                                              displayName: string;
                                                                                              /** The email of the commit committer */
                                                                                              emailAddress: string;
                                                                                              };
                                                                                              • The author of the commit, assumed to be the person who committed/merged the code into a project.

                                                                                              property committerTimestamp

                                                                                              committerTimestamp: number;
                                                                                              • When the commit was committed to the project

                                                                                              property displayId

                                                                                              displayId: string;
                                                                                              • The shortened SHA for the commit

                                                                                              property id

                                                                                              id: string;
                                                                                              • The SHA for the commit

                                                                                              property message

                                                                                              message: string;
                                                                                              • The commit's message

                                                                                              property parents

                                                                                              parents: {
                                                                                              /** The full SHA */
                                                                                              id: string;
                                                                                              /** The simplified sha */
                                                                                              displayId: string;
                                                                                              }[];
                                                                                              • The commit's parents

                                                                                              interface BitBucketServerDiff

                                                                                              interface BitBucketServerDiff {}

                                                                                                property destination

                                                                                                destination?: BitBucketServerFile;
                                                                                                • The file reference when moved

                                                                                                property fromHash

                                                                                                fromHash: string;
                                                                                                • Last SHA where this hunk was changed

                                                                                                property hunks

                                                                                                hunks: BitBucketServerHunk[];
                                                                                                • A set of diff changes

                                                                                                property source

                                                                                                source?: BitBucketServerFile;
                                                                                                • The original file reference

                                                                                                property toHash

                                                                                                toHash: string;
                                                                                                • The commit SHA which changed this hunk

                                                                                                property truncated

                                                                                                truncated: boolean;
                                                                                                • If the hunk is massive, then it will be truncated

                                                                                                property whitespace

                                                                                                whitespace: 'SHOW' | 'IGNORE_ALL';
                                                                                                • The settings for the whitespace

                                                                                                interface BitBucketServerDSL

                                                                                                interface BitBucketServerDSL extends BitBucketServerJSONDSL {}
                                                                                                • The BitBucketServer metadata for your PR

                                                                                                property api

                                                                                                api: BitBucketServerAPIDSL;
                                                                                                • An authenticated API so you can extend danger's behavior.

                                                                                                interface BitBucketServerFile

                                                                                                interface BitBucketServerFile {}

                                                                                                  property components

                                                                                                  components: string[];

                                                                                                    property name

                                                                                                    name: string;

                                                                                                      property parent

                                                                                                      parent: string;

                                                                                                        property toString

                                                                                                        toString: string;

                                                                                                          interface BitBucketServerHunk

                                                                                                          interface BitBucketServerHunk {}

                                                                                                            property destinationLine

                                                                                                            destinationLine: number;

                                                                                                              property destinationSpan

                                                                                                              destinationSpan: number;

                                                                                                                property segments

                                                                                                                segments: BitBucketServerSegment[];

                                                                                                                  property sourceLine

                                                                                                                  sourceLine: number;

                                                                                                                    property sourceSpan

                                                                                                                    sourceSpan: number;

                                                                                                                      property truncated

                                                                                                                      truncated: boolean;

                                                                                                                        interface BitBucketServerJSONDSL

                                                                                                                        interface BitBucketServerJSONDSL {}

                                                                                                                          property activities

                                                                                                                          activities: BitBucketServerPRActivity[];
                                                                                                                          • The activities such as OPENING, CLOSING, MERGING or UPDATING a pull request

                                                                                                                          property comments

                                                                                                                          comments: BitBucketServerPRActivity[];
                                                                                                                          • The comments on the pull request

                                                                                                                          property commits

                                                                                                                          commits: BitBucketServerCommit[];
                                                                                                                          • The commits associated with the pull request

                                                                                                                          property issues

                                                                                                                          issues: JIRAIssue[];
                                                                                                                          • The related JIRA issues

                                                                                                                          property metadata

                                                                                                                          metadata: RepoMetaData;
                                                                                                                          • The pull request and repository metadata

                                                                                                                          property pr

                                                                                                                          pr: BitBucketServerPRDSL;
                                                                                                                          • The PR metadata

                                                                                                                          interface BitBucketServerLine

                                                                                                                          interface BitBucketServerLine {}

                                                                                                                            property commentIds

                                                                                                                            commentIds?: number[];

                                                                                                                              property conflictMarker

                                                                                                                              conflictMarker?: 'OURS';

                                                                                                                                property destination

                                                                                                                                destination: number;

                                                                                                                                  property line

                                                                                                                                  line: string;

                                                                                                                                    property source

                                                                                                                                    source: number;

                                                                                                                                      property truncated

                                                                                                                                      truncated: boolean;

                                                                                                                                        interface BitBucketServerMergeRef

                                                                                                                                        interface BitBucketServerMergeRef {}

                                                                                                                                          property displayId

                                                                                                                                          displayId: string;

                                                                                                                                            property id

                                                                                                                                            id: string;

                                                                                                                                              property latestCommit

                                                                                                                                              latestCommit: string;

                                                                                                                                                property repository

                                                                                                                                                repository: BitBucketServerRepo;

                                                                                                                                                  interface BitBucketServerPagedResponse

                                                                                                                                                  interface BitBucketServerPagedResponse<T> {}

                                                                                                                                                    property filter

                                                                                                                                                    filter: never | null;

                                                                                                                                                      property isLastPage

                                                                                                                                                      isLastPage: boolean;

                                                                                                                                                        property limit

                                                                                                                                                        limit: number;

                                                                                                                                                          property nextPageStart

                                                                                                                                                          nextPageStart: number | null;

                                                                                                                                                            property size

                                                                                                                                                            size: number;

                                                                                                                                                              property start

                                                                                                                                                              start: number;

                                                                                                                                                                property values

                                                                                                                                                                values: T;

                                                                                                                                                                  interface BitBucketServerPRActivity

                                                                                                                                                                  interface BitBucketServerPRActivity {}

                                                                                                                                                                    property action

                                                                                                                                                                    action: 'COMMENTED' | 'OPENED' | 'MERGED' | 'DECLINED' | 'UPDATED';

                                                                                                                                                                      property comment

                                                                                                                                                                      comment?: BitBucketServerPRComment;

                                                                                                                                                                        property commentAction

                                                                                                                                                                        commentAction?: 'ADDED' | 'UPDATED';

                                                                                                                                                                          property commentAnchor

                                                                                                                                                                          commentAnchor?: {
                                                                                                                                                                          diffType: 'COMMIT' | 'EFFECTIVE' | 'REQUIRED' | 'RANGE';
                                                                                                                                                                          line: number;
                                                                                                                                                                          lineType: 'CONTEXT' | 'ADDED' | 'REMOVED';
                                                                                                                                                                          fileType: 'FROM' | 'TO';
                                                                                                                                                                          fromHash: string;
                                                                                                                                                                          path: string;
                                                                                                                                                                          srcPath: string;
                                                                                                                                                                          toHash: string;
                                                                                                                                                                          };

                                                                                                                                                                            property createdDate

                                                                                                                                                                            createdDate: number;

                                                                                                                                                                              property id

                                                                                                                                                                              id: number;

                                                                                                                                                                                property user

                                                                                                                                                                                user: BitBucketServerUser;

                                                                                                                                                                                  interface BitBucketServerPRComment

                                                                                                                                                                                  interface BitBucketServerPRComment {}

                                                                                                                                                                                    property author

                                                                                                                                                                                    author: BitBucketServerUser;

                                                                                                                                                                                      property comments

                                                                                                                                                                                      comments: BitBucketServerPRActivity[];

                                                                                                                                                                                        property createdDate

                                                                                                                                                                                        createdDate: number;

                                                                                                                                                                                          property id

                                                                                                                                                                                          id: number;

                                                                                                                                                                                            property parent

                                                                                                                                                                                            parent?: {
                                                                                                                                                                                            id: number;
                                                                                                                                                                                            };

                                                                                                                                                                                              property permittedOperations

                                                                                                                                                                                              permittedOperations: {
                                                                                                                                                                                              deletable: boolean;
                                                                                                                                                                                              editable: boolean;
                                                                                                                                                                                              };

                                                                                                                                                                                                property text

                                                                                                                                                                                                text: string;

                                                                                                                                                                                                  property updatedDate

                                                                                                                                                                                                  updatedDate: number;

                                                                                                                                                                                                    property version

                                                                                                                                                                                                    version: number;

                                                                                                                                                                                                      interface BitBucketServerPRDSL

                                                                                                                                                                                                      interface BitBucketServerPRDSL {}
                                                                                                                                                                                                      • An exact copy of the PR's reference JSON. This interface has type'd the majority of it for tooling's sake, but any extra metadata which BitBucket Server send will still be inside the JS object.

                                                                                                                                                                                                      property author

                                                                                                                                                                                                      author: BitBucketServerPRParticipant & { role: 'AUTHOR' };
                                                                                                                                                                                                      • The creator of the PR

                                                                                                                                                                                                      property closed

                                                                                                                                                                                                      closed: boolean;
                                                                                                                                                                                                      • Is the PR closed?

                                                                                                                                                                                                      property createdDate

                                                                                                                                                                                                      createdDate: number;
                                                                                                                                                                                                      • Date PR created as number of milliseconds since the unix epoch

                                                                                                                                                                                                      property description

                                                                                                                                                                                                      description: string;
                                                                                                                                                                                                      • The text describing the PR

                                                                                                                                                                                                      property fromRef

                                                                                                                                                                                                      fromRef: BitBucketServerMergeRef;
                                                                                                                                                                                                      • The PR submitter's reference

                                                                                                                                                                                                      property id

                                                                                                                                                                                                      id: number;
                                                                                                                                                                                                      • The PR's ID

                                                                                                                                                                                                      links: BitBucketServerLinks<'self'>;
                                                                                                                                                                                                      • Misc links for hypermedia conformance

                                                                                                                                                                                                      property locked

                                                                                                                                                                                                      locked: boolean;
                                                                                                                                                                                                      • Was this PR locked?

                                                                                                                                                                                                      property open

                                                                                                                                                                                                      open: boolean;
                                                                                                                                                                                                      • Is the PR open?

                                                                                                                                                                                                      property participants

                                                                                                                                                                                                      participants: (BitBucketServerPRParticipant & { role: 'PARTICIPANT' })[];
                                                                                                                                                                                                      • People who have participated in the PR

                                                                                                                                                                                                      property reviewers

                                                                                                                                                                                                      reviewers: (BitBucketServerPRParticipant & { role: 'REVIEWER' })[];
                                                                                                                                                                                                      • People requested as reviewers

                                                                                                                                                                                                      property state

                                                                                                                                                                                                      state: 'OPEN' | 'MERGED' | 'DECLINED' | 'SUPERSEDED';
                                                                                                                                                                                                      • The pull request's current status.

                                                                                                                                                                                                      property title

                                                                                                                                                                                                      title: string;
                                                                                                                                                                                                      • Title of the pull request.

                                                                                                                                                                                                      property toRef

                                                                                                                                                                                                      toRef: BitBucketServerMergeRef;
                                                                                                                                                                                                      • The repo Danger is running on

                                                                                                                                                                                                      property updatedDate

                                                                                                                                                                                                      updatedDate: number;
                                                                                                                                                                                                      • Date PR updated as number of milliseconds since the unix epoch

                                                                                                                                                                                                      property version

                                                                                                                                                                                                      version: number;
                                                                                                                                                                                                      • The API version

                                                                                                                                                                                                      interface BitBucketServerPRParticipant

                                                                                                                                                                                                      interface BitBucketServerPRParticipant {}

                                                                                                                                                                                                        property approved

                                                                                                                                                                                                        approved: boolean;
                                                                                                                                                                                                        • Did they approve of the PR?

                                                                                                                                                                                                        property role

                                                                                                                                                                                                        role: 'AUTHOR' | 'REVIEWER' | 'PARTICIPANT';
                                                                                                                                                                                                        • How did they contribute

                                                                                                                                                                                                        property status

                                                                                                                                                                                                        status: 'APPROVED' | 'UNAPPROVED' | 'NEEDS_WORK';
                                                                                                                                                                                                        • Their review feedback

                                                                                                                                                                                                        property user

                                                                                                                                                                                                        user: BitBucketServerUser;

                                                                                                                                                                                                          interface BitBucketServerRepo

                                                                                                                                                                                                          interface BitBucketServerRepo {}
                                                                                                                                                                                                          • A BitBucket Server Repo

                                                                                                                                                                                                          property forkable

                                                                                                                                                                                                          forkable: boolean;
                                                                                                                                                                                                          • Can someone fork this repo?

                                                                                                                                                                                                          links: BitBucketServerLinks<'self' | 'clone'>;
                                                                                                                                                                                                          • Links for the projects

                                                                                                                                                                                                          property name

                                                                                                                                                                                                          name?: string;
                                                                                                                                                                                                          • The repo name

                                                                                                                                                                                                          property project

                                                                                                                                                                                                          project: {
                                                                                                                                                                                                          /** The project unique id */
                                                                                                                                                                                                          id: number;
                                                                                                                                                                                                          /** The project's human readable project key */
                                                                                                                                                                                                          key: string;
                                                                                                                                                                                                          /** Is the project publicly available */
                                                                                                                                                                                                          public: boolean;
                                                                                                                                                                                                          /** The name of the project */
                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                          /** The project's type */
                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                          /** Hyperlinks for the project */
                                                                                                                                                                                                          links: BitBucketServerLinks<'self'>;
                                                                                                                                                                                                          };
                                                                                                                                                                                                          • An abstraction for grouping repos

                                                                                                                                                                                                          property public

                                                                                                                                                                                                          public: boolean;
                                                                                                                                                                                                          • Is the repo public?

                                                                                                                                                                                                          property scmId

                                                                                                                                                                                                          scmId: string;
                                                                                                                                                                                                          • The type of SCM tool, probably "git"

                                                                                                                                                                                                          property slug

                                                                                                                                                                                                          slug: string;
                                                                                                                                                                                                          • The slug for the repo

                                                                                                                                                                                                          interface BitBucketServerSegment

                                                                                                                                                                                                          interface BitBucketServerSegment {}

                                                                                                                                                                                                            property lines

                                                                                                                                                                                                            lines: BitBucketServerLine[];

                                                                                                                                                                                                              property truncated

                                                                                                                                                                                                              truncated: boolean;

                                                                                                                                                                                                                property type

                                                                                                                                                                                                                type: 'ADDED' | 'REMOVED' | 'CONTEXT';

                                                                                                                                                                                                                  interface BitBucketServerUser

                                                                                                                                                                                                                  interface BitBucketServerUser {}
                                                                                                                                                                                                                  • A BitBucketServer user account.

                                                                                                                                                                                                                  property active

                                                                                                                                                                                                                  active: boolean;
                                                                                                                                                                                                                  • Is the account active

                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                  displayName: string;
                                                                                                                                                                                                                  • The name to use when referencing the user

                                                                                                                                                                                                                  property emailAddress

                                                                                                                                                                                                                  emailAddress: string;
                                                                                                                                                                                                                  • The email for the user

                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                  id: number;
                                                                                                                                                                                                                  • The unique user ID

                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                  name: string;
                                                                                                                                                                                                                  • The name of the user

                                                                                                                                                                                                                  property slug

                                                                                                                                                                                                                  slug: string;
                                                                                                                                                                                                                  • The user's slug for URLs

                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                  type: 'NORMAL' | 'SERVICE';
                                                                                                                                                                                                                  • The type of a user, "NORMAL" being a typical user3

                                                                                                                                                                                                                  interface CliArgs

                                                                                                                                                                                                                  interface CliArgs {}
                                                                                                                                                                                                                  • Describes the possible arguments that could be used when calling the CLI

                                                                                                                                                                                                                  property base

                                                                                                                                                                                                                  base: string;
                                                                                                                                                                                                                  • The base reference used by danger PR (e.g. not master)

                                                                                                                                                                                                                  property dangerfile

                                                                                                                                                                                                                  dangerfile: string;
                                                                                                                                                                                                                  • A custom path for the dangerfile (can also be a remote reference)

                                                                                                                                                                                                                  property externalCiProvider

                                                                                                                                                                                                                  externalCiProvider: string;
                                                                                                                                                                                                                  • Used by danger-js o allow having a custom CI

                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                  id: string;
                                                                                                                                                                                                                  • So you can have many danger runs in one code review

                                                                                                                                                                                                                  property staging

                                                                                                                                                                                                                  staging?: boolean;
                                                                                                                                                                                                                  • Use staged changes

                                                                                                                                                                                                                  property textOnly

                                                                                                                                                                                                                  textOnly: string;
                                                                                                                                                                                                                  • Use SDTOUT instead of posting to the code review side

                                                                                                                                                                                                                  property verbose

                                                                                                                                                                                                                  verbose: string;
                                                                                                                                                                                                                  • For debugging

                                                                                                                                                                                                                  interface DangerDSLJSONType

                                                                                                                                                                                                                  interface DangerDSLJSONType {}
                                                                                                                                                                                                                  • The root of the Danger JSON DSL.

                                                                                                                                                                                                                  property bitbucket_cloud

                                                                                                                                                                                                                  bitbucket_cloud?: BitBucketCloudJSONDSL;
                                                                                                                                                                                                                  • The data only version of BitBucket Cloud DSL

                                                                                                                                                                                                                  property bitbucket_server

                                                                                                                                                                                                                  bitbucket_server?: BitBucketServerJSONDSL;
                                                                                                                                                                                                                  • The data only version of BitBucket Server DSL

                                                                                                                                                                                                                  property git

                                                                                                                                                                                                                  git: GitJSONDSL;
                                                                                                                                                                                                                  • The data only version of Git DSL

                                                                                                                                                                                                                  property github

                                                                                                                                                                                                                  github?: GitHubDSL;
                                                                                                                                                                                                                  • The data only version of GitHub DSL

                                                                                                                                                                                                                  property gitlab

                                                                                                                                                                                                                  gitlab?: GitLabDSL;
                                                                                                                                                                                                                  • The data only version of GitLab DSL

                                                                                                                                                                                                                  property settings

                                                                                                                                                                                                                  settings: {
                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                  * Saves each client re-implementing logic to grab these vars
                                                                                                                                                                                                                  * for their API clients
                                                                                                                                                                                                                  */
                                                                                                                                                                                                                  github: {
                                                                                                                                                                                                                  /** API token for the GitHub client to use */
                                                                                                                                                                                                                  accessToken: string;
                                                                                                                                                                                                                  /** Optional URL for enterprise GitHub */
                                                                                                                                                                                                                  baseURL: string | undefined;
                                                                                                                                                                                                                  /** Optional headers to add to a request */
                                                                                                                                                                                                                  additionalHeaders: any;
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                  * This is still a bit of a WIP, but this should
                                                                                                                                                                                                                  * pass args/opts from the original CLI call through
                                                                                                                                                                                                                  * to the process.
                                                                                                                                                                                                                  */
                                                                                                                                                                                                                  cliArgs: CliArgs;
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  • Used in the Danger JSON DSL to pass metadata between processes. It will be undefined when used inside the Danger DSL

                                                                                                                                                                                                                  interface DangerDSLType

                                                                                                                                                                                                                  interface DangerDSLType {}
                                                                                                                                                                                                                  • The Danger DSL provides the metadata for introspection in order to create your own rules.

                                                                                                                                                                                                                  property bitbucket_cloud

                                                                                                                                                                                                                  readonly bitbucket_cloud: BitBucketCloudDSL;
                                                                                                                                                                                                                  • The BitBucket Cloud metadata. This covers things like PR info, comments and reviews on the PR, commits, comments, and activities.

                                                                                                                                                                                                                    Strictly speaking, bitbucket_cloud is a nullable type, if you are not using BitBucket Cloud then it will be undefined. For the DSL convenience sake though, it is classed as non-nullable

                                                                                                                                                                                                                  property bitbucket_server

                                                                                                                                                                                                                  readonly bitbucket_server: BitBucketServerDSL;
                                                                                                                                                                                                                  • The BitBucket Server metadata. This covers things like PR info, comments and reviews on the PR, related issues, commits, comments and activities.

                                                                                                                                                                                                                    Strictly speaking, bitbucket_server is a nullable type, if you are not using BitBucket Server then it will be undefined. For the DSL convenience sake though, it is classed as non-nullable

                                                                                                                                                                                                                  property git

                                                                                                                                                                                                                  readonly git: GitDSL;
                                                                                                                                                                                                                  • Details specific to the git changes within the code changes. Currently, this is just the raw file paths that have been added, removed or modified.

                                                                                                                                                                                                                  property github

                                                                                                                                                                                                                  readonly github: GitHubDSL;
                                                                                                                                                                                                                  • The GitHub metadata. This covers things like PR info, comments and reviews on the PR, label metadata, commits with GitHub user identities and some useful utility functions for displaying links to files.

                                                                                                                                                                                                                    Strictly speaking, github is a nullable type, if you are not using GitHub then it will be undefined. For the DSL convenience sake though, it is classed as non-nullable

                                                                                                                                                                                                                    Provides an authenticated API so you can work directly with the GitHub API. This is an instance of the "@octokit/rest" npm module.

                                                                                                                                                                                                                    Finally, if running through Peril on an event other than a PR this is the full JSON from the webhook. [github-webhook-event-types](https://github.com/orta/github-webhook-event-types) has the full typings for those webhooks.

                                                                                                                                                                                                                  property gitlab

                                                                                                                                                                                                                  readonly gitlab: GitLabDSL;
                                                                                                                                                                                                                  • The GitLab metadata. This covers things like PR info, comments and reviews on the MR, commits, comments and activities.

                                                                                                                                                                                                                    Strictly speaking, gitlab is a nullable type, if you are not using GitLab then it will be undefined. For the DSL convenience sake though, it is classed as non-nullable

                                                                                                                                                                                                                  property utils

                                                                                                                                                                                                                  readonly utils: DangerUtilsDSL;
                                                                                                                                                                                                                  • Functions which are globally useful in most Dangerfiles. Right now, these functions are around making sentences of arrays, or for making a like of href links easily.

                                                                                                                                                                                                                  interface DangerInlineResults

                                                                                                                                                                                                                  interface DangerInlineResults {}

                                                                                                                                                                                                                    property fails

                                                                                                                                                                                                                    fails: string[];
                                                                                                                                                                                                                    • Failed messages

                                                                                                                                                                                                                    property file

                                                                                                                                                                                                                    file: string;
                                                                                                                                                                                                                    • Path to the file

                                                                                                                                                                                                                    property line

                                                                                                                                                                                                                    line: number;
                                                                                                                                                                                                                    • Line in the file

                                                                                                                                                                                                                    property markdowns

                                                                                                                                                                                                                    markdowns: string[];
                                                                                                                                                                                                                    • Markdown messages to attach at the bottom of the comment

                                                                                                                                                                                                                    property messages

                                                                                                                                                                                                                    messages: string[];
                                                                                                                                                                                                                    • A set of messages to show inline

                                                                                                                                                                                                                    property warnings

                                                                                                                                                                                                                    warnings: string[];
                                                                                                                                                                                                                    • Messages for info

                                                                                                                                                                                                                    interface DangerJSON

                                                                                                                                                                                                                    interface DangerJSON {}
                                                                                                                                                                                                                    • The shape of the JSON passed between Danger and a subprocess. It's built to be expanded in the future.

                                                                                                                                                                                                                    property danger

                                                                                                                                                                                                                    danger: DangerDSLJSONType;

                                                                                                                                                                                                                      interface DangerResults

                                                                                                                                                                                                                      interface DangerResults {}
                                                                                                                                                                                                                      • The representation of what running a Dangerfile generates. This needs to be passed between processes, so data only please.

                                                                                                                                                                                                                      property fails

                                                                                                                                                                                                                      fails: Violation[];
                                                                                                                                                                                                                      • Failed messages

                                                                                                                                                                                                                      property markdowns

                                                                                                                                                                                                                      markdowns: Violation[];
                                                                                                                                                                                                                      • Markdown messages to attach at the bottom of the comment

                                                                                                                                                                                                                      property messages

                                                                                                                                                                                                                      messages: Violation[];
                                                                                                                                                                                                                      • A set of messages to show inline

                                                                                                                                                                                                                      property meta

                                                                                                                                                                                                                      meta?: {
                                                                                                                                                                                                                      /** E.g. "dangerJS", or "Danger Swift" */
                                                                                                                                                                                                                      runtimeName: string;
                                                                                                                                                                                                                      /** e.g. "https://danger.systems/js" */
                                                                                                                                                                                                                      runtimeHref: string;
                                                                                                                                                                                                                      };
                                                                                                                                                                                                                      • Meta information about the runtime evaluation

                                                                                                                                                                                                                      property warnings

                                                                                                                                                                                                                      warnings: Violation[];
                                                                                                                                                                                                                      • Messages for info

                                                                                                                                                                                                                      interface DangerRuntimeContainer

                                                                                                                                                                                                                      interface DangerRuntimeContainer extends DangerResults {}

                                                                                                                                                                                                                        property scheduled

                                                                                                                                                                                                                        scheduled?: any[];
                                                                                                                                                                                                                        • Asynchronous functions to be run after parsing

                                                                                                                                                                                                                        interface DangerUtilsDSL

                                                                                                                                                                                                                        interface DangerUtilsDSL {}
                                                                                                                                                                                                                        • The Danger Utils DSL contains utility functions that are specific to universal Danger use-cases.

                                                                                                                                                                                                                        method href

                                                                                                                                                                                                                        href: (href: string, text: string) => string | null;
                                                                                                                                                                                                                        • Creates a link using HTML.

                                                                                                                                                                                                                          If href and text are falsy, null is returned. If href is falsy and text is truthy, text is returned. If href is truthy and text is falsy, an tag is returned with href as its href and text value. Otherwise, if href and text are truthy, an tag is returned with the href and text inserted as expected.

                                                                                                                                                                                                                          Parameter href

                                                                                                                                                                                                                          The HTML link's destination.

                                                                                                                                                                                                                          Parameter text

                                                                                                                                                                                                                          The HTML link's text.

                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                          {string|null} The HTML tag.

                                                                                                                                                                                                                        method sentence

                                                                                                                                                                                                                        sentence: (array: string[]) => string;
                                                                                                                                                                                                                        • Converts an array of strings into a sentence.

                                                                                                                                                                                                                          Parameter array

                                                                                                                                                                                                                          The array of strings.

                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                          {string} The sentence.

                                                                                                                                                                                                                        interface GitCommit

                                                                                                                                                                                                                        interface GitCommit {}
                                                                                                                                                                                                                        • A platform agnostic reference to a Git commit

                                                                                                                                                                                                                        property author

                                                                                                                                                                                                                        author: GitCommitAuthor;
                                                                                                                                                                                                                        • Who wrote the commit

                                                                                                                                                                                                                        property committer

                                                                                                                                                                                                                        committer: GitCommitAuthor;
                                                                                                                                                                                                                        • Who deployed the commit

                                                                                                                                                                                                                        property message

                                                                                                                                                                                                                        message: string;
                                                                                                                                                                                                                        • The commit message

                                                                                                                                                                                                                        property parents

                                                                                                                                                                                                                        parents?: string[];
                                                                                                                                                                                                                        • SHAs for the commit's parents

                                                                                                                                                                                                                        property sha

                                                                                                                                                                                                                        sha: string;
                                                                                                                                                                                                                        • The SHA for the commit

                                                                                                                                                                                                                        property tree

                                                                                                                                                                                                                        tree: any;
                                                                                                                                                                                                                        • Potential parent commits, and other assorted metadata

                                                                                                                                                                                                                        property url

                                                                                                                                                                                                                        url: string;
                                                                                                                                                                                                                        • Link to the commit

                                                                                                                                                                                                                        interface GitCommitAuthor

                                                                                                                                                                                                                        interface GitCommitAuthor {}
                                                                                                                                                                                                                        • An author of a commit

                                                                                                                                                                                                                        property date

                                                                                                                                                                                                                        date: string;
                                                                                                                                                                                                                        • ISO6801 date string

                                                                                                                                                                                                                        property email

                                                                                                                                                                                                                        email: string;
                                                                                                                                                                                                                        • The authors email

                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                        • The display name for the author

                                                                                                                                                                                                                        interface GitDSL

                                                                                                                                                                                                                        interface GitDSL extends GitJSONDSL {}
                                                                                                                                                                                                                        • The git specific metadata for a PR

                                                                                                                                                                                                                        property base

                                                                                                                                                                                                                        base: string;
                                                                                                                                                                                                                        • The git commit Danger is comparing from.

                                                                                                                                                                                                                        property fileMatch

                                                                                                                                                                                                                        fileMatch: Chainsmoker<GitMatchResult>;
                                                                                                                                                                                                                        • A Chainsmoker object to help match paths as an elegant DSL. It lets you write a globbed string and then get booleans on whether there are matches within a certain part of the git DSL.

                                                                                                                                                                                                                          Use this to create an object which has booleans set on 4 keys modified, created, edited (created + modified) and deleted.

                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                          const packageJSON = danger.git.fileMatch("package.json") const lockfile = danger.git.fileMatch("yarn.lock")

                                                                                                                                                                                                                          if (packageJSON.modified && !lockfile.modified) { warn("You might have forgotten to run yarn.") }

                                                                                                                                                                                                                          Example 2

                                                                                                                                                                                                                          const needsSchemaChange = danger.git.fileMatch("src/app/analytics/*.ts") const schema = danger.git.fileMatch("src/app/analytics/schema.ts")

                                                                                                                                                                                                                          if (needsSchemaChange.edited && !schema.modified) { fail("Changes to the analytics files need to edit update the schema.") }

                                                                                                                                                                                                                        property head

                                                                                                                                                                                                                        head: string;
                                                                                                                                                                                                                        • The git commit Danger is comparing to.

                                                                                                                                                                                                                        method diffForFile

                                                                                                                                                                                                                        diffForFile: (filename: string) => Promise<TextDiff | null>;
                                                                                                                                                                                                                        • Offers the diff for a specific file

                                                                                                                                                                                                                          Parameter filename

                                                                                                                                                                                                                          the path to the json file

                                                                                                                                                                                                                        method JSONDiffForFile

                                                                                                                                                                                                                        JSONDiffForFile: (filename: string) => Promise<JSONDiff>;
                                                                                                                                                                                                                        • Provides a simplified JSON diff between the two versions of a JSON file. This will always be an object whose keys represent what has changed inside a JSON file.

                                                                                                                                                                                                                          Any changed values will be represented with the same path, but with a different object instead. This object will always show a before and after for the changes. If both values are arrays or objects the before and after, then there will also be added and removed inside the object.

                                                                                                                                                                                                                          In the case of two objects, the added and removed will be an array of keys rather than the values.

                                                                                                                                                                                                                          This object is represented as JSONDiffValue but I don't know how to make TypeScript force declare that kind of type structure.

                                                                                                                                                                                                                          This should make it really easy to do work when specific keypaths have changed inside a JSON file.

                                                                                                                                                                                                                          Parameter filename

                                                                                                                                                                                                                          the path to the json file

                                                                                                                                                                                                                        method JSONPatchForFile

                                                                                                                                                                                                                        JSONPatchForFile: (filename: string) => Promise<JSONPatch | null>;
                                                                                                                                                                                                                        • Provides a JSON patch (rfc6902) between the two versions of a JSON file, returns null if you don't have any changes for the file in the diff.

                                                                                                                                                                                                                          Note that if you are looking to just see changes like: before, after, added or removed - you should use JSONDiffForFile instead, as this can be a bit unwieldy for a Dangerfile.

                                                                                                                                                                                                                          Parameter filename

                                                                                                                                                                                                                          the path to the json file

                                                                                                                                                                                                                        method linesOfCode

                                                                                                                                                                                                                        linesOfCode: (pattern?: string) => Promise<number | null>;
                                                                                                                                                                                                                        • Offers the overall lines of code added/removed in the diff

                                                                                                                                                                                                                          Parameter pattern

                                                                                                                                                                                                                          an option glob pattern to filer files that will considered for lines of code.

                                                                                                                                                                                                                        method structuredDiffForFile

                                                                                                                                                                                                                        structuredDiffForFile: (filename: string) => Promise<StructuredDiff | null>;
                                                                                                                                                                                                                        • Offers the structured diff for a specific file

                                                                                                                                                                                                                          Parameter filename

                                                                                                                                                                                                                          the path to the json file

                                                                                                                                                                                                                        interface GitHubAPIPR

                                                                                                                                                                                                                        interface GitHubAPIPR {}
                                                                                                                                                                                                                        • Provides the current PR in an easily used way for params in github.api calls

                                                                                                                                                                                                                        property number

                                                                                                                                                                                                                        number: number;
                                                                                                                                                                                                                        • The PR number

                                                                                                                                                                                                                        property owner

                                                                                                                                                                                                                        owner: string;
                                                                                                                                                                                                                        • The repo owner

                                                                                                                                                                                                                        property repo

                                                                                                                                                                                                                        repo: string;
                                                                                                                                                                                                                        • The repo name

                                                                                                                                                                                                                        interface GitHubCommit

                                                                                                                                                                                                                        interface GitHubCommit {}
                                                                                                                                                                                                                        • A GitHub specific implementation of a git commit, it has GitHub user names instead of an email.

                                                                                                                                                                                                                        property author

                                                                                                                                                                                                                        author: GitHubUser;
                                                                                                                                                                                                                        • The GitHub user who wrote the code

                                                                                                                                                                                                                        property commit

                                                                                                                                                                                                                        commit: GitCommit;
                                                                                                                                                                                                                        • The raw commit metadata

                                                                                                                                                                                                                        property committer

                                                                                                                                                                                                                        committer: GitHubUser;
                                                                                                                                                                                                                        • The GitHub user who shipped the code

                                                                                                                                                                                                                        property parents

                                                                                                                                                                                                                        parents: any[];
                                                                                                                                                                                                                        • An array of parent commit shas

                                                                                                                                                                                                                        property sha

                                                                                                                                                                                                                        sha: string;
                                                                                                                                                                                                                        • The SHA for the commit

                                                                                                                                                                                                                        property url

                                                                                                                                                                                                                        url: string;
                                                                                                                                                                                                                        • the url for the commit on GitHub

                                                                                                                                                                                                                        interface GitHubDSL

                                                                                                                                                                                                                        interface GitHubDSL extends GitHubJSONDSL {}
                                                                                                                                                                                                                        • The GitHub metadata for your PR

                                                                                                                                                                                                                        property api

                                                                                                                                                                                                                        api: GitHub;
                                                                                                                                                                                                                        • An authenticated API so you can extend danger's behavior by using the [GitHub v3 API](https://developer.github.com/v3/).

                                                                                                                                                                                                                          A set up instance of the "github" npm module. You can get the full [API here](https://octokit.github.io/node-github/).

                                                                                                                                                                                                                        property utils

                                                                                                                                                                                                                        utils: GitHubUtilsDSL;
                                                                                                                                                                                                                        • A scope for useful functions related to GitHub

                                                                                                                                                                                                                        interface GitHubIssue

                                                                                                                                                                                                                        interface GitHubIssue {}
                                                                                                                                                                                                                        • This is danger.github.issue It refers to the issue that makes up the Pull Request. GitHub treats all pull requests as a special type of issue. This DSL contains only parts of the issue that are not found in the PR DSL, however it does contain the full JSON structure.

                                                                                                                                                                                                                          A GitHub Issue

                                                                                                                                                                                                                        property labels

                                                                                                                                                                                                                        labels: GitHubIssueLabel[];
                                                                                                                                                                                                                        • The labels associated with this issue

                                                                                                                                                                                                                        interface GitHubIssueComment

                                                                                                                                                                                                                        interface GitHubIssueComment {}

                                                                                                                                                                                                                          property body

                                                                                                                                                                                                                          body: string;
                                                                                                                                                                                                                          • Textual representation of comment

                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                          id: string;
                                                                                                                                                                                                                          • UUID for the comment

                                                                                                                                                                                                                          property user

                                                                                                                                                                                                                          user: GitHubUser;
                                                                                                                                                                                                                          • The User who made the comment

                                                                                                                                                                                                                          interface GitHubIssueLabel

                                                                                                                                                                                                                          interface GitHubIssueLabel {}

                                                                                                                                                                                                                            property color

                                                                                                                                                                                                                            color: string;
                                                                                                                                                                                                                            • The color associated with this label

                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                            id: number;
                                                                                                                                                                                                                            • The identifying number of this label

                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                            • The name of the label

                                                                                                                                                                                                                            property url

                                                                                                                                                                                                                            url: string;
                                                                                                                                                                                                                            • The URL that links to this label

                                                                                                                                                                                                                            interface GitHubJSONDSL

                                                                                                                                                                                                                            interface GitHubJSONDSL {}

                                                                                                                                                                                                                              property commits

                                                                                                                                                                                                                              commits: GitHubCommit[];
                                                                                                                                                                                                                              • The github commit metadata for a code review session

                                                                                                                                                                                                                              property issue

                                                                                                                                                                                                                              issue: GitHubIssue;
                                                                                                                                                                                                                              • The issue metadata for a code review session

                                                                                                                                                                                                                              property pr

                                                                                                                                                                                                                              pr: GitHubPRDSL;
                                                                                                                                                                                                                              • The PR metadata for a code review session

                                                                                                                                                                                                                              property requested_reviewers

                                                                                                                                                                                                                              requested_reviewers: GitHubReviewers;
                                                                                                                                                                                                                              • The people/teams requested to review this PR

                                                                                                                                                                                                                              property reviews

                                                                                                                                                                                                                              reviews: GitHubReview[];
                                                                                                                                                                                                                              • The reviews left on this pull request

                                                                                                                                                                                                                              property thisPR

                                                                                                                                                                                                                              thisPR: GitHubAPIPR;
                                                                                                                                                                                                                              • The PR metadata specifically formatted for using with the GitHub API client

                                                                                                                                                                                                                              interface GitHubMergeRef

                                                                                                                                                                                                                              interface GitHubMergeRef {}

                                                                                                                                                                                                                                property label

                                                                                                                                                                                                                                label: string;
                                                                                                                                                                                                                                • The human display name for the merge reference, e.g. "artsy:master"

                                                                                                                                                                                                                                property ref

                                                                                                                                                                                                                                ref: string;
                                                                                                                                                                                                                                • The reference point for the merge, e.g. "master"

                                                                                                                                                                                                                                property repo

                                                                                                                                                                                                                                repo: GitHubRepo;
                                                                                                                                                                                                                                • The repo from whch the reference comes from

                                                                                                                                                                                                                                property sha

                                                                                                                                                                                                                                sha: string;
                                                                                                                                                                                                                                • The reference point for the merge, e.g. "704dc55988c6996f69b6873c2424be7d1de67bbe"

                                                                                                                                                                                                                                property user

                                                                                                                                                                                                                                user: GitHubUser;
                                                                                                                                                                                                                                • The user that owns the merge reference e.g. "artsy"

                                                                                                                                                                                                                                interface GitHubPRDSL

                                                                                                                                                                                                                                interface GitHubPRDSL {}
                                                                                                                                                                                                                                • An exact copy of the PR's reference JSON. This interface has type'd the majority of it for tooling's sake, but any extra metadata which GitHub send will still be inside the JS object.

                                                                                                                                                                                                                                property additions

                                                                                                                                                                                                                                additions: number;
                                                                                                                                                                                                                                • The number of additional lines in the PR

                                                                                                                                                                                                                                property assignee

                                                                                                                                                                                                                                assignee: GitHubUser;
                                                                                                                                                                                                                                • The User who is assigned the PR

                                                                                                                                                                                                                                property assignees

                                                                                                                                                                                                                                assignees: GitHubUser[];
                                                                                                                                                                                                                                • The Users who are assigned to the PR

                                                                                                                                                                                                                                property author_association

                                                                                                                                                                                                                                author_association:
                                                                                                                                                                                                                                | 'COLLABORATOR'
                                                                                                                                                                                                                                | 'CONTRIBUTOR'
                                                                                                                                                                                                                                | 'FIRST_TIMER'
                                                                                                                                                                                                                                | 'FIRST_TIME_CONTRIBUTOR'
                                                                                                                                                                                                                                | 'MEMBER'
                                                                                                                                                                                                                                | 'NONE'
                                                                                                                                                                                                                                | 'OWNER';
                                                                                                                                                                                                                                • How does the PR author relate to this repo/org?

                                                                                                                                                                                                                                property base

                                                                                                                                                                                                                                base: GitHubMergeRef;
                                                                                                                                                                                                                                • Merge reference for _this_ repo.

                                                                                                                                                                                                                                property body

                                                                                                                                                                                                                                body: string;
                                                                                                                                                                                                                                • The markdown body message of the PR

                                                                                                                                                                                                                                property changed_files

                                                                                                                                                                                                                                changed_files: number;
                                                                                                                                                                                                                                • The number of changed files in the PR

                                                                                                                                                                                                                                property closed_at

                                                                                                                                                                                                                                closed_at: string | null;
                                                                                                                                                                                                                                • optional ISO6801 Date string for when PR was closed

                                                                                                                                                                                                                                property comments

                                                                                                                                                                                                                                comments: number;
                                                                                                                                                                                                                                • The number of comments on the PR

                                                                                                                                                                                                                                property commits

                                                                                                                                                                                                                                commits: number;
                                                                                                                                                                                                                                • The number of commits in the PR

                                                                                                                                                                                                                                property created_at

                                                                                                                                                                                                                                created_at: string;
                                                                                                                                                                                                                                • ISO6801 Date string for when PR was created

                                                                                                                                                                                                                                property deletions

                                                                                                                                                                                                                                deletions: number;
                                                                                                                                                                                                                                • The number of deleted lines in the PR

                                                                                                                                                                                                                                property head

                                                                                                                                                                                                                                head: GitHubMergeRef;
                                                                                                                                                                                                                                • Merge reference for the _other_ repo.

                                                                                                                                                                                                                                property html_url

                                                                                                                                                                                                                                html_url: string;
                                                                                                                                                                                                                                • The link back to this PR as user-facing

                                                                                                                                                                                                                                property locked

                                                                                                                                                                                                                                locked: boolean;
                                                                                                                                                                                                                                • Has the PR been locked to contributors only?

                                                                                                                                                                                                                                property merged

                                                                                                                                                                                                                                merged: boolean;
                                                                                                                                                                                                                                • Has the PR been merged yet?

                                                                                                                                                                                                                                property merged_at

                                                                                                                                                                                                                                merged_at: string | null;
                                                                                                                                                                                                                                • Optional ISO6801 Date string for when PR was merged. Danger probably shouldn't be running in this state.

                                                                                                                                                                                                                                property number

                                                                                                                                                                                                                                number: number;
                                                                                                                                                                                                                                • The UUID for the PR

                                                                                                                                                                                                                                property review_comments

                                                                                                                                                                                                                                review_comments: number;
                                                                                                                                                                                                                                • The number of review-specific comments on the PR

                                                                                                                                                                                                                                property state

                                                                                                                                                                                                                                state: 'closed' | 'open' | 'locked' | 'merged';
                                                                                                                                                                                                                                • The state for the PR

                                                                                                                                                                                                                                property title

                                                                                                                                                                                                                                title: string;
                                                                                                                                                                                                                                • The title of the PR

                                                                                                                                                                                                                                property updated_at

                                                                                                                                                                                                                                updated_at: string;
                                                                                                                                                                                                                                • ISO6801 Date string for when PR was updated

                                                                                                                                                                                                                                property user

                                                                                                                                                                                                                                user: GitHubUser;
                                                                                                                                                                                                                                • The User who submitted the PR

                                                                                                                                                                                                                                interface GitHubRepo

                                                                                                                                                                                                                                interface GitHubRepo {}
                                                                                                                                                                                                                                • A GitHub Repo

                                                                                                                                                                                                                                property assignee

                                                                                                                                                                                                                                assignee: GitHubUser;
                                                                                                                                                                                                                                • Is someone assigned to this PR?

                                                                                                                                                                                                                                property assignees

                                                                                                                                                                                                                                assignees: GitHubUser[];
                                                                                                                                                                                                                                • Are there people assigned to this PR?

                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                description: string;
                                                                                                                                                                                                                                • The textual description of the repo

                                                                                                                                                                                                                                property fork

                                                                                                                                                                                                                                fork: boolean;
                                                                                                                                                                                                                                • Is the repo a fork?

                                                                                                                                                                                                                                property full_name

                                                                                                                                                                                                                                full_name: string;
                                                                                                                                                                                                                                • The full name of the owner + repo, e.g. "Danger/Danger-JS"

                                                                                                                                                                                                                                property html_url

                                                                                                                                                                                                                                html_url: string;
                                                                                                                                                                                                                                • The root web URL for the repo, e.g. https://github.com/artsy/emission

                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                id: number;
                                                                                                                                                                                                                                • Generic UUID

                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                name: string;
                                                                                                                                                                                                                                • The name of the repo, e.g. "Danger-JS"

                                                                                                                                                                                                                                property owner

                                                                                                                                                                                                                                owner: GitHubUser;
                                                                                                                                                                                                                                • The owner of the repo

                                                                                                                                                                                                                                property private

                                                                                                                                                                                                                                private: boolean;
                                                                                                                                                                                                                                • Is the repo publicly accessible?

                                                                                                                                                                                                                                interface GitHubReview

                                                                                                                                                                                                                                interface GitHubReview {}
                                                                                                                                                                                                                                • GitHubReview While a review is pending, it will only have a user. Once a review is complete, the rest of the review attributes will be present GitHubReview

                                                                                                                                                                                                                                property body

                                                                                                                                                                                                                                body?: string;
                                                                                                                                                                                                                                • If there is a review, the body of the review

                                                                                                                                                                                                                                property commit_id

                                                                                                                                                                                                                                commit_id?: string;
                                                                                                                                                                                                                                • If there is a review, the commit ID this review was made on

                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                id?: number;
                                                                                                                                                                                                                                • If there is a review, this provides the ID for it

                                                                                                                                                                                                                                property state

                                                                                                                                                                                                                                state?: 'APPROVED' | 'REQUEST_CHANGES' | 'COMMENT' | 'PENDING';
                                                                                                                                                                                                                                • The state of the review APPROVED, REQUEST_CHANGES, COMMENT or PENDING

                                                                                                                                                                                                                                property user

                                                                                                                                                                                                                                user: GitHubUser;
                                                                                                                                                                                                                                • The user requested to review, or the user who has completed the review

                                                                                                                                                                                                                                interface GitHubReviewers

                                                                                                                                                                                                                                interface GitHubReviewers {}

                                                                                                                                                                                                                                  property teams

                                                                                                                                                                                                                                  teams: any[];
                                                                                                                                                                                                                                  • Teams that have been requested

                                                                                                                                                                                                                                  property users

                                                                                                                                                                                                                                  users: GitHubUser[];
                                                                                                                                                                                                                                  • Users that have been requested

                                                                                                                                                                                                                                  interface GitHubUser

                                                                                                                                                                                                                                  interface GitHubUser {}
                                                                                                                                                                                                                                  • A GitHub user account.

                                                                                                                                                                                                                                  property avatar_url

                                                                                                                                                                                                                                  avatar_url: string;
                                                                                                                                                                                                                                  • The url for a users's image

                                                                                                                                                                                                                                  property href

                                                                                                                                                                                                                                  href: string;
                                                                                                                                                                                                                                  • The href for a users's page

                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                  id: number;
                                                                                                                                                                                                                                  • Generic UUID

                                                                                                                                                                                                                                  property login

                                                                                                                                                                                                                                  login: string;
                                                                                                                                                                                                                                  • The handle for the user/org

                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                  type: 'User' | 'Organization' | 'Bot';
                                                                                                                                                                                                                                  • Whether the user is an org, or a user

                                                                                                                                                                                                                                  interface GitHubUtilsDSL

                                                                                                                                                                                                                                  interface GitHubUtilsDSL {}
                                                                                                                                                                                                                                  • Useful functions for GitHub related work

                                                                                                                                                                                                                                  property createOrAddLabel

                                                                                                                                                                                                                                  createOrAddLabel: (
                                                                                                                                                                                                                                  labelConfig: { name: string; color: string; description: string },
                                                                                                                                                                                                                                  repoConfig?: { owner: string; repo: string; id: number }
                                                                                                                                                                                                                                  ) => Promise<void>;
                                                                                                                                                                                                                                  • An API for creating, or setting a label to an issue. Usable from Peril by adding an additional param for settings about a repo.

                                                                                                                                                                                                                                    Parameter labelConfig

                                                                                                                                                                                                                                    The config for the label

                                                                                                                                                                                                                                    Parameter Optional

                                                                                                                                                                                                                                    : the config for the issue

                                                                                                                                                                                                                                    Returns

                                                                                                                                                                                                                                    {Promise} No return value.

                                                                                                                                                                                                                                  property createOrUpdatePR

                                                                                                                                                                                                                                  createOrUpdatePR: (
                                                                                                                                                                                                                                  config: {
                                                                                                                                                                                                                                  /** PR title */
                                                                                                                                                                                                                                  title: string;
                                                                                                                                                                                                                                  /** PR body */
                                                                                                                                                                                                                                  body: string;
                                                                                                                                                                                                                                  /** The danger in danger/danger-js - defaults to the PR base name if undefined */
                                                                                                                                                                                                                                  owner?: string;
                                                                                                                                                                                                                                  /** The danger-js in danger/danger-js - defaults to the PR base repo if undefined */
                                                                                                                                                                                                                                  repo?: string;
                                                                                                                                                                                                                                  /** A message for the commit */
                                                                                                                                                                                                                                  commitMessage: string;
                                                                                                                                                                                                                                  /** The name of the branch on the repo */
                                                                                                                                                                                                                                  newBranchName: string;
                                                                                                                                                                                                                                  /** Base branch for the new branch e.g. what should Danger create the new branch from */
                                                                                                                                                                                                                                  baseBranch: string;
                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                  fileMap: any
                                                                                                                                                                                                                                  ) => Promise<any>;

                                                                                                                                                                                                                                    property createUpdatedIssueWithID

                                                                                                                                                                                                                                    createUpdatedIssueWithID: (
                                                                                                                                                                                                                                    id: string,
                                                                                                                                                                                                                                    content: string,
                                                                                                                                                                                                                                    config: { title: string; open: boolean; owner: string; repo: string }
                                                                                                                                                                                                                                    ) => Promise<string>;
                                                                                                                                                                                                                                    • An API for creating, updating and closing an issue. Basically this is really useful for reporting back via a separate issue that you may want to keep up to date at all times.

                                                                                                                                                                                                                                      Parameter id

                                                                                                                                                                                                                                      The unique ID for the message to create, close

                                                                                                                                                                                                                                      Parameter content

                                                                                                                                                                                                                                      the content of the message

                                                                                                                                                                                                                                      Parameter config

                                                                                                                                                                                                                                      settings for the issue

                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                      {string} A HTML string of 's built as a sentence.

                                                                                                                                                                                                                                    method fileContents

                                                                                                                                                                                                                                    fileContents: (path: string, repoSlug?: string, ref?: string) => Promise<string>;
                                                                                                                                                                                                                                    • Downloads a file's contents via the GitHub API. You'll want to use this instead of fs.readFile when aiming to support working with Peril.

                                                                                                                                                                                                                                      Parameter path

                                                                                                                                                                                                                                      The path fo the file that exists

                                                                                                                                                                                                                                      Parameter repoSlug

                                                                                                                                                                                                                                      An optional reference to the repo's slug: e.g. danger/danger-js

                                                                                                                                                                                                                                      Parameter ref

                                                                                                                                                                                                                                      An optional reference to a branch/sha

                                                                                                                                                                                                                                    fileLinks: (
                                                                                                                                                                                                                                    paths: string[],
                                                                                                                                                                                                                                    useBasename?: boolean,
                                                                                                                                                                                                                                    repoSlug?: string,
                                                                                                                                                                                                                                    branch?: string
                                                                                                                                                                                                                                    ) => string;
                                                                                                                                                                                                                                    • Creates HTML for a sentence of clickable links for an array of paths. This uses the source of the PR as the target, not the destination repo. You can manually set the target repo and branch however, to make it work how you want.

                                                                                                                                                                                                                                      Parameter paths

                                                                                                                                                                                                                                      A list of strings representing file paths

                                                                                                                                                                                                                                      Parameter useBasename

                                                                                                                                                                                                                                      Show either the file name, or the full path - defaults to just file name e.g. true.

                                                                                                                                                                                                                                      Parameter repoSlug

                                                                                                                                                                                                                                      An optional override for the repo slug, ex: "orta/ORStackView"

                                                                                                                                                                                                                                      Parameter branch

                                                                                                                                                                                                                                      An optional override for the branch, ex: "v3"

                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                      {string} A HTML string of 's built as a sentence.

                                                                                                                                                                                                                                    interface GitJSONDSL

                                                                                                                                                                                                                                    interface GitJSONDSL {}
                                                                                                                                                                                                                                    • The Git Related Metadata which is available inside the Danger DSL JSON

                                                                                                                                                                                                                                      JSONDSL

                                                                                                                                                                                                                                    property commits

                                                                                                                                                                                                                                    readonly commits: GitCommit[];
                                                                                                                                                                                                                                    • The Git commit metadata

                                                                                                                                                                                                                                    property created_files

                                                                                                                                                                                                                                    readonly created_files: string[];
                                                                                                                                                                                                                                    • Newly created filepaths relative to the git root

                                                                                                                                                                                                                                    property deleted_files

                                                                                                                                                                                                                                    readonly deleted_files: string[];
                                                                                                                                                                                                                                    • Removed filepaths relative to the git root

                                                                                                                                                                                                                                    property modified_files

                                                                                                                                                                                                                                    readonly modified_files: string[];
                                                                                                                                                                                                                                    • Filepaths with changes relative to the git root

                                                                                                                                                                                                                                    interface GitLabApproval

                                                                                                                                                                                                                                    interface GitLabApproval {}

                                                                                                                                                                                                                                      property approvals_left

                                                                                                                                                                                                                                      approvals_left: number;

                                                                                                                                                                                                                                        property approvals_required

                                                                                                                                                                                                                                        approvals_required: number;

                                                                                                                                                                                                                                          property approved_by

                                                                                                                                                                                                                                          approved_by?:
                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                          user: GitLabUser;
                                                                                                                                                                                                                                          }[]
                                                                                                                                                                                                                                          | GitLabUser[];

                                                                                                                                                                                                                                            property created_at

                                                                                                                                                                                                                                            created_at: string;

                                                                                                                                                                                                                                              property description

                                                                                                                                                                                                                                              description: string;

                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                id: number;

                                                                                                                                                                                                                                                  property iid

                                                                                                                                                                                                                                                  iid: number;

                                                                                                                                                                                                                                                    property merge_status

                                                                                                                                                                                                                                                    merge_status: 'can_be_merged';

                                                                                                                                                                                                                                                      property project_id

                                                                                                                                                                                                                                                      project_id: number;

                                                                                                                                                                                                                                                        property state

                                                                                                                                                                                                                                                        state: 'closed' | 'open' | 'locked' | 'merged';

                                                                                                                                                                                                                                                          property title

                                                                                                                                                                                                                                                          title: string;

                                                                                                                                                                                                                                                            property updated_at

                                                                                                                                                                                                                                                            updated_at: string;

                                                                                                                                                                                                                                                              interface GitLabCommit

                                                                                                                                                                                                                                                              interface GitLabCommit {}

                                                                                                                                                                                                                                                                property author_email

                                                                                                                                                                                                                                                                author_email: string;

                                                                                                                                                                                                                                                                  property author_name

                                                                                                                                                                                                                                                                  author_name: string;

                                                                                                                                                                                                                                                                    property created_at

                                                                                                                                                                                                                                                                    created_at: string;

                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                        property short_id

                                                                                                                                                                                                                                                                        short_id: string;

                                                                                                                                                                                                                                                                          property title

                                                                                                                                                                                                                                                                          title: string;

                                                                                                                                                                                                                                                                            interface GitLabDiscussionTextPosition

                                                                                                                                                                                                                                                                            interface GitLabDiscussionTextPosition {}

                                                                                                                                                                                                                                                                              property base_sha

                                                                                                                                                                                                                                                                              base_sha: string;

                                                                                                                                                                                                                                                                                property head_sha

                                                                                                                                                                                                                                                                                head_sha: string;

                                                                                                                                                                                                                                                                                  property new_line

                                                                                                                                                                                                                                                                                  new_line: number;

                                                                                                                                                                                                                                                                                    property new_path

                                                                                                                                                                                                                                                                                    new_path: string;

                                                                                                                                                                                                                                                                                      property old_line

                                                                                                                                                                                                                                                                                      old_line: number | null;

                                                                                                                                                                                                                                                                                        property old_path

                                                                                                                                                                                                                                                                                        old_path: string;

                                                                                                                                                                                                                                                                                          property position_type

                                                                                                                                                                                                                                                                                          position_type: 'text';

                                                                                                                                                                                                                                                                                            property start_sha

                                                                                                                                                                                                                                                                                            start_sha: string;

                                                                                                                                                                                                                                                                                              interface GitLabDSL

                                                                                                                                                                                                                                                                                              interface GitLabDSL extends GitLabJSONDSL {}
                                                                                                                                                                                                                                                                                              • The GitLab metadata for your MR

                                                                                                                                                                                                                                                                                              property api

                                                                                                                                                                                                                                                                                              api: InstanceType<typeof Gitlab>;

                                                                                                                                                                                                                                                                                                property utils

                                                                                                                                                                                                                                                                                                utils: {
                                                                                                                                                                                                                                                                                                fileContents(path: string, repoSlug?: string, ref?: string): Promise<string>;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  interface GitLabInlineNote

                                                                                                                                                                                                                                                                                                  interface GitLabInlineNote extends GitLabNote {}

                                                                                                                                                                                                                                                                                                    property position

                                                                                                                                                                                                                                                                                                    position: {
                                                                                                                                                                                                                                                                                                    base_sha: string;
                                                                                                                                                                                                                                                                                                    start_sha: string;
                                                                                                                                                                                                                                                                                                    head_sha: string;
                                                                                                                                                                                                                                                                                                    old_path: string;
                                                                                                                                                                                                                                                                                                    new_path: string;
                                                                                                                                                                                                                                                                                                    position_type: 'text'; // XXX: other types?
                                                                                                                                                                                                                                                                                                    old_line: number | null;
                                                                                                                                                                                                                                                                                                    new_line: number;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      property resolvable

                                                                                                                                                                                                                                                                                                      resolvable: boolean;

                                                                                                                                                                                                                                                                                                        property resolved

                                                                                                                                                                                                                                                                                                        resolved: boolean;

                                                                                                                                                                                                                                                                                                          property resolved_by

                                                                                                                                                                                                                                                                                                          resolved_by: GitLabUser | null;

                                                                                                                                                                                                                                                                                                            interface GitLabJSONDSL

                                                                                                                                                                                                                                                                                                            interface GitLabJSONDSL {}

                                                                                                                                                                                                                                                                                                              property approvals

                                                                                                                                                                                                                                                                                                              approvals: GitLabApproval;
                                                                                                                                                                                                                                                                                                              • Merge Request-level MR approvals Configuration

                                                                                                                                                                                                                                                                                                              property commits

                                                                                                                                                                                                                                                                                                              commits: GitLabMRCommit[];
                                                                                                                                                                                                                                                                                                              • All of the individual commits in the merge request

                                                                                                                                                                                                                                                                                                              property metadata

                                                                                                                                                                                                                                                                                                              metadata: RepoMetaData;
                                                                                                                                                                                                                                                                                                              • Info about the repo

                                                                                                                                                                                                                                                                                                              property mr

                                                                                                                                                                                                                                                                                                              mr: GitLabMR;
                                                                                                                                                                                                                                                                                                              • Info about the merge request

                                                                                                                                                                                                                                                                                                              interface GitLabMR

                                                                                                                                                                                                                                                                                                              interface GitLabMR extends GitLabMRBase {}
                                                                                                                                                                                                                                                                                                              • TODO: These need more comments from someone who uses GitLab, see GitLabDSL.ts in the danger-js repo

                                                                                                                                                                                                                                                                                                              property approvals_before_merge

                                                                                                                                                                                                                                                                                                              approvals_before_merge: null | null;

                                                                                                                                                                                                                                                                                                                property changes_count

                                                                                                                                                                                                                                                                                                                changes_count: string;

                                                                                                                                                                                                                                                                                                                  property closed_at

                                                                                                                                                                                                                                                                                                                  closed_at: string | null;

                                                                                                                                                                                                                                                                                                                    property closed_by

                                                                                                                                                                                                                                                                                                                    closed_by: GitLabUser | null;

                                                                                                                                                                                                                                                                                                                      property diff_refs

                                                                                                                                                                                                                                                                                                                      diff_refs: {
                                                                                                                                                                                                                                                                                                                      base_sha: string;
                                                                                                                                                                                                                                                                                                                      head_sha: string;
                                                                                                                                                                                                                                                                                                                      start_sha: string;
                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                        property diverged_commits_count

                                                                                                                                                                                                                                                                                                                        diverged_commits_count: number;

                                                                                                                                                                                                                                                                                                                          property first_deployed_to_production_at

                                                                                                                                                                                                                                                                                                                          first_deployed_to_production_at: string | null;

                                                                                                                                                                                                                                                                                                                            property latest_build_finished_at

                                                                                                                                                                                                                                                                                                                            latest_build_finished_at: string;

                                                                                                                                                                                                                                                                                                                              property latest_build_started_at

                                                                                                                                                                                                                                                                                                                              latest_build_started_at: string;

                                                                                                                                                                                                                                                                                                                                property merged_at

                                                                                                                                                                                                                                                                                                                                merged_at: string;

                                                                                                                                                                                                                                                                                                                                  property merged_by

                                                                                                                                                                                                                                                                                                                                  merged_by: GitLabUser;

                                                                                                                                                                                                                                                                                                                                    property pipeline

                                                                                                                                                                                                                                                                                                                                    pipeline: {
                                                                                                                                                                                                                                                                                                                                    id: number;
                                                                                                                                                                                                                                                                                                                                    sha: string;
                                                                                                                                                                                                                                                                                                                                    ref: string;
                                                                                                                                                                                                                                                                                                                                    status:
                                                                                                                                                                                                                                                                                                                                    | 'canceled'
                                                                                                                                                                                                                                                                                                                                    | 'failed'
                                                                                                                                                                                                                                                                                                                                    | 'pending'
                                                                                                                                                                                                                                                                                                                                    | 'running'
                                                                                                                                                                                                                                                                                                                                    | 'skipped'
                                                                                                                                                                                                                                                                                                                                    | 'success';
                                                                                                                                                                                                                                                                                                                                    web_url: string;
                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                      property rebase_in_progress

                                                                                                                                                                                                                                                                                                                                      rebase_in_progress: boolean;

                                                                                                                                                                                                                                                                                                                                        property squash

                                                                                                                                                                                                                                                                                                                                        squash: boolean;

                                                                                                                                                                                                                                                                                                                                          property subscribed

                                                                                                                                                                                                                                                                                                                                          subscribed: boolean;

                                                                                                                                                                                                                                                                                                                                            interface GitLabMRBase

                                                                                                                                                                                                                                                                                                                                            interface GitLabMRBase {}

                                                                                                                                                                                                                                                                                                                                              property allow_collaboration

                                                                                                                                                                                                                                                                                                                                              allow_collaboration: boolean;

                                                                                                                                                                                                                                                                                                                                                property allow_maintainer_to_push

                                                                                                                                                                                                                                                                                                                                                allow_maintainer_to_push: boolean;

                                                                                                                                                                                                                                                                                                                                                  property assignee

                                                                                                                                                                                                                                                                                                                                                  assignee?: GitLabUser;
                                                                                                                                                                                                                                                                                                                                                  • Who was assigned as the person to review

                                                                                                                                                                                                                                                                                                                                                  property author

                                                                                                                                                                                                                                                                                                                                                  author: GitLabUser;
                                                                                                                                                                                                                                                                                                                                                  • Who made it

                                                                                                                                                                                                                                                                                                                                                  property created_at

                                                                                                                                                                                                                                                                                                                                                  created_at: string;
                                                                                                                                                                                                                                                                                                                                                  • When was the MR made

                                                                                                                                                                                                                                                                                                                                                  property description

                                                                                                                                                                                                                                                                                                                                                  description: string;
                                                                                                                                                                                                                                                                                                                                                  • The body text describing the MR

                                                                                                                                                                                                                                                                                                                                                  property discussion_locked

                                                                                                                                                                                                                                                                                                                                                  discussion_locked: null | null;

                                                                                                                                                                                                                                                                                                                                                    property downvotes

                                                                                                                                                                                                                                                                                                                                                    downvotes: number;
                                                                                                                                                                                                                                                                                                                                                    • How many folks have given it an downvote

                                                                                                                                                                                                                                                                                                                                                    property force_remove_source_branch

                                                                                                                                                                                                                                                                                                                                                    force_remove_source_branch: boolean;

                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                      id: number;
                                                                                                                                                                                                                                                                                                                                                      • The MR's id

                                                                                                                                                                                                                                                                                                                                                      property iid

                                                                                                                                                                                                                                                                                                                                                      iid: number;
                                                                                                                                                                                                                                                                                                                                                      • The unique ID for this MR

                                                                                                                                                                                                                                                                                                                                                      property labels

                                                                                                                                                                                                                                                                                                                                                      labels: string[];

                                                                                                                                                                                                                                                                                                                                                        property merge_commit_sha

                                                                                                                                                                                                                                                                                                                                                        merge_commit_sha: string | null;

                                                                                                                                                                                                                                                                                                                                                          property merge_error

                                                                                                                                                                                                                                                                                                                                                          merge_error: null | null;

                                                                                                                                                                                                                                                                                                                                                            property merge_status

                                                                                                                                                                                                                                                                                                                                                            merge_status: 'can_be_merged';

                                                                                                                                                                                                                                                                                                                                                              property merge_when_pipeline_succeeds

                                                                                                                                                                                                                                                                                                                                                              merge_when_pipeline_succeeds: boolean;

                                                                                                                                                                                                                                                                                                                                                                property milestone

                                                                                                                                                                                                                                                                                                                                                                milestone: {
                                                                                                                                                                                                                                                                                                                                                                id: number;
                                                                                                                                                                                                                                                                                                                                                                iid: number;
                                                                                                                                                                                                                                                                                                                                                                project_id: number;
                                                                                                                                                                                                                                                                                                                                                                title: string;
                                                                                                                                                                                                                                                                                                                                                                description: string;
                                                                                                                                                                                                                                                                                                                                                                state: 'closed' | 'active';
                                                                                                                                                                                                                                                                                                                                                                created_at: string;
                                                                                                                                                                                                                                                                                                                                                                updated_at: string;
                                                                                                                                                                                                                                                                                                                                                                due_date: string;
                                                                                                                                                                                                                                                                                                                                                                start_date: string;
                                                                                                                                                                                                                                                                                                                                                                web_url: string;
                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                  property project_id

                                                                                                                                                                                                                                                                                                                                                                  project_id: number;
                                                                                                                                                                                                                                                                                                                                                                  • The project ID for this MR

                                                                                                                                                                                                                                                                                                                                                                  property sha

                                                                                                                                                                                                                                                                                                                                                                  sha: string;

                                                                                                                                                                                                                                                                                                                                                                    property should_remove_source_branch

                                                                                                                                                                                                                                                                                                                                                                    should_remove_source_branch: boolean;

                                                                                                                                                                                                                                                                                                                                                                      property source_branch

                                                                                                                                                                                                                                                                                                                                                                      source_branch: string;
                                                                                                                                                                                                                                                                                                                                                                      • What branch is this MR come from

                                                                                                                                                                                                                                                                                                                                                                      property source_project_id

                                                                                                                                                                                                                                                                                                                                                                      source_project_id: number;

                                                                                                                                                                                                                                                                                                                                                                        property state

                                                                                                                                                                                                                                                                                                                                                                        state: 'closed' | 'open' | 'locked' | 'merged';
                                                                                                                                                                                                                                                                                                                                                                        • The MR's current availability

                                                                                                                                                                                                                                                                                                                                                                        property target_branch

                                                                                                                                                                                                                                                                                                                                                                        target_branch: string;
                                                                                                                                                                                                                                                                                                                                                                        • What branch is this MR being merged into

                                                                                                                                                                                                                                                                                                                                                                        property target_project_id

                                                                                                                                                                                                                                                                                                                                                                        target_project_id: number;

                                                                                                                                                                                                                                                                                                                                                                          property time_stats

                                                                                                                                                                                                                                                                                                                                                                          time_stats: {
                                                                                                                                                                                                                                                                                                                                                                          time_estimate: number;
                                                                                                                                                                                                                                                                                                                                                                          total_time_spent: number;
                                                                                                                                                                                                                                                                                                                                                                          human_time_estimate: number | null;
                                                                                                                                                                                                                                                                                                                                                                          human_total_time_spent: number | null;
                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                            property title

                                                                                                                                                                                                                                                                                                                                                                            title: string;
                                                                                                                                                                                                                                                                                                                                                                            • The given name of the MR

                                                                                                                                                                                                                                                                                                                                                                            property updated_at

                                                                                                                                                                                                                                                                                                                                                                            updated_at: string;
                                                                                                                                                                                                                                                                                                                                                                            • When was the MR updated

                                                                                                                                                                                                                                                                                                                                                                            property upvotes

                                                                                                                                                                                                                                                                                                                                                                            upvotes: number;
                                                                                                                                                                                                                                                                                                                                                                            • How many folks have given it an upvote

                                                                                                                                                                                                                                                                                                                                                                            property user

                                                                                                                                                                                                                                                                                                                                                                            user: {
                                                                                                                                                                                                                                                                                                                                                                            /** Does the author have access to merge? */
                                                                                                                                                                                                                                                                                                                                                                            can_merge: boolean;
                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                            • Access rights for the user who created the MR

                                                                                                                                                                                                                                                                                                                                                                            property user_notes_count

                                                                                                                                                                                                                                                                                                                                                                            user_notes_count: number;

                                                                                                                                                                                                                                                                                                                                                                              property web_url

                                                                                                                                                                                                                                                                                                                                                                              web_url: string;

                                                                                                                                                                                                                                                                                                                                                                                property work_in_progress

                                                                                                                                                                                                                                                                                                                                                                                work_in_progress: boolean;

                                                                                                                                                                                                                                                                                                                                                                                  interface GitLabMRChange

                                                                                                                                                                                                                                                                                                                                                                                  interface GitLabMRChange {}

                                                                                                                                                                                                                                                                                                                                                                                    property a_mode

                                                                                                                                                                                                                                                                                                                                                                                    a_mode: string;

                                                                                                                                                                                                                                                                                                                                                                                      property b_mode

                                                                                                                                                                                                                                                                                                                                                                                      b_mode: string;

                                                                                                                                                                                                                                                                                                                                                                                        property deleted_file

                                                                                                                                                                                                                                                                                                                                                                                        deleted_file: boolean;

                                                                                                                                                                                                                                                                                                                                                                                          property diff

                                                                                                                                                                                                                                                                                                                                                                                          diff: string;

                                                                                                                                                                                                                                                                                                                                                                                            property new_file

                                                                                                                                                                                                                                                                                                                                                                                            new_file: boolean;

                                                                                                                                                                                                                                                                                                                                                                                              property new_path

                                                                                                                                                                                                                                                                                                                                                                                              new_path: string;

                                                                                                                                                                                                                                                                                                                                                                                                property old_path

                                                                                                                                                                                                                                                                                                                                                                                                old_path: string;

                                                                                                                                                                                                                                                                                                                                                                                                  property renamed_file

                                                                                                                                                                                                                                                                                                                                                                                                  renamed_file: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                    interface GitLabMRChanges

                                                                                                                                                                                                                                                                                                                                                                                                    interface GitLabMRChanges extends GitLabMRBase {}

                                                                                                                                                                                                                                                                                                                                                                                                      property changes

                                                                                                                                                                                                                                                                                                                                                                                                      changes: GitLabMRChange[];

                                                                                                                                                                                                                                                                                                                                                                                                        interface GitLabMRCommit

                                                                                                                                                                                                                                                                                                                                                                                                        interface GitLabMRCommit {}

                                                                                                                                                                                                                                                                                                                                                                                                          property author_email

                                                                                                                                                                                                                                                                                                                                                                                                          author_email: string;

                                                                                                                                                                                                                                                                                                                                                                                                            property author_name

                                                                                                                                                                                                                                                                                                                                                                                                            author_name: string;

                                                                                                                                                                                                                                                                                                                                                                                                              property authored_date

                                                                                                                                                                                                                                                                                                                                                                                                              authored_date: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property committed_date

                                                                                                                                                                                                                                                                                                                                                                                                                committed_date: string;

                                                                                                                                                                                                                                                                                                                                                                                                                  property committer_email

                                                                                                                                                                                                                                                                                                                                                                                                                  committer_email: string;

                                                                                                                                                                                                                                                                                                                                                                                                                    property committer_name

                                                                                                                                                                                                                                                                                                                                                                                                                    committer_name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property created_at

                                                                                                                                                                                                                                                                                                                                                                                                                      created_at: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                                                                                                                                                                                                                          message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property parent_ids

                                                                                                                                                                                                                                                                                                                                                                                                                            parent_ids: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                              property short_id

                                                                                                                                                                                                                                                                                                                                                                                                                              short_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                property title

                                                                                                                                                                                                                                                                                                                                                                                                                                title: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GitLabNote

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GitLabNote {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property attachment

                                                                                                                                                                                                                                                                                                                                                                                                                                    attachment: null;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property author

                                                                                                                                                                                                                                                                                                                                                                                                                                      author: GitLabUser;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property body

                                                                                                                                                                                                                                                                                                                                                                                                                                        body: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property created_at

                                                                                                                                                                                                                                                                                                                                                                                                                                          created_at: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                                                                                                            id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property noteable_id

                                                                                                                                                                                                                                                                                                                                                                                                                                              noteable_id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property noteable_iid

                                                                                                                                                                                                                                                                                                                                                                                                                                                noteable_iid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property noteable_type

                                                                                                                                                                                                                                                                                                                                                                                                                                                  noteable_type: 'MergeRequest';

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property resolvable

                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolvable: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property system

                                                                                                                                                                                                                                                                                                                                                                                                                                                      system: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'DiffNote' | 'DiscussionNote' | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property updated_at

                                                                                                                                                                                                                                                                                                                                                                                                                                                          updated_at: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GitLabRepositoryCompare

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GitLabRepositoryCompare {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property commit

                                                                                                                                                                                                                                                                                                                                                                                                                                                              commit: GitLabCommit;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property commits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                commits: GitLabCommit[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property compare_same_ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  compare_same_ref: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property compare_timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    compare_timeout: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property diffs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      diffs: GitLabMRChange[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GitLabRepositoryFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GitLabRepositoryFile {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property blob_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          blob_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property commit_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            commit_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              content: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property content_sha256

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                content_sha256: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  encoding: 'base64';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property file_name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    file_name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property file_path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      file_path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property last_commit_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        last_commit_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ref: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GitLabUser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GitLabUser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property avatar_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                avatar_url: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      state: 'active' | 'blocked';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property username

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        username: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property web_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          web_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GitLabUserProfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GitLabUserProfile extends GitLabUser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bio: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property can_create_group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                can_create_group: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property can_create_project

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  can_create_project: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property color_scheme_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    color_scheme_id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property confirmed_at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      confirmed_at: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property created_at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        created_at: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property current_sign_in_at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          current_sign_in_at: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property external

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            external: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property identities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              identities: [{ provider: string; extern_uid: string }];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property last_activity_on

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                last_activity_on: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property last_sign_in_at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  last_sign_in_at: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property linkedin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    linkedin: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      location: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property organization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        organization: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property private_profile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          private_profile: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property projects_limit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projects_limit: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property public_email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              public_email: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property skype

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                skype: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property theme_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  theme_id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property twitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    twitter: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property two_factor_enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      two_factor_enabled: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property website_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        website_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JIRAIssue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JIRAIssue {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • This is danger.bitbucket_server.issues It refers to the issues that are linked to the Pull Request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The unique key for the issue e.g. JRA-11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The user-facing URL for that issue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JSONDiff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JSONDiff {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • A map of string keys to JSONDiffValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [name: string]: JSONDiffValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JSONDiffValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JSONDiffValue {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • All JSON diff values will be this shape

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property added

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            added?: any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If both before & after are arrays, then you optionally get what is added. Empty if no additional objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property after

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            after: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The value after the PR's applied changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property before

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            before: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The value before the PR's applied changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property removed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            removed?: any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If both before & after are arrays, then you optionally get what is removed. Empty if no removed objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JSONPatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JSONPatch {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The results of running a JSON patch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property after

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            after: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The JSON in a file from the PR submitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property before

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            before: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The JSON in a file at the PR merge base

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property diff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff: JSONPatchOperation[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The set of operations to go from one JSON to another JSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JSONPatchOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JSONPatchOperation {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • An individual operation inside an rfc6902 JSON Patch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property op

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            op: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • An operation type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            path: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The JSON keypath which the operation applies on

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The changes for applied

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PerilDSL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PerilDSL {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The available Peril interface, it is possible that this is not always up to date with true DSL in Peril, but I'll be giving it a good shot.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • When running a task, the data passed in when the task was originally scheduled, you can also get this as the first argument in a default function. Deprecated, use a default export function. I'll remove this sometime.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            env: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A set of key:value string based on ENV vars that have been set to be exposed to your Peril config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property runTask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            runTask: (taskName: string, time: string, data: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Allows you to schedule a task declared in your Peril config to run in a certain time-frame, e.g runTask("reminder_pr_merge", "in 2 days", { number: 2 }). For more details on how this works, see the Peril documentation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter taskName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              the name found in your Peril config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              the time interval (uses human-internal module)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data which will be passed through to the script

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RepoMetaData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RepoMetaData {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Key details about a repo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pullRequestID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pullRequestID: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The ID for the pull/merge request "11"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property repoSlug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            repoSlug: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A path like "artsy/eigen"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StructuredDiff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface StructuredDiff {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Git diff sliced into chunks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property chunks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chunks: any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Git diff chunks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TextDiff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TextDiff {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • All Text diff values will be this shape

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property added

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            added: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A string containing just the added lines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property after

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            after: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The value after the PR's applied changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property before

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            before: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The value before the PR's applied changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property diff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            diff: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A string containing the full set of changes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property removed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            removed: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A string containing just the removed lines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Violation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Violation {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The result of user doing warn, message or fail, built this way for expansion later.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            file?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional path to the file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property icon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            icon?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional icon for table (Only valid for messages)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            line?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional line in the file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            message: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BitBucketCloudLinks<Names extends string> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key in Names]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            href: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BitBucketServerChangesValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BitBucketServerChangesValue =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | BitBucketServerChangesValueAddCopyModifyDelete
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | BitBucketServerChangesValueMove;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BitBucketServerLinks<Names> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key in keyof Names]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                href: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CallbackableFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CallbackableFn = (callback: (done: any) => void) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • A function with a callback function, which Danger wraps in a Promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Chainsmoker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Chainsmoker<T> = (...patterns: Pattern[]) => MatchResult<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • A vendored copy of the Chainsmoker module on NPM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GitMatchResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GitMatchResult = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** Did any file paths match from the git modified list? */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  modified: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** Did any file paths match from the git created list? */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  created: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** Did any file paths match from the combination of the git modified and created list? */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  edited: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** Did any file paths match from the git deleted list? */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deleted: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The shape of the Chainsmoker response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type KeyedPaths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type KeyedPaths<T> = { readonly [K in keyof T]: Path[] };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type KeyedPatterns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type KeyedPatterns<T> = { readonly [K in keyof T]: Pattern[] };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MarkdownString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MarkdownString = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MatchResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MatchResult<T> = _MatchResult<T> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /** Returns an object containing arrays of matched files instead of the usual boolean values. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getKeyedPaths(): KeyedPaths<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Path = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Pattern = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Scheduleable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Scheduleable = Promise<any> | Promise<void> | CallbackableFn;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Types of things which Danger will schedule for you, it's recommended that you just throw in an async () => { [...] } function. Can also handle a function that has a single 'done' arg.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (36)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (45)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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/danger.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/danger)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/danger"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>