--- title: Full GitHub API reference keywords: fastai sidebar: home_sidebar summary: "All operations available through the GitHub API" description: "All operations available through the GitHub API" nb_path: "50_fullapi.ipynb" ---
{% raw %}
{% endraw %}

By calling the `full_docs` method, we can get the name, documentation link, parameters, and summary for every endpoint in the GitHub API. Here is the full reference:

{% raw %}

    Markdown(GhApi().full_docs())

## actions

- actions.get_github_actions_permissions_organization(org): Get GitHub Actions permissions for an organization
- actions.set_github_actions_permissions_organization(org, enabled_repositories, allowed_actions): Set GitHub Actions permissions for an organization
- actions.list_selected_repositories_enabled_github_actions_organization(org, per_page, page): List selected repositories enabled for GitHub Actions in an organization
- actions.set_selected_repositories_enabled_github_actions_organization(org, selected_repository_ids): Set selected repositories enabled for GitHub Actions in an organization
- actions.enable_selected_repository_github_actions_organization(org, repository_id): Enable a selected repository for GitHub Actions in an organization
- actions.disable_selected_repository_github_actions_organization(org, repository_id): Disable a selected repository for GitHub Actions in an organization
- actions.get_allowed_actions_organization(org): Get allowed actions for an organization
- actions.set_allowed_actions_organization(org, github_owned_allowed, verified_allowed, patterns_allowed): Set allowed actions for an organization
- actions.list_self_hosted_runner_groups_for_org(org, per_page, page): List self-hosted runner groups for an organization
- actions.create_self_hosted_runner_group_for_org(org, name, visibility, selected_repository_ids, runners): Create a self-hosted runner group for an organization
- actions.get_self_hosted_runner_group_for_org(org, runner_group_id): Get a self-hosted runner group for an organization
- actions.update_self_hosted_runner_group_for_org(org, runner_group_id, name, visibility): Update a self-hosted runner group for an organization
- actions.delete_self_hosted_runner_group_from_org(org, runner_group_id): Delete a self-hosted runner group from an organization
- actions.list_repo_access_to_self_hosted_runner_group_in_org(org, runner_group_id): List repository access to a self-hosted runner group in an organization
- actions.set_repo_access_to_self_hosted_runner_group_in_org(org, runner_group_id, selected_repository_ids): Set repository access for a self-hosted runner group in an organization
- actions.add_repo_access_to_self_hosted_runner_group_in_org(org, runner_group_id, repository_id): Add repository access to a self-hosted runner group in an organization
- actions.remove_repo_access_to_self_hosted_runner_group_in_org(org, runner_group_id, repository_id): Remove repository access to a self-hosted runner group in an organization
- actions.list_self_hosted_runners_in_group_for_org(org, runner_group_id, per_page, page): List self-hosted runners in a group for an organization
- actions.set_self_hosted_runners_in_group_for_org(org, runner_group_id, runners): Set self-hosted runners in a group for an organization
- actions.add_self_hosted_runner_to_group_for_org(org, runner_group_id, runner_id): Add a self-hosted runner to a group for an organization
- actions.remove_self_hosted_runner_from_group_for_org(org, runner_group_id, runner_id): Remove a self-hosted runner from a group for an organization
- actions.list_self_hosted_runners_for_org(org, per_page, page): List self-hosted runners for an organization
- actions.list_runner_applications_for_org(org): List runner applications for an organization
- actions.create_registration_token_for_org(org): Create a registration token for an organization
- actions.create_remove_token_for_org(org): Create a remove token for an organization
- actions.get_self_hosted_runner_for_org(org, runner_id): Get a self-hosted runner for an organization
- actions.delete_self_hosted_runner_from_org(org, runner_id): Delete a self-hosted runner from an organization
- actions.list_org_secrets(org, per_page, page): List organization secrets
- actions.get_org_public_key(org): Get an organization public key
- actions.get_org_secret(org, secret_name): Get an organization secret
- actions.create_or_update_org_secret(org, secret_name, encrypted_value, key_id, visibility, selected_repository_ids): Create or update an organization secret
- actions.delete_org_secret(org, secret_name): Delete an organization secret
- actions.list_selected_repos_for_org_secret(org, secret_name): List selected repositories for an organization secret
- actions.set_selected_repos_for_org_secret(org, secret_name, selected_repository_ids): Set selected repositories for an organization secret
- actions.add_selected_repo_to_org_secret(org, secret_name, repository_id): Add selected repository to an organization secret
- actions.remove_selected_repo_from_org_secret(org, secret_name, repository_id): Remove selected repository from an organization secret
- actions.list_artifacts_for_repo(owner, repo, per_page, page): List artifacts for a repository
- actions.get_artifact(owner, repo, artifact_id): Get an artifact
- actions.delete_artifact(owner, repo, artifact_id): Delete an artifact
- actions.download_artifact(owner, repo, artifact_id, archive_format): Download an artifact
- actions.get_job_for_workflow_run(owner, repo, job_id): Get a job for a workflow run
- actions.download_job_logs_for_workflow_run(owner, repo, job_id): Download job logs for a workflow run
- actions.get_github_actions_permissions_repository(owner, repo): Get GitHub Actions permissions for a repository
- actions.set_github_actions_permissions_repository(owner, repo, enabled, allowed_actions): Set GitHub Actions permissions for a repository
- actions.get_allowed_actions_repository(owner, repo): Get allowed actions for a repository
- actions.set_allowed_actions_repository(owner, repo, github_owned_allowed, verified_allowed, patterns_allowed): Set allowed actions for a repository
- actions.list_self_hosted_runners_for_repo(owner, repo, per_page, page): List self-hosted runners for a repository
- actions.list_runner_applications_for_repo(owner, repo): List runner applications for a repository
- actions.create_registration_token_for_repo(owner, repo): Create a registration token for a repository
- actions.create_remove_token_for_repo(owner, repo): Create a remove token for a repository
- actions.get_self_hosted_runner_for_repo(owner, repo, runner_id): Get a self-hosted runner for a repository
- actions.delete_self_hosted_runner_from_repo(owner, repo, runner_id): Delete a self-hosted runner from a repository
- actions.list_workflow_runs_for_repo(owner, repo, actor, branch, event, status, per_page, page): List workflow runs for a repository
- actions.get_workflow_run(owner, repo, run_id): Get a workflow run
- actions.delete_workflow_run(owner, repo, run_id): Delete a workflow run
- actions.list_workflow_run_artifacts(owner, repo, run_id, per_page, page): List workflow run artifacts
- actions.cancel_workflow_run(owner, repo, run_id): Cancel a workflow run
- actions.list_jobs_for_workflow_run(owner, repo, run_id, filter, per_page, page): List jobs for a workflow run
- actions.download_workflow_run_logs(owner, repo, run_id): Download workflow run logs
- actions.delete_workflow_run_logs(owner, repo, run_id): Delete workflow run logs
- actions.re_run_workflow(owner, repo, run_id): Re-run a workflow
- actions.get_workflow_run_usage(owner, repo, run_id): Get workflow run usage
- actions.list_repo_secrets(owner, repo, per_page, page): List repository secrets
- actions.get_repo_public_key(owner, repo): Get a repository public key
- actions.get_repo_secret(owner, repo, secret_name): Get a repository secret
- actions.create_or_update_repo_secret(owner, repo, secret_name, encrypted_value, key_id): Create or update a repository secret
- actions.delete_repo_secret(owner, repo, secret_name): Delete a repository secret
- actions.list_repo_workflows(owner, repo, per_page, page): List repository workflows
- actions.get_workflow(owner, repo, workflow_id): Get a workflow
- actions.disable_workflow(owner, repo, workflow_id): Disable a workflow
- actions.create_workflow_dispatch(owner, repo, workflow_id, ref, inputs): Create a workflow dispatch event
- actions.enable_workflow(owner, repo, workflow_id): Enable a workflow
- actions.list_workflow_runs(owner, repo, workflow_id, actor, branch, event, status, per_page, page): List workflow runs
- actions.get_workflow_usage(owner, repo, workflow_id): Get workflow usage

## activity

