octokit.actions.addCustomLabelsToSelfHostedRunnerForOrg({
org,
runner_id,
labels,
});
octokit.actions.addCustomLabelsToSelfHostedRunnerForRepo({
owner,
repo,
runner_id,
labels,
});
octokit.actions.addRepoAccessToSelfHostedRunnerGroupInOrg({
org,
runner_group_id,
repository_id,
});
octokit.actions.addSelectedRepoToOrgSecret({ org, secret_name, repository_id });
octokit.actions.addSelectedRepoToOrgVariable({ org, name, repository_id });
octokit.actions.cancelWorkflowRun({ owner, repo, run_id });
octokit.actions.createEnvironmentVariable({
owner,
repo,
environment_name,
name,
value,
});
octokit.actions.createOrUpdateEnvironmentSecret({
owner,
repo,
environment_name,
secret_name,
encrypted_value,
key_id,
});
octokit.actions.createOrUpdateOrgSecret({
org,
secret_name,
encrypted_value,
key_id,
visibility,
selected_repository_ids,
});
octokit.actions.createOrUpdateRepoSecret({
owner,
repo,
secret_name,
encrypted_value,
key_id,
});
octokit.actions.createOrgVariable({
org,
name,
value,
visibility,
selected_repository_ids,
});
octokit.actions.createRegistrationTokenForOrg({ org });
octokit.actions.createRegistrationTokenForRepo({ owner, repo });
octokit.actions.createRemoveTokenForOrg({ org });
octokit.actions.createRemoveTokenForRepo({ owner, repo });
octokit.actions.createRepoVariable({ owner, repo, name, value });
octokit.actions.createWorkflowDispatch({
owner,
repo,
workflow_id,
ref,
inputs,
});
octokit.actions.deleteActionsCacheById({ owner, repo, cache_id });
octokit.actions.deleteActionsCacheByKey({ owner, repo, key, ref });
octokit.actions.deleteArtifact({ owner, repo, artifact_id });
octokit.actions.deleteEnvironmentSecret({
owner,
repo,
environment_name,
secret_name,
});
octokit.actions.deleteEnvironmentVariable({
owner,
repo,
name,
environment_name,
});
octokit.actions.deleteOrgSecret({ org, secret_name });
octokit.actions.deleteOrgVariable({ org, name });
octokit.actions.deleteRepoSecret({ owner, repo, secret_name });
octokit.actions.deleteRepoVariable({ owner, repo, name });
octokit.actions.deleteSelfHostedRunnerFromOrg({ org, runner_id });
octokit.actions.deleteSelfHostedRunnerFromRepo({ owner, repo, runner_id });
octokit.actions.deleteWorkflowRun({ owner, repo, run_id });
octokit.actions.deleteWorkflowRunLogs({ owner, repo, run_id });
octokit.actions.disableSelectedRepositoryGithubActionsOrganization({
org,
repository_id,
});
octokit.actions.disableWorkflow({ owner, repo, workflow_id });
octokit.actions.downloadArtifact({ owner, repo, artifact_id, archive_format });
octokit.actions.downloadJobLogsForWorkflowRun({ owner, repo, job_id });
octokit.actions.downloadWorkflowRunAttemptLogs({
owner,
repo,
run_id,
attempt_number,
});
octokit.actions.downloadWorkflowRunLogs({ owner, repo, run_id });
octokit.actions.enableSelectedRepositoryGithubActionsOrganization({
org,
repository_id,
});
octokit.actions.enableWorkflow({ owner, repo, workflow_id });
octokit.actions.forceCancelWorkflowRun({ owner, repo, run_id });
octokit.actions.generateRunnerJitconfigForOrg({
org,
name,
runner_group_id,
labels,
work_folder,
});
octokit.actions.generateRunnerJitconfigForRepo({
owner,
repo,
name,
runner_group_id,
labels,
work_folder,
});
octokit.actions.getActionsCacheList({
owner,
repo,
per_page,
page,
ref,
key,
sort,
direction,
});
octokit.actions.getActionsCacheUsage({ owner, repo });
octokit.actions.getActionsCacheUsageByRepoForOrg({ org, per_page, page });
octokit.actions.getActionsCacheUsageForOrg({ org });
octokit.actions.getActionsCacheUsagePolicy({ owner, repo });
octokit.actions.getActionsCacheUsagePolicyForEnterprise({ enterprise });
octokit.actions.getAllowedActionsOrganization({ org });
octokit.actions.getAllowedActionsRepository({ owner, repo });
octokit.actions.getArtifact({ owner, repo, artifact_id });
octokit.actions.getCustomOidcSubClaimForRepo({ owner, repo });
octokit.actions.getEnvironmentPublicKey({ owner, repo, environment_name });
octokit.actions.getEnvironmentSecret({
owner,
repo,
environment_name,
secret_name,
});
octokit.actions.getEnvironmentVariable({ owner, repo, environment_name, name });
octokit.actions.getGithubActionsDefaultWorkflowPermissionsOrganization({ org });
octokit.actions.getGithubActionsDefaultWorkflowPermissionsRepository({
owner,
repo,
});
octokit.actions.getGithubActionsPermissionsOrganization({ org });
octokit.actions.getGithubActionsPermissionsRepository({ owner, repo });
octokit.actions.getJobForWorkflowRun({ owner, repo, job_id });
octokit.actions.getOrgPublicKey({ org });
octokit.actions.getOrgSecret({ org, secret_name });
octokit.actions.getOrgVariable({ org, name });
octokit.actions.getPendingDeploymentsForRun({ owner, repo, run_id });
octokit.actions.getRepoPublicKey({ owner, repo });
octokit.actions.getRepoSecret({ owner, repo, secret_name });
octokit.actions.getRepoVariable({ owner, repo, name });
octokit.actions.getReviewsForRun({ owner, repo, run_id });
octokit.actions.getSelfHostedRunnerForOrg({ org, runner_id });
octokit.actions.getSelfHostedRunnerForRepo({ owner, repo, runner_id });
octokit.actions.getWorkflow({ owner, repo, workflow_id });
octokit.actions.getWorkflowAccessToRepository({ owner, repo });
octokit.actions.getWorkflowRun({ owner, repo, run_id, exclude_pull_requests });
octokit.actions.getWorkflowRunAttempt({
owner,
repo,
run_id,
attempt_number,
exclude_pull_requests,
});
octokit.actions.listArtifactsForRepo({ owner, repo, per_page, page, name });
octokit.actions.listEnvironmentSecrets({
owner,
repo,
environment_name,
per_page,
page,
});
octokit.actions.listEnvironmentVariables({
owner,
repo,
environment_name,
per_page,
page,
});
octokit.actions.listJobsForWorkflowRun({
owner,
repo,
run_id,
filter,
per_page,
page,
});
octokit.actions.listJobsForWorkflowRunAttempt({
owner,
repo,
run_id,
attempt_number,
per_page,
page,
});
octokit.actions.listLabelsForSelfHostedRunnerForOrg({ org, runner_id });
octokit.actions.listLabelsForSelfHostedRunnerForRepo({
owner,
repo,
runner_id,
});
octokit.actions.listOrgSecrets({ org, per_page, page });
octokit.actions.listOrgVariables({ org, per_page, page });
octokit.actions.listRepoOrganizationSecrets({ owner, repo, per_page, page });
octokit.actions.listRepoOrganizationVariables({ owner, repo, per_page, page });
octokit.actions.listRepoSecrets({ owner, repo, per_page, page });
octokit.actions.listRepoVariables({ owner, repo, per_page, page });
octokit.actions.listRepoWorkflows({ owner, repo, per_page, page });
octokit.actions.listRunnerApplicationsForOrg({ org });
octokit.actions.listRunnerApplicationsForRepo({ owner, repo });
octokit.actions.listSelectedReposForOrgSecret({
org,
secret_name,
page,
per_page,
});
octokit.actions.listSelectedReposForOrgVariable({ org, name, page, per_page });
octokit.actions.listSelectedRepositoriesEnabledGithubActionsOrganization({
org,
per_page,
page,
});
octokit.actions.listSelfHostedRunnersForOrg({ name, org, per_page, page });
octokit.actions.listSelfHostedRunnersForRepo({
name,
owner,
repo,
per_page,
page,
});
octokit.actions.listWorkflowRunArtifacts({
owner,
repo,
run_id,
per_page,
page,
name,
});
octokit.actions.listWorkflowRuns({
owner,
repo,
workflow_id,
actor,
branch,
event,
status,
per_page,
page,
created,
exclude_pull_requests,
check_suite_id,
head_sha,
});
octokit.actions.listWorkflowRunsForRepo({
owner,
repo,
actor,
branch,
event,
status,
per_page,
page,
created,
exclude_pull_requests,
check_suite_id,
head_sha,
});
octokit.actions.reRunJobForWorkflowRun({
owner,
repo,
job_id,
enable_debug_logging,
});
octokit.actions.reRunWorkflow({ owner, repo, run_id, enable_debug_logging });
octokit.actions.reRunWorkflowFailedJobs({
owner,
repo,
run_id,
enable_debug_logging,
});
octokit.actions.removeAllCustomLabelsFromSelfHostedRunnerForOrg({
org,
runner_id,
});
octokit.actions.removeAllCustomLabelsFromSelfHostedRunnerForRepo({
owner,
repo,
runner_id,
});
octokit.actions.removeCustomLabelFromSelfHostedRunnerForOrg({
org,
runner_id,
name,
});
octokit.actions.removeCustomLabelFromSelfHostedRunnerForRepo({
owner,
repo,
runner_id,
name,
});
octokit.actions.removeSelectedRepoFromOrgSecret({
org,
secret_name,
repository_id,
});
octokit.actions.removeSelectedRepoFromOrgVariable({ org, name, repository_id });
octokit.actions.reviewCustomGatesForRun({ owner, repo, run_id });
octokit.actions.reviewPendingDeploymentsForRun({
owner,
repo,
run_id,
environment_ids,
state,
comment,
});
octokit.actions.setActionsCacheUsagePolicy({
owner,
repo,
repo_cache_size_limit_in_gb,
});
octokit.actions.setActionsCacheUsagePolicyForEnterprise({
enterprise,
repo_cache_size_limit_in_gb,
max_repo_cache_size_limit_in_gb,
});
octokit.actions.setAllowedActionsOrganization({
org,
github_owned_allowed,
patterns_allowed,
});
octokit.actions.setAllowedActionsRepository({
owner,
repo,
github_owned_allowed,
patterns_allowed,
});
octokit.actions.setCustomLabelsForSelfHostedRunnerForOrg({
org,
runner_id,
labels,
});
octokit.actions.setCustomLabelsForSelfHostedRunnerForRepo({
owner,
repo,
runner_id,
labels,
});
octokit.actions.setCustomOidcSubClaimForRepo({
owner,
repo,
use_default,
include_claim_keys,
});
octokit.actions.setGithubActionsDefaultWorkflowPermissionsOrganization({
org,
default_workflow_permissions,
can_approve_pull_request_reviews,
});
octokit.actions.setGithubActionsDefaultWorkflowPermissionsRepository({
owner,
repo,
default_workflow_permissions,
can_approve_pull_request_reviews,
});
octokit.actions.setGithubActionsPermissionsOrganization({
org,
enabled_repositories,
allowed_actions,
});
octokit.actions.setGithubActionsPermissionsRepository({
owner,
repo,
enabled,
allowed_actions,
});
octokit.actions.setSelectedReposForOrgSecret({
org,
secret_name,
selected_repository_ids,
});
octokit.actions.setSelectedReposForOrgVariable({
org,
name,
selected_repository_ids,
});
octokit.actions.setSelectedRepositoriesEnabledGithubActionsOrganization({
org,
selected_repository_ids,
});
octokit.actions.setWorkflowAccessToRepository({ owner, repo, access_level });
octokit.actions.updateEnvironmentVariable({
owner,
repo,
name,
environment_name,
value,
});
octokit.actions.updateOrgVariable({
org,
name,
value,
visibility,
selected_repository_ids,
});
octokit.actions.updateRepoVariable({ owner, repo, name, value });
octokit.activity.checkRepoIsStarredByAuthenticatedUser({ owner, repo });
octokit.activity.deleteRepoSubscription({ owner, repo });
octokit.activity.deleteThreadSubscription({ thread_id });
octokit.activity.getFeeds();
octokit.activity.getRepoSubscription({ owner, repo });
octokit.activity.getThread({ thread_id });
octokit.activity.getThreadSubscriptionForAuthenticatedUser({ thread_id });
octokit.activity.listEventsForAuthenticatedUser({ username, per_page, page });
octokit.activity.listNotificationsForAuthenticatedUser({
all,
participating,
since,
before,
page,
per_page,
});
octokit.activity.listOrgEventsForAuthenticatedUser({
username,
org,
per_page,
page,
});
octokit.activity.listPublicEvents({ per_page, page });
octokit.activity.listPublicEventsForRepoNetwork({
owner,
repo,
per_page,
page,
});
octokit.activity.listPublicEventsForUser({ username, per_page, page });
octokit.activity.listPublicOrgEvents({ org, per_page, page });
octokit.activity.listReceivedEventsForUser({ username, per_page, page });
octokit.activity.listReceivedPublicEventsForUser({ username, per_page, page });
octokit.activity.listRepoEvents({ owner, repo, per_page, page });
octokit.activity.listRepoNotificationsForAuthenticatedUser({
owner,
repo,
all,
participating,
since,
before,
per_page,
page,
});
octokit.activity.listReposStarredByAuthenticatedUser({
sort,
direction,
per_page,
page,
});
octokit.activity.listReposStarredByUser({
username,
sort,
direction,
per_page,
page,
});
octokit.activity.listReposWatchedByUser({ username, per_page, page });
octokit.activity.listStargazersForRepo({ owner, repo, per_page, page });
octokit.activity.listWatchedReposForAuthenticatedUser({ per_page, page });
octokit.activity.listWatchersForRepo({ owner, repo, per_page, page });
octokit.activity.markNotificationsAsRead({ last_read_at, read });
octokit.activity.markRepoNotificationsAsRead({ owner, repo, last_read_at });
octokit.activity.markThreadAsDone({ thread_id });
octokit.activity.markThreadAsRead({ thread_id });
octokit.activity.setRepoSubscription({ owner, repo, subscribed, ignored });
octokit.activity.setThreadSubscription({ thread_id, ignored });
octokit.activity.starRepoForAuthenticatedUser({ owner, repo });
octokit.activity.unstarRepoForAuthenticatedUser({ owner, repo });
octokit.apps.addRepoToInstallation({ installation_id, repository_id });
octokit.apps.addRepoToInstallationForAuthenticatedUser({
installation_id,
repository_id,
});
octokit.apps.checkToken({ client_id, access_token });
octokit.apps.createFromManifest({ code });
octokit.apps.createInstallationAccessToken({
installation_id,
repositories,
repository_ids,
permissions,
});
octokit.apps.deleteAuthorization({ client_id, access_token });
octokit.apps.deleteInstallation({ installation_id });
octokit.apps.deleteToken({ client_id, access_token });
octokit.apps.getAuthenticated();
octokit.apps.getBySlug({ app_slug });
octokit.apps.getInstallation({ installation_id });
octokit.apps.getOrgInstallation({ org });
octokit.apps.getRepoInstallation({ owner, repo });
octokit.apps.getUserInstallation({ username });
octokit.apps.getWebhookConfigForApp();
octokit.apps.getWebhookDelivery({ delivery_id });
octokit.apps.listInstallationReposForAuthenticatedUser({
installation_id,
per_page,
page,
});
octokit.apps.listInstallationRequestsForAuthenticatedApp({ per_page, page });
octokit.apps.listInstallations({ per_page, page, since, outdated });
octokit.apps.listInstallationsForAuthenticatedUser({ per_page, page });
octokit.apps.listReposAccessibleToInstallation({ per_page, page });
octokit.apps.listWebhookDeliveries({ per_page, cursor });
octokit.apps.redeliverWebhookDelivery({ delivery_id });
octokit.apps.removeRepoFromInstallation({ installation_id, repository_id });
octokit.apps.removeRepoFromInstallationForAuthenticatedUser({
installation_id,
repository_id,
});
octokit.apps.resetToken({ client_id, access_token });
octokit.apps.revokeInstallationAccessToken();
octokit.apps.scopeToken({
client_id,
access_token,
target,
target_id,
repositories,
repository_ids,
permissions,
});
octokit.apps.suspendInstallation({ installation_id });
octokit.apps.unsuspendInstallation({ installation_id });
octokit.apps.updateWebhookConfigForApp({
url,
content_type,
secret,
insecure_ssl,
});
octokit.checks.create({
owner,
repo,
name,
head_sha,
details_url,
external_id,
status,
started_at,
conclusion,
completed_at,
output,
actions,
});
octokit.checks.createSuite({ owner, repo, head_sha });
octokit.checks.get({ owner, repo, check_run_id });
octokit.checks.getSuite({ owner, repo, check_suite_id });
octokit.checks.listAnnotations({ owner, repo, check_run_id, per_page, page });
octokit.checks.listForRef({
owner,
repo,
ref,
check_name,
status,
filter,
per_page,
page,
app_id,
});
octokit.checks.listForSuite({
owner,
repo,
check_suite_id,
check_name,
status,
filter,
per_page,
page,
});
octokit.checks.listSuitesForRef({
owner,
repo,
ref,
app_id,
check_name,
per_page,
page,
});
octokit.checks.rerequestRun({ owner, repo, check_run_id });
octokit.checks.rerequestSuite({ owner, repo, check_suite_id });
octokit.checks.setSuitesPreferences({ owner, repo, auto_trigger_checks });
octokit.checks.update({
owner,
repo,
check_run_id,
name,
details_url,
external_id,
started_at,
status,
conclusion,
completed_at,
output,
actions,
});
octokit.codeScanning.deleteAnalysis({
owner,
repo,
analysis_id,
confirm_delete,
});
octokit.codeScanning.getAlert({ owner, repo, alert_number });
octokit.codeScanning.getAnalysis({ owner, repo, analysis_id });
octokit.codeScanning.getDefaultSetup({ owner, repo });
octokit.codeScanning.getSarif({ owner, repo, sarif_id });
octokit.codeScanning.listAlertInstances({
owner,
repo,
alert_number,
page,
per_page,
ref,
});
octokit.codeScanning.listAlertsForOrg({
org,
tool_name,
tool_guid,
before,
after,
page,
per_page,
direction,
state,
sort,
severity,
});
octokit.codeScanning.listAlertsForRepo({
owner,
repo,
tool_name,
tool_guid,
page,
per_page,
ref,
direction,
sort,
state,
severity,
});
octokit.codeScanning.listAlertsInstances({
owner,
repo,
alert_number,
page,
per_page,
ref,
});
octokit.codeScanning.listRecentAnalyses({
owner,
repo,
tool_name,
tool_guid,
page,
per_page,
ref,
sarif_id,
direction,
sort,
});
octokit.codeScanning.updateAlert({
owner,
repo,
alert_number,
state,
dismissed_reason,
dismissed_comment,
});
octokit.codeScanning.updateDefaultSetup({
owner,
repo,
state,
query_suite,
languages,
});
octokit.codeScanning.uploadSarif({
owner,
repo,
commit_sha,
ref,
sarif,
checkout_uri,
started_at,
tool_name,
});
octokit.codeSecurity.attachConfiguration({
org,
configuration_id,
scope,
selected_repository_ids,
});
octokit.codeSecurity.createConfiguration({
org,
name,
description,
advanced_security,
dependency_graph,
dependabot_alerts,
dependabot_security_updates,
code_scanning_default_setup,
secret_scanning,
secret_scanning_push_protection,
secret_scanning_delegated_bypass,
secret_scanning_delegated_bypass_options,
secret_scanning_validity_checks,
secret_scanning_non_provider_patterns,
private_vulnerability_reporting,
enforcement,
});
octokit.codeSecurity.deleteConfiguration({ org, configuration_id });
octokit.codeSecurity.detachConfiguration({ org, selected_repository_ids });
octokit.codeSecurity.getConfiguration({ org, configuration_id });
octokit.codeSecurity.getConfigurationForRepository({ owner, repo });
octokit.codeSecurity.getConfigurationsForOrg({
org,
target_type,
per_page,
before,
after,
});
octokit.codeSecurity.getDefaultConfigurations({ org });
octokit.codeSecurity.getRepositoriesForConfiguration({
org,
configuration_id,
per_page,
before,
after,
status,
});
octokit.codeSecurity.setConfigurationAsDefault({
org,
configuration_id,
default_for_new_repos,
});
octokit.codeSecurity.updateConfiguration({
org,
configuration_id,
name,
description,
advanced_security,
dependency_graph,
dependabot_alerts,
dependabot_security_updates,
code_scanning_default_setup,
secret_scanning,
secret_scanning_push_protection,
secret_scanning_delegated_bypass,
secret_scanning_delegated_bypass_options,
secret_scanning_validity_checks,
secret_scanning_non_provider_patterns,
private_vulnerability_reporting,
enforcement,
});
octokit.codesOfConduct.getAllCodesOfConduct();
octokit.codesOfConduct.getConductCode({ key });
octokit.dependabot.addSelectedRepoToOrgSecret({
org,
secret_name,
repository_id,
});
octokit.dependabot.createOrUpdateOrgSecret({
org,
secret_name,
encrypted_value,
key_id,
visibility,
selected_repository_ids,
});
octokit.dependabot.createOrUpdateRepoSecret({
owner,
repo,
secret_name,
encrypted_value,
key_id,
});
octokit.dependabot.deleteOrgSecret({ org, secret_name });
octokit.dependabot.deleteRepoSecret({ owner, repo, secret_name });
octokit.dependabot.getAlert({ owner, repo, alert_number });
octokit.dependabot.getOrgPublicKey({ org });
octokit.dependabot.getOrgSecret({ org, secret_name });
octokit.dependabot.getRepoPublicKey({ owner, repo });
octokit.dependabot.getRepoSecret({ owner, repo, secret_name });
octokit.dependabot.listAlertsForEnterprise({
enterprise,
state,
severity,
ecosystem,
package,
scope,
sort,
direction,
before,
after,
first,
last,
per_page,
});
octokit.dependabot.listAlertsForOrg({
org,
state,
severity,
ecosystem,
package,
scope,
sort,
direction,
before,
after,
first,
last,
per_page,
});
octokit.dependabot.listAlertsForRepo({
owner,
repo,
state,
severity,
ecosystem,
package,
manifest,
scope,
sort,
direction,
page,
per_page,
before,
after,
first,
last,
});
octokit.dependabot.listOrgSecrets({ org, per_page, page });
octokit.dependabot.listRepoSecrets({ owner, repo, per_page, page });
octokit.dependabot.listSelectedReposForOrgSecret({
org,
secret_name,
page,
per_page,
});
octokit.dependabot.removeSelectedRepoFromOrgSecret({
org,
secret_name,
repository_id,
});
octokit.dependabot.setSelectedReposForOrgSecret({
org,
secret_name,
selected_repository_ids,
});
octokit.dependabot.updateAlert({
owner,
repo,
alert_number,
state,
dismissed_reason,
dismissed_comment,
});
octokit.dependencyGraph.createRepositorySnapshot({
owner,
repo,
version,
job,
sha,
ref,
detector,
metadata,
manifests,
scanned,
});
octokit.dependencyGraph.diffRange({ owner, repo, basehead, name });
octokit.dependencyGraph.exportSbom({ owner, repo });
octokit.emojis.get();
octokit.gists.checkIsStarred({ gist_id });
octokit.gists.create({ description, files, public });
octokit.gists.createComment({ gist_id, body });
octokit.gists.delete({ gist_id });
octokit.gists.deleteComment({ gist_id, comment_id });
octokit.gists.fork({ gist_id });
octokit.gists.get({ gist_id });
octokit.gists.getComment({ gist_id, comment_id });
octokit.gists.getRevision({ gist_id, sha });
octokit.gists.list({ since, per_page, page });
octokit.gists.listComments({ gist_id, per_page, page });
octokit.gists.listCommits({ gist_id, per_page, page });
octokit.gists.listForUser({ username, since, per_page, page });
octokit.gists.listForks({ gist_id, per_page, page });
octokit.gists.listPublic({ since, per_page, page });
octokit.gists.listStarred({ since, per_page, page });
octokit.gists.star({ gist_id });
octokit.gists.unstar({ gist_id });
octokit.gists.update({ gist_id, description, files });
octokit.gists.updateComment({ gist_id, comment_id, body });
octokit.git.createBlob({ owner, repo, content, encoding });
octokit.git.createCommit({
owner,
repo,
message,
tree,
parents,
author,
committer,
signature,
});
octokit.git.createRef({ owner, repo, ref, sha });
octokit.git.createTag({ owner, repo, tag, message, object, type, tagger });
octokit.git.createTree({ owner, repo, tree, base_tree });
octokit.git.deleteRef({ owner, repo, ref });
octokit.git.getBlob({ owner, repo, file_sha });
octokit.git.getCommit({ owner, repo, commit_sha });
octokit.git.getRef({ owner, repo, ref });
octokit.git.getTag({ owner, repo, tag_sha });
octokit.git.getTree({ owner, repo, tree_sha, recursive });
octokit.git.listMatchingRefs({ owner, repo, ref });
octokit.git.updateRef({ owner, repo, ref, sha, force });
octokit.gitignore.getAllTemplates();
octokit.gitignore.getTemplate({ name });
octokit.issues.addAssignees({ owner, repo, issue_number, assignees });
octokit.issues.addLabels({ owner, repo, issue_number, labels });
octokit.issues.checkUserCanBeAssigned({ owner, repo, assignee });
octokit.issues.checkUserCanBeAssignedToIssue({
owner,
repo,
issue_number,
assignee,
});
octokit.issues.create({
owner,
repo,
title,
body,
assignee,
milestone,
labels,
assignees,
});
octokit.issues.createComment({ owner, repo, issue_number, body });
octokit.issues.createLabel({ owner, repo, name, color, description });
octokit.issues.createMilestone({
owner,
repo,
title,
state,
description,
due_on,
});
octokit.issues.deleteComment({ owner, repo, comment_id });
octokit.issues.deleteLabel({ owner, repo, name });
octokit.issues.deleteMilestone({ owner, repo, milestone_number });
octokit.issues.get({ owner, repo, issue_number });
octokit.issues.getComment({ owner, repo, comment_id });
octokit.issues.getEvent({ owner, repo, event_id });
octokit.issues.getLabel({ owner, repo, name });
octokit.issues.getMilestone({ owner, repo, milestone_number });
octokit.issues.list({
filter,
state,
labels,
sort,
direction,
since,
collab,
orgs,
owned,
pulls,
per_page,
page,
});
octokit.issues.listAssignees({ owner, repo, per_page, page });
octokit.issues.listComments({
owner,
repo,
issue_number,
since,
per_page,
page,
});
octokit.issues.listCommentsForRepo({
owner,
repo,
sort,
direction,
since,
per_page,
page,
});
octokit.issues.listEvents({ owner, repo, issue_number, per_page, page });
octokit.issues.listEventsForRepo({ owner, repo, per_page, page });
octokit.issues.listEventsForTimeline({
owner,
repo,
issue_number,
per_page,
page,
});
octokit.issues.listForAuthenticatedUser({
filter,
state,
labels,
sort,
direction,
since,
per_page,
page,
});
octokit.issues.listForOrg({
org,
filter,
state,
labels,
sort,
direction,
since,
per_page,
page,
});
octokit.issues.listForRepo({
owner,
repo,
milestone,
state,
assignee,
creator,
mentioned,
labels,
sort,
direction,
since,
per_page,
page,
});
octokit.issues.listLabelsForMilestone({
owner,
repo,
milestone_number,
per_page,
page,
});
octokit.issues.listLabelsForRepo({ owner, repo, per_page, page });
octokit.issues.listLabelsOnIssue({ owner, repo, issue_number, per_page, page });
octokit.issues.listMilestones({
owner,
repo,
state,
sort,
direction,
per_page,
page,
});
octokit.issues.lock({ owner, repo, issue_number, lock_reason });
octokit.issues.removeAllLabels({ owner, repo, issue_number });
octokit.issues.removeAssignees({ owner, repo, issue_number, assignees });
octokit.issues.removeLabel({ owner, repo, issue_number, name });
octokit.issues.setLabels({ owner, repo, issue_number, labels });
octokit.issues.unlock({ owner, repo, issue_number });
octokit.issues.update({
owner,
repo,
issue_number,
title,
body,
assignee,
state,
state_reason,
milestone,
labels,
assignees,
});
octokit.issues.updateComment({ owner, repo, comment_id, body });
octokit.issues.updateLabel({ owner, repo, name, new_name, color, description });
octokit.issues.updateMilestone({
owner,
repo,
milestone_number,
title,
state,
description,
due_on,
});
octokit.licenses.get({ license });
octokit.licenses.getAllCommonlyUsed({ featured, per_page, page });
octokit.licenses.getForRepo({ owner, repo, ref });
octokit.markdown.render({ text, mode, context });
octokit.markdown.renderRaw({ data });
octokit.meta.get();
octokit.meta.getOctocat({ s });
octokit.meta.getZen();
octokit.meta.root();
octokit.migrations.deleteArchiveForOrg({ org, migration_id });
octokit.migrations.downloadArchiveForOrg({ org, migration_id });
octokit.migrations.getArchiveForAuthenticatedUser({ migration_id });
octokit.migrations.getStatusForOrg({ org, migration_id, exclude });
octokit.migrations.listForAuthenticatedUser({ per_page, page });
octokit.migrations.listForOrg({ org, per_page, page, exclude });
octokit.migrations.listReposForAuthenticatedUser({
migration_id,
per_page,
page,
});
octokit.migrations.listReposForOrg({ org, migration_id, per_page, page });
octokit.migrations.listReposForUser({ migration_id, per_page, page });
octokit.migrations.startForAuthenticatedUser({
lock_repositories,
exclude_metadata,
exclude_git_data,
exclude_attachments,
exclude_releases,
exclude_owner_projects,
org_metadata_only,
exclude,
repositories,
});
octokit.migrations.startForOrg({
org,
repositories,
lock_repositories,
exclude_metadata,
exclude_git_data,
exclude_attachments,
exclude_releases,
exclude_owner_projects,
org_metadata_only,
exclude,
});
octokit.migrations.unlockRepoForOrg({ org, migration_id, repo_name });
octokit.oidc.getOidcCustomSubTemplateForOrg({ org });
octokit.oidc.updateOidcCustomSubTemplateForOrg({ org, include_claim_keys });
octokit.orgs.addSecurityManagerTeam({ org, team_slug });
octokit.orgs.assignTeamToOrgRole({ org, team_slug, role_id });
octokit.orgs.assignUserToOrgRole({ org, username, role_id });
octokit.orgs.checkMembershipForUser({ org, username });
octokit.orgs.checkPublicMembershipForUser({ org, username });
octokit.orgs.convertMemberToOutsideCollaborator({ org, username, async });
octokit.orgs.createOrUpdateCustomProperties({ org, properties });
octokit.orgs.createOrUpdateCustomPropertiesValuesForRepos({
org,
repository_names,
properties,
});
octokit.orgs.createOrUpdateCustomProperty({
org,
custom_property_name,
value_type,
required,
default_value,
description,
allowed_values,
});
octokit.orgs.createWebhook({ org, name, config, events, active });
octokit.orgs.delete({ org });
octokit.orgs.deleteWebhook({ org, hook_id });
octokit.orgs.enableOrDisableSecurityProductOnAllOrgRepos({
org,
security_product,
enablement,
query_suite,
});
octokit.orgs.get({ org });
octokit.orgs.getAllCustomProperties({ org });
octokit.orgs.getCustomProperty({ org, custom_property_name });
octokit.orgs.getMembershipForAuthenticatedUser({ org });
octokit.orgs.getMembershipForUser({ org, username });
octokit.orgs.getOrgRole({ org, role_id });
octokit.orgs.getWebhook({ org, hook_id });
octokit.orgs.getWebhookConfigForOrg({ org, hook_id });
octokit.orgs.getWebhookDelivery({ org, hook_id, delivery_id });
octokit.orgs.list({ since, per_page });
octokit.orgs.listAppInstallations({ org, per_page, page });
octokit.orgs.listCustomPropertiesValuesForRepos({
org,
per_page,
page,
repository_query,
});
octokit.orgs.listForAuthenticatedUser({ per_page, page });
octokit.orgs.listForUser({ username, per_page, page });
octokit.orgs.listMembers({ org, filter, role, per_page, page });
octokit.orgs.listMembershipsForAuthenticatedUser({ state, per_page, page });
octokit.orgs.listOrgRoleTeams({ org, role_id, per_page, page });
octokit.orgs.listOrgRoleUsers({ org, role_id, per_page, page });
octokit.orgs.listOrgRoles({ org });
octokit.orgs.listOrganizationFineGrainedPermissions({ org });
octokit.orgs.listOutsideCollaborators({ org, filter, per_page, page });
octokit.orgs.listPatGrantRepositories({ org, pat_id, per_page, page });
octokit.orgs.listPatGrantRequestRepositories({
org,
pat_request_id,
per_page,
page,
});
octokit.orgs.listPatGrantRequests({
org,
per_page,
page,
sort,
direction,
owner,
repository,
permission,
last_used_before,
last_used_after,
});
octokit.orgs.listPatGrants({
org,
per_page,
page,
sort,
direction,
owner,
repository,
permission,
last_used_before,
last_used_after,
});
octokit.orgs.listPublicMembers({ org, per_page, page });
octokit.orgs.listSecurityManagerTeams({ org });
octokit.orgs.listWebhookDeliveries({ org, hook_id, per_page, cursor });
octokit.orgs.listWebhooks({ org, per_page, page });
octokit.orgs.pingWebhook({ org, hook_id });
octokit.orgs.redeliverWebhookDelivery({ org, hook_id, delivery_id });
octokit.orgs.removeCustomProperty({ org, custom_property_name });
octokit.orgs.removeMember({ org, username });
octokit.orgs.removeMembershipForUser({ org, username });
octokit.orgs.removeOutsideCollaborator({ org, username });
octokit.orgs.removePublicMembershipForAuthenticatedUser({ org, username });
octokit.orgs.removeSecurityManagerTeam({ org, team_slug });
octokit.orgs.reviewPatGrantRequest({ org, pat_request_id, action, reason });
octokit.orgs.reviewPatGrantRequestsInBulk({
org,
pat_request_ids,
action,
reason,
});
octokit.orgs.revokeAllOrgRolesTeam({ org, team_slug });
octokit.orgs.revokeAllOrgRolesUser({ org, username });
octokit.orgs.revokeOrgRoleTeam({ org, team_slug, role_id });
octokit.orgs.revokeOrgRoleUser({ org, username, role_id });
octokit.orgs.setMembershipForUser({ org, username, role });
octokit.orgs.setPublicMembershipForAuthenticatedUser({ org, username });
octokit.orgs.update({
org,
billing_email,
company,
email,
twitter_username,
location,
name,
description,
has_organization_projects,
has_repository_projects,
default_repository_permission,
members_can_create_repositories,
members_can_create_internal_repositories,
members_can_create_private_repositories,
members_can_create_public_repositories,
members_allowed_repository_creation_type,
members_can_create_pages,
members_can_fork_private_repositories,
web_commit_signoff_required,
blog,
advanced_security_enabled_for_new_repositories,
dependabot_alerts_enabled_for_new_repositories,
dependabot_security_updates_enabled_for_new_repositories,
dependency_graph_enabled_for_new_repositories,
secret_scanning_enabled_for_new_repositories,
secret_scanning_push_protection_enabled_for_new_repositories,
secret_scanning_push_protection_custom_link_enabled,
secret_scanning_push_protection_custom_link,
});
octokit.orgs.updateMembershipForAuthenticatedUser({ org, state });
octokit.orgs.updatePatAccess({ org, pat_id, action });
octokit.orgs.updatePatAccesses({ org, action, pat_ids });
octokit.orgs.updateWebhook({ org, hook_id, config, events, active, name });
octokit.orgs.updateWebhookConfigForOrg({
org,
hook_id,
url,
content_type,
secret,
insecure_ssl,
});
octokit.packages.deletePackageForAuthenticatedUser({
package_type,
package_name,
});
octokit.packages.deletePackageForOrg({ package_type, package_name, org });
octokit.packages.deletePackageForUser({ package_type, package_name, username });
octokit.packages.deletePackageVersionForAuthenticatedUser({
package_type,
package_name,
package_version_id,
});
octokit.packages.deletePackageVersionForOrg({
package_type,
package_name,
org,
package_version_id,
});
octokit.packages.deletePackageVersionForUser({
package_type,
package_name,
username,
package_version_id,
});
octokit.packages.getAllPackageVersionsForAPackageOwnedByAnOrg({
package_type,
package_name,
org,
page,
per_page,
state,
});
octokit.packages.getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser({
package_type,
package_name,
page,
per_page,
state,
});
octokit.packages.getAllPackageVersionsForPackageOwnedByAuthenticatedUser({
package_type,
package_name,
page,
per_page,
state,
});
octokit.packages.getAllPackageVersionsForPackageOwnedByOrg({
package_type,
package_name,
org,
page,
per_page,
state,
});
octokit.packages.getAllPackageVersionsForPackageOwnedByUser({
package_type,
package_name,
username,
});
octokit.packages.getPackageForAuthenticatedUser({ package_type, package_name });
octokit.packages.getPackageForOrganization({ package_type, package_name, org });
octokit.packages.getPackageForUser({ package_type, package_name, username });
octokit.packages.getPackageVersionForAuthenticatedUser({
package_type,
package_name,
package_version_id,
});
octokit.packages.getPackageVersionForOrganization({
package_type,
package_name,
org,
package_version_id,
});
octokit.packages.getPackageVersionForUser({
package_type,
package_name,
package_version_id,
username,
});
octokit.packages.listDockerMigrationConflictingPackagesForAuthenticatedUser();
octokit.packages.listDockerMigrationConflictingPackagesForOrganization({ org });
octokit.packages.listDockerMigrationConflictingPackagesForUser({ username });
octokit.packages.listPackagesForAuthenticatedUser({
package_type,
visibility,
page,
per_page,
});
octokit.packages.listPackagesForOrganization({
package_type,
org,
visibility,
page,
per_page,
});
octokit.packages.listPackagesForUser({
package_type,
visibility,
username,
page,
per_page,
});
octokit.packages.restorePackageForAuthenticatedUser({
package_type,
package_name,
token,
});
octokit.packages.restorePackageForOrg({
package_type,
package_name,
org,
token,
});
octokit.packages.restorePackageForUser({
package_type,
package_name,
username,
token,
});
octokit.packages.restorePackageVersionForAuthenticatedUser({
package_type,
package_name,
package_version_id,
});
octokit.packages.restorePackageVersionForOrg({
package_type,
package_name,
org,
package_version_id,
});
octokit.packages.restorePackageVersionForUser({
package_type,
package_name,
username,
package_version_id,
});
octokit.projects.addCollaborator({ project_id, username, permission });
octokit.projects.createCard({ column_id, note, content_id, content_type });
octokit.projects.createColumn({ project_id, name });
octokit.projects.createForAuthenticatedUser({ name, body });
octokit.projects.createForOrg({ org, name, body });
octokit.projects.createForRepo({ owner, repo, name, body });
octokit.projects.delete({ project_id });
octokit.projects.deleteCard({ card_id });
octokit.projects.deleteColumn({ column_id });
octokit.projects.get({ project_id });
octokit.projects.getCard({ card_id });
octokit.projects.getColumn({ column_id });
octokit.projects.getPermissionForUser({ project_id, username });
octokit.projects.listCards({ column_id, archived_state, per_page, page });
octokit.projects.listCollaborators({ project_id, affiliation, per_page, page });
octokit.projects.listColumns({ project_id, per_page, page });
octokit.projects.listForOrg({ org, state, per_page, page });
octokit.projects.listForRepo({ owner, repo, state, per_page, page });
octokit.projects.listForUser({ username, state, per_page, page });
octokit.projects.moveCard({ card_id, position, column_id });
octokit.projects.moveColumn({ column_id, position });
octokit.projects.removeCollaborator({ project_id, username });
octokit.projects.update({
project_id,
name,
body,
state,
organization_permission,
private,
});
octokit.projects.updateCard({ card_id, note, archived });
octokit.projects.updateColumn({ column_id, name });
octokit.pulls.checkIfMerged({ owner, repo, pull_number });
octokit.pulls.create({
owner,
repo,
title,
head,
head_repo,
base,
body,
maintainer_can_modify,
draft,
issue,
});
octokit.pulls.createReplyForReviewComment({
owner,
repo,
pull_number,
comment_id,
body,
});
octokit.pulls.createReview({
owner,
repo,
pull_number,
commit_id,
body,
event,
comments,
});
octokit.pulls.createReviewComment({
owner,
repo,
pull_number,
body,
commit_id,
path,
position,
side,
line,
start_line,
start_side,
in_reply_to,
subject_type,
});
octokit.pulls.deletePendingReview({ owner, repo, pull_number, review_id });
octokit.pulls.deleteReviewComment({ owner, repo, comment_id });
octokit.pulls.dismissReview({
owner,
repo,
pull_number,
review_id,
message,
event,
});
octokit.pulls.get({ owner, repo, pull_number });
octokit.pulls.getReview({ owner, repo, pull_number, review_id });
octokit.pulls.getReviewComment({ owner, repo, comment_id });
octokit.pulls.list({
owner,
repo,
state,
head,
base,
sort,
direction,
per_page,
page,
});
octokit.pulls.listCommentsForReview({
owner,
repo,
pull_number,
review_id,
per_page,
page,
});
octokit.pulls.listCommits({ owner, repo, pull_number, per_page, page });
octokit.pulls.listFiles({ owner, repo, pull_number, per_page, page });
octokit.pulls.listRequestedReviewers({ owner, repo, pull_number });
octokit.pulls.listReviewComments({
owner,
repo,
pull_number,
sort,
direction,
since,
per_page,
page,
});
octokit.pulls.listReviewCommentsForRepo({
owner,
repo,
sort,
direction,
since,
per_page,
page,
});
octokit.pulls.listReviews({ owner, repo, pull_number, per_page, page });
octokit.pulls.merge({
owner,
repo,
pull_number,
commit_title,
commit_message,
sha,
merge_method,
});
octokit.pulls.removeRequestedReviewers({
owner,
repo,
pull_number,
reviewers,
team_reviewers,
});
octokit.pulls.requestReviewers({
owner,
repo,
pull_number,
reviewers,
team_reviewers,
});
octokit.pulls.submitReview({
owner,
repo,
pull_number,
review_id,
body,
event,
});
octokit.pulls.update({
owner,
repo,
pull_number,
title,
body,
state,
base,
maintainer_can_modify,
});
octokit.pulls.updateBranch({ owner, repo, pull_number, expected_head_sha });
octokit.pulls.updateReview({ owner, repo, pull_number, review_id, body });
octokit.pulls.updateReviewComment({ owner, repo, comment_id, body });
octokit.rateLimit.get();
octokit.reactions.createForCommitComment({ owner, repo, comment_id, content });
octokit.reactions.createForIssue({ owner, repo, issue_number, content });
octokit.reactions.createForIssueComment({ owner, repo, comment_id, content });
octokit.reactions.createForPullRequestReviewComment({
owner,
repo,
comment_id,
content,
});
octokit.reactions.createForRelease({ owner, repo, release_id, content });
octokit.reactions.createForTeamDiscussionCommentInOrg({
org,
team_slug,
discussion_number,
comment_number,
content,
});
octokit.reactions.createForTeamDiscussionCommentLegacy({
team_id,
discussion_number,
comment_number,
content,
});
octokit.reactions.createForTeamDiscussionInOrg({
org,
team_slug,
discussion_number,
content,
});
octokit.reactions.createForTeamDiscussionLegacy({
team_id,
discussion_number,
content,
});
octokit.reactions.deleteForCommitComment({
owner,
repo,
comment_id,
reaction_id,
});
octokit.reactions.deleteForIssue({ owner, repo, issue_number, reaction_id });
octokit.reactions.deleteForIssueComment({
owner,
repo,
comment_id,
reaction_id,
});
octokit.reactions.deleteForPullRequestComment({
owner,
repo,
comment_id,
reaction_id,
});
octokit.reactions.deleteForRelease({ owner, repo, release_id, reaction_id });
octokit.reactions.deleteForTeamDiscussion({
org,
team_slug,
discussion_number,
reaction_id,
});
octokit.reactions.deleteForTeamDiscussionComment({
org,
team_slug,
discussion_number,
comment_number,
reaction_id,
});
octokit.reactions.listForCommitComment({
owner,
repo,
comment_id,
content,
per_page,
page,
});
octokit.reactions.listForIssue({
owner,
repo,
issue_number,
content,
per_page,
page,
});
octokit.reactions.listForIssueComment({
owner,
repo,
comment_id,
content,
per_page,
page,
});
octokit.reactions.listForPullRequestReviewComment({
owner,
repo,
comment_id,
content,
per_page,
page,
});
octokit.reactions.listForRelease({
owner,
repo,
release_id,
content,
per_page,
page,
});
octokit.reactions.listForTeamDiscussionCommentInOrg({
org,
team_slug,
discussion_number,
comment_number,
content,
per_page,
page,
});
octokit.reactions.listForTeamDiscussionCommentLegacy({
team_id,
discussion_number,
comment_number,
content,
per_page,
page,
});
octokit.reactions.listForTeamDiscussionInOrg({
org,
team_slug,
discussion_number,
content,
per_page,
page,
});
octokit.reactions.listForTeamDiscussionLegacy({
team_id,
discussion_number,
content,
per_page,
page,
});
octokit.repos.acceptInvitation({ invitation_id });
octokit.repos.acceptInvitationForAuthenticatedUser({ invitation_id });
octokit.repos.addAppAccessRestrictions({ owner, repo, branch, apps });
octokit.repos.addCollaborator({ owner, repo, username, permission });
octokit.repos.addStatusCheckContexts({ owner, repo, branch, contexts });
octokit.repos.addTeamAccessRestrictions({ owner, repo, branch, teams });
octokit.repos.addUserAccessRestrictions({ owner, repo, branch, users });
octokit.repos.cancelPagesDeployment({ owner, repo, pages_deployment_id });
octokit.repos.checkAutomatedSecurityFixes({ owner, repo });
octokit.repos.checkCollaborator({ owner, repo, username });
octokit.repos.checkVulnerabilityAlerts({ owner, repo });
octokit.repos.codeownersErrors({ owner, repo, ref });
octokit.repos.compareCommits({ owner, repo, base, head, per_page, page });
octokit.repos.compareCommitsWithBasehead({
owner,
repo,
page,
per_page,
basehead,
});
octokit.repos.createAutolink({
owner,
repo,
key_prefix,
url_template,
is_alphanumeric,
});
octokit.repos.createCommitComment({
owner,
repo,
commit_sha,
body,
path,
position,
line,
});
octokit.repos.createCommitSignatureProtection({ owner, repo, branch });
octokit.repos.createCommitStatus({
owner,
repo,
sha,
state,
target_url,
description,
context,
});
octokit.repos.createDeployKey({ owner, repo, title, key, read_only });
octokit.repos.createDeployment({
owner,
repo,
ref,
task,
auto_merge,
required_contexts,
payload,
environment,
description,
transient_environment,
production_environment,
});
octokit.repos.createDeploymentBranchPolicy({
owner,
repo,
environment_name,
name,
type,
});
octokit.repos.createDeploymentProtectionRule({
environment_name,
repo,
owner,
integration_id,
});
octokit.repos.createDeploymentStatus({
owner,
repo,
deployment_id,
state,
target_url,
log_url,
description,
environment,
environment_url,
auto_inactive,
});
octokit.repos.createDispatchEvent({ owner, repo, event_type, client_payload });
octokit.repos.createForAuthenticatedUser({
name,
description,
homepage,
private,
has_issues,
has_projects,
has_wiki,
has_discussions,
team_id,
auto_init,
gitignore_template,
license_template,
allow_squash_merge,
allow_merge_commit,
allow_rebase_merge,
allow_auto_merge,
delete_branch_on_merge,
squash_merge_commit_title,
squash_merge_commit_message,
merge_commit_title,
merge_commit_message,
has_downloads,
is_template,
});
octokit.repos.createFork({
owner,
repo,
organization,
name,
default_branch_only,
});
octokit.repos.createInOrg({
org,
name,
description,
homepage,
private,
visibility,
has_issues,
has_projects,
has_wiki,
has_downloads,
is_template,
team_id,
auto_init,
gitignore_template,
license_template,
allow_squash_merge,
allow_merge_commit,
allow_rebase_merge,
allow_auto_merge,
delete_branch_on_merge,
use_squash_pr_title_as_default,
squash_merge_commit_title,
squash_merge_commit_message,
merge_commit_title,
merge_commit_message,
custom_properties,
});
octokit.repos.createOrUpdateCustomPropertiesValues({ owner, repo, properties });
octokit.repos.createOrUpdateEnvironment({
owner,
repo,
environment_name,
wait_timer,
prevent_self_review,
reviewers,
deployment_branch_policy,
});
octokit.repos.createOrUpdateFileContents({
owner,
repo,
path,
message,
content,
sha,
branch,
committer,
author,
});
octokit.repos.createOrgRuleset({
org,
name,
target,
enforcement,
bypass_actors,
conditions,
rules,
source_type,
});
octokit.repos.createPagesDeployment({
owner,
repo,
artifact_url,
environment,
pages_build_version,
oidc_token,
});
octokit.repos.createPagesSite({ owner, repo, build_type, source });
octokit.repos.createRelease({
owner,
repo,
tag_name,
target_commitish,
name,
body,
draft,
prerelease,
generate_release_notes,
make_latest,
});
octokit.repos.createRepoRuleset({
owner,
repo,
name,
target,
enforcement,
bypass_actors,
conditions,
rules,
});
octokit.repos.createTagProtection({ owner, repo, pattern });
octokit.repos.createUsingTemplate({
template_owner,
template_repo,
owner,
name,
description,
include_all_branches,
private,
});
octokit.repos.createWebhook({ owner, repo, name, config, events, active });
octokit.repos.declineInvitation({ invitation_id });
octokit.repos.declineInvitationForAuthenticatedUser({ invitation_id });
octokit.repos.delete({ owner, repo });
octokit.repos.deleteAccessRestrictions({ owner, repo, branch });
octokit.repos.deleteAdminBranchProtection({ owner, repo, branch });
octokit.repos.deleteAnEnvironment({ owner, repo, environment_name });
octokit.repos.deleteAutolink({ owner, repo, autolink_id });
octokit.repos.deleteBranchProtection({ owner, repo, branch });
octokit.repos.deleteCommitComment({ owner, repo, comment_id });
octokit.repos.deleteCommitSignatureProtection({ owner, repo, branch });
octokit.repos.deleteDeployKey({ owner, repo, key_id });
octokit.repos.deleteDeployment({ owner, repo, deployment_id });
octokit.repos.deleteDeploymentBranchPolicy({
owner,
repo,
environment_name,
branch_policy_id,
});
octokit.repos.deleteFile({
owner,
repo,
path,
message,
sha,
branch,
committer,
author,
});
octokit.repos.deleteInvitation({ owner, repo, invitation_id });
octokit.repos.deleteOrgRuleset({ org, ruleset_id });
octokit.repos.deletePagesSite({ owner, repo });
octokit.repos.deletePullRequestReviewProtection({ owner, repo, branch });
octokit.repos.deleteRelease({ owner, repo, release_id });
octokit.repos.deleteReleaseAsset({ owner, repo, asset_id });
octokit.repos.deleteRepoRuleset({ owner, repo, ruleset_id });
octokit.repos.deleteTagProtection({ owner, repo, tag_protection_id });
octokit.repos.deleteWebhook({ owner, repo, hook_id });
octokit.repos.disableDeploymentProtectionRule({
environment_name,
repo,
owner,
protection_rule_id,
});
octokit.repos.disableVulnerabilityAlerts({ owner, repo });
octokit.repos.downloadTarballArchive({ owner, repo, ref });
octokit.repos.downloadZipballArchive({ owner, repo, ref });
octokit.repos.enableVulnerabilityAlerts({ owner, repo });
octokit.repos.generateReleaseNotes({
owner,
repo,
tag_name,
target_commitish,
previous_tag_name,
configuration_file_path,
});
octokit.repos.get({ owner, repo });
octokit.repos.getAccessRestrictions({ owner, repo, branch });
octokit.repos.getAdminBranchProtection({ owner, repo, branch });
octokit.repos.getAllDeploymentProtectionRules({
environment_name,
repo,
owner,
});
octokit.repos.getAllEnvironments({ owner, repo, per_page, page });
octokit.repos.getAllStatusCheckContexts({ owner, repo, branch });
octokit.repos.getAllTopics({ owner, repo, page, per_page });
octokit.repos.getAppsWithAccessToProtectedBranch({ owner, repo, branch });
octokit.repos.getAutolink({ owner, repo, autolink_id });
octokit.repos.getBranch({ owner, repo, branch });
octokit.repos.getBranchProtection({ owner, repo, branch });
octokit.repos.getBranchRules({ owner, repo, branch, per_page, page });
octokit.repos.getCodeFrequencyStats({ owner, repo });
octokit.repos.getCollaboratorPermissionLevel({ owner, repo, username });
octokit.repos.getCombinedStatusForRef({ owner, repo, ref, per_page, page });
octokit.repos.getCommit({ owner, repo, page, per_page, ref });
octokit.repos.getCommitActivityStats({ owner, repo });
octokit.repos.getCommitComment({ owner, repo, comment_id });
octokit.repos.getCommitSignatureProtection({ owner, repo, branch });
octokit.repos.getContent({ owner, repo, path, ref });
octokit.repos.getContributorsStats({ owner, repo });
octokit.repos.getCustomDeploymentProtectionRule({
owner,
repo,
environment_name,
protection_rule_id,
});
octokit.repos.getCustomPropertiesValues({ owner, repo });
octokit.repos.getDeployKey({ owner, repo, key_id });
octokit.repos.getDeployment({ owner, repo, deployment_id });
octokit.repos.getDeploymentBranchPolicy({
owner,
repo,
environment_name,
branch_policy_id,
});
octokit.repos.getDeploymentStatus({ owner, repo, deployment_id, status_id });
octokit.repos.getEnvironment({ owner, repo, environment_name });
octokit.repos.getLatestPagesBuild({ owner, repo });
octokit.repos.getLatestRelease({ owner, repo });
octokit.repos.getOrgRuleSuite({ org, rule_suite_id });
octokit.repos.getOrgRuleSuites({
org,
ref,
repository_name,
time_period,
actor_name,
rule_suite_result,
per_page,
page,
});
octokit.repos.getOrgRuleset({ org, ruleset_id });
octokit.repos.getOrgRulesets({ org, per_page, page, targets });
octokit.repos.getPages({ owner, repo });
octokit.repos.getPagesBuild({ owner, repo, build_id });
octokit.repos.getPagesDeployment({ owner, repo, pages_deployment_id });
octokit.repos.getParticipationStats({ owner, repo });
octokit.repos.getPullRequestReviewProtection({ owner, repo, branch });
octokit.repos.getPunchCardStats({ owner, repo });
octokit.repos.getReadme({ owner, repo, ref });
octokit.repos.getReadmeInDirectory({ owner, repo, dir, ref });
octokit.repos.getRelease({ owner, repo, release_id });
octokit.repos.getReleaseAsset({ owner, repo, asset_id });
octokit.repos.getReleaseByTag({ owner, repo, tag });
octokit.repos.getRepoRuleSuite({ owner, repo, rule_suite_id });
octokit.repos.getRepoRuleSuites({
owner,
repo,
ref,
time_period,
actor_name,
rule_suite_result,
per_page,
page,
});
octokit.repos.getRepoRuleset({ owner, repo, ruleset_id, includes_parents });
octokit.repos.getRepoRulesets({
owner,
repo,
per_page,
page,
includes_parents,
targets,
});
octokit.repos.getStatusChecksProtection({ owner, repo, branch });
octokit.repos.getTeamsWithAccessToProtectedBranch({ owner, repo, branch });
octokit.repos.getUsersWithAccessToProtectedBranch({ owner, repo, branch });
octokit.repos.getWebhook({ owner, repo, hook_id });
octokit.repos.getWebhookConfigForRepo({ owner, repo, hook_id });
octokit.repos.getWebhookDelivery({ owner, repo, hook_id, delivery_id });
octokit.repos.listActivities({
owner,
repo,
direction,
per_page,
before,
after,
ref,
actor,
time_period,
activity_type,
});
octokit.repos.listAutolinks({ owner, repo });
octokit.repos.listBranches({ owner, repo, protected, per_page, page });
octokit.repos.listBranchesForHeadCommit({ owner, repo, commit_sha });
octokit.repos.listCacheInfo({ owner, repo, per_page, page });
octokit.repos.listCollaborators({
owner,
repo,
affiliation,
permission,
per_page,
page,
});
octokit.repos.listCommentsForCommit({
owner,
repo,
commit_sha,
per_page,
page,
});
octokit.repos.listCommitCommentsForRepo({ owner, repo, per_page, page });
octokit.repos.listCommitStatusesForRef({ owner, repo, ref, per_page, page });
octokit.repos.listCommits({
owner,
repo,
sha,
path,
author,
committer,
since,
until,
per_page,
page,
});
octokit.repos.listContributors({ owner, repo, anon, per_page, page });
octokit.repos.listCustomDeploymentRuleIntegrations({
environment_name,
repo,
owner,
page,
per_page,
});
octokit.repos.listDeployKeys({ owner, repo, per_page, page });
octokit.repos.listDeploymentBranchPolicies({
owner,
repo,
environment_name,
per_page,
page,
});
octokit.repos.listDeploymentStatuses({
owner,
repo,
deployment_id,
per_page,
page,
});
octokit.repos.listDeployments({
owner,
repo,
sha,
ref,
task,
environment,
per_page,
page,
});
octokit.repos.listForAuthenticatedUser({
visibility,
affiliation,
type,
sort,
direction,
per_page,
page,
since,
before,
});
octokit.repos.listForOrg({ org, type, sort, direction, per_page, page });
octokit.repos.listForUser({ username, type, sort, direction, per_page, page });
octokit.repos.listForks({ owner, repo, sort, per_page, page });
octokit.repos.listInvitations({ owner, repo, per_page, page });
octokit.repos.listInvitationsForAuthenticatedUser({ per_page, page });
octokit.repos.listLanguages({ owner, repo });
octokit.repos.listPagesBuilds({ owner, repo, per_page, page });
octokit.repos.listPublic({ since, visibility });
octokit.repos.listPullRequestsAssociatedWithCommit({
owner,
repo,
commit_sha,
per_page,
page,
});
octokit.repos.listReleaseAssets({ owner, repo, release_id, per_page, page });
octokit.repos.listReleases({ owner, repo, per_page, page });
octokit.repos.listTagProtection({ owner, repo });
octokit.repos.listTags({ owner, repo, per_page, page });
octokit.repos.listTeams({ owner, repo, per_page, page });
octokit.repos.listWebhookDeliveries({ owner, repo, hook_id, per_page, cursor });
octokit.repos.listWebhooks({ owner, repo, per_page, page });
octokit.repos.merge({ owner, repo, base, head, commit_message });
octokit.repos.mergeUpstream({ owner, repo, branch });
octokit.repos.pingWebhook({ owner, repo, hook_id });
octokit.repos.redeliverWebhookDelivery({ owner, repo, hook_id, delivery_id });
octokit.repos.removeAppAccessRestrictions({ owner, repo, branch, apps });
octokit.repos.removeCollaborator({ owner, repo, username });
octokit.repos.removeStatusCheckContexts({ owner, repo, branch, contexts });
octokit.repos.removeStatusCheckProtection({ owner, repo, branch });
octokit.repos.removeTeamAccessRestrictions({ owner, repo, branch, teams });
octokit.repos.removeUserAccessRestrictions({ owner, repo, branch, users });
octokit.repos.renameBranch({ owner, repo, branch, new_name });
octokit.repos.replaceAllTopics({ owner, repo, names });
octokit.repos.requestPagesBuild({ owner, repo });
octokit.repos.setAdminBranchProtection({ owner, repo, branch });
octokit.repos.setAppAccessRestrictions({ owner, repo, branch, apps });
octokit.repos.setStatusCheckContexts({ owner, repo, branch, contexts });
octokit.repos.setTeamAccessRestrictions({ owner, repo, branch, teams });
octokit.repos.setUserAccessRestrictions({ owner, repo, branch, users });
octokit.repos.testPushWebhook({ owner, repo, hook_id });
octokit.repos.transfer({ owner, repo, new_owner, new_name, team_ids });
octokit.repos.update({
owner,
repo,
name,
description,
homepage,
private,
visibility,
security_and_analysis,
has_issues,
has_projects,
has_wiki,
is_template,
default_branch,
allow_squash_merge,
allow_merge_commit,
allow_rebase_merge,
delete_branch_on_merge,
allow_update_branch,
use_squash_pr_title_as_default,
squash_merge_commit_title,
squash_merge_commit_message,
merge_commit_title,
merge_commit_message,
archived,
allow_forking,
web_commit_signoff_required,
});
octokit.repos.updateBranchProtection({
owner,
repo,
branch,
required_status_checks,
enforce_admins,
required_pull_request_reviews,
restrictions,
required_linear_history,
allow_force_pushes,
allow_deletions,
block_creations,
required_conversation_resolution,
lock_branch,
allow_fork_syncing,
});
octokit.repos.updateCommitComment({ owner, repo, comment_id, body });
octokit.repos.updateDeploymentBranchPolicy({
owner,
repo,
environment_name,
branch_policy_id,
name,
});
octokit.repos.updateInformationAboutPagesSite({
owner,
repo,
cname,
https_enforced,
build_type,
source,
});
octokit.repos.updateInvitation({ owner, repo, invitation_id, permissions });
octokit.repos.updateOrgRuleset({
org,
ruleset_id,
name,
target,
enforcement,
bypass_actors,
conditions,
rules,
});
octokit.repos.updatePullRequestReviewProtection({
owner,
repo,
branch,
dismissal_restrictions,
dismiss_stale_reviews,
require_code_owner_reviews,
required_approving_review_count,
require_last_push_approval,
bypass_pull_request_allowances,
});
octokit.repos.updateRelease({
owner,
repo,
release_id,
tag_name,
target_commitish,
name,
body,
draft,
prerelease,
make_latest,
});
octokit.repos.updateReleaseAsset({ owner, repo, asset_id, name, label, state });
octokit.repos.updateRepoRuleset({
owner,
repo,
ruleset_id,
name,
target,
enforcement,
bypass_actors,
conditions,
rules,
});
octokit.repos.updateStatusCheckProtection({
owner,
repo,
branch,
strict,
contexts,
checks,
});
octokit.repos.updateWebhook({
owner,
repo,
hook_id,
config,
events,
add_events,
remove_events,
active,
});
octokit.repos.updateWebhookConfigForRepo({
owner,
repo,
hook_id,
url,
content_type,
secret,
insecure_ssl,
});
octokit.repos.uploadReleaseAsset({
owner,
repo,
release_id,
name,
label,
data,
origin,
});
octokit.search.code({ q, sort, order, per_page, page });
octokit.search.commits({ q, sort, order, per_page, page });
octokit.search.issuesAndPullRequests({ q, sort, order, per_page, page });
octokit.search.labels({ repository_id, q, sort, order, per_page, page });
octokit.search.repos({ q, sort, order, per_page, page });
octokit.search.topics({ q, per_page, page });
octokit.search.users({ q, sort, order, per_page, page });
octokit.secretScanning.createPushProtectionBypass({
owner,
repo,
reason,
placeholder_id,
});
octokit.secretScanning.getAlert({ owner, repo, alert_number });
octokit.secretScanning.listAlertsForEnterprise({
enterprise,
state,
secret_type,
resolution,
sort,
direction,
per_page,
before,
after,
validity,
});
octokit.secretScanning.listAlertsForOrg({
org,
state,
secret_type,
resolution,
sort,
direction,
page,
per_page,
before,
after,
validity,
});
octokit.secretScanning.listAlertsForRepo({
owner,
repo,
state,
secret_type,
resolution,
sort,
direction,
page,
per_page,
before,
after,
validity,
});
octokit.secretScanning.listLocationsForAlert({
owner,
repo,
alert_number,
page,
per_page,
});
octokit.secretScanning.updateAlert({
owner,
repo,
alert_number,
state,
resolution,
resolution_comment,
});
octokit.securityAdvisories.getGlobalAdvisory({ ghsa_id });
octokit.securityAdvisories.listGlobalAdvisories({
ghsa_id,
type,
cve_id,
ecosystem,
severity,
cwes,
is_withdrawn,
affects,
published,
updated,
modified,
epss_percentage,
epss_percentile,
before,
after,
direction,
per_page,
sort,
});
octokit.teams.addMemberLegacy({ team_id, username });
octokit.teams.addOrUpdateMembershipForUserInOrg({
org,
team_slug,
username,
role,
});
octokit.teams.addOrUpdateMembershipForUserLegacy({ team_id, username, role });
octokit.teams.addOrUpdateProjectPermissionsInOrg({
org,
team_slug,
project_id,
permission,
});
octokit.teams.addOrUpdateProjectPermissionsLegacy({
team_id,
project_id,
permission,
});
octokit.teams.addOrUpdateRepoPermissionsInOrg({
org,
team_slug,
owner,
repo,
permission,
});
octokit.teams.addOrUpdateRepoPermissionsLegacy({
team_id,
owner,
repo,
permission,
});
octokit.teams.checkPermissionsForProjectInOrg({ org, team_slug, project_id });
octokit.teams.checkPermissionsForProjectLegacy({ team_id, project_id });
octokit.teams.checkPermissionsForRepoInOrg({ org, team_slug, owner, repo });
octokit.teams.checkPermissionsForRepoLegacy({ team_id, owner, repo });
octokit.teams.create({
org,
name,
description,
maintainers,
repo_names,
privacy,
notification_setting,
permission,
parent_team_id,
ldap_dn,
});
octokit.teams.createDiscussionCommentInOrg({
org,
team_slug,
discussion_number,
body,
});
octokit.teams.createDiscussionCommentLegacy({
team_id,
discussion_number,
body,
});
octokit.teams.createDiscussionInOrg({ org, team_slug, title, body, private });
octokit.teams.createDiscussionLegacy({ team_id, title, body, private });
octokit.teams.deleteDiscussionCommentInOrg({
org,
team_slug,
discussion_number,
comment_number,
});
octokit.teams.deleteDiscussionCommentLegacy({
team_id,
discussion_number,
comment_number,
});
octokit.teams.deleteDiscussionInOrg({ org, team_slug, discussion_number });
octokit.teams.deleteDiscussionLegacy({ team_id, discussion_number });
octokit.teams.deleteInOrg({ org, team_slug });
octokit.teams.deleteLegacy({ team_id });
octokit.teams.getByName({ org, team_slug });
octokit.teams.getDiscussionCommentInOrg({
org,
team_slug,
discussion_number,
comment_number,
});
octokit.teams.getDiscussionCommentLegacy({
team_id,
discussion_number,
comment_number,
});
octokit.teams.getDiscussionInOrg({ org, team_slug, discussion_number });
octokit.teams.getDiscussionLegacy({ team_id, discussion_number });
octokit.teams.getLegacy({ team_id });
octokit.teams.getMemberLegacy({ team_id, username });
octokit.teams.getMembershipForUserInOrg({ org, team_slug, username });
octokit.teams.getMembershipForUserLegacy({ team_id, username });
octokit.teams.list({ org, per_page, page });
octokit.teams.listChildInOrg({ org, team_slug, per_page, page });
octokit.teams.listChildLegacy({ team_id, per_page, page });
octokit.teams.listDiscussionCommentsInOrg({
org,
team_slug,
discussion_number,
direction,
per_page,
page,
});
octokit.teams.listDiscussionCommentsLegacy({
team_id,
discussion_number,
direction,
per_page,
page,
});
octokit.teams.listDiscussionsInOrg({
org,
team_slug,
direction,
per_page,
page,
pinned,
});
octokit.teams.listDiscussionsLegacy({ team_id, direction, per_page, page });
octokit.teams.listForAuthenticatedUser({ per_page, page });
octokit.teams.listMembersInOrg({ org, team_slug, role, per_page, page });
octokit.teams.listMembersLegacy({ team_id, role, per_page, page });
octokit.teams.listProjectsInOrg({ org, team_slug, per_page, page });
octokit.teams.listProjectsLegacy({ team_id, per_page, page });
octokit.teams.listReposInOrg({ org, team_slug, per_page, page });
octokit.teams.listReposLegacy({ team_id, per_page, page });
octokit.teams.removeMemberLegacy({ team_id, username });
octokit.teams.removeMembershipForUserInOrg({ org, team_slug, username });
octokit.teams.removeMembershipForUserLegacy({ team_id, username });
octokit.teams.removeProjectInOrg({ org, team_slug, project_id });
octokit.teams.removeProjectLegacy({ team_id, project_id });
octokit.teams.removeRepoInOrg({ org, team_slug, owner, repo });
octokit.teams.removeRepoLegacy({ team_id, owner, repo });
octokit.teams.updateDiscussionCommentInOrg({
org,
team_slug,
discussion_number,
comment_number,
body,
});
octokit.teams.updateDiscussionCommentLegacy({
team_id,
discussion_number,
comment_number,
body,
});
octokit.teams.updateDiscussionInOrg({
org,
team_slug,
discussion_number,
title,
body,
});
octokit.teams.updateDiscussionLegacy({
team_id,
discussion_number,
title,
body,
});
octokit.teams.updateInOrg({
org,
team_slug,
name,
description,
privacy,
notification_setting,
permission,
parent_team_id,
});
octokit.teams.updateLegacy({
team_id,
name,
description,
privacy,
notification_setting,
permission,
parent_team_id,
});
octokit.users.addEmailForAuthenticated({ emails });
octokit.users.addEmailForAuthenticatedUser({ emails });
octokit.users.addSocialAccountForAuthenticatedUser({ account_urls });
octokit.users.checkFollowingForUser({ username, target_user });
octokit.users.checkPersonIsFollowedByAuthenticated({ username });
octokit.users.createGpgKeyForAuthenticated({ name, armored_public_key });
octokit.users.createGpgKeyForAuthenticatedUser({ name, armored_public_key });
octokit.users.createPublicSshKeyForAuthenticated({ title, key });
octokit.users.createPublicSshKeyForAuthenticatedUser({ title, key });
octokit.users.createSshSigningKeyForAuthenticatedUser({ title, key });
octokit.users.deleteEmailForAuthenticated({ emails });
octokit.users.deleteEmailForAuthenticatedUser({ emails });
octokit.users.deleteGpgKeyForAuthenticated({ gpg_key_id });
octokit.users.deleteGpgKeyForAuthenticatedUser({ gpg_key_id });
octokit.users.deletePublicSshKeyForAuthenticated({ key_id });
octokit.users.deletePublicSshKeyForAuthenticatedUser({ key_id });
octokit.users.deleteSocialAccountForAuthenticatedUser({ account_urls });
octokit.users.deleteSshSigningKeyForAuthenticatedUser({ ssh_signing_key_id });
octokit.users.follow({ username });
octokit.users.getAuthenticated();
octokit.users.getById({ account_id });
octokit.users.getByUsername({ username });
octokit.users.getContextForUser({ username, subject_type, subject_id });
octokit.users.getGpgKeyForAuthenticated({ gpg_key_id });
octokit.users.getGpgKeyForAuthenticatedUser({ gpg_key_id });
octokit.users.getPublicSshKeyForAuthenticated({ key_id });
octokit.users.getPublicSshKeyForAuthenticatedUser({ key_id });
octokit.users.getSshSigningKeyForAuthenticatedUser({ ssh_signing_key_id });
octokit.users.list({ since, per_page });
octokit.users.listEmailsForAuthenticated({ per_page, page });
octokit.users.listEmailsForAuthenticatedUser({ per_page, page });
octokit.users.listFollowedByAuthenticated({ per_page, page });
octokit.users.listFollowedByAuthenticatedUser({ per_page, page });
octokit.users.listFollowersForAuthenticatedUser({ per_page, page });
octokit.users.listFollowersForUser({ username, per_page, page });
octokit.users.listFollowingForUser({ username, per_page, page });
octokit.users.listGpgKeysForAuthenticated({ per_page, page });
octokit.users.listGpgKeysForAuthenticatedUser({ per_page, page });
octokit.users.listGpgKeysForUser({ username, per_page, page });
octokit.users.listPublicEmailsForAuthenticated({ per_page, page });
octokit.users.listPublicEmailsForAuthenticatedUser({ per_page, page });
octokit.users.listPublicKeysForUser({ username, per_page, page });
octokit.users.listPublicSshKeysForAuthenticated({ per_page, page });
octokit.users.listPublicSshKeysForAuthenticatedUser({ per_page, page });
octokit.users.listSocialAccountsForAuthenticatedUser({ per_page, page });
octokit.users.listSocialAccountsForUser({ username, per_page, page });
octokit.users.listSshSigningKeysForAuthenticatedUser({ per_page, page });
octokit.users.listSshSigningKeysForUser({ username, per_page, page });
octokit.users.unfollow({ username });
octokit.users.updateAuthenticated({
name,
email,
blog,
twitter_username,
company,
location,
hireable,
bio,
});