Class RepositoryResource

Represents a GitHub repository resource with chainable async methods.

Implements PromiseLike<GitHubRepository> so it can be awaited directly to fetch repository info, while also exposing sub-resource methods.

Example

// Await directly to get repository info
const repo = await gh.org('github').repo('linguist');

// Get pull requests
const prs = await gh.org('github').repo('linguist').pullRequests({ state: 'open' });

// Navigate into a specific pull request
const files = await gh.org('github').repo('linguist').pullRequest(42).files();

// Get commits
const commits = await gh.org('github').repo('linguist').commits({ per_page: 10 });

// Get raw file content
const content = await gh.org('github').repo('linguist').raw('README.md');

Implements

PromiseLike<GitHubRepository>

Methods

addCollaborator

addCollaborator(
    username: string,
    data?: AddCollaboratorData,
    signal?: AbortSignal,
): Promise<void>
Adds a collaborator to this repository.

PUT /repos/{owner}/{repo}/collaborators/{username}

Sends an invitation if the user is not yet a collaborator, or updates their permission level if they already are. Returns void in both cases.
Parameters
- username: string
  The GitHub login of the user to add
- Optionaldata: AddCollaboratorData
  Optional permission level (defaults to 'push')
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<void>
Throws
If the user is not found or access is denied
Example
```
await gh.repo('octocat', 'Hello-World').addCollaborator('hubot');
await gh.repo('octocat', 'Hello-World').addCollaborator('hubot', { permission: 'maintain' });
```
- Defined in src/resources/RepositoryResource.ts:839

branch

branch(name: string, signal?: AbortSignal): Promise<GitHubBranch>
Fetches a specific branch by name.

GET /repos/{owner}/{repo}/branches/{branch}
Parameters
- name: string
  The branch name (e.g., 'main')
- Optionalsignal: AbortSignal
Returns Promise<GitHubBranch>
The branch object
- Defined in src/resources/RepositoryResource.ts:203

branches