- activity.list_public_events(per_page, page): List public events
- activity.get_feeds(): Get feeds
- activity.list_public_events_for_repo_network(owner, repo, per_page, page): List public events for a network of repositories
- activity.list_notifications_for_authenticated_user(all, participating, since, before, per_page, page): List notifications for the authenticated user
- activity.mark_notifications_as_read(last_read_at, read): Mark notifications as read
- activity.get_thread(thread_id): Get a thread
- activity.mark_thread_as_read(thread_id): Mark a thread as read
- activity.get_thread_subscription_for_authenticated_user(thread_id): Get a thread subscription for the authenticated user
- activity.set_thread_subscription(thread_id, ignored): Set a thread subscription
- activity.delete_thread_subscription(thread_id): Delete a thread subscription
- activity.list_public_org_events(org, per_page, page): List public organization events
- activity.list_repo_events(owner, repo, per_page, page): List repository events
- activity.list_repo_notifications_for_authenticated_user(owner, repo, all, participating, since, before, per_page, page): List repository notifications for the authenticated user
- activity.mark_repo_notifications_as_read(owner, repo, last_read_at): Mark repository notifications as read
- activity.list_stargazers_for_repo(owner, repo, per_page, page): List stargazers
- activity.list_watchers_for_repo(owner, repo, per_page, page): List watchers
- activity.get_repo_subscription(owner, repo): Get a repository subscription
- activity.set_repo_subscription(owner, repo, subscribed, ignored): Set a repository subscription
- activity.delete_repo_subscription(owner, repo): Delete a repository subscription
- activity.list_repos_starred_by_authenticated_user(sort, direction, per_page, page): List repositories starred by the authenticated user
- activity.check_repo_is_starred_by_authenticated_user(owner, repo): Check if a repository is starred by the authenticated user
- activity.star_repo_for_authenticated_user(owner, repo): Star a repository for the authenticated user
- activity.unstar_repo_for_authenticated_user(owner, repo): Unstar a repository for the authenticated user
- activity.list_watched_repos_for_authenticated_user(per_page, page): List repositories watched by the authenticated user
- activity.list_events_for_authenticated_user(username, per_page, page): List events for the authenticated user
- activity.list_org_events_for_authenticated_user(username, org, per_page, page): List organization events for the authenticated user
- activity.list_public_events_for_user(username, per_page, page): List public events for a user
- activity.list_received_events_for_user(username, per_page, page): List events received by the authenticated user
- activity.list_received_public_events_for_user(username, per_page, page): List public events received by a user
- activity.list_repos_starred_by_user(username, sort, direction, per_page, page): List repositories starred by a user
- activity.list_repos_watched_by_user(username, per_page, page): List repositories watched by a user

## apps

- apps.get_authenticated(): Get the authenticated app
- apps.create_from_manifest(code): Create a GitHub App from a manifest
- apps.get_webhook_config_for_app(): Get a webhook configuration for an app
- apps.update_webhook_config_for_app(url, content_type, secret, insecure_ssl): Update a webhook configuration for an app
- apps.list_installations(per_page, page, since, outdated): List installations for the authenticated app
- apps.get_installation(installation_id): Get an installation for the authenticated app
- apps.delete_installation(installation_id): Delete an installation for the authenticated app
- apps.create_installation_access_token(installation_id, repositories, repository_ids, permissions): Create an installation access token for an app
- apps.suspend_installation(installation_id): Suspend an app installation
- apps.unsuspend_installation(installation_id): Unsuspend an app installation
- apps.delete_authorization(client_id, access_token): Delete an app authorization
- apps.revoke_grant_for_application(client_id, access_token): Revoke a grant for an application
- apps.check_token(client_id, access_token): Check a token
- apps.reset_token(client_id, access_token): Reset a token
- apps.delete_token(client_id, access_token): Delete an app token
- apps.check_authorization(client_id, access_token): Check an authorization
- apps.reset_authorization(client_id, access_token): Reset an authorization
- apps.revoke_authorization_for_application(client_id, access_token): Revoke an authorization for an application
- apps.get_by_slug(app_slug): Get an app
- apps.create_content_attachment(content_reference_id, title, body): Create a content attachment
- apps.list_repos_accessible_to_installation(per_page, page): List repositories accessible to the app installation
- apps.revoke_installation_access_token(): Revoke an installation access token
- apps.get_subscription_plan_for_account(account_id): Get a subscription plan for an account
- apps.list_plans(per_page, page): List plans
- apps.list_accounts_for_plan(plan_id, sort, direction, per_page, page): List accounts for a plan
- apps.get_subscription_plan_for_account_stubbed(account_id): Get a subscription plan for an account (stubbed)
- apps.list_plans_stubbed(per_page, page): List plans (stubbed)
- apps.list_accounts_for_plan_stubbed(plan_id, sort, direction, per_page, page): List accounts for a plan (stubbed)
- apps.get_org_installation(org): Get an organization installation for the authenticated app
- apps.get_repo_installation(owner, repo): Get a repository installation for the authenticated app
- apps.list_installations_for_authenticated_user(per_page, page): List app installations accessible to the user access token
- apps.list_installation_repos_for_authenticated_user(installation_id, per_page, page): List repositories accessible to the user access token
- apps.add_repo_to_installation(installation_id, repository_id): Add a repository to an app installation
- apps.remove_repo_from_installation(installation_id, repository_id): Remove a repository from an app installation
- apps.list_subscriptions_for_authenticated_user(per_page, page): List subscriptions for the authenticated user
- apps.list_subscriptions_for_authenticated_user_stubbed(per_page, page): List subscriptions for the authenticated user (stubbed)
- apps.get_user_installation(username): Get a user installation for the authenticated app

## billing

- billing.get_github_actions_billing_ghe(enterprise): Get GitHub Actions billing for an enterprise
- billing.get_github_packages_billing_ghe(enterprise): Get GitHub Packages billing for an enterprise
- billing.get_shared_storage_billing_ghe(enterprise): Get shared storage billing for an enterprise
- billing.get_github_actions_billing_org(org): Get GitHub Actions billing for an organization
- billing.get_github_packages_billing_org(org): Get GitHub Packages billing for an organization
- billing.get_shared_storage_billing_org(org): Get shared storage billing for an organization
- billing.get_github_actions_billing_user(username): Get GitHub Actions billing for a user
- billing.get_github_packages_billing_user(username): Get GitHub Packages billing for a user
- billing.get_shared_storage_billing_user(username): Get shared storage billing for a user

## checks

- checks.create(owner, repo, name, head_sha, details_url, external_id, status, started_at, conclusion, completed_at, output, actions): Create a check run
- checks.get(owner, repo, check_run_id): Get a check run
- checks.update(owner, repo, check_run_id, name, details_url, external_id, started_at, status, conclusion, completed_at, output, actions): Update a check run
- checks.list_annotations(owner, repo, check_run_id, per_page, page): List check run annotations
- checks.create_suite(owner, repo, head_sha): Create a check suite
- checks.set_suites_preferences(owner, repo, auto_trigger_checks): Update repository preferences for check suites
- checks.get_suite(owner, repo, check_suite_id): Get a check suite
- checks.list_for_suite(owner, repo, check_suite_id, check_name, status, filter, per_page, page): List check runs in a check suite
- checks.rerequest_suite(owner, repo, check_suite_id): Rerequest a check suite
- checks.list_for_ref(owner, repo, ref, check_name, status, filter, per_page, page): List check runs for a Git reference
- checks.list_suites_for_ref(owner, repo, ref, app_id, check_name, per_page, page): List check suites for a Git reference

## code_scanning

- code-scanning.list_alerts_for_repo(owner, repo, state, ref): List code scanning alerts for a repository
- code-scanning.get_alert(owner, repo, alert_number): Get a code scanning alert
- code-scanning.update_alert(owner, repo, alert_number, state, dismissed_reason): Update a code scanning alert
- code-scanning.list_recent_analyses(owner, repo, ref, tool_name): List recent code scanning analyses for a repository
- code-scanning.upload_sarif(owner, repo, commit_sha, ref, sarif, checkout_uri, started_at, tool_name): Upload a SARIF file

## codes_of_conduct

- codes-of-conduct.get_all_codes_of_conduct(): Get all codes of conduct
- codes-of-conduct.get_conduct_code(key): Get a code of conduct
- codes-of-conduct.get_for_repo(owner, repo): Get the code of conduct for a repository

## emojis

- emojis.get(): Get emojis

## enterprise_admin

- enterprise-admin.get_github_actions_permissions_enterprise(enterprise): Get GitHub Actions permissions for an enterprise
- enterprise-admin.set_github_actions_permissions_enterprise(enterprise, enabled_organizations, allowed_actions): Set GitHub Actions permissions for an enterprise
- enterprise-admin.list_selected_organizations_enabled_github_actions_enterprise(enterprise, per_page, page): List selected organizations enabled for GitHub Actions in an enterprise
- enterprise-admin.set_selected_organizations_enabled_github_actions_enterprise(enterprise, selected_organization_ids): Set selected organizations enabled for GitHub Actions in an enterprise
- enterprise-admin.enable_selected_organization_github_actions_enterprise(enterprise, org_id): Enable a selected organization for GitHub Actions in an enterprise
- enterprise-admin.disable_selected_organization_github_actions_enterprise(enterprise, org_id): Disable a selected organization for GitHub Actions in an enterprise
- enterprise-admin.get_allowed_actions_enterprise(enterprise): Get allowed actions for an enterprise
- enterprise-admin.set_allowed_actions_enterprise(enterprise, github_owned_allowed, verified_allowed, patterns_allowed): Set allowed actions for an enterprise
- enterprise-admin.list_self_hosted_runner_groups_for_enterprise(enterprise, per_page, page): List self-hosted runner groups for an enterprise
- enterprise-admin.create_self_hosted_runner_group_for_enterprise(enterprise, name, visibility, selected_organization_ids, runners): Create a self-hosted runner group for an enterprise
- enterprise-admin.get_self_hosted_runner_group_for_enterprise(enterprise, runner_group_id): Get a self-hosted runner group for an enterprise
- enterprise-admin.update_self_hosted_runner_group_for_enterprise(enterprise, runner_group_id, name, visibility): Update a self-hosted runner group for an enterprise
- enterprise-admin.delete_self_hosted_runner_group_from_enterprise(enterprise, runner_group_id): Delete a self-hosted runner group from an enterprise
- enterprise-admin.list_org_access_to_self_hosted_runner_group_in_enterprise(enterprise, runner_group_id, per_page, page): List organization access to a self-hosted runner group in an enterprise
- enterprise-admin.set_org_access_to_self_hosted_runner_group_in_enterprise(enterprise, runner_group_id, selected_organization_ids): Set organization access for a self-hosted runner group in an enterprise
- enterprise-admin.add_org_access_to_self_hosted_runner_group_in_enterprise(enterprise, runner_group_id, org_id): Add organization access to a self-hosted runner group in an enterprise
- enterprise-admin.remove_org_access_to_self_hosted_runner_group_in_enterprise(enterprise, runner_group_id, org_id): Remove organization access to a self-hosted runner group in an enterprise
- enterprise-admin.list_self_hosted_runners_in_group_for_enterprise(enterprise, runner_group_id, per_page, page): List self-hosted runners in a group for an enterprise
- enterprise-admin.set_self_hosted_runners_in_group_for_enterprise(enterprise, runner_group_id, runners): Set self-hosted runners in a group for an enterprise
- enterprise-admin.add_self_hosted_runner_to_group_for_enterprise(enterprise, runner_group_id, runner_id): Add a self-hosted runner to a group for an enterprise
- enterprise-admin.remove_self_hosted_runner_from_group_for_enterprise(enterprise, runner_group_id, runner_id): Remove a self-hosted runner from a group for an enterprise
- enterprise-admin.list_self_hosted_runners_for_enterprise(enterprise, per_page, page): List self-hosted runners for an enterprise
- enterprise-admin.list_runner_applications_for_enterprise(enterprise): List runner applications for an enterprise
- enterprise-admin.create_registration_token_for_enterprise(enterprise): Create a registration token for an enterprise
- enterprise-admin.create_remove_token_for_enterprise(enterprise): Create a remove token for an enterprise
- enterprise-admin.get_self_hosted_runner_for_enterprise(enterprise, runner_id): Get a self-hosted runner for an enterprise
- enterprise-admin.delete_self_hosted_runner_from_enterprise(enterprise, runner_id): Delete a self-hosted runner from an enterprise
- enterprise-admin.list_provisioned_groups_enterprise(enterprise, startIndex, count): List provisioned SCIM groups for an enterprise
- enterprise-admin.provision_and_invite_enterprise_group(enterprise, schemas, displayName, members): Provision a SCIM enterprise group and invite users
- enterprise-admin.get_provisioning_information_for_enterprise_group(enterprise, scim_group_id): Get SCIM provisioning information for an enterprise group
- enterprise-admin.set_information_for_provisioned_enterprise_group(enterprise, scim_group_id, schemas, displayName, members): Set SCIM information for a provisioned enterprise group
- enterprise-admin.update_attribute_for_enterprise_group(enterprise, scim_group_id, schemas, Operations): Update an attribute for a SCIM enterprise group
- enterprise-admin.delete_scim_group_from_enterprise(enterprise, scim_group_id): Delete a SCIM group from an enterprise
- enterprise-admin.list_provisioned_identities_enterprise(enterprise, startIndex, count): List SCIM provisioned identities for an enterprise
- enterprise-admin.provision_and_invite_enterprise_user(enterprise, schemas, userName, name, emails, groups): Provision and invite a SCIM enterprise user
- enterprise-admin.get_provisioning_information_for_enterprise_user(enterprise, scim_user_id): Get SCIM provisioning information for an enterprise user
- enterprise-admin.set_information_for_provisioned_enterprise_user(enterprise, scim_user_id, schemas, userName, name, emails, groups): Set SCIM information for a provisioned enterprise user
- enterprise-admin.update_attribute_for_enterprise_user(enterprise, scim_user_id, schemas, Operations): Update an attribute for a SCIM enterprise user
- enterprise-admin.delete_user_from_enterprise(enterprise, scim_user_id): Delete a SCIM user from an enterprise

## gists

- gists.list(since, per_page, page): List gists for the authenticated user
- gists.create(description, files, public): Create a gist
- gists.list_public(since, per_page, page): List public gists
- gists.list_starred(since, per_page, page): List starred gists
- gists.get(gist_id): Get a gist
- gists.update(gist_id, description, files): Update a gist
- gists.delete(gist_id): Delete a gist
- gists.list_comments(gist_id, per_page, page): List gist comments
- gists.create_comment(gist_id, body): Create a gist comment
- gists.get_comment(gist_id, comment_id): Get a gist comment
- gists.update_comment(gist_id, comment_id, body): Update a gist comment
- gists.delete_comment(gist_id, comment_id): Delete a gist comment
- gists.list_commits(gist_id, per_page, page): List gist commits
- gists.list_forks(gist_id, per_page, page): List gist forks
- gists.fork(gist_id): Fork a gist
- gists.check_is_starred(gist_id): Check if a gist is starred
- gists.star(gist_id): Star a gist
- gists.unstar(gist_id): Unstar a gist
- gists.get_revision(gist_id, sha): Get a gist revision
- gists.list_for_user(username, since, per_page, page): List gists for a user

## git

- git.create_blob(owner, repo, content, encoding): Create a blob
- git.get_blob(owner, repo, file_sha): Get a blob
- git.create_commit(owner, repo, message, tree, parents, author, committer, signature): Create a commit
- git.get_commit(owner, repo, commit_sha): Get a commit
- git.list_matching_refs(owner, repo, ref, per_page, page): List matching references
- git.get_ref(owner, repo, ref): Get a reference
- git.create_ref(owner, repo, ref, sha, key): Create a reference
- git.update_ref(owner, repo, ref, sha, force): Update a reference
- git.delete_ref(owner, repo, ref): Delete a reference
- git.create_tag(owner, repo, tag, message, object, type, tagger): Create a tag object
- git.get_tag(owner, repo, tag_sha): Get a tag
- git.create_tree(owner, repo, tree, base_tree): Create a tree
- git.get_tree(owner, repo, tree_sha, recursive): Get a tree