branches(
params?: BranchesParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubBranch>>
Fetches branches for this repository.

GET /repos/{owner}/{repo}/branches
Parameters
- Optionalparams: BranchesParams
  Optional filters: protected, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubBranch>>
A paged response of branches
- Defined in src/resources/RepositoryResource.ts:187

cancelWorkflowRun

cancelWorkflowRun(runId: number, signal?: AbortSignal): Promise<void>
Cancels a workflow run in progress.

POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel
Parameters
- runId: number
  The workflow run ID to cancel
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<void>
Throws
If the run is not found or cannot be cancelled
Example
```
await gh.repo('octocat', 'Hello-World').cancelWorkflowRun(12345);
```
- Defined in src/resources/RepositoryResource.ts:1028

collaborators

collaborators(
params?: CollaboratorsParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubUser>>
Lists collaborators for this repository.

GET /repos/{owner}/{repo}/collaborators
Parameters
- Optionalparams: CollaboratorsParams
  Optional filters: affiliation, permission, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubUser>>
A paged response of users who are collaborators
Example
```
const collabs = await gh.repo('octocat', 'Hello-World').collaborators();
const outside = await gh.repo('octocat', 'Hello-World').collaborators({ affiliation: 'outside' });
```
- Defined in src/resources/RepositoryResource.ts:812

commit

commit(ref: string): CommitResource
Returns a CommitResource for a given commit ref (SHA, branch, or tag).
Parameters
- ref: string
  Commit SHA, branch name, or tag name
Returns CommitResource
A chainable commit resource
- Defined in src/resources/RepositoryResource.ts:168

commits

commits(
params?: CommitsParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubCommit>>
Fetches commits for this repository.

GET /repos/{owner}/{repo}/commits
Parameters
- Optionalparams: CommitsParams
  Optional filters: sha, path, author, since, until, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubCommit>>
A paged response of commits
- Defined in src/resources/RepositoryResource.ts:154

contents(
    path?: string,
    params?: ContentParams,
    signal?: AbortSignal,
): Promise<GitHubContent | GitHubContent[]>
Fetches the contents of a file or directory in this repository.

GET /repos/{owner}/{repo}/contents/{path}

Returns a single GitHubContent for files, or an array for directories.
Parameters
- Optionalpath: string
  Path to the file or directory. Omit for root.
- Optionalparams: ContentParams
  Optional: ref (branch, tag, or commit SHA)
- Optionalsignal: AbortSignal
Returns Promise<GitHubContent | GitHubContent[]>
- Defined in src/resources/RepositoryResource.ts:456

contributors

contributors(
    params?: PaginationParams & { anon?: boolean },
    signal?: AbortSignal,
): Promise<
    GitHubPagedResponse<
        {
            avatar_url?: string;
            contributions: number;
            html_url?: string;
            id?: number;
            login?: string;
        },
    >,
>
Fetches contributors to this repository.

GET /repos/{owner}/{repo}/contributors
Parameters
- Optionalparams: PaginationParams & { anon?: boolean }
  Optional filters: anon, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<
    GitHubPagedResponse<
        {
            avatar_url?: string;
            contributions: number;
            html_url?: string;
            id?: number;
            login?: string;
        },
    >,
>
- Defined in src/resources/RepositoryResource.ts:530

createAdvisory

createAdvisory(
data: CreateAdvisoryData,
signal?: AbortSignal,
): Promise<GitHubRepositoryAdvisory>
Creates a draft security advisory in this repository.

POST /repos/{owner}/{repo}/security-advisories
Parameters
- data: CreateAdvisoryData
  Advisory data. summary and description are required.
- Optionalsignal: AbortSignal
Returns Promise<GitHubRepositoryAdvisory>
The created advisory draft
Example
```
const advisory = await gh.repo('octocat', 'Hello-World').createAdvisory({
  summary: 'Remote code execution via crafted input',
  description: 'A vulnerability in...',
  severity: 'critical',
});
```
- Defined in src/resources/RepositoryResource.ts:899

createFork

createFork(
data?: CreateForkData,
signal?: AbortSignal,
): Promise<GitHubRepository>
Creates a fork of this repository.

POST /repos/{owner}/{repo}/forks

Note: Forking is asynchronous on GitHub's side. The returned repository may not be fully ready immediately after this call returns.
Parameters
- Optionaldata: CreateForkData
  Optional: target organization, custom name, default-branch-only flag
- Optionalsignal: AbortSignal
Returns Promise<GitHubRepository>
The newly created fork
Example
```
// Fork into authenticated user's account
const fork = await gh.repo('octocat', 'Hello-World').createFork();

// Fork into an organization with a custom name
const fork = await gh.repo('octocat', 'Hello-World').createFork({
  organization: 'my-org',
  name: 'hello-world-fork',
});
```
- Defined in src/resources/RepositoryResource.ts:369

createIssue

createIssue(data: CreateIssueData, signal?: AbortSignal): Promise<GitHubIssue>
Creates an issue in this repository.

POST /repos/{owner}/{repo}/issues
Parameters
- data: CreateIssueData
  Issue data. title is required.
- Optionalsignal: AbortSignal
Returns Promise<GitHubIssue>
The created issue
Example
```
const issue = await gh.repo('octocat', 'Hello-World').createIssue({
  title: 'Found a bug',
  body: 'Steps to reproduce...',
  labels: ['bug'],
});
```
- Defined in src/resources/RepositoryResource.ts:601

createLabel

createLabel(data: CreateLabelData, signal?: AbortSignal): Promise<GitHubLabel>
Creates a label in this repository.

POST /repos/{owner}/{repo}/labels
Parameters
- data: CreateLabelData
  Label data: name and color are required
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubLabel>
The created label
Throws
If a label with that name already exists
Example
```
const label = await gh.repo('octocat', 'Hello-World').createLabel({ name: 'enhancement', color: '84b6eb' });
```
- Defined in src/resources/RepositoryResource.ts:660

createMilestone

createMilestone(
data: CreateMilestoneData,
signal?: AbortSignal,
): Promise<GitHubMilestone>
Creates a milestone in this repository.

POST /repos/{owner}/{repo}/milestones
Parameters
- data: CreateMilestoneData
  Milestone data: title is required
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubMilestone>
The created milestone
Example
```
const ms = await gh.repo('octocat', 'Hello-World').createMilestone({ title: 'v2.0', due_on: '2025-12-31T00:00:00Z' });
```
- Defined in src/resources/RepositoryResource.ts:756

createRelease

createRelease(
data: CreateReleaseData,
signal?: AbortSignal,
): Promise<GitHubRelease>
Creates a new release.

POST /repos/{owner}/{repo}/releases
Parameters
- data: CreateReleaseData
  Release data: tag_name (required), name, body, draft, prerelease, target_commitish
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubRelease>
The created release
Throws
If the tag already has a release or access is denied
Example
```
const release = await gh.repo('octocat', 'Hello-World').createRelease({
  tag_name: 'v1.2.0',
  name:     'v1.2.0',
  body:     '## Changelog\n- Fix bug #42',
});
```
- Defined in src/resources/RepositoryResource.ts:288

createWebhook

createWebhook(
data: CreateWebhookData,
signal?: AbortSignal,
): Promise<GitHubWebhook>
Creates a webhook on this repository.

POST /repos/{owner}/{repo}/hooks
Parameters
- data: CreateWebhookData
  Webhook configuration. config.url is required.
- Optionalsignal: AbortSignal
Returns Promise<GitHubWebhook>
The created webhook
Example
```
const hook = await gh.repo('octocat', 'Hello-World').createWebhook({
  config: { url: 'https://example.com/webhook', content_type: 'json', secret: 'mysecret' },
  events: ['push', 'pull_request'],
});
```
- Defined in src/resources/RepositoryResource.ts:405

deleteLabel

deleteLabel(name: string, signal?: AbortSignal): Promise<void>
Deletes a label.

DELETE /repos/{owner}/{repo}/labels/{name}
Parameters
- name: string
  The label name to delete
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<void>
Throws
If the label is not found
Example
```
await gh.repo('octocat', 'Hello-World').deleteLabel('wontfix');
```
- Defined in src/resources/RepositoryResource.ts:698

deleteMilestone

deleteMilestone(milestoneNumber: number, signal?: AbortSignal): Promise<void>
Deletes a milestone.

DELETE /repos/{owner}/{repo}/milestones/{milestone_number}
Parameters
- milestoneNumber: number
  The milestone number to delete
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<void>
Throws
If the milestone is not found
Example
```
await gh.repo('octocat', 'Hello-World').deleteMilestone(1);
```
- Defined in src/resources/RepositoryResource.ts:794

deleteRelease

deleteRelease(releaseId: number, signal?: AbortSignal): Promise<void>
Deletes a release.

DELETE /repos/{owner}/{repo}/releases/{release_id}
Parameters
- releaseId: number
  The release ID to delete
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<void>
Throws
If the release is not found or access is denied
Example
```
await gh.repo('octocat', 'Hello-World').deleteRelease(1);
```
- Defined in src/resources/RepositoryResource.ts:326

deleteWebhook

deleteWebhook(hookId: number, signal?: AbortSignal): Promise<void>
Deletes a webhook from this repository.

DELETE /repos/{owner}/{repo}/hooks/{hook_id}
Parameters
- hookId: number
  The webhook ID to delete
- Optionalsignal: AbortSignal
Returns Promise<void>
Example
```
await gh.repo('octocat', 'Hello-World').deleteWebhook(1);
```
- Defined in src/resources/RepositoryResource.ts:442

forks

forks(
params?: ForksParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubRepository>>
Fetches the forks of this repository.

GET /repos/{owner}/{repo}/forks
Parameters
- Optionalparams: ForksParams
  Optional filters: sort, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubRepository>>
A paged response of forked repositories
- Defined in src/resources/RepositoryResource.ts:338

get

get(signal?: AbortSignal): Promise<GitHubRepository>
Fetches the repository details.

GET /repos/{owner}/{repo}
Parameters
- Optionalsignal: AbortSignal
Returns Promise<GitHubRepository>
The repository object
- Defined in src/resources/RepositoryResource.ts:88

gitTree

gitTree(
    treeSha: string,
    params?: GitTreeParams,
    signal?: AbortSignal,
): Promise<GitHubTree>
Fetches a git tree for this repository.

GET /repos/{owner}/{repo}/git/trees/{tree_sha}

The treeSha parameter accepts a tree SHA, a branch name, or a tag name.
Parameters
- treeSha: string
  Tree SHA, branch name (e.g. 'main'), or tag name
- Optionalparams: GitTreeParams
  Optional: recursive: '1' to fetch the full tree recursively
- Optionalsignal: AbortSignal
Returns Promise<GitHubTree>
The tree object with its entries
Example
```
// Get the tree of the 'main' branch
const tree = await gh.repo('octocat', 'Hello-World').gitTree('main');

// Get the full recursive tree for a specific SHA
const fullTree = await gh.repo('octocat', 'Hello-World').gitTree('abc123', { recursive: '1' });
console.log(fullTree.tree.map(item => item.path));
```
- Defined in src/resources/RepositoryResource.ts:1073

issue

issue(issueNumber: number): IssueResource
Returns an IssueResource for a given issue number.

The returned resource can be awaited directly to fetch issue info, or chained to access sub-resources (comments).
Parameters
- issueNumber: number
  The issue number within the repository
Returns IssueResource
A chainable issue resource
Example
```
const issue    = await gh.repo('octocat', 'Hello-World').issue(1);
const comments = await gh.repo('octocat', 'Hello-World').issue(1).comments();
```
- Defined in src/resources/RepositoryResource.ts:572

issues

issues(
params?: IssuesParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubIssue>>
Fetches issues for this repository.

GET /repos/{owner}/{repo}/issues

Note: GitHub returns pull requests as issues in this endpoint. Filter them out by checking for the absence of pull_request.
Parameters
- Optionalparams: IssuesParams
  Optional filters: state, labels, sort, direction, since, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubIssue>>
A paged response of issues
- Defined in src/resources/RepositoryResource.ts:549

label

label(name: string, signal?: AbortSignal): Promise<GitHubLabel>
Fetches a single label by name.

GET /repos/{owner}/{repo}/labels/{name}
Parameters
- name: string
  The label name
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubLabel>
The label object
Throws
If the label is not found
Example
```
const label = await gh.repo('octocat', 'Hello-World').label('bug');
```
- Defined in src/resources/RepositoryResource.ts:641

labels

labels(
params?: PaginationParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubLabel>>
Lists labels for this repository.

GET /repos/{owner}/{repo}/labels
Parameters
- Optionalparams: PaginationParams
  Optional pagination: per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubLabel>>
A paged response of labels
Example
```
const labels = await gh.repo('octocat', 'Hello-World').labels();
```
- Defined in src/resources/RepositoryResource.ts:618

languages

languages(signal?: AbortSignal): Promise<RepoLanguages>
Returns the programming languages used in the repository and the number of bytes of code written in each language.

GET /repos/{owner}/{repo}/languages
Parameters
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<RepoLanguages>
Object mapping language names to byte counts
Throws
If the repository is not found or access is denied
Example
```
const langs = await gh.repo('facebook', 'react').languages();
// { JavaScript: 1234567, TypeScript: 89012 }
```
- Defined in src/resources/RepositoryResource.ts:107

latestRelease

latestRelease(signal?: AbortSignal): Promise<GitHubRelease>
Fetches the latest published release for this repository.

GET /repos/{owner}/{repo}/releases/latest
Parameters
- Optionalsignal: AbortSignal
Returns Promise<GitHubRelease>
The latest release object
- Defined in src/resources/RepositoryResource.ts:246

milestone

milestone(
milestoneNumber: number,
signal?: AbortSignal,
): Promise<GitHubMilestone>
Fetches a single milestone by number.

GET /repos/{owner}/{repo}/milestones/{milestone_number}
Parameters
- milestoneNumber: number
  The milestone number
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubMilestone>
The milestone object
Throws
If the milestone is not found
Example
```
const milestone = await gh.repo('octocat', 'Hello-World').milestone(1);
```
- Defined in src/resources/RepositoryResource.ts:738

milestones

milestones(
params?: MilestonesParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubMilestone>>
Lists milestones for this repository.

GET /repos/{owner}/{repo}/milestones
Parameters
- Optionalparams: MilestonesParams
  Optional filters: state, sort, direction, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubMilestone>>
A paged response of milestones
Example
```
const milestones = await gh.repo('octocat', 'Hello-World').milestones({ state: 'open' });
```
- Defined in src/resources/RepositoryResource.ts:715

multipleRaw

multipleRaw(
    filePaths: string[],
    params?: ContentParams,
    signal?: AbortSignal,
): Promise<Record<string, string>>
Fetches the raw text content of multiple files in this repository.

Uses Accept: application/vnd.github.raw+json for each file request.

Files are fetched concurrently. If an individual file request fails, that file is omitted from the returned record and the remaining files are still returned.
Parameters
- filePaths: string[]
  Paths to the files (e.g., ['README.md', 'src/index.ts'])
- Optionalparams: ContentParams
  Optional: ref (branch, tag, or commit SHA)
- Optionalsignal: AbortSignal
Returns Promise<Record<string, string>>
A record mapping each fetched file path to its raw content
- Defined in src/resources/RepositoryResource.ts:497

pullRequest

pullRequest(pullNumber: number): PullRequestResource
Returns a PullRequestResource for a given pull request number.
Parameters
- pullNumber: number
  The pull request number (not the ID)
Returns PullRequestResource
A chainable pull request resource
- Defined in src/resources/RepositoryResource.ts:133

pullRequests

pullRequests(
params?: PullRequestsParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubPullRequest>>
Fetches pull requests for this repository.

GET /repos/{owner}/{repo}/pulls
Parameters
- Optionalparams: PullRequestsParams
  Optional filters: state, head, base, sort, direction, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubPullRequest>>
A paged response of pull requests
- Defined in src/resources/RepositoryResource.ts:119

raw

raw(
    filePath: string,
    params?: ContentParams,
    signal?: AbortSignal,
): Promise<string>
Fetches the raw text content of a file in this repository.

Uses Accept: application/vnd.github.raw+json.

GET /repos/{owner}/{repo}/contents/{filePath}
Parameters
- filePath: string
  Path to the file (e.g., 'src/index.ts')
- Optionalparams: ContentParams
  Optional: ref (branch, tag, or commit SHA)
- Optionalsignal: AbortSignal
Returns Promise<string>
The raw file content as a string
- Defined in src/resources/RepositoryResource.ts:476

release

release(releaseId: number, signal?: AbortSignal): Promise<GitHubRelease>
Fetches a single release by its numeric ID.

GET /repos/{owner}/{repo}/releases/{release_id}
Parameters
- releaseId: number
  The release ID
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubRelease>
The release object
Throws
If the release is not found or access is denied
Example
```
const release = await gh.repo('octocat', 'Hello-World').release(1);
```
- Defined in src/resources/RepositoryResource.ts:265

releases

releases(
params?: PaginationParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubRelease>>
Fetches releases for this repository.

GET /repos/{owner}/{repo}/releases
Parameters
- Optionalparams: PaginationParams
  Optional pagination: per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubRelease>>
A paged response of releases
- Defined in src/resources/RepositoryResource.ts:231

removeCollaborator

removeCollaborator(username: string, signal?: AbortSignal): Promise<void>
Removes a collaborator from this repository.

DELETE /repos/{owner}/{repo}/collaborators/{username}
Parameters
- username: string
  The GitHub login of the user to remove
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<void>
Throws
If the user is not found or access is denied
Example
```
await gh.repo('octocat', 'Hello-World').removeCollaborator('hubot');
```
- Defined in src/resources/RepositoryResource.ts:857

repoAdvisories

repoAdvisories(
params?: RepoAdvisoriesParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubRepositoryAdvisory>>
Lists security advisories for this repository.

GET /repos/{owner}/{repo}/security-advisories
Parameters
- Optionalparams: RepoAdvisoriesParams
  Optional filters: direction, sort, state, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubRepositoryAdvisory>>
A paged response of repository advisories
Example
```
const advisories = await gh.repo('octocat', 'Hello-World').repoAdvisories({ state: 'published' });
```
- Defined in src/resources/RepositoryResource.ts:874

repoAdvisory

repoAdvisory(
ghsaId: string,
signal?: AbortSignal,
): Promise<GitHubRepositoryAdvisory>
Fetches a single repository security advisory by its GHSA ID.

GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}
Parameters
- ghsaId: string
  The GHSA identifier (e.g., 'GHSA-xxxx-xxxx-xxxx')
- Optionalsignal: AbortSignal
Returns Promise<GitHubRepositoryAdvisory>
The repository advisory object
- Defined in src/resources/RepositoryResource.ts:911

requestCve

requestCve(
ghsaId: string,
signal?: AbortSignal,
): Promise<GitHubRepositoryAdvisory>
Requests a CVE ID for a repository security advisory.

POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve
Parameters
- ghsaId: string
  The GHSA identifier
- Optionalsignal: AbortSignal
Returns Promise<GitHubRepositoryAdvisory>
The updated advisory with the CVE request submitted
- Defined in src/resources/RepositoryResource.ts:943

then

then<TResult1 = GitHubRepository, TResult2 = never>(
    onfulfilled?:
        | null
        | (value: GitHubRepository) => TResult1 | PromiseLike<TResult1>,
    onrejected?: null | (reason: unknown) => TResult2 | PromiseLike<TResult2>,
): PromiseLike<TResult1 | TResult2>
Allows the resource to be awaited directly, resolving with the repository info. Delegates to RepositoryResource.get.
Type Parameters
- TResult1 = GitHubRepository
- TResult2 = never
Parameters
- Optionalonfulfilled: null | (value: GitHubRepository) => TResult1 | PromiseLike<TResult1>
- Optionalonrejected: null | (reason: unknown) => TResult2 | PromiseLike<TResult2>
Returns PromiseLike<TResult1 | TResult2>
Implementation of PromiseLike.then
- Defined in src/resources/RepositoryResource.ts:74

topics

topics(signal?: AbortSignal): Promise<string[]>
Fetches the repository topics.

GET /repos/{owner}/{repo}/topics
Parameters
- Optionalsignal: AbortSignal
Returns Promise<string[]>
An array of topic strings
- Defined in src/resources/RepositoryResource.ts:518

triggerWorkflow

triggerWorkflow(
    workflowId: string | number,
    data: TriggerWorkflowData,
    signal?: AbortSignal,
): Promise<void>
Triggers a workflow dispatch event.

POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches
Parameters
- workflowId: string | number
  The workflow ID (number) or file name (e.g., 'ci.yml')
- data: TriggerWorkflowData
  Dispatch data: ref is required; inputs are optional
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<void>
Throws
If the workflow is not found or ref is invalid
Example
```
await gh.repo('octocat', 'Hello-World').triggerWorkflow('ci.yml', { ref: 'main' });
await gh.repo('octocat', 'Hello-World').triggerWorkflow('ci.yml', { ref: 'main', inputs: { environment: 'staging' } });
```
- Defined in src/resources/RepositoryResource.ts:1048

updateAdvisory

updateAdvisory(
    ghsaId: string,
    data: UpdateAdvisoryData,
    signal?: AbortSignal,
): Promise<GitHubRepositoryAdvisory>
Updates a repository security advisory.

PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}
Parameters
- ghsaId: string
  The GHSA identifier
- data: UpdateAdvisoryData
  Fields to update
- Optionalsignal: AbortSignal
Returns Promise<GitHubRepositoryAdvisory>
The updated advisory
Example
```
const updated = await gh.repo('octocat', 'Hello-World').updateAdvisory('GHSA-1234-5678-9abc', {
  state: 'published',
});
```
- Defined in src/resources/RepositoryResource.ts:931

updateLabel

updateLabel(
    name: string,
    data: UpdateLabelData,
    signal?: AbortSignal,
): Promise<GitHubLabel>
Updates a label.

PATCH /repos/{owner}/{repo}/labels/{name}
Parameters
- name: string
  The current label name
- data: UpdateLabelData
  Fields to update: name, color, description
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubLabel>
The updated label
Throws
If the label is not found
Example
```
await gh.repo('octocat', 'Hello-World').updateLabel('bug', { color: 'ee0701' });
```
- Defined in src/resources/RepositoryResource.ts:680

updateMilestone

updateMilestone(
    milestoneNumber: number,
    data: UpdateMilestoneData,
    signal?: AbortSignal,
): Promise<GitHubMilestone>
Updates a milestone.

PATCH /repos/{owner}/{repo}/milestones/{milestone_number}
Parameters
- milestoneNumber: number
  The milestone number to update
- data: UpdateMilestoneData
  Fields to update: title, state, description, due_on
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubMilestone>
The updated milestone
Throws
If the milestone is not found
Example
```
await gh.repo('octocat', 'Hello-World').updateMilestone(1, { state: 'closed' });
```
- Defined in src/resources/RepositoryResource.ts:776

updateRelease

updateRelease(
    releaseId: number,
    data: UpdateReleaseData,
    signal?: AbortSignal,
): Promise<GitHubRelease>
Updates an existing release.

PATCH /repos/{owner}/{repo}/releases/{release_id}
Parameters
- releaseId: number
  The release ID to update
- data: UpdateReleaseData
  Fields to update: tag_name, name, body, draft, prerelease
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubRelease>
The updated release
Throws
If the release is not found or access is denied
Example
```
await gh.repo('octocat', 'Hello-World').updateRelease(1, { draft: false });
```
- Defined in src/resources/RepositoryResource.ts:308

updateWebhook

updateWebhook(
    hookId: number,
    data: UpdateWebhookData,
    signal?: AbortSignal,
): Promise<GitHubWebhook>
Updates an existing webhook on this repository.

PATCH /repos/{owner}/{repo}/hooks/{hook_id}
Parameters
- hookId: number
  The webhook ID
- data: UpdateWebhookData
  Fields to update
- Optionalsignal: AbortSignal
Returns Promise<GitHubWebhook>
The updated webhook
Example
```
const hook = await gh.repo('octocat', 'Hello-World').updateWebhook(1, {
  active: false,
  add_events: ['issues'],
});
```
- Defined in src/resources/RepositoryResource.ts:426

webhooks

webhooks(
params?: PaginationParams,
signal?: AbortSignal,
): Promise<GitHubPagedResponse<GitHubWebhook>>
Fetches webhooks configured on this repository.

GET /repos/{owner}/{repo}/hooks
Parameters
- Optionalparams: PaginationParams
  Optional pagination: per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubPagedResponse<GitHubWebhook>>
A paged response of webhooks
- Defined in src/resources/RepositoryResource.ts:381

workflowRun

workflowRun(runId: number, signal?: AbortSignal): Promise<GitHubWorkflowRun>
Fetches a single workflow run by its ID.

GET /repos/{owner}/{repo}/actions/runs/{run_id}
Parameters
- runId: number
  The workflow run ID
- Optionalsignal: AbortSignal
  Optional AbortSignal to cancel the request
Returns Promise<GitHubWorkflowRun>
The workflow run object
Throws
If the run is not found
Example
```
const run = await gh.repo('octocat', 'Hello-World').workflowRun(12345);
```
- Defined in src/resources/RepositoryResource.ts:1010

workflowRuns

workflowRuns(
params?: WorkflowRunsParams,
signal?: AbortSignal,
): Promise<GitHubWorkflowRunsResponse>
Lists workflow runs for this repository.

GET /repos/{owner}/{repo}/actions/runs

Returns the raw GitHub Actions response envelope including total_count and the workflow_runs array. Use params.per_page to limit how many runs are fetched (default GitHub: 30, max: 100).
Parameters
- Optionalparams: WorkflowRunsParams
  Optional filters: branch, event, status, actor, created, per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubWorkflowRunsResponse>
Response envelope with total_count and workflow_runs
Example
```
const { total_count, workflow_runs } = await gh.repo('octocat', 'Hello-World').workflowRuns({ per_page: 10 });
const lastRun = workflow_runs[0];
console.log(lastRun.conclusion); // 'success' | 'failure' | null ...
```
- Defined in src/resources/RepositoryResource.ts:966

workflows

workflows(
params?: PaginationParams,
signal?: AbortSignal,
): Promise<GitHubWorkflowsResponse>
Lists workflows defined in this repository.

GET /repos/{owner}/{repo}/actions/workflows
Parameters
- Optionalparams: PaginationParams
  Optional pagination: per_page, page
- Optionalsignal: AbortSignal
Returns Promise<GitHubWorkflowsResponse>
Response envelope with total_count and workflows
Example
```
const { workflows } = await gh.repo('octocat', 'Hello-World').workflows();
```
- Defined in src/resources/RepositoryResource.ts:987

Class RepositoryResource

Example

Implements

Index

Methods

Methods

addCollaborator

Parameters

Returns Promise<void>

Throws

Example

branch

Parameters

Returns Promise<GitHubBranch>

branches

Parameters

Returns Promise<GitHubPagedResponse<GitHubBranch>>

cancelWorkflowRun

Parameters

Returns Promise<void>

Throws

Example

collaborators

Parameters

Returns Promise<GitHubPagedResponse<GitHubUser>>

Example

commit

Parameters

Returns CommitResource

commits

Parameters

Returns Promise<GitHubPagedResponse<GitHubCommit>>

contents

Parameters

Returns Promise<GitHubContent | GitHubContent[]>

contributors

Parameters

Returns Promise< GitHubPagedResponse< { avatar_url?: string; contributions: number; html_url?: string; id?: number; login?: string; }, >,>

createAdvisory

Parameters

Returns Promise<GitHubRepositoryAdvisory>

Example

createFork

Parameters

Returns Promise<GitHubRepository>

Example

createIssue

Parameters

Returns Promise<GitHubIssue>

Example

createLabel

Parameters

Returns Promise<GitHubLabel>

Throws

Example

createMilestone

Parameters

Returns Promise<GitHubMilestone>

Example

createRelease

Parameters

Returns Promise<GitHubRelease>

Throws

Example

createWebhook

Parameters

Returns Promise<GitHubWebhook>

Example

deleteLabel

Parameters

Returns Promise<void>

Throws

Example

deleteMilestone

Parameters

Returns Promise<void>

Throws

Example

deleteRelease

Parameters

Returns Promise<
GitHubPagedResponse<
{
avatar_url?: string;
contributions: number;
html_url?: string;
id?: number;
login?: string;
},
>,
>