## gitignore

- gitignore.get_all_templates(): Get all gitignore templates
- gitignore.get_template(name): Get a gitignore template

## interactions

- interactions.get_restrictions_for_org(org): Get interaction restrictions for an organization
- interactions.set_restrictions_for_org(org, limit, expiry): Set interaction restrictions for an organization
- interactions.remove_restrictions_for_org(org): Remove interaction restrictions for an organization
- interactions.get_restrictions_for_repo(owner, repo): Get interaction restrictions for a repository
- interactions.set_restrictions_for_repo(owner, repo, limit, expiry): Set interaction restrictions for a repository
- interactions.remove_restrictions_for_repo(owner, repo): Remove interaction restrictions for a repository
- interactions.get_restrictions_for_your_public_repos(): Get interaction restrictions for your public repositories
- interactions.set_restrictions_for_your_public_repos(limit, expiry): Set interaction restrictions for your public repositories
- interactions.remove_restrictions_for_your_public_repos(): Remove interaction restrictions from your public repositories

## issues

- issues.list(filter, state, labels, sort, direction, since, collab, orgs, owned, pulls, per_page, page): List issues assigned to the authenticated user
- issues.list_for_org(org, filter, state, labels, sort, direction, since, per_page, page): List organization issues assigned to the authenticated user
- issues.list_assignees(owner, repo, per_page, page): List assignees
- issues.check_user_can_be_assigned(owner, repo, assignee): Check if a user can be assigned
- issues.list_for_repo(owner, repo, milestone, state, assignee, creator, mentioned, labels, sort, direction, since, per_page, page): List repository issues
- issues.create(owner, repo, title, body, assignee, milestone, labels, assignees): Create an issue
- issues.list_comments_for_repo(owner, repo, sort, direction, since, per_page, page): List issue comments for a repository
- issues.get_comment(owner, repo, comment_id): Get an issue comment
- issues.update_comment(owner, repo, comment_id, body): Update an issue comment
- issues.delete_comment(owner, repo, comment_id): Delete an issue comment
- issues.list_events_for_repo(owner, repo, per_page, page): List issue events for a repository
- issues.get_event(owner, repo, event_id): Get an issue event
- issues.get(owner, repo, issue_number): Get an issue
- issues.update(owner, repo, issue_number, title, body, assignee, state, milestone, labels, assignees): Update an issue
- issues.add_assignees(owner, repo, issue_number, assignees): Add assignees to an issue
- issues.remove_assignees(owner, repo, issue_number, assignees): Remove assignees from an issue
- issues.list_comments(owner, repo, issue_number, since, per_page, page): List issue comments
- issues.create_comment(owner, repo, issue_number, body): Create an issue comment
- issues.list_events(owner, repo, issue_number, per_page, page): List issue events
- issues.list_labels_on_issue(owner, repo, issue_number, per_page, page): List labels for an issue
- issues.add_labels(owner, repo, issue_number, labels): Add labels to an issue
- issues.set_labels(owner, repo, issue_number, labels): Set labels for an issue
- issues.remove_all_labels(owner, repo, issue_number): Remove all labels from an issue
- issues.remove_label(owner, repo, issue_number, name): Remove a label from an issue
- issues.lock(owner, repo, issue_number, lock_reason): Lock an issue
- issues.unlock(owner, repo, issue_number): Unlock an issue
- issues.list_events_for_timeline(owner, repo, issue_number, per_page, page): List timeline events for an issue
- issues.list_labels_for_repo(owner, repo, per_page, page): List labels for a repository
- issues.create_label(owner, repo, name, color, description): Create a label
- issues.get_label(owner, repo, name): Get a label
- issues.update_label(owner, repo, name, new_name, color, description): Update a label
- issues.delete_label(owner, repo, name): Delete a label
- issues.list_milestones(owner, repo, state, sort, direction, per_page, page): List milestones
- issues.create_milestone(owner, repo, title, state, description, due_on): Create a milestone
- issues.get_milestone(owner, repo, milestone_number): Get a milestone
- issues.update_milestone(owner, repo, milestone_number, title, state, description, due_on): Update a milestone
- issues.delete_milestone(owner, repo, milestone_number): Delete a milestone
- issues.list_labels_for_milestone(owner, repo, milestone_number, per_page, page): List labels for issues in a milestone
- issues.list_for_authenticated_user(filter, state, labels, sort, direction, since, per_page, page): List user account issues assigned to the authenticated user

## licenses

- licenses.get_all_commonly_used(featured, per_page): Get all commonly used licenses
- licenses.get(license): Get a license
- licenses.get_for_repo(owner, repo): Get the license for a repository

## markdown

- markdown.render(text, mode, context): Render a Markdown document
- markdown.render_raw(): Render a Markdown document in raw mode

## meta

- meta.get(): Get GitHub meta information

## migrations

- migrations.list_for_org(org, per_page, page): List organization migrations
- migrations.start_for_org(org, repositories, lock_repositories, exclude_attachments, exclude): Start an organization migration
- migrations.get_status_for_org(org, migration_id): Get an organization migration status
- migrations.download_archive_for_org(org, migration_id): Download an organization migration archive
- migrations.delete_archive_for_org(org, migration_id): Delete an organization migration archive
- migrations.unlock_repo_for_org(org, migration_id, repo_name): Unlock an organization repository
- migrations.list_repos_for_org(org, migration_id, per_page, page): List repositories in an organization migration
- migrations.get_import_status(owner, repo): Get an import status
- migrations.start_import(owner, repo, vcs_url, vcs, vcs_username, vcs_password, tfvc_project): Start an import
- migrations.update_import(owner, repo, vcs_username, vcs_password, vcs, tfvc_project): Update an import
- migrations.cancel_import(owner, repo): Cancel an import
- migrations.get_commit_authors(owner, repo, since): Get commit authors
- migrations.map_commit_author(owner, repo, author_id, email, name, remote_id): Map a commit author
- migrations.get_large_files(owner, repo): Get large files
- migrations.set_lfs_preference(owner, repo, use_lfs): Update Git LFS preference
- migrations.list_for_authenticated_user(per_page, page): List user migrations
- migrations.start_for_authenticated_user(lock_repositories, exclude_attachments, exclude, repositories): Start a user migration
- migrations.get_status_for_authenticated_user(migration_id, exclude): Get a user migration status
- migrations.get_archive_for_authenticated_user(migration_id): Download a user migration archive
- migrations.delete_archive_for_authenticated_user(migration_id): Delete a user migration archive
- migrations.unlock_repo_for_authenticated_user(migration_id, repo_name): Unlock a user repository
- migrations.list_repos_for_user(migration_id, per_page, page): List repositories for a user migration

## oauth_authorizations

- oauth-authorizations.list_grants(per_page, page): List your grants
- oauth-authorizations.get_grant(grant_id): Get a single grant
- oauth-authorizations.delete_grant(grant_id): Delete a grant
- oauth-authorizations.list_authorizations(per_page, page): List your authorizations
- oauth-authorizations.create_authorization(scopes, note, note_url, client_id, client_secret, fingerprint): Create a new authorization
- oauth-authorizations.get_or_create_authorization_for_app(client_id, client_secret, scopes, note, note_url, fingerprint): Get-or-create an authorization for a specific app
- oauth-authorizations.get_or_create_authorization_for_app_and_fingerprint(client_id, fingerprint, client_secret, scopes, note, note_url): Get-or-create an authorization for a specific app and fingerprint
- oauth-authorizations.get_authorization(authorization_id): Get a single authorization
- oauth-authorizations.update_authorization(authorization_id, scopes, add_scopes, remove_scopes, note, note_url, fingerprint): Update an existing authorization
- oauth-authorizations.delete_authorization(authorization_id): Delete an authorization

## orgs

- orgs.list(since, per_page): List organizations
- orgs.get(org): Get an organization
- 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, blog): Update an organization
- orgs.list_blocked_users(org): List users blocked by an organization
- orgs.check_blocked_user(org, username): Check if a user is blocked by an organization
- orgs.block_user(org, username): Block a user from an organization
- orgs.unblock_user(org, username): Unblock a user from an organization
- orgs.list_saml_sso_authorizations(org): List SAML SSO authorizations for an organization
- orgs.remove_saml_sso_authorization(org, credential_id): Remove a SAML SSO authorization for an organization
- orgs.list_webhooks(org, per_page, page): List organization webhooks
- orgs.create_webhook(org, name, config, events, active): Create an organization webhook
- orgs.get_webhook(org, hook_id): Get an organization webhook
- orgs.update_webhook(org, hook_id, config, events, active, name): Update an organization webhook
- orgs.delete_webhook(org, hook_id): Delete an organization webhook
- orgs.get_webhook_config_for_org(org, hook_id): Get a webhook configuration for an organization
- orgs.update_webhook_config_for_org(org, hook_id, url, content_type, secret, insecure_ssl): Update a webhook configuration for an organization
- orgs.ping_webhook(org, hook_id): Ping an organization webhook
- orgs.list_app_installations(org, per_page, page): List app installations for an organization
- orgs.list_pending_invitations(org, per_page, page): List pending organization invitations
- orgs.create_invitation(org, invitee_id, email, role, team_ids): Create an organization invitation
- orgs.list_invitation_teams(org, invitation_id, per_page, page): List organization invitation teams
- orgs.list_members(org, filter, role, per_page, page): List organization members
- orgs.check_membership_for_user(org, username): Check organization membership for a user
- orgs.remove_member(org, username): Remove an organization member
- orgs.get_membership_for_user(org, username): Get organization membership for a user
- orgs.set_membership_for_user(org, username, role): Set organization membership for a user
- orgs.remove_membership_for_user(org, username): Remove organization membership for a user
- orgs.list_outside_collaborators(org, filter, per_page, page): List outside collaborators for an organization
- orgs.convert_member_to_outside_collaborator(org, username): Convert an organization member to outside collaborator
- orgs.remove_outside_collaborator(org, username): Remove outside collaborator from an organization
- orgs.list_public_members(org, per_page, page): List public organization members
- orgs.check_public_membership_for_user(org, username): Check public organization membership for a user
- orgs.set_public_membership_for_authenticated_user(org, username): Set public organization membership for the authenticated user
- orgs.remove_public_membership_for_authenticated_user(org, username): Remove public organization membership for the authenticated user
- orgs.list_memberships_for_authenticated_user(state, per_page, page): List organization memberships for the authenticated user
- orgs.get_membership_for_authenticated_user(org): Get an organization membership for the authenticated user
- orgs.update_membership_for_authenticated_user(org, state): Update an organization membership for the authenticated user
- orgs.list_for_authenticated_user(per_page, page): List organizations for the authenticated user
- orgs.list_for_user(username, per_page, page): List organizations for a user

## projects

- projects.list_for_org(org, state, per_page, page): List organization projects
- projects.create_for_org(org, name, body): Create an organization project
- projects.get_card(card_id): Get a project card
- projects.update_card(card_id, note, archived): Update an existing project card
- projects.delete_card(card_id): Delete a project card
- projects.move_card(card_id, position, column_id): Move a project card
- projects.get_column(column_id): Get a project column
- projects.update_column(column_id, name): Update an existing project column
- projects.delete_column(column_id): Delete a project column
- projects.list_cards(column_id, archived_state, per_page, page): List project cards
- projects.create_card(column_id): Create a project card
- projects.move_column(column_id, position): Move a project column
- projects.get(project_id): Get a project
- projects.update(project_id, name, body, state, organization_permission, private): Update a project
- projects.delete(project_id): Delete a project
- projects.list_collaborators(project_id, affiliation, per_page, page): List project collaborators
- projects.add_collaborator(project_id, username, permission): Add project collaborator
- projects.remove_collaborator(project_id, username): Remove user as a collaborator
- projects.get_permission_for_user(project_id, username): Get project permission for a user
- projects.list_columns(project_id, per_page, page): List project columns
- projects.create_column(project_id, name): Create a project column
- projects.list_for_repo(owner, repo, state, per_page, page): List repository projects
- projects.create_for_repo(owner, repo, name, body): Create a repository project
- projects.create_for_authenticated_user(name, body): Create a user project
- projects.list_for_user(username, state, per_page, page): List user projects

## pulls

- pulls.list(owner, repo, state, head, base, sort, direction, per_page, page): List pull requests
- pulls.create(owner, repo, title, head, base, body, maintainer_can_modify, draft, issue): Create a pull request
- pulls.list_review_comments_for_repo(owner, repo, sort, direction, since, per_page, page): List review comments in a repository
- pulls.get_review_comment(owner, repo, comment_id): Get a review comment for a pull request
- pulls.update_review_comment(owner, repo, comment_id, body): Update a review comment for a pull request
- pulls.delete_review_comment(owner, repo, comment_id): Delete a review comment for a pull request
- pulls.get(owner, repo, pull_number): Get a pull request
- pulls.update(owner, repo, pull_number, title, body, state, base, maintainer_can_modify): Update a pull request
- pulls.list_review_comments(owner, repo, pull_number, sort, direction, since, per_page, page): List review comments on a pull request
- pulls.create_review_comment(owner, repo, pull_number, body, commit_id, path, position, side, line, start_line, start_side, in_reply_to): Create a review comment for a pull request
- pulls.create_reply_for_review_comment(owner, repo, pull_number, comment_id, body): Create a reply for a review comment
- pulls.list_commits(owner, repo, pull_number, per_page, page): List commits on a pull request
- pulls.list_files(owner, repo, pull_number, per_page, page): List pull requests files
- pulls.check_if_merged(owner, repo, pull_number): Check if a pull request has been merged
- pulls.merge(owner, repo, pull_number, commit_title, commit_message, sha, merge_method): Merge a pull request
- pulls.list_requested_reviewers(owner, repo, pull_number, per_page, page): List requested reviewers for a pull request
- pulls.request_reviewers(owner, repo, pull_number, reviewers, team_reviewers): Request reviewers for a pull request
- pulls.remove_requested_reviewers(owner, repo, pull_number, reviewers, team_reviewers): Remove requested reviewers from a pull request
- pulls.list_reviews(owner, repo, pull_number, per_page, page): List reviews for a pull request
- pulls.create_review(owner, repo, pull_number, commit_id, body, event, comments): Create a review for a pull request
- pulls.get_review(owner, repo, pull_number, review_id): Get a review for a pull request
- pulls.update_review(owner, repo, pull_number, review_id, body): Update a review for a pull request
- pulls.delete_pending_review(owner, repo, pull_number, review_id): Delete a pending review for a pull request
- pulls.list_comments_for_review(owner, repo, pull_number, review_id, per_page, page): List comments for a pull request review
- pulls.dismiss_review(owner, repo, pull_number, review_id, message, event): Dismiss a review for a pull request
- pulls.submit_review(owner, repo, pull_number, review_id, body, event): Submit a review for a pull request
- pulls.update_branch(owner, repo, pull_number, expected_head_sha): Update a pull request branch

## rate_limit

- rate-limit.get(): Get rate limit status for the authenticated user

## reactions

- reactions.list_for_team_discussion_comment_in_org(org, team_slug, discussion_number, comment_number, content, per_page, page): List reactions for a team discussion comment
- reactions.create_for_team_discussion_comment_in_org(org, team_slug, discussion_number, comment_number, content): Create reaction for a team discussion comment
- reactions.delete_for_team_discussion_comment(org, team_slug, discussion_number, comment_number, reaction_id): Delete team discussion comment reaction
- reactions.list_for_team_discussion_in_org(org, team_slug, discussion_number, content, per_page, page): List reactions for a team discussion
- reactions.create_for_team_discussion_in_org(org, team_slug, discussion_number, content): Create reaction for a team discussion
- reactions.delete_for_team_discussion(org, team_slug, discussion_number, reaction_id): Delete team discussion reaction
- reactions.delete_legacy(reaction_id): Delete a reaction (Legacy)
- reactions.list_for_commit_comment(owner, repo, comment_id, content, per_page, page): List reactions for a commit comment
- reactions.create_for_commit_comment(owner, repo, comment_id, content): Create reaction for a commit comment
- reactions.delete_for_commit_comment(owner, repo, comment_id, reaction_id): Delete a commit comment reaction
- reactions.list_for_issue_comment(owner, repo, comment_id, content, per_page, page): List reactions for an issue comment
- reactions.create_for_issue_comment(owner, repo, comment_id, content): Create reaction for an issue comment
- reactions.delete_for_issue_comment(owner, repo, comment_id, reaction_id): Delete an issue comment reaction
- reactions.list_for_issue(owner, repo, issue_number, content, per_page, page): List reactions for an issue
- reactions.create_for_issue(owner, repo, issue_number, content): Create reaction for an issue
- reactions.delete_for_issue(owner, repo, issue_number, reaction_id): Delete an issue reaction
- reactions.list_for_pull_request_review_comment(owner, repo, comment_id, content, per_page, page): List reactions for a pull request review comment
- reactions.create_for_pull_request_review_comment(owner, repo, comment_id, content): Create reaction for a pull request review comment
- reactions.delete_for_pull_request_comment(owner, repo, comment_id, reaction_id): Delete a pull request comment reaction
- reactions.list_for_team_discussion_comment_legacy(team_id, discussion_number, comment_number, content, per_page, page): List reactions for a team discussion comment (Legacy)
- reactions.create_for_team_discussion_comment_legacy(team_id, discussion_number, comment_number, content): Create reaction for a team discussion comment (Legacy)
- reactions.list_for_team_discussion_legacy(team_id, discussion_number, content, per_page, page): List reactions for a team discussion (Legacy)
- reactions.create_for_team_discussion_legacy(team_id, discussion_number, content): Create reaction for a team discussion (Legacy)

## repos

- repos.list_for_org(org, type, sort, direction, per_page, page): List organization repositories
- repos.create_in_org(org, name, description, homepage, private, visibility, has_issues, has_projects, has_wiki, is_template, team_id, auto_init, gitignore_template, license_template, allow_squash_merge, allow_merge_commit, allow_rebase_merge, delete_branch_on_merge): Create an organization repository
- repos.get(owner, repo): Get a repository
- repos.update(owner, repo, name, description, homepage, private, visibility, has_issues, has_projects, has_wiki, is_template, default_branch, allow_squash_merge, allow_merge_commit, allow_rebase_merge, delete_branch_on_merge, archived): Update a repository
- repos.delete(owner, repo): Delete a repository
- repos.enable_automated_security_fixes(owner, repo): Enable automated security fixes
- repos.disable_automated_security_fixes(owner, repo): Disable automated security fixes
- repos.list_branches(owner, repo, protected, per_page, page): List branches
- repos.get_branch(owner, repo, branch): Get a branch
- repos.get_branch_protection(owner, repo, branch): Get branch protection
- repos.update_branch_protection(owner, repo, branch, required_status_checks, enforce_admins, required_pull_request_reviews, restrictions, required_linear_history, allow_force_pushes, allow_deletions): Update branch protection
- repos.delete_branch_protection(owner, repo, branch): Delete branch protection
- repos.get_admin_branch_protection(owner, repo, branch): Get admin branch protection
- repos.set_admin_branch_protection(owner, repo, branch): Set admin branch protection
- repos.delete_admin_branch_protection(owner, repo, branch): Delete admin branch protection
- repos.get_pull_request_review_protection(owner, repo, branch): Get pull request review protection
- repos.update_pull_request_review_protection(owner, repo, branch, dismissal_restrictions, dismiss_stale_reviews, require_code_owner_reviews, required_approving_review_count): Update pull request review protection
- repos.delete_pull_request_review_protection(owner, repo, branch): Delete pull request review protection
- repos.get_commit_signature_protection(owner, repo, branch): Get commit signature protection
- repos.create_commit_signature_protection(owner, repo, branch): Create commit signature protection
- repos.delete_commit_signature_protection(owner, repo, branch): Delete commit signature protection
- repos.get_status_checks_protection(owner, repo, branch): Get status checks protection
- repos.update_status_check_protection(owner, repo, branch, strict, contexts): Update status check protection
- repos.remove_status_check_protection(owner, repo, branch): Remove status check protection
- repos.get_all_status_check_contexts(owner, repo, branch): Get all status check contexts
- repos.add_status_check_contexts(owner, repo, branch, contexts): Add status check contexts
- repos.set_status_check_contexts(owner, repo, branch, contexts): Set status check contexts
- repos.remove_status_check_contexts(owner, repo, branch, contexts): Remove status check contexts
- repos.get_access_restrictions(owner, repo, branch): Get access restrictions
- repos.delete_access_restrictions(owner, repo, branch): Delete access restrictions
- repos.get_apps_with_access_to_protected_branch(owner, repo, branch): Get apps with access to the protected branch
- repos.add_app_access_restrictions(owner, repo, branch, apps): Add app access restrictions
- repos.set_app_access_restrictions(owner, repo, branch, apps): Set app access restrictions
- repos.remove_app_access_restrictions(owner, repo, branch, apps): Remove app access restrictions
- repos.get_teams_with_access_to_protected_branch(owner, repo, branch): Get teams with access to the protected branch
- repos.add_team_access_restrictions(owner, repo, branch, teams): Add team access restrictions
- repos.set_team_access_restrictions(owner, repo, branch, teams): Set team access restrictions
- repos.remove_team_access_restrictions(owner, repo, branch, teams): Remove team access restrictions
- repos.get_users_with_access_to_protected_branch(owner, repo, branch): Get users with access to the protected branch
- repos.add_user_access_restrictions(owner, repo, branch, users): Add user access restrictions
- repos.set_user_access_restrictions(owner, repo, branch, users): Set user access restrictions
- repos.remove_user_access_restrictions(owner, repo, branch, users): Remove user access restrictions
- repos.list_collaborators(owner, repo, affiliation, per_page, page): List repository collaborators
- repos.check_collaborator(owner, repo, username): Check if a user is a repository collaborator
- repos.add_collaborator(owner, repo, username, permission, permissions): Add a repository collaborator
- repos.remove_collaborator(owner, repo, username): Remove a repository collaborator
- repos.get_collaborator_permission_level(owner, repo, username): Get repository permissions for a user
- repos.list_commit_comments_for_repo(owner, repo, per_page, page): List commit comments for a repository
- repos.get_commit_comment(owner, repo, comment_id): Get a commit comment
- repos.update_commit_comment(owner, repo, comment_id, body): Update a commit comment
- repos.delete_commit_comment(owner, repo, comment_id): Delete a commit comment
- repos.list_commits(owner, repo, sha, path, author, since, until, per_page, page): List commits
- repos.list_branches_for_head_commit(owner, repo, commit_sha): List branches for HEAD commit
- repos.list_comments_for_commit(owner, repo, commit_sha, per_page, page): List commit comments
- repos.create_commit_comment(owner, repo, commit_sha, body, path, position, line): Create a commit comment
- repos.list_pull_requests_associated_with_commit(owner, repo, commit_sha, per_page, page): List pull requests associated with a commit
- repos.get_commit(owner, repo, ref): Get a commit
- repos.get_combined_status_for_ref(owner, repo, ref): Get the combined status for a specific reference
- repos.list_commit_statuses_for_ref(owner, repo, ref, per_page, page): List commit statuses for a reference
- repos.get_community_profile_metrics(owner, repo): Get community profile metrics
- repos.compare_commits(owner, repo, base, head): Compare two commits
- repos.get_content(owner, repo, path, ref): Get repository content
- repos.create_or_update_file_contents(owner, repo, path, message, content, sha, branch, committer, author): Create or update file contents
- repos.delete_file(owner, repo, path, message, sha, branch, committer, author): Delete a file
- repos.list_contributors(owner, repo, anon, per_page, page): List repository contributors
- repos.list_deployments(owner, repo, sha, ref, task, environment, per_page, page): List deployments
- repos.create_deployment(owner, repo, ref, task, auto_merge, required_contexts, payload, environment, description, transient_environment, production_environment, created_at): Create a deployment
- repos.get_deployment(owner, repo, deployment_id): Get a deployment
- repos.delete_deployment(owner, repo, deployment_id): Delete a deployment
- repos.list_deployment_statuses(owner, repo, deployment_id, per_page, page): List deployment statuses
- repos.create_deployment_status(owner, repo, deployment_id, state, target_url, log_url, description, environment, environment_url, auto_inactive): Create a deployment status
- repos.get_deployment_status(owner, repo, deployment_id, status_id): Get a deployment status
- repos.create_dispatch_event(owner, repo, event_type, client_payload): Create a repository dispatch event
- repos.list_forks(owner, repo, sort, per_page, page): List forks
- repos.create_fork(owner, repo, organization): Create a fork
- repos.list_webhooks(owner, repo, per_page, page): List repository webhooks
- repos.create_webhook(owner, repo, name, config, events, active): Create a repository webhook
- repos.get_webhook(owner, repo, hook_id): Get a repository webhook
- repos.update_webhook(owner, repo, hook_id, config, events, add_events, remove_events, active): Update a repository webhook
- repos.delete_webhook(owner, repo, hook_id): Delete a repository webhook
- repos.get_webhook_config_for_repo(owner, repo, hook_id): Get a webhook configuration for a repository
- repos.update_webhook_config_for_repo(owner, repo, hook_id, url, content_type, secret, insecure_ssl): Update a webhook configuration for a repository
- repos.ping_webhook(owner, repo, hook_id): Ping a repository webhook
- repos.test_push_webhook(owner, repo, hook_id): Test the push repository webhook
- repos.list_invitations(owner, repo, per_page, page): List repository invitations
- repos.update_invitation(owner, repo, invitation_id, permissions): Update a repository invitation
- repos.delete_invitation(owner, repo, invitation_id): Delete a repository invitation
- repos.list_deploy_keys(owner, repo, per_page, page): List deploy keys
- repos.create_deploy_key(owner, repo, title, key, read_only): Create a deploy key
- repos.get_deploy_key(owner, repo, key_id): Get a deploy key
- repos.delete_deploy_key(owner, repo, key_id): Delete a deploy key
- repos.list_languages(owner, repo): List repository languages
- repos.merge(owner, repo, base, head, commit_message): Merge a branch
- repos.get_pages(owner, repo): Get a GitHub Pages site
- repos.create_pages_site(owner, repo, source): Create a GitHub Pages site
- repos.update_information_about_pages_site(owner, repo, cname, source): Update information about a GitHub Pages site
- repos.delete_pages_site(owner, repo): Delete a GitHub Pages site
- repos.list_pages_builds(owner, repo, per_page, page): List GitHub Pages builds
- repos.request_pages_build(owner, repo): Request a GitHub Pages build
- repos.get_latest_pages_build(owner, repo): Get latest Pages build
- repos.get_pages_build(owner, repo, build_id): Get GitHub Pages build
- repos.get_readme(owner, repo, ref): Get a repository README
- repos.list_releases(owner, repo, per_page, page): List releases
- repos.create_release(owner, repo, tag_name, target_commitish, name, body, draft, prerelease): Create a release
- repos.get_release_asset(owner, repo, asset_id): Get a release asset
- repos.update_release_asset(owner, repo, asset_id, name, label, state): Update a release asset
- repos.delete_release_asset(owner, repo, asset_id): Delete a release asset
- repos.get_latest_release(owner, repo): Get the latest release
- repos.get_release_by_tag(owner, repo, tag): Get a release by tag name
- repos.get_release(owner, repo, release_id): Get a release
- repos.update_release(owner, repo, release_id, tag_name, target_commitish, name, body, draft, prerelease): Update a release
- repos.delete_release(owner, repo, release_id): Delete a release
- repos.list_release_assets(owner, repo, release_id, per_page, page): List release assets
- repos.upload_release_asset(owner, repo, release_id, name, label): Upload a release asset
- repos.get_code_frequency_stats(owner, repo): Get the weekly commit activity
- repos.get_commit_activity_stats(owner, repo): Get the last year of commit activity
- repos.get_contributors_stats(owner, repo): Get all contributor commit activity
- repos.get_participation_stats(owner, repo): Get the weekly commit count
- repos.get_punch_card_stats(owner, repo): Get the hourly commit count for each day
- repos.create_commit_status(owner, repo, sha, state, target_url, description, context): Create a commit status
- repos.list_tags(owner, repo, per_page, page): List repository tags
- repos.download_tarball_archive(owner, repo, ref): Download a repository archive (tar)
- repos.list_teams(owner, repo, per_page, page): List repository teams
- repos.get_all_topics(owner, repo): Get all repository topics
- repos.replace_all_topics(owner, repo, names): Replace all repository topics
- repos.get_clones(owner, repo, per): Get repository clones
- repos.get_top_paths(owner, repo): Get top referral paths
- repos.get_top_referrers(owner, repo): Get top referral sources
- repos.get_views(owner, repo, per): Get page views
- repos.transfer(owner, repo, new_owner, team_ids): Transfer a repository
- repos.check_vulnerability_alerts(owner, repo): Check if vulnerability alerts are enabled for a repository
- repos.enable_vulnerability_alerts(owner, repo): Enable vulnerability alerts
- repos.disable_vulnerability_alerts(owner, repo): Disable vulnerability alerts
- repos.download_zipball_archive(owner, repo, ref): Download a repository archive (zip)
- repos.create_using_template(template_owner, template_repo, owner, name, description, include_all_branches, private): Create a repository using a template
- repos.list_public(since): List public repositories
- repos.list_for_authenticated_user(visibility, affiliation, type, sort, direction, per_page, page, since, before): List repositories for the authenticated user
- repos.create_for_authenticated_user(name, description, homepage, private, has_issues, has_projects, has_wiki, team_id, auto_init, gitignore_template, license_template, allow_squash_merge, allow_merge_commit, allow_rebase_merge, delete_branch_on_merge, has_downloads, is_template): Create a repository for the authenticated user
- repos.list_invitations_for_authenticated_user(per_page, page): List repository invitations for the authenticated user
- repos.accept_invitation(invitation_id): Accept a repository invitation
- repos.decline_invitation(invitation_id): Decline a repository invitation
- repos.list_for_user(username, type, sort, direction, per_page, page): List repositories for a user

## scim

- scim.list_provisioned_identities(org, startIndex, count, filter): List SCIM provisioned identities
- scim.provision_and_invite_user(org, userName, displayName, name, emails, schemas, externalId, groups, active): Provision and invite a SCIM user
- scim.get_provisioning_information_for_user(org, scim_user_id): Get SCIM provisioning information for a user
- scim.set_information_for_provisioned_user(org, scim_user_id, schemas, displayName, externalId, groups, active, userName, name, emails): Update a provisioned organization membership
- scim.update_attribute_for_user(org, scim_user_id, schemas, Operations): Update an attribute for a SCIM user
- scim.delete_user_from_org(org, scim_user_id): Delete a SCIM user from an organization

## search

- search.code(q, sort, order, per_page, page): Search code
- search.commits(q, sort, order, per_page, page): Search commits
- search.issues_and_pull_requests(q, sort, order, per_page, page): Search issues and pull requests
- search.labels(repository_id, q, sort, order): Search labels
- search.repos(q, sort, order, per_page, page): Search repositories
- search.topics(q): Search topics
- search.users(q, sort, order, per_page, page): Search users

## teams

- teams.list_idp_groups_for_org(org, per_page, page): List IdP groups for an organization
- teams.list(org, per_page, page): List teams
- teams.create(org, name, description, maintainers, repo_names, privacy, permission, parent_team_id): Create a team
- teams.get_by_name(org, team_slug): Get a team by name
- teams.update_in_org(org, team_slug, name, description, privacy, permission, parent_team_id): Update a team
- teams.delete_in_org(org, team_slug): Delete a team
- teams.list_discussions_in_org(org, team_slug, direction, per_page, page): List discussions
- teams.create_discussion_in_org(org, team_slug, title, body, private): Create a discussion
- teams.get_discussion_in_org(org, team_slug, discussion_number): Get a discussion
- teams.update_discussion_in_org(org, team_slug, discussion_number, title, body): Update a discussion
- teams.delete_discussion_in_org(org, team_slug, discussion_number): Delete a discussion
- teams.list_discussion_comments_in_org(org, team_slug, discussion_number, direction, per_page, page): List discussion comments
- teams.create_discussion_comment_in_org(org, team_slug, discussion_number, body): Create a discussion comment
- teams.get_discussion_comment_in_org(org, team_slug, discussion_number, comment_number): Get a discussion comment
- teams.update_discussion_comment_in_org(org, team_slug, discussion_number, comment_number, body): Update a discussion comment
- teams.delete_discussion_comment_in_org(org, team_slug, discussion_number, comment_number): Delete a discussion comment
- teams.list_pending_invitations_in_org(org, team_slug, per_page, page): List pending team invitations
- teams.list_members_in_org(org, team_slug, role, per_page, page): List team members
- teams.get_membership_for_user_in_org(org, team_slug, username): Get team membership for a user
- teams.add_or_update_membership_for_user_in_org(org, team_slug, username, role): Add or update team membership for a user
- teams.remove_membership_for_user_in_org(org, team_slug, username): Remove team membership for a user
- teams.list_projects_in_org(org, team_slug, per_page, page): List team projects
- teams.check_permissions_for_project_in_org(org, team_slug, project_id): Check team permissions for a project
- teams.add_or_update_project_permissions_in_org(org, team_slug, project_id, permission): Add or update team project permissions
- teams.remove_project_in_org(org, team_slug, project_id): Remove a project from a team
- teams.list_repos_in_org(org, team_slug, per_page, page): List team repositories
- teams.check_permissions_for_repo_in_org(org, team_slug, owner, repo): Check team permissions for a repository
- teams.add_or_update_repo_permissions_in_org(org, team_slug, owner, repo, permission): Add or update team repository permissions
- teams.remove_repo_in_org(org, team_slug, owner, repo): Remove a repository from a team
- teams.list_idp_groups_in_org(org, team_slug): List IdP groups for a team
- teams.create_or_update_idp_group_connections_in_org(org, team_slug, groups): Create or update IdP group connections
- teams.list_child_in_org(org, team_slug, per_page, page): List child teams
- teams.get_legacy(team_id): Get a team (Legacy)
- teams.update_legacy(team_id, name, description, privacy, permission, parent_team_id): Update a team (Legacy)
- teams.delete_legacy(team_id): Delete a team (Legacy)
- teams.list_discussions_legacy(team_id, direction, per_page, page): List discussions (Legacy)
- teams.create_discussion_legacy(team_id, title, body, private): Create a discussion (Legacy)
- teams.get_discussion_legacy(team_id, discussion_number): Get a discussion (Legacy)
- teams.update_discussion_legacy(team_id, discussion_number, title, body): Update a discussion (Legacy)
- teams.delete_discussion_legacy(team_id, discussion_number): Delete a discussion (Legacy)
- teams.list_discussion_comments_legacy(team_id, discussion_number, direction, per_page, page): List discussion comments (Legacy)
- teams.create_discussion_comment_legacy(team_id, discussion_number, body): Create a discussion comment (Legacy)
- teams.get_discussion_comment_legacy(team_id, discussion_number, comment_number): Get a discussion comment (Legacy)
- teams.update_discussion_comment_legacy(team_id, discussion_number, comment_number, body): Update a discussion comment (Legacy)
- teams.delete_discussion_comment_legacy(team_id, discussion_number, comment_number): Delete a discussion comment (Legacy)
- teams.list_pending_invitations_legacy(team_id, per_page, page): List pending team invitations (Legacy)
- teams.list_members_legacy(team_id, role, per_page, page): List team members (Legacy)
- teams.get_member_legacy(team_id, username): Get team member (Legacy)
- teams.add_member_legacy(team_id, username): Add team member (Legacy)
- teams.remove_member_legacy(team_id, username): Remove team member (Legacy)
- teams.get_membership_for_user_legacy(team_id, username): Get team membership for a user (Legacy)
- teams.add_or_update_membership_for_user_legacy(team_id, username, role): Add or update team membership for a user (Legacy)
- teams.remove_membership_for_user_legacy(team_id, username): Remove team membership for a user (Legacy)
- teams.list_projects_legacy(team_id, per_page, page): List team projects (Legacy)
- teams.check_permissions_for_project_legacy(team_id, project_id): Check team permissions for a project (Legacy)
- teams.add_or_update_project_permissions_legacy(team_id, project_id, permission): Add or update team project permissions (Legacy)
- teams.remove_project_legacy(team_id, project_id): Remove a project from a team (Legacy)
- teams.list_repos_legacy(team_id, per_page, page): List team repositories (Legacy)
- teams.check_permissions_for_repo_legacy(team_id, owner, repo): Check team permissions for a repository (Legacy)
- teams.add_or_update_repo_permissions_legacy(team_id, owner, repo, permission): Add or update team repository permissions (Legacy)
- teams.remove_repo_legacy(team_id, owner, repo): Remove a repository from a team (Legacy)
- teams.list_idp_groups_for_legacy(team_id): List IdP groups for a team (Legacy)
- teams.create_or_update_idp_group_connections_legacy(team_id, groups, synced_at): Create or update IdP group connections (Legacy)
- teams.list_child_legacy(team_id, per_page, page): List child teams (Legacy)
- teams.list_for_authenticated_user(per_page, page): List teams for the authenticated user

## users

- users.get_authenticated(): Get the authenticated user
- users.update_authenticated(name, email, blog, twitter_username, company, location, hireable, bio): Update the authenticated user
- users.list_blocked_by_authenticated(): List users blocked by the authenticated user
- users.check_blocked(username): Check if a user is blocked by the authenticated user
- users.block(username): Block a user
- users.unblock(username): Unblock a user
- users.set_primary_email_visibility_for_authenticated(email, visibility): Set primary email visibility for the authenticated user
- users.list_emails_for_authenticated(per_page, page): List email addresses for the authenticated user
- users.add_email_for_authenticated(): Add an email address for the authenticated user
- users.delete_email_for_authenticated(): Delete an email address for the authenticated user
- users.list_followers_for_authenticated_user(per_page, page): List followers of the authenticated user
- users.list_followed_by_authenticated(per_page, page): List the people the authenticated user follows
- users.check_person_is_followed_by_authenticated(username): Check if a person is followed by the authenticated user
- users.follow(username): Follow a user
- users.unfollow(username): Unfollow a user
- users.list_gpg_keys_for_authenticated(per_page, page): List GPG keys for the authenticated user
- users.create_gpg_key_for_authenticated(armored_public_key): Create a GPG key for the authenticated user
- users.get_gpg_key_for_authenticated(gpg_key_id): Get a GPG key for the authenticated user
- users.delete_gpg_key_for_authenticated(gpg_key_id): Delete a GPG key for the authenticated user
- users.list_public_ssh_keys_for_authenticated(per_page, page): List public SSH keys for the authenticated user
- users.create_public_ssh_key_for_authenticated(title, key): Create a public SSH key for the authenticated user
- users.get_public_ssh_key_for_authenticated(key_id): Get a public SSH key for the authenticated user
- users.delete_public_ssh_key_for_authenticated(key_id): Delete a public SSH key for the authenticated user
- users.list_public_emails_for_authenticated(per_page, page): List public email addresses for the authenticated user
- users.list(since, per_page): List users
- users.get_by_username(username): Get a user
- users.list_followers_for_user(username, per_page, page): List followers of a user
- users.list_following_for_user(username, per_page, page): List the people a user follows
- users.check_following_for_user(username, target_user): Check if a user follows another user
- users.list_gpg_keys_for_user(username, per_page, page): List GPG keys for a user
- users.get_context_for_user(username, subject_type, subject_id): Get contextual information for a user
- users.list_public_keys_for_user(username, per_page, page): List public keys for a user

{% endraw %}