<file_sep># Javascript API

The Javascript API of the githubApp endpoint has three pieces:

- **HTTP requests**: These allow to make regular HTTP requests.
- **Shortcuts**: These are helpers to make HTTP request to the API in a more convenient way.
- **Additional Helpers**: These helpers provide additional features that facilitate or improves the endpoint usage in SLINGR.

## HTTP requests
You can make `GET`,`POST`,`DELETE`,`PATCH`,`PUT` requests to the [githubApp API](API_URL_HERE) like this:
```javascript
var response = app.endpoints.githubApp.get('/orgs/:org/teams')
var response = app.endpoints.githubApp.post('/repos/:owner/:repo/git/refs', body)
var response = app.endpoints.githubApp.post('/repos/:owner/:repo/git/refs')
var response = app.endpoints.githubApp.delete('/orgs/:org/outside_collaborators/:username')
var response = app.endpoints.githubApp.patch('/repos/:owner/:repo/git/refs/:ref', body)
var response = app.endpoints.githubApp.patch('/repos/:owner/:repo/git/refs/:ref')
var response = app.endpoints.githubApp.put('/notifications', body)
var response = app.endpoints.githubApp.put('/notifications')
```

Please take a look at the documentation of the [HTTP endpoint](https://github.com/slingr-stack/http-endpoint#javascript-api)
for more information about generic requests.

## Shortcuts

Instead of having to use the generic HTTP methods, you can (and should) make use of the helpers provided in the endpoint:
<details>
    <summary>Click here to see all the helpers</summary>

<br>

* API URL: '/events'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.events.get()
```
---
* API URL: '/repos/:owner/:repo/events'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.events.get(owner, repo)
```
---
* API URL: '/networks/:owner/:repo/events'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.networks.events.get(owner, repo)
```
---
* API URL: '/orgs/:org/events'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.events.get(org)
```
---
* API URL: '/users/:username/received_events'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.receivedEvents.get(username)
```
---
* API URL: '/users/:username/events'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.events.get(username)
```
---
* API URL: '/users/:username/events/public'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.events.public.get(username)
```
---
* API URL: '/users/:username/events/orgs/:org'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.events.orgs.get(username, org)
```
---
* API URL: '/feeds'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.feeds.get()
```
---
* API URL: '/notifications'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.notifications.get()
```
---
* API URL: '/repos/:owner/:repo/notifications'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.notifications.get(owner, repo)
```
---
* API URL: '/notifications/threads/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.notifications.threads.get(id)
```
---
* API URL: '/notifications/threads/:id/subscription'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.notifications.threads.subscription.get(id)
```
---
* API URL: '/repos/:owner/:repo/stargazers'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.stargazers.get(owner, repo)
```
---
* API URL: '/users/:username/starred'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.starred.get(username)
```
---
* API URL: '/user/starred'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.starred.get()
```
---
* API URL: '/user/starred/:owner/:repo'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.starred.get(owner)
```
---
* API URL: '/repos/:owner/:repo/subscribers'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.subscribers.get(owner, repo)
```
---
* API URL: '/users/:username/subscriptions'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.subscriptions.get(username)
```
---
* API URL: '/user/subscriptions'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.subscriptions.get()
```
---
* API URL: '/repos/:owner/:repo/subscription'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.subscription.get(owner, repo)
```
---
* API URL: '/users/:username/gists'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.gists.get(username)
```
---
* API URL: '/gists'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gists.get()
```
---
* API URL: '/gists/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gists.get()
```
---
* API URL: '/gists/:id/:sha'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gists.get(id)
```
---
* API URL: '/gists/public'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gists.public.get()
```
---
* API URL: '/gists/starred'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gists.starred.get()
```
---
* API URL: '/gists/:id/commits'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gists.commits.get(id)
```
---
* API URL: '/gists/:id/star'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gists.star.get(id)
```
---
* API URL: '/gists/:id/forks'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gists.forks.get(id)
```
---
* API URL: '/repos/:owner/:repo/git/blobs/:sha'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.git.blobs.get(owner, repo, sha)
```
---
* API URL: '/repos/:owner/:repo/git/commits/:sha'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.git.commits.get(owner, repo, sha)
```
---
* API URL: '/repos/:owner/:repo/git/refs/:ref'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.git.refs.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/git/refs'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.git.refs.get(owner)
```
---
* API URL: '/repos/:owner/:repo/git/tags/:sha'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.git.tags.get(owner, repo, sha)
```
---
* API URL: '/repos/:owner/:repo/git/trees/:sha'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.git.trees.get(owner, repo, sha)
```
---
* API URL: '/apps/:app_slug'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.apps.get(appSlug)
```
---
* API URL: '/app'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.app.get()
```
---
* API URL: '/app/installations'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.app.installations.get()
```
---
* API URL: '/app/installations/:installation_id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.app.installations.get()
```
---
* API URL: '/user/installations'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.installations.get()
```
---
* API URL: '/installation/repositories'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.installation.repositories.get()
```
---
* API URL: '/user/installations/:installation_id/repositories'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.installations.repositories.get(installationId)
```
---
* API URL: '/marketplace_listing/plans'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.marketplaceListing.plans.get()
```
---
* API URL: '/marketplace_listing/plans/:id/accounts'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.marketplaceListing.plans.accounts.get(id)
```
---
* API URL: '/marketplace_listing/accounts/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.marketplaceListing.accounts.get(id)
```
---
* API URL: '/user/marketplace_purchases'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.marketplacePurchases.get()
```
---
* API URL: '/issues'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.issues.get()
```
---
* API URL: '/user/issues'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.issues.get()
```
---
* API URL: '/orgs/:org/issues'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.issues.get(org)
```
---
* API URL: '/repos/:owner/:repo/issues'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.get(owner)
```
---
* API URL: '/repos/:owner/:repo/issues/:number'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/assignees'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.assignees.get(owner)
```
---
* API URL: '/repos/:owner/:repo/assignees/:assignee'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.assignees.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/comments'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.comments.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/issues/comments'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.comments.get(owner)
```
---
* API URL: '/repos/:owner/:repo/issues/:issue_number/events'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.events.byIssue.get(owner, repo, issueNumber)
```
---
* API URL: '/repos/:owner/:repo/issues/events'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.events.get(owner)
```
---
* API URL: '/repos/:owner/:repo/issues/events/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.events.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/labels'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.labels.get(owner)
```
---
* API URL: '/repos/:owner/:repo/labels/:name'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.labels.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/labels'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.labels.get(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/milestones/:number/labels'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.milestones.labels.get(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/milestones'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.milestones.get(owner)
```
---
* API URL: '/repos/:owner/:repo/milestones/:number'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.milestones.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/issues/:issue_number/timeline'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.timeline.get(owner, repo, issueNumber)
```
---
* API URL: '/codes_of_conduct'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.codesOfConduct.get()
```
---
* API URL: '/codes_of_conduct/:key'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.codesOfConduct.get()
```
---
* API URL: '/repos/:owner/:repo'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.get(owner)
```
---
* API URL: '/repos/:owner/:repo/:archive_format/:ref'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.get(owner, repo, archiveFormat)
```
---
* API URL: '/repos/:owner/:repo/community/code_of_conduct'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.community.codeOfConduct.get(owner, repo)
```
---
* API URL: '/emojis'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.emojis.get()
```
---
* API URL: '/gitignore/templates'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gitignore.templates.get()
```
---
* API URL: '/gitignore/templates/:name'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.gitignore.templates.get()
```
---
* API URL: '/licenses'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.licenses.get()
```
---
* API URL: '/licenses/:license'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.licenses.get()
```
---
* API URL: '/repos/:owner/:repo/license'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.license.get(owner, repo)
```
---
* API URL: '/meta'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.meta.get()
```
---
* API URL: '/rate_limit'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.rateLimit.get()
```
---
* API URL: '/user/orgs'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.orgs.get()
```
---
* API URL: '/organizations'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.organizations.get()
```
---
* API URL: '/users/:username/orgs'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.orgs.get(username)
```
---
* API URL: '/orgs/:org'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.get(org)
```
---
* API URL: '/orgs/:org/members'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.members.get()
```
---
* API URL: '/orgs/:org/members/:username'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.members.get(org)
```
---
* API URL: '/orgs/:org/public_members/:username'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.publicMembers.get(org)
```
---
* API URL: '/orgs/:org/public_members'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.publicMembers.get()
```
---
* API URL: '/orgs/:org/invitations'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.invitations.get(org)
```
---
* API URL: '/orgs/:org/memberships/:username'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.memberships.get(org, username)
```
---
* API URL: '/user/memberships/orgs'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.memberships.orgs.get()
```
---
* API URL: '/user/memberships/orgs/:org'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.memberships.orgs.get()
```
---
* API URL: '/orgs/:org/outside_collaborators'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.outsideCollaborators.get(org)
```
---
* API URL: '/orgs/:org/teams'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.teams.get(org)
```
---
* API URL: '/teams/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.teams.get(id)
```
---
* API URL: '/teams/:id/teams'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.teams.teams.get(id)
```
---
* API URL: '/teams/:id/members'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.teams.members.get()
```
---
* API URL: '/teams/:id/members/:username'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.teams.members.get(id)
```
---
* API URL: '/teams/:id/memberships/:username'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.teams.memberships.get(id, username)
```
---
* API URL: '/teams/:id/invitations'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.teams.invitations.get(id)
```
---
* API URL: '/teams/:id/repos'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.teams.repos.get()
```
---
* API URL: '/teams/:id/repos/:owner/:repo'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.teams.repos.get(id, owner)
```
---
* API URL: '/user/teams'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.teams.get()
```
---
* API URL: '/orgs/:org/hooks'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.hooks.get()
```
---
* API URL: '/orgs/:org/hooks/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.hooks.get(org)
```
---
* API URL: '/orgs/:org/blocks'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.blocks.get()
```
---
* API URL: '/orgs/:org/blocks/:username'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.blocks.get(org)
```
---
* API URL: '/repos/:owner/:repo/projects'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.projects.get(owner, repo)
```
---
* API URL: '/orgs/:org/projects'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.projects.get(org)
```
---
* API URL: '/projects/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.projects.get(id)
```
---
* API URL: '/projects/columns/:column_id/cards'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.projects.columns.cards.get(columnId)
```
---
* API URL: '/projects/columns/cards/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.projects.columns.cards.byId.get(id)
```
---
* API URL: '/projects/:project_id/columns'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.projects.columns.get(projectId)
```
---
* API URL: '/projects/columns/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.projects.columns.byId.get(id)
```
---
* API URL: '/repos/:owner/:repo/pulls'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.get(owner)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/commits'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.commits.get(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/files'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.files.get(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/merge'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.merge.get(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/reviews'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.reviews.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/reviews/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.reviews.get(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/reviews/:id/comments'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.reviews.comments.get(owner, repo, number, id)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/comments'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.comments.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/pulls/comments'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.comments.get(owner)
```
---
* API URL: '/repos/:owner/:repo/pulls/comments/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.comments.byId.get(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/requested_reviewers'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.requestedReviewers.get(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/comments/:id/reactions'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.comments.reactions.get(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/reactions'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.reactions.get(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/issues/comments/:id/reactions'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.issues.comments.reactions.get(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/pulls/comments/:id/reactions'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pulls.comments.reactions.get(owner, repo, id)
```
---
* API URL: '/user/repos'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.repos.get()
```
---
* API URL: '/users/:username/repos'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.users.repos.get(username)
```
---
* API URL: '/orgs/:org/repos'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.orgs.repos.get(org)
```
---
* API URL: '/repositories'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repositories.get()
```
---
* API URL: '/repos/:owner/:repo/topics'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.topics.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/contributors'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.contributors.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/languages'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.languages.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/teams'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.teams.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/tags'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.tags.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/branches'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.get(owner)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.protection.get(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_status_checks'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredStatusChecks.get(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredStatusChecks.contexts.get(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredPullRequestReviews.get(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/enforce_admins'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.protection.enforceAdmins.get(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.get(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions/teams'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.teams.get(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions/users'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.users.get(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/collaborators'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.collaborators.get(owner)
```
---
* API URL: '/repos/:owner/:repo/collaborators/:username'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.collaborators.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/collaborators/:username/permission'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.collaborators.permission.get(owner, repo, username)
```
---
* API URL: '/repos/:owner/:repo/comments'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.comments.get(owner)
```
---
* API URL: '/repos/:owner/:repo/comments/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.comments.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/commits/:ref/comments'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.commits.comments.get(owner, repo, ref)
```
---
* API URL: '/repos/:owner/:name/community/profile'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.community.profile.get(owner, name)
```
---
* API URL: '/repos/:owner/:repo/commits'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.commits.get(owner)
```
---
* API URL: '/repos/:owner/:repo/commits/:sha'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.commits.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/compare/:baseCommitSuspensivePointsHeadCommit'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.compare.get(owner, repo, baseCommitSuspensivePointsHeadCommit)
```
---
* API URL: '/repos/:owner/:repo/readme'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.readme.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/contents/:path'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.contents.get(owner, repo, path)
```
---
* API URL: '/repos/:owner/:repo/keys'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.keys.get(owner)
```
---
* API URL: '/repos/:owner/:repo/keys/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.keys.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/deployments'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.deployments.get(owner)
```
---
* API URL: '/repos/:owner/:repo/deployments/:deployment_id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.deployments.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/deployments/:id/statuses'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.deployments.statuses.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/deployments/:id/statuses/:status_id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.deployments.statuses.get(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/downloads'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.downloads.get(owner)
```
---
* API URL: '/repos/:owner/:repo/downloads/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.downloads.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/forks'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.forks.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/invitations'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.invitations.get(owner, repo)
```
---
* API URL: '/user/repository_invitations'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.user.repositoryInvitations.get()
```
---
* API URL: '/repos/:owner/:repo/pages'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pages.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/pages/builds'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pages.builds.get(owner)
```
---
* API URL: '/repos/:owner/:repo/pages/builds/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pages.builds.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/pages/builds/latest'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.pages.builds.latest.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/releases'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.releases.get(owner)
```
---
* API URL: '/repos/:owner/:repo/releases/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.releases.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/releases/latest'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.releases.latest.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/releases/tags/:tag'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.releases.tags.get(owner, repo, tag)
```
---
* API URL: '/repos/:owner/:repo/releases/:id/assets'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.releases.assets.get(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/releases/assets/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.releases.assets.byId.get(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/stats/contributors'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.stats.contributors.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/stats/commit_activity'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.stats.commitActivity.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/stats/code_frequency'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.stats.codeFrequency.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/stats/participation'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.stats.participation.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/stats/punch_card'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.stats.punchCard.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/commits/:ref/statuses'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.commits.statuses.get(owner, repo, ref)
```
---
* API URL: '/repos/:owner/:repo/commits/:ref/status'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.commits.status.get(owner, repo, ref)
```
---
* API URL: '/repos/:owner/:repo/traffic/popular/referrers'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.traffic.popular.referrers.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/traffic/popular/paths'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.traffic.popular.paths.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/traffic/views'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.traffic.views.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/traffic/clones'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.traffic.clones.get(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/hooks'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.hooks.get(owner)
```
---
* API URL: '/repos/:owner/:repo/hooks/:id'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.repos.hooks.get(owner, repo)
```
---
* API URL: '/search/repositories'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.search.repositories.get()
```
---
* API URL: '/search/commits'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.search.commits.get()
```
---
* API URL: '/search/code'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.search.code.get()
```
---
* API URL: '/search/issues'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.search.issues.get()
```
---
* API URL: '/search/users'
* HTTP Method: 'GET'
```javascript
app.endpoints.githubApp.search.users.get()
```
---
* API URL: '/gists'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.gists.post(body)
```
---
* API URL: '/gists/:id/forks'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.gists.forks.post(id, body)
```
---
* API URL: '/repos/:owner/:repo/git/blobs'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.git.blobs.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/git/commits'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.git.commits.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/git/refs'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.git.refs.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/git/tags'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.git.tags.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/git/trees'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.git.trees.post(owner, repo, body)
```
---
* API URL: '/installations/:installation_id/access_tokens'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.installations.accessTokens.post(installationId, body)
```
---
* API URL: '/repos/:owner/:repo/issues'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.issues.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/assignees'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.issues.assignees.post(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/comments'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.issues.comments.post(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/labels'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.labels.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/labels'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.issues.labels.post(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/milestones'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.milestones.post(owner, repo, body)
```
---
* API URL: '/markdown'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.markdown.post(body)
```
---
* API URL: '/markdown/raw'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.markdown.raw.post(body)
```
---
* API URL: '/orgs/:org/teams'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.orgs.teams.post(org, body)
```
---
* API URL: '/orgs/:org/hooks'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.orgs.hooks.post(org, body)
```
---
* API URL: '/orgs/:org/hooks/:id/pings'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.orgs.hooks.pings.post(org, id, body)
```
---
* API URL: '/repos/:owner/:repo/projects'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.projects.post(owner, repo, body)
```
---
* API URL: '/orgs/:org/projects'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.orgs.projects.post(org, body)
```
---
* API URL: '/projects/columns/:column_id/cards'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.projects.columns.cards.post(columnId, body)
```
---
* API URL: '/projects/columns/cards/:id/moves'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.projects.columns.cards.moves.post(id, body)
```
---
* API URL: '/projects/:project_id/columns'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.projects.columns.post(projectId, body)
```
---
* API URL: '/projects/columns/:id/moves'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.projects.columns.moves.post(id, body)
```
---
* API URL: '/repos/:owner/:repo/pulls'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.pulls.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/reviews'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.pulls.reviews.post(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/reviews/:id/events'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.pulls.reviews.events.post(owner, repo, number, id, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/comments'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.pulls.comments.post(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/requested_reviewers'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.pulls.requestedReviewers.post(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/comments/:id/reactions'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.comments.reactions.post(owner, repo, id, body)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/reactions'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.issues.reactions.post(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/issues/comments/:id/reactions'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.issues.comments.reactions.post(owner, repo, id, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/comments/:id/reactions'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.pulls.comments.reactions.post(owner, repo, id, body)
```
---
* API URL: '/user/repos'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.user.repos.post(body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredStatusChecks.contexts.post(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/enforce_admins'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.branches.protection.enforceAdmins.post(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions/teams'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.teams.post(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions/users'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.users.post(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/commits/:sha/comments'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.commits.comments.post(owner, repo, sha, body)
```
---
* API URL: '/repos/:owner/:repo/keys'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.keys.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/merges'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.merges.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/pages/builds'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.pages.builds.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/releases'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.releases.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/statuses/:sha'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.statuses.post(owner, repo, sha, body)
```
---
* API URL: '/repos/:owner/:repo/hooks'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.hooks.post(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/hooks/:id/tests'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.hooks.tests.post(owner, repo, id, body)
```
---
* API URL: '/repos/:owner/:repo/hooks/:id/pings'
* HTTP Method: 'POST'
```javascript
app.endpoints.githubApp.repos.hooks.pings.post(owner, repo, id, body)
```
---
* API URL: '/notifications/threads/:id/subscription'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.notifications.threads.subscription.delete(id)
```
---
* API URL: '/user/starred/:owner/:repo'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.user.starred.delete(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/subscription'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.subscription.delete(owner, repo)
```
---
* API URL: '/gists/:id/star'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.gists.star.delete(id)
```
---
* API URL: '/gists/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.gists.delete(id)
```
---
* API URL: '/repos/:owner/:repo/git/refs/:ref'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.git.refs.delete(owner, repo, ref)
```
---
* API URL: '/user/installations/:installation_id/repositories/:repository_id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.user.installations.repositories.delete(installationId, repositoryId)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/lock'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.issues.lock.delete(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/assignees'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.issues.assignees.delete(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/issues/comments/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.issues.comments.delete(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/labels/:name'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.labels.delete(owner, repo, name)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/labels/:name'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.issues.labels.delete(owner, repo, number)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/labels'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.issues.labels.delete(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/milestones/:number'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.milestones.delete(owner, repo, number)
```
---
* API URL: '/orgs/:org/members/:username'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.orgs.members.delete(org, username)
```
---
* API URL: '/orgs/:org/public_members/:username'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.orgs.publicMembers.delete(org, username)
```
---
* API URL: '/orgs/:org/memberships/:username'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.orgs.memberships.delete(org, username)
```
---
* API URL: '/orgs/:org/outside_collaborators/:username'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.orgs.outsideCollaborators.delete(org, username)
```
---
* API URL: '/teams/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.teams.delete(id)
```
---
* API URL: '/teams/:id/memberships/:username'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.teams.memberships.delete(id, username)
```
---
* API URL: '/teams/:id/repos/:owner/:repo'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.teams.repos.delete(id, owner, repo)
```
---
* API URL: '/orgs/:org/hooks/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.orgs.hooks.delete(org, id)
```
---
* API URL: '/orgs/:org/blocks/:username'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.orgs.blocks.delete(org, username)
```
---
* API URL: '/projects/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.projects.delete(id)
```
---
* API URL: '/projects/columns/cards/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.projects.columns.cards.delete(id)
```
---
* API URL: '/projects/columns/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.projects.columns.delete(id)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/reviews/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.pulls.reviews.delete(owner, repo, number, id)
```
---
* API URL: '/repos/:owner/:repo/pulls/comments/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.pulls.comments.delete(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/requested_reviewers'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.pulls.requestedReviewers.delete(owner, repo, number)
```
---
* API URL: '/reactions/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.reactions.delete(id)
```
---
* API URL: '/repos/:owner/:repo'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.delete(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.branches.protection.delete(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_status_checks'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredStatusChecks.delete(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredStatusChecks.contexts.delete(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredPullRequestReviews.delete(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/enforce_admins'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.branches.protection.enforceAdmins.delete(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.delete(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions/teams'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.teams.delete(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions/users'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.users.delete(owner, repo, branch)
```
---
* API URL: '/repos/:owner/:repo/collaborators/:username'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.collaborators.delete(owner, repo, username)
```
---
* API URL: '/repos/:owner/:repo/comments/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.comments.delete(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/contents/:path'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.contents.delete(owner, repo, path)
```
---
* API URL: '/repos/:owner/:repo/keys/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.keys.delete(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/deployments'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.deployments.delete(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/deployments/:id/statuses'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.deployments.statuses.delete(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/downloads/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.downloads.delete(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/forks'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.forks.delete(owner, repo)
```
---
* API URL: '/repos/:owner/:repo/invitations/:invitation_id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.invitations.delete(owner, repo, invitationId)
```
---
* API URL: '/user/repository_invitations/:invitation_id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.user.repositoryInvitations.delete(invitationId)
```
---
* API URL: '/repos/:owner/:repo/releases/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.releases.delete(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/releases/assets/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.releases.assets.delete(owner, repo, id)
```
---
* API URL: '/repos/:owner/:repo/hooks/:id'
* HTTP Method: 'DELETE'
```javascript
app.endpoints.githubApp.repos.hooks.delete(owner, repo, id)
```
---
* API URL: '/notifications/threads/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.notifications.threads.patch(id, body)
```
---
* API URL: '/gists/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.gists.patch(id, body)
```
---
* API URL: '/repos/:owner/:repo/git/refs/:ref'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.git.refs.patch(owner, repo, ref, body)
```
---
* API URL: '/repos/:owner/:repo/issues/:number'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.issues.patch(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/issues/comments/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.issues.comments.patch(owner, repo, id, body)
```
---
* API URL: '/repos/:owner/:repo/labels/:name'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.labels.patch(owner, repo, name, body)
```
---
* API URL: '/repos/:owner/:repo/milestones/:number'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.milestones.patch(owner, repo, number, body)
```
---
* API URL: '/orgs/:org'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.orgs.patch(org, body)
```
---
* API URL: '/user/memberships/orgs/:org'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.user.memberships.orgs.patch(org, body)
```
---
* API URL: '/teams/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.teams.patch(id, body)
```
---
* API URL: '/orgs/:org/hooks/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.orgs.hooks.patch(org, id, body)
```
---
* API URL: '/projects/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.projects.patch(id, body)
```
---
* API URL: '/projects/columns/cards/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.projects.columns.cards.patch(id, body)
```
---
* API URL: '/projects/columns/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.projects.columns.patch(id, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.pulls.patch(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/comments/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.pulls.comments.patch(owner, repo, id, body)
```
---
* API URL: '/repos/:owner/:repo'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.patch(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_status_checks'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredStatusChecks.patch(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredPullRequestReviews.patch(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/comments/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.comments.patch(owner, repo, id, body)
```
---
* API URL: '/repos/:owner/:repo/invitations/:invitation_id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.invitations.patch(owner, repo, invitationId, body)
```
---
* API URL: '/user/repository_invitations/:invitation_id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.user.repositoryInvitations.patch(invitationId, body)
```
---
* API URL: '/repos/:owner/:repo/releases/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.releases.patch(owner, repo, id, body)
```
---
* API URL: '/repos/:owner/:repo/releases/assets/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.releases.assets.patch(owner, repo, id, body)
```
---
* API URL: '/repos/:owner/:repo/hooks/:id'
* HTTP Method: 'PATCH'
```javascript
app.endpoints.githubApp.repos.hooks.patch(owner, repo, id, body)
```
---
* API URL: '/notifications'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.notifications.put(body)
```
---
* API URL: '/repos/:owner/:repo/notifications'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.notifications.put(owner, repo, body)
```
---
* API URL: '/notifications/threads/:id/subscription'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.notifications.threads.subscription.put(id, body)
```
---
* API URL: '/user/starred/:owner/:repo'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.user.starred.put(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/subscription'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.subscription.put(owner, repo, body)
```
---
* API URL: '/gists/:id/star'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.gists.star.put(id, body)
```
---
* API URL: '/user/installations/:installation_id/repositories/:repository_id'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.user.installations.repositories.put(installationId, repositoryId, body)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/lock'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.issues.lock.put(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/issues/:number/labels'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.issues.labels.put(owner, repo, number, body)
```
---
* API URL: '/orgs/:org/public_members/:username'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.orgs.publicMembers.put(org, username, body)
```
---
* API URL: '/orgs/:org/memberships/:username'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.orgs.memberships.put(org, username, body)
```
---
* API URL: '/orgs/:org/outside_collaborators/:username'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.orgs.outsideCollaborators.put(org, username, body)
```
---
* API URL: '/teams/:id/members/:username'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.teams.members.put(id, username, body)
```
---
* API URL: '/teams/:id/memberships/:username'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.teams.memberships.put(id, username, body)
```
---
* API URL: '/teams/:id/repos/:org/:repo'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.teams.repos.put(id, org, repo, body)
```
---
* API URL: '/orgs/:org/blocks/:username'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.orgs.blocks.put(org, username, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/merge'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.pulls.merge.put(owner, repo, number, body)
```
---
* API URL: '/repos/:owner/:repo/pulls/:number/reviews/:id/dismissals'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.pulls.reviews.dismissals.put(owner, repo, number, id, body)
```
---
* API URL: '/repos/:owner/:repo/topics'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.topics.put(owner, repo, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.branches.protection.put(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.branches.protection.requiredStatusChecks.contexts.put(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions/teams'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.teams.put(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/branches/:branch/protection/restrictions/users'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.branches.protection.restrictions.users.put(owner, repo, branch, body)
```
---
* API URL: '/repos/:owner/:repo/collaborators/:username'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.collaborators.put(owner, repo, username, body)
```
---
* API URL: '/repos/:owner/:repo/contents/:path'
* HTTP Method: 'PUT'
```javascript
app.endpoints.githubApp.repos.contents.put(owner, repo, path, body)
```
---

</details>
    
## Flow Step

As an alternative option to using scripts, you can make use of Flows and Flow Steps specifically created for the endpoint: 
<details>
    <summary>Click here to see the Flow Steps</summary>

<br>



### Generic Flow Step

Generic flow step for full use of the entire endpoint and its services.

<h3>Inputs</h3>

<table>
    <thead>
    <tr>
        <th>Label</th>
        <th>Type</th>
        <th>Required</th>
        <th>Default</th>
        <th>Visibility</th>
        <th>Description</th>
    </tr>
    </thead>
    <tbody>
    <tr>
        <td>URL (Method)</td>
        <td>choice</td>
        <td>yes</td>
        <td> - </td>
        <td>Always</td>
        <td>
            This is the http method to be used against the endpoint. <br>
            Possible values are: <br>
            <i><strong>GET,POST,DELETE,PATCH,PUT</strong></i>
        </td>
    </tr>
    <tr>
        <td>URL (Path)</td>
        <td>choice</td>
        <td>yes</td>
        <td> - </td>
        <td>Always</td>
        <td>
            The url to which this endpoint will send the request. This is the exact service to which the http request will be made. <br>
            Possible values are: <br>
            <i><strong>/events<br>/repos/{owner}/{repo}/events<br>/networks/{owner}/{repo}/events<br>/orgs/{org}/events<br>/users/{username}/received_events<br>/users/{username}/events<br>/users/{username}/events/public<br>/users/{username}/events/orgs/{org}<br>/feeds<br>/notifications<br>/repos/{owner}/{repo}/notifications<br>/notifications/threads/{id}<br>/notifications/threads/{id}/subscription<br>/repos/{owner}/{repo}/stargazers<br>/users/{username}/starred<br>/user/starred<br>/user/starred/{owner}/{repo}<br>/repos/{owner}/{repo}/subscribers<br>/users/{username}/subscriptions<br>/user/subscriptions<br>/repos/{owner}/{repo}/subscription<br>/users/{username}/gists<br>/gists<br>/gists/{id}<br>/gists/{id}/{sha}<br>/gists/public<br>/gists/starred<br>/gists/{id}/commits<br>/gists/{id}/star<br>/gists/{id}/forks<br>/repos/{owner}/{repo}/git/blobs/{sha}<br>/repos/{owner}/{repo}/git/commits/{sha}<br>/repos/{owner}/{repo}/git/refs/{ref}<br>/repos/{owner}/{repo}/git/refs<br>/repos/{owner}/{repo}/git/tags/{sha}<br>/repos/{owner}/{repo}/git/trees/{sha}<br>/apps/{app_slug}<br>/app<br>/app/installations<br>/app/installations/{installation_id}<br>/user/installations<br>/installation/repositories<br>/user/installations/{installation_id}/repositories<br>/marketplace_listing/plans<br>/marketplace_listing/plans/{id}/accounts<br>/marketplace_listing/accounts/{id}<br>/user/marketplace_purchases<br>/issues<br>/user/issues<br>/orgs/{org}/issues<br>/repos/{owner}/{repo}/issues<br>/repos/{owner}/{repo}/issues/{number}<br>/repos/{owner}/{repo}/assignees<br>/repos/{owner}/{repo}/assignees/{assignee}<br>/repos/{owner}/{repo}/issues/{number}/comments<br>/repos/{owner}/{repo}/issues/comments<br>/repos/{owner}/{repo}/issues/{issue_number}/events<br>/repos/{owner}/{repo}/issues/events<br>/repos/{owner}/{repo}/issues/events/{id}<br>/repos/{owner}/{repo}/labels<br>/repos/{owner}/{repo}/labels/{name}<br>/repos/{owner}/{repo}/issues/{number}/labels<br>/repos/{owner}/{repo}/milestones/{number}/labels<br>/repos/{owner}/{repo}/milestones<br>/repos/{owner}/{repo}/milestones/{number}<br>/repos/{owner}/{repo}/issues/{issue_number}/timeline<br>/codes_of_conduct<br>/codes_of_conduct/{key}<br>/repos/{owner}/{repo}<br>/repos/{owner}/{repo}/{archive_format}/{ref}<br>/repos/{owner}/{repo}/community/code_of_conduct<br>/emojis<br>/gitignore/templates<br>/gitignore/templates/{name}<br>/licenses<br>/licenses/{license}<br>/repos/{owner}/{repo}/license<br>/meta<br>/rate_limit<br>/user/orgs<br>/organizations<br>/users/{username}/orgs<br>/orgs/{org}<br>/orgs/{org}/members<br>/orgs/{org}/members/{username}<br>/orgs/{org}/public_members/{username}<br>/orgs/{org}/public_members<br>/orgs/{org}/invitations<br>/orgs/{org}/memberships/{username}<br>/user/memberships/orgs<br>/user/memberships/orgs/{org}<br>/orgs/{org}/outside_collaborators<br>/orgs/{org}/teams<br>/teams/{id}<br>/teams/{id}/teams<br>/teams/{id}/members<br>/teams/{id}/members/{username}<br>/teams/{id}/memberships/{username}<br>/teams/{id}/invitations<br>/teams/{id}/repos<br>/teams/{id}/repos/{owner}/{repo}<br>/user/teams<br>/orgs/{org}/hooks<br>/orgs/{org}/hooks/{id}<br>/orgs/{org}/blocks<br>/orgs/{org}/blocks/{username}<br>/repos/{owner}/{repo}/projects<br>/orgs/{org}/projects<br>/projects/{id}<br>/projects/columns/{column_id}/cards<br>/projects/columns/cards/{id}<br>/projects/{project_id}/columns<br>/projects/columns/{id}<br>/repos/{owner}/{repo}/pulls<br>/repos/{owner}/{repo}/pulls/{number}<br>/repos/{owner}/{repo}/pulls/{number}/commits<br>/repos/{owner}/{repo}/pulls/{number}/files<br>/repos/{owner}/{repo}/pulls/{number}/merge<br>/repos/{owner}/{repo}/pulls/{number}/reviews<br>/repos/{owner}/{repo}/pulls/{number}/reviews/{id}<br>/repos/{owner}/{repo}/pulls/{number}/reviews/{id}/comments<br>/repos/{owner}/{repo}/pulls/{number}/comments<br>/repos/{owner}/{repo}/pulls/comments<br>/repos/{owner}/{repo}/pulls/comments/{id}<br>/repos/{owner}/{repo}/pulls/{number}/requested_reviewers<br>/repos/{owner}/{repo}/comments/{id}/reactions<br>/repos/{owner}/{repo}/issues/{number}/reactions<br>/repos/{owner}/{repo}/issues/comments/{id}/reactions<br>/repos/{owner}/{repo}/pulls/comments/{id}/reactions<br>/user/repos<br>/users/{username}/repos<br>/orgs/{org}/repos<br>/repositories<br>/repos/{owner}/{repo}/topics<br>/repos/{owner}/{repo}/contributors<br>/repos/{owner}/{repo}/languages<br>/repos/{owner}/{repo}/teams<br>/repos/{owner}/{repo}/tags<br>/repos/{owner}/{repo}/branches<br>/repos/{owner}/{repo}/branches/{branch}<br>/repos/{owner}/{repo}/branches/{branch}/protection<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews<br>/repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users<br>/repos/{owner}/{repo}/collaborators<br>/repos/{owner}/{repo}/collaborators/{username}<br>/repos/{owner}/{repo}/collaborators/{username}/permission<br>/repos/{owner}/{repo}/comments<br>/repos/{owner}/{repo}/comments/{id}<br>/repos/{owner}/{repo}/commits/{ref}/comments<br>/repos/{owner}/{name}/community/profile<br>/repos/{owner}/{repo}/commits<br>/repos/{owner}/{repo}/commits/{sha}<br>/repos/{owner}/{repo}/compare/{baseCommitSuspensivePointsHeadCommit}<br>/repos/{owner}/{repo}/readme<br>/repos/{owner}/{repo}/contents/{path}<br>/repos/{owner}/{repo}/keys<br>/repos/{owner}/{repo}/keys/{id}<br>/repos/{owner}/{repo}/deployments<br>/repos/{owner}/{repo}/deployments/{deployment_id}<br>/repos/{owner}/{repo}/deployments/{id}/statuses<br>/repos/{owner}/{repo}/deployments/{id}/statuses/{status_id}<br>/repos/{owner}/{repo}/downloads<br>/repos/{owner}/{repo}/downloads/{id}<br>/repos/{owner}/{repo}/forks<br>/repos/{owner}/{repo}/invitations<br>/user/repository_invitations<br>/repos/{owner}/{repo}/pages<br>/repos/{owner}/{repo}/pages/builds<br>/repos/{owner}/{repo}/pages/builds/{id}<br>/repos/{owner}/{repo}/pages/builds/latest<br>/repos/{owner}/{repo}/releases<br>/repos/{owner}/{repo}/releases/{id}<br>/repos/{owner}/{repo}/releases/latest<br>/repos/{owner}/{repo}/releases/tags/{tag}<br>/repos/{owner}/{repo}/releases/{id}/assets<br>/repos/{owner}/{repo}/releases/assets/{id}<br>/repos/{owner}/{repo}/stats/contributors<br>/repos/{owner}/{repo}/stats/commit_activity<br>/repos/{owner}/{repo}/stats/code_frequency<br>/repos/{owner}/{repo}/stats/participation<br>/repos/{owner}/{repo}/stats/punch_card<br>/repos/{owner}/{repo}/commits/{ref}/statuses<br>/repos/{owner}/{repo}/commits/{ref}/status<br>/repos/{owner}/{repo}/traffic/popular/referrers<br>/repos/{owner}/{repo}/traffic/popular/paths<br>/repos/{owner}/{repo}/traffic/views<br>/repos/{owner}/{repo}/traffic/clones<br>/repos/{owner}/{repo}/hooks<br>/repos/{owner}/{repo}/hooks/{id}<br>/search/repositories<br>/search/commits<br>/search/code<br>/search/issues<br>/search/users<br>/gists<br>/gists/{id}/forks<br>/repos/{owner}/{repo}/git/blobs<br>/repos/{owner}/{repo}/git/commits<br>/repos/{owner}/{repo}/git/refs<br>/repos/{owner}/{repo}/git/tags<br>/repos/{owner}/{repo}/git/trees<br>/installations/{installation_id}/access_tokens<br>/repos/{owner}/{repo}/issues<br>/repos/{owner}/{repo}/issues/{number}/assignees<br>/repos/{owner}/{repo}/issues/{number}/comments<br>/repos/{owner}/{repo}/labels<br>/repos/{owner}/{repo}/issues/{number}/labels<br>/repos/{owner}/{repo}/milestones<br>/markdown<br>/markdown/raw<br>/orgs/{org}/teams<br>/orgs/{org}/hooks<br>/orgs/{org}/hooks/{id}/pings<br>/repos/{owner}/{repo}/projects<br>/orgs/{org}/projects<br>/projects/columns/{column_id}/cards<br>/projects/columns/cards/{id}/moves<br>/projects/{project_id}/columns<br>/projects/columns/{id}/moves<br>/repos/{owner}/{repo}/pulls<br>/repos/{owner}/{repo}/pulls/{number}/reviews<br>/repos/{owner}/{repo}/pulls/{number}/reviews/{id}/events<br>/repos/{owner}/{repo}/pulls/{number}/comments<br>/repos/{owner}/{repo}/pulls/{number}/requested_reviewers<br>/repos/{owner}/{repo}/comments/{id}/reactions<br>/repos/{owner}/{repo}/issues/{number}/reactions<br>/repos/{owner}/{repo}/issues/comments/{id}/reactions<br>/repos/{owner}/{repo}/pulls/comments/{id}/reactions<br>/user/repos<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts<br>/repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users<br>/repos/{owner}/{repo}/commits/{sha}/comments<br>/repos/{owner}/{repo}/keys<br>/repos/{owner}/{repo}/merges<br>/repos/{owner}/{repo}/pages/builds<br>/repos/{owner}/{repo}/releases<br>/repos/{owner}/{repo}/statuses/{sha}<br>/repos/{owner}/{repo}/hooks<br>/repos/{owner}/{repo}/hooks/{id}/tests<br>/repos/{owner}/{repo}/hooks/{id}/pings<br>/notifications/threads/{id}/subscription<br>/user/starred/{owner}/{repo}<br>/repos/{owner}/{repo}/subscription<br>/gists/{id}/star<br>/gists/{id}<br>/repos/{owner}/{repo}/git/refs/{ref}<br>/user/installations/{installation_id}/repositories/{repository_id}<br>/repos/{owner}/{repo}/issues/{number}/lock<br>/repos/{owner}/{repo}/issues/{number}/assignees<br>/repos/{owner}/{repo}/issues/comments/{id}<br>/repos/{owner}/{repo}/labels/{name}<br>/repos/{owner}/{repo}/issues/{number}/labels/{name}<br>/repos/{owner}/{repo}/issues/{number}/labels<br>/repos/{owner}/{repo}/milestones/{number}<br>/orgs/{org}/members/{username}<br>/orgs/{org}/public_members/{username}<br>/orgs/{org}/memberships/{username}<br>/orgs/{org}/outside_collaborators/{username}<br>/teams/{id}<br>/teams/{id}/memberships/{username}<br>/teams/{id}/repos/{owner}/{repo}<br>/orgs/{org}/hooks/{id}<br>/orgs/{org}/blocks/{username}<br>/projects/{id}<br>/projects/columns/cards/{id}<br>/projects/columns/{id}<br>/repos/{owner}/{repo}/pulls/{number}/reviews/{id}<br>/repos/{owner}/{repo}/pulls/comments/{id}<br>/repos/{owner}/{repo}/pulls/{number}/requested_reviewers<br>/reactions/{id}<br>/repos/{owner}/{repo}<br>/repos/{owner}/{repo}/branches/{branch}/protection<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews<br>/repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users<br>/repos/{owner}/{repo}/collaborators/{username}<br>/repos/{owner}/{repo}/comments/{id}<br>/repos/{owner}/{repo}/contents/{path}<br>/repos/{owner}/{repo}/keys/{id}<br>/repos/{owner}/{repo}/deployments<br>/repos/{owner}/{repo}/deployments/{id}/statuses<br>/repos/{owner}/{repo}/downloads/{id}<br>/repos/{owner}/{repo}/forks<br>/repos/{owner}/{repo}/invitations/{invitation_id}<br>/user/repository_invitations/{invitation_id}<br>/repos/{owner}/{repo}/releases/{id}<br>/repos/{owner}/{repo}/releases/assets/{id}<br>/repos/{owner}/{repo}/hooks/{id}<br>/notifications/threads/{id}<br>/gists/{id}<br>/repos/{owner}/{repo}/git/refs/{ref}<br>/repos/{owner}/{repo}/issues/{number}<br>/repos/{owner}/{repo}/issues/comments/{id}<br>/repos/{owner}/{repo}/labels/{name}<br>/repos/{owner}/{repo}/milestones/{number}<br>/orgs/{org}<br>/user/memberships/orgs/{org}<br>/teams/{id}<br>/orgs/{org}/hooks/{id}<br>/projects/{id}<br>/projects/columns/cards/{id}<br>/projects/columns/{id}<br>/repos/{owner}/{repo}/pulls/{number}<br>/repos/{owner}/{repo}/pulls/comments/{id}<br>/repos/{owner}/{repo}<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews<br>/repos/{owner}/{repo}/comments/{id}<br>/repos/{owner}/{repo}/invitations/{invitation_id}<br>/user/repository_invitations/{invitation_id}<br>/repos/{owner}/{repo}/releases/{id}<br>/repos/{owner}/{repo}/releases/assets/{id}<br>/repos/{owner}/{repo}/hooks/{id}<br>/notifications<br>/repos/{owner}/{repo}/notifications<br>/notifications/threads/{id}/subscription<br>/user/starred/{owner}/{repo}<br>/repos/{owner}/{repo}/subscription<br>/gists/{id}/star<br>/user/installations/{installation_id}/repositories/{repository_id}<br>/repos/{owner}/{repo}/issues/{number}/lock<br>/repos/{owner}/{repo}/issues/{number}/labels<br>/orgs/{org}/public_members/{username}<br>/orgs/{org}/memberships/{username}<br>/orgs/{org}/outside_collaborators/{username}<br>/teams/{id}/members/{username}<br>/teams/{id}/memberships/{username}<br>/teams/{id}/repos/{org}/{repo}<br>/orgs/{org}/blocks/{username}<br>/repos/{owner}/{repo}/pulls/{number}/merge<br>/repos/{owner}/{repo}/pulls/{number}/reviews/{id}/dismissals<br>/repos/{owner}/{repo}/topics<br>/repos/{owner}/{repo}/branches/{branch}/protection<br>/repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams<br>/repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users<br>/repos/{owner}/{repo}/collaborators/{username}<br>/repos/{owner}/{repo}/contents/{path}<br></strong></i>
        </td>
    </tr>
    <tr>
        <td>Headers</td>
        <td>keyValue</td>
        <td>no</td>
        <td> - </td>
        <td>Always</td>
        <td>
            Used when you want to have a custom http header for the request.
        </td>
    </tr>
    <tr>
        <td>Query Params</td>
        <td>keyValue</td>
        <td>no</td>
        <td> - </td>
        <td>Always</td>
        <td>
            Used when you want to have a custom query params for the http call.
        </td>
    </tr>
    <tr>
        <td>Body</td>
        <td>json</td>
        <td>no</td>
        <td> - </td>
        <td>Always</td>
        <td>
            A payload of data can be sent to the server in the body of the request.
        </td>
    </tr>
    <tr>
        <td>Override Settings</td>
        <td>boolean</td>
        <td>no</td>
        <td> false </td>
        <td>Always</td>
        <td></td>
    </tr>
    <tr>
        <td>Follow Redirect</td>
        <td>boolean</td>
        <td>no</td>
        <td> false </td>
        <td> overrideSettings </td>
        <td>Indicates that the resource has to be downloaded into a file instead of returning it in the response.</td>
    </tr>
    <tr>
        <td>Download</td>
        <td>boolean</td>
        <td>no</td>
        <td> false </td>
        <td> overrideSettings </td>
        <td>If true the method won't return until the file has been downloaded, and it will return all the information of the file.</td>
    </tr>
    <tr>
        <td>File name</td>
        <td>text</td>
        <td>no</td>
        <td></td>
        <td> overrideSettings </td>
        <td>If provided, the file will be stored with this name. If empty the file name will be calculated from the URL.</td>
    </tr>
    <tr>
        <td>Full response</td>
        <td> boolean </td>
        <td>no</td>
        <td> false </td>
        <td> overrideSettings </td>
        <td>Include extended information about response</td>
    </tr>
    <tr>
        <td>Connection Timeout</td>
        <td> number </td>
        <td>no</td>
        <td> 5000 </td>
        <td> overrideSettings </td>
        <td>Connect timeout interval, in milliseconds (0 = infinity).</td>
    </tr>
    <tr>
        <td>Read Timeout</td>
        <td> number </td>
        <td>no</td>
        <td> 60000 </td>
        <td> overrideSettings </td>
        <td>Read timeout interval, in milliseconds (0 = infinity).</td>
    </tr>
    </tbody>
</table>

<h3>Outputs</h3>

<table>
    <thead>
    <tr>
        <th>Name</th>
        <th>Type</th>
        <th>Description</th>
    </tr>
    </thead>
    <tbody>
    <tr>
        <td>response</td>
        <td>object</td>
        <td>
            Object resulting from the response to the endpoint call.
        </td>
    </tr>
    </tbody>
</table>


</details>

For more information about how shortcuts or flow steps works, and how they are generated, take a look at the [slingr-helpgen tool](https://github.com/slingr-stack/slingr-helpgen).

## Additional Flow Step


<details>
    <summary>Click here to see the Customs Flow Steps</summary>

<br>



### Custom Flow Steps Name

Description of Custom Flow Steps

*MANUALLY ADD THE DOCUMENTATION OF THESE FLOW STEPS HERE...*


</details>

## Additional Helpers
*MANUALLY ADD THE DOCUMENTATION OF THESE HELPERS HERE...*<file_sep>////////////////////////////////////////////////////////////////////////////
//                                                                        //
//             This file was generated with "slingr-helpgen"              //
//                                                                        //
//               For more info, check the following links:                //
//             https://www.npmjs.com/package/slingr-helpgen               //
//           https://github.com/slingr-stack/slingr-helpgen               //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

endpoint.events = {};

endpoint.repos = {};

endpoint.repos.events = {};

endpoint.networks = {};

endpoint.networks.events = {};

endpoint.orgs = {};

endpoint.orgs.events = {};

endpoint.users = {};

endpoint.users.receivedEvents = {};

endpoint.users.events = {};

endpoint.users.events.public = {};

endpoint.users.events.orgs = {};

endpoint.feeds = {};

endpoint.notifications = {};

endpoint.repos.notifications = {};

endpoint.notifications.threads = {};

endpoint.notifications.threads.subscription = {};

endpoint.repos.stargazers = {};

endpoint.users.starred = {};

endpoint.user = {};

endpoint.user.starred = {};

endpoint.repos.subscribers = {};

endpoint.users.subscriptions = {};

endpoint.user.subscriptions = {};

endpoint.repos.subscription = {};

endpoint.users.gists = {};

endpoint.gists = {};

endpoint.gists.public = {};

endpoint.gists.starred = {};

endpoint.gists.commits = {};

endpoint.gists.star = {};

endpoint.gists.forks = {};

endpoint.repos.git = {};

endpoint.repos.git.blobs = {};

endpoint.repos.git.commits = {};

endpoint.repos.git.refs = {};

endpoint.repos.git.tags = {};

endpoint.repos.git.trees = {};

endpoint.apps = {};

endpoint.app = {};

endpoint.app.installations = {};

endpoint.user.installations = {};

endpoint.installation = {};

endpoint.installation.repositories = {};

endpoint.user.installations.repositories = {};

endpoint.marketplaceListing = {};

endpoint.marketplaceListing.plans = {};

endpoint.marketplaceListing.plans.accounts = {};

endpoint.marketplaceListing.accounts = {};

endpoint.user.marketplacePurchases = {};

endpoint.issues = {};

endpoint.user.issues = {};

endpoint.orgs.issues = {};

endpoint.repos.issues = {};

endpoint.repos.assignees = {};

endpoint.repos.issues.comments = {};

endpoint.repos.issues.events = {};

endpoint.repos.issues.events.byIssue = {};

endpoint.repos.labels = {};

endpoint.repos.issues.labels = {};

endpoint.repos.milestones = {};

endpoint.repos.milestones.labels = {};

endpoint.repos.issues.timeline = {};

endpoint.codesOfConduct = {};

endpoint.repos.community = {};

endpoint.repos.community.codeOfConduct = {};

endpoint.emojis = {};

endpoint.gitignore = {};

endpoint.gitignore.templates = {};

endpoint.licenses = {};

endpoint.repos.license = {};

endpoint.meta = {};

endpoint.rateLimit = {};

endpoint.user.orgs = {};

endpoint.organizations = {};

endpoint.users.orgs = {};

endpoint.orgs.members = {};

endpoint.orgs.publicMembers = {};

endpoint.orgs.invitations = {};

endpoint.orgs.memberships = {};

endpoint.user.memberships = {};

endpoint.user.memberships.orgs = {};

endpoint.orgs.outsideCollaborators = {};

endpoint.orgs.teams = {};

endpoint.teams = {};

endpoint.teams.teams = {};

endpoint.teams.members = {};

endpoint.teams.memberships = {};

endpoint.teams.invitations = {};

endpoint.teams.repos = {};

endpoint.user.teams = {};

endpoint.orgs.hooks = {};

endpoint.orgs.blocks = {};

endpoint.repos.projects = {};

endpoint.orgs.projects = {};

endpoint.projects = {};

endpoint.projects.columns = {};

endpoint.projects.columns.cards = {};

endpoint.projects.columns.cards.byId = {};

endpoint.projects.columns.byId = {};

endpoint.repos.pulls = {};

endpoint.repos.pulls.commits = {};

endpoint.repos.pulls.files = {};

endpoint.repos.pulls.merge = {};

endpoint.repos.pulls.reviews = {};

endpoint.repos.pulls.reviews.comments = {};

endpoint.repos.pulls.comments = {};

endpoint.repos.pulls.comments.byId = {};

endpoint.repos.pulls.requestedReviewers = {};

endpoint.repos.comments = {};

endpoint.repos.comments.reactions = {};

endpoint.repos.issues.reactions = {};

endpoint.repos.issues.comments.reactions = {};

endpoint.repos.pulls.comments.reactions = {};

endpoint.user.repos = {};

endpoint.users.repos = {};

endpoint.orgs.repos = {};

endpoint.repositories = {};

endpoint.repos.topics = {};

endpoint.repos.contributors = {};

endpoint.repos.languages = {};

endpoint.repos.teams = {};

endpoint.repos.tags = {};

endpoint.repos.branches = {};

endpoint.repos.branches.protection = {};

endpoint.repos.branches.protection.requiredStatusChecks = {};

endpoint.repos.branches.protection.requiredStatusChecks.contexts = {};

endpoint.repos.branches.protection.requiredPullRequestReviews = {};

endpoint.repos.branches.protection.enforceAdmins = {};

endpoint.repos.branches.protection.restrictions = {};

endpoint.repos.branches.protection.restrictions.teams = {};

endpoint.repos.branches.protection.restrictions.users = {};

endpoint.repos.collaborators = {};

endpoint.repos.collaborators.permission = {};

endpoint.repos.commits = {};

endpoint.repos.commits.comments = {};

endpoint.repos.community.profile = {};

endpoint.repos.compare = {};

endpoint.repos.readme = {};

endpoint.repos.contents = {};

endpoint.repos.keys = {};

endpoint.repos.deployments = {};

endpoint.repos.deployments.statuses = {};

endpoint.repos.downloads = {};

endpoint.repos.forks = {};

endpoint.repos.invitations = {};

endpoint.user.repositoryInvitations = {};

endpoint.repos.pages = {};

endpoint.repos.pages.builds = {};

endpoint.repos.pages.builds.latest = {};

endpoint.repos.releases = {};

endpoint.repos.releases.latest = {};

endpoint.repos.releases.tags = {};

endpoint.repos.releases.assets = {};

endpoint.repos.releases.assets.byId = {};

endpoint.repos.stats = {};

endpoint.repos.stats.contributors = {};

endpoint.repos.stats.commitActivity = {};

endpoint.repos.stats.codeFrequency = {};

endpoint.repos.stats.participation = {};

endpoint.repos.stats.punchCard = {};

endpoint.repos.commits.statuses = {};

endpoint.repos.commits.status = {};

endpoint.repos.traffic = {};

endpoint.repos.traffic.popular = {};

endpoint.repos.traffic.popular.referrers = {};

endpoint.repos.traffic.popular.paths = {};

endpoint.repos.traffic.views = {};

endpoint.repos.traffic.clones = {};

endpoint.repos.hooks = {};

endpoint.search = {};

endpoint.search.repositories = {};

endpoint.search.commits = {};

endpoint.search.code = {};

endpoint.search.issues = {};

endpoint.search.users = {};

endpoint.installations = {};

endpoint.installations.accessTokens = {};

endpoint.repos.issues.assignees = {};

endpoint.markdown = {};

endpoint.markdown.raw = {};

endpoint.orgs.hooks.pings = {};

endpoint.projects.columns.cards.moves = {};

endpoint.projects.columns.moves = {};

endpoint.repos.pulls.reviews.events = {};

endpoint.repos.merges = {};

endpoint.repos.statuses = {};

endpoint.repos.hooks.tests = {};

endpoint.repos.hooks.pings = {};

endpoint.repos.issues.lock = {};

endpoint.reactions = {};

endpoint.repos.pulls.reviews.dismissals = {};

endpoint.events.get = function(httpOptions) {
    var url = parse('/events');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.events.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/events', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.networks.events.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/networks/:owner/:repo/events', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.events.get = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/events', [org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.receivedEvents.get = function(username, httpOptions) {
    if (!username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username].');
        return;
    }
    var url = parse('/users/:username/received_events', [username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.events.get = function(username, httpOptions) {
    if (!username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username].');
        return;
    }
    var url = parse('/users/:username/events', [username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.events.public.get = function(username, httpOptions) {
    if (!username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username].');
        return;
    }
    var url = parse('/users/:username/events/public', [username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.events.orgs.get = function(username, org, httpOptions) {
    if (!username || !org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username,org].');
        return;
    }
    var url = parse('/users/:username/events/orgs/:org', [username, org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.feeds.get = function(httpOptions) {
    var url = parse('/feeds');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.notifications.get = function(httpOptions) {
    var url = parse('/notifications');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.notifications.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/notifications', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.notifications.threads.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/notifications/threads/:id', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.notifications.threads.subscription.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/notifications/threads/:id/subscription', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.stargazers.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/stargazers', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.starred.get = function(username, httpOptions) {
    if (!username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username].');
        return;
    }
    var url = parse('/users/:username/starred', [username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.starred.get = function(owner, repo, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 0:
			url = parse('/user/starred');
			break;
		case 2:
			url = parse('/user/starred/:owner/:repo', [owner, repo]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.subscribers.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/subscribers', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.subscriptions.get = function(username, httpOptions) {
    if (!username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username].');
        return;
    }
    var url = parse('/users/:username/subscriptions', [username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.subscriptions.get = function(httpOptions) {
    var url = parse('/user/subscriptions');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.subscription.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/subscription', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.gists.get = function(username, httpOptions) {
    if (!username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username].');
        return;
    }
    var url = parse('/users/:username/gists', [username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.gists.get = function(id, sha, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 0:
			url = parse('/gists');
			break;
		case 1:
			url = parse('/gists/:id', [id]);
			break;
		case 2:
			url = parse('/gists/:id/:sha', [id, sha]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.gists.public.get = function(httpOptions) {
    var url = parse('/gists/public');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.gists.starred.get = function(httpOptions) {
    var url = parse('/gists/starred');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.gists.commits.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/gists/:id/commits', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.gists.star.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/gists/:id/star', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.gists.forks.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/gists/:id/forks', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.git.blobs.get = function(owner, repo, sha, httpOptions) {
    if (!owner || !repo || !sha) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,sha].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/blobs/:sha', [owner, repo, sha]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.git.commits.get = function(owner, repo, sha, httpOptions) {
    if (!owner || !repo || !sha) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,sha].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/commits/:sha', [owner, repo, sha]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.git.refs.get = function(owner, repo, ref, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 3:
			url = parse('/repos/:owner/:repo/git/refs/:ref', [owner, repo, ref]);
			break;
		case 2:
			url = parse('/repos/:owner/:repo/git/refs', [owner, repo]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.git.tags.get = function(owner, repo, sha, httpOptions) {
    if (!owner || !repo || !sha) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,sha].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/tags/:sha', [owner, repo, sha]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.git.trees.get = function(owner, repo, sha, httpOptions) {
    if (!owner || !repo || !sha) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,sha].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/trees/:sha', [owner, repo, sha]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.apps.get = function(appSlug, httpOptions) {
    if (!appSlug) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [appSlug].');
        return;
    }
    var url = parse('/apps/:app_slug', [appSlug]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.app.get = function(httpOptions) {
    var url = parse('/app');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.app.installations.get = function(installationId, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 0:
			url = parse('/app/installations');
			break;
		case 1:
			url = parse('/app/installations/:installation_id', [installationId]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.user.installations.get = function(httpOptions) {
    var url = parse('/user/installations');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.installation.repositories.get = function(httpOptions) {
    var url = parse('/installation/repositories');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.installations.repositories.get = function(installationId, httpOptions) {
    if (!installationId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [installationId].');
        return;
    }
    var url = parse('/user/installations/:installation_id/repositories', [installationId]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.marketplaceListing.plans.get = function(httpOptions) {
    var url = parse('/marketplace_listing/plans');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.marketplaceListing.plans.accounts.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/marketplace_listing/plans/:id/accounts', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.marketplaceListing.accounts.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/marketplace_listing/accounts/:id', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.marketplacePurchases.get = function(httpOptions) {
    var url = parse('/user/marketplace_purchases');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.issues.get = function(httpOptions) {
    var url = parse('/issues');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.issues.get = function(httpOptions) {
    var url = parse('/user/issues');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.issues.get = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/issues', [org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.issues.get = function(owner, repo, number, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/issues', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/issues/:number', [owner, repo, number]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.assignees.get = function(owner, repo, assignee, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/assignees', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/assignees/:assignee', [owner, repo, assignee]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.issues.comments.get = function(owner, repo, number, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 3:
			url = parse('/repos/:owner/:repo/issues/:number/comments', [owner, repo, number]);
			break;
		case 2:
			url = parse('/repos/:owner/:repo/issues/comments', [owner, repo]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.issues.events.byIssue.get = function(owner, repo, issueNumber, httpOptions) {
    if (!owner || !repo || !issueNumber) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,issueNumber].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:issue_number/events', [owner, repo, issueNumber]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.issues.events.get = function(owner, repo, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/issues/events', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/issues/events/:id', [owner, repo, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.labels.get = function(owner, repo, name, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/labels', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/labels/:name', [owner, repo, name]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.issues.labels.get = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/labels', [owner, repo, number]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.milestones.labels.get = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/milestones/:number/labels', [owner, repo, number]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.milestones.get = function(owner, repo, number, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/milestones', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/milestones/:number', [owner, repo, number]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.issues.timeline.get = function(owner, repo, issueNumber, httpOptions) {
    if (!owner || !repo || !issueNumber) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,issueNumber].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:issue_number/timeline', [owner, repo, issueNumber]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.codesOfConduct.get = function(key, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 0:
			url = parse('/codes_of_conduct');
			break;
		case 1:
			url = parse('/codes_of_conduct/:key', [key]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.get = function(owner, repo, archiveFormat, ref, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo', [owner, repo]);
			break;
		case 4:
			url = parse('/repos/:owner/:repo/:archive_format/:ref', [owner, repo, archiveFormat, ref]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.community.codeOfConduct.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/community/code_of_conduct', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.emojis.get = function(httpOptions) {
    var url = parse('/emojis');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.gitignore.templates.get = function(name, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 0:
			url = parse('/gitignore/templates');
			break;
		case 1:
			url = parse('/gitignore/templates/:name', [name]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.licenses.get = function(license, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 0:
			url = parse('/licenses');
			break;
		case 1:
			url = parse('/licenses/:license', [license]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.license.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/license', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.meta.get = function(httpOptions) {
    var url = parse('/meta');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.rateLimit.get = function(httpOptions) {
    var url = parse('/rate_limit');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.orgs.get = function(httpOptions) {
    var url = parse('/user/orgs');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.organizations.get = function(httpOptions) {
    var url = parse('/organizations');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.orgs.get = function(username, httpOptions) {
    if (!username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username].');
        return;
    }
    var url = parse('/users/:username/orgs', [username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.get = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org', [org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.members.get = function(org, username, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 1:
			url = parse('/orgs/:org/members', [org]);
			break;
		case 2:
			url = parse('/orgs/:org/members/:username', [org, username]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.orgs.publicMembers.get = function(org, username, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/orgs/:org/public_members/:username', [org, username]);
			break;
		case 1:
			url = parse('/orgs/:org/public_members', [org]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.orgs.invitations.get = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/invitations', [org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.memberships.get = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/memberships/:username', [org, username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.memberships.orgs.get = function(org, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 0:
			url = parse('/user/memberships/orgs');
			break;
		case 1:
			url = parse('/user/memberships/orgs/:org', [org]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.orgs.outsideCollaborators.get = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/outside_collaborators', [org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.teams.get = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/teams', [org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.teams.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/teams/:id', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.teams.teams.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/teams/:id/teams', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.teams.members.get = function(id, username, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 1:
			url = parse('/teams/:id/members', [id]);
			break;
		case 2:
			url = parse('/teams/:id/members/:username', [id, username]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.teams.memberships.get = function(id, username, httpOptions) {
    if (!id || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id,username].');
        return;
    }
    var url = parse('/teams/:id/memberships/:username', [id, username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.teams.invitations.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/teams/:id/invitations', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.teams.repos.get = function(id, owner, repo, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 1:
			url = parse('/teams/:id/repos', [id]);
			break;
		case 3:
			url = parse('/teams/:id/repos/:owner/:repo', [id, owner, repo]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.user.teams.get = function(httpOptions) {
    var url = parse('/user/teams');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.hooks.get = function(org, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 1:
			url = parse('/orgs/:org/hooks', [org]);
			break;
		case 2:
			url = parse('/orgs/:org/hooks/:id', [org, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.orgs.blocks.get = function(org, username, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 1:
			url = parse('/orgs/:org/blocks', [org]);
			break;
		case 2:
			url = parse('/orgs/:org/blocks/:username', [org, username]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.projects.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/projects', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.projects.get = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/projects', [org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.projects.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/:id', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.projects.columns.cards.get = function(columnId, httpOptions) {
    if (!columnId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [columnId].');
        return;
    }
    var url = parse('/projects/columns/:column_id/cards', [columnId]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.projects.columns.cards.byId.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/columns/cards/:id', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.projects.columns.get = function(projectId, httpOptions) {
    if (!projectId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [projectId].');
        return;
    }
    var url = parse('/projects/:project_id/columns', [projectId]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.projects.columns.byId.get = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/columns/:id', [id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pulls.get = function(owner, repo, number, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/pulls', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/pulls/:number', [owner, repo, number]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.pulls.commits.get = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/commits', [owner, repo, number]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pulls.files.get = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/files', [owner, repo, number]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pulls.merge.get = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/merge', [owner, repo, number]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pulls.reviews.get = function(owner, repo, number, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 3:
			url = parse('/repos/:owner/:repo/pulls/:number/reviews', [owner, repo, number]);
			break;
		case 4:
			url = parse('/repos/:owner/:repo/pulls/:number/reviews/:id', [owner, repo, number, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.pulls.reviews.comments.get = function(owner, repo, number, id, httpOptions) {
    if (!owner || !repo || !number || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/reviews/:id/comments', [owner, repo, number, id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pulls.comments.get = function(owner, repo, number, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 3:
			url = parse('/repos/:owner/:repo/pulls/:number/comments', [owner, repo, number]);
			break;
		case 2:
			url = parse('/repos/:owner/:repo/pulls/comments', [owner, repo]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.pulls.comments.byId.get = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/comments/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pulls.requestedReviewers.get = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/requested_reviewers', [owner, repo, number]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.comments.reactions.get = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/comments/:id/reactions', [owner, repo, id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.issues.reactions.get = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/reactions', [owner, repo, number]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.issues.comments.reactions.get = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/comments/:id/reactions', [owner, repo, id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pulls.comments.reactions.get = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/comments/:id/reactions', [owner, repo, id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.repos.get = function(httpOptions) {
    var url = parse('/user/repos');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.users.repos.get = function(username, httpOptions) {
    if (!username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [username].');
        return;
    }
    var url = parse('/users/:username/repos', [username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.orgs.repos.get = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/repos', [org]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repositories.get = function(httpOptions) {
    var url = parse('/repositories');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.topics.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/topics', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.contributors.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/contributors', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.languages.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/languages', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.teams.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/teams', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.tags.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/tags', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.branches.get = function(owner, repo, branch, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/branches', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/branches/:branch', [owner, repo, branch]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.branches.protection.get = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection', [owner, repo, branch]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.branches.protection.requiredStatusChecks.get = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_status_checks', [owner, repo, branch]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.branches.protection.requiredStatusChecks.contexts.get = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts', [owner, repo, branch]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.branches.protection.requiredPullRequestReviews.get = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews', [owner, repo, branch]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.branches.protection.enforceAdmins.get = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/enforce_admins', [owner, repo, branch]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.branches.protection.restrictions.get = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions', [owner, repo, branch]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.branches.protection.restrictions.teams.get = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions/teams', [owner, repo, branch]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.branches.protection.restrictions.users.get = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions/users', [owner, repo, branch]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.collaborators.get = function(owner, repo, username, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/collaborators', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/collaborators/:username', [owner, repo, username]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.collaborators.permission.get = function(owner, repo, username, httpOptions) {
    if (!owner || !repo || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,username].');
        return;
    }
    var url = parse('/repos/:owner/:repo/collaborators/:username/permission', [owner, repo, username]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.comments.get = function(owner, repo, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/comments', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/comments/:id', [owner, repo, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.commits.comments.get = function(owner, repo, ref, httpOptions) {
    if (!owner || !repo || !ref) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,ref].');
        return;
    }
    var url = parse('/repos/:owner/:repo/commits/:ref/comments', [owner, repo, ref]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.community.profile.get = function(owner, name, httpOptions) {
    if (!owner || !name) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,name].');
        return;
    }
    var url = parse('/repos/:owner/:name/community/profile', [owner, name]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.commits.get = function(owner, repo, sha, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/commits', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/commits/:sha', [owner, repo, sha]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.compare.get = function(owner, repo, baseCommitSuspensivePointsHeadCommit, httpOptions) {
    if (!owner || !repo || !baseCommitSuspensivePointsHeadCommit) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,baseCommitSuspensivePointsHeadCommit].');
        return;
    }
    var url = parse('/repos/:owner/:repo/compare/:baseCommitSuspensivePointsHeadCommit', [owner, repo, baseCommitSuspensivePointsHeadCommit]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.readme.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/readme', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.contents.get = function(owner, repo, path, httpOptions) {
    if (!owner || !repo || !path) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,path].');
        return;
    }
    var url = parse('/repos/:owner/:repo/contents/:path', [owner, repo, path]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.keys.get = function(owner, repo, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/keys', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/keys/:id', [owner, repo, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.deployments.get = function(owner, repo, deploymentId, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/deployments', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/deployments/:deployment_id', [owner, repo, deploymentId]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.deployments.statuses.get = function(owner, repo, id, statusId, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 3:
			url = parse('/repos/:owner/:repo/deployments/:id/statuses', [owner, repo, id]);
			break;
		case 4:
			url = parse('/repos/:owner/:repo/deployments/:id/statuses/:status_id', [owner, repo, id, statusId]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.downloads.get = function(owner, repo, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/downloads', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/downloads/:id', [owner, repo, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.forks.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/forks', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.invitations.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/invitations', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.user.repositoryInvitations.get = function(httpOptions) {
    var url = parse('/user/repository_invitations');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pages.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pages', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.pages.builds.get = function(owner, repo, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/pages/builds', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/pages/builds/:id', [owner, repo, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.pages.builds.latest.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pages/builds/latest', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.releases.get = function(owner, repo, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/releases', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/releases/:id', [owner, repo, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.repos.releases.latest.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases/latest', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.releases.tags.get = function(owner, repo, tag, httpOptions) {
    if (!owner || !repo || !tag) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,tag].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases/tags/:tag', [owner, repo, tag]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.releases.assets.get = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases/:id/assets', [owner, repo, id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.releases.assets.byId.get = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases/assets/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.stats.contributors.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/stats/contributors', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.stats.commitActivity.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/stats/commit_activity', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.stats.codeFrequency.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/stats/code_frequency', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.stats.participation.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/stats/participation', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.stats.punchCard.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/stats/punch_card', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.commits.statuses.get = function(owner, repo, ref, httpOptions) {
    if (!owner || !repo || !ref) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,ref].');
        return;
    }
    var url = parse('/repos/:owner/:repo/commits/:ref/statuses', [owner, repo, ref]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.commits.status.get = function(owner, repo, ref, httpOptions) {
    if (!owner || !repo || !ref) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,ref].');
        return;
    }
    var url = parse('/repos/:owner/:repo/commits/:ref/status', [owner, repo, ref]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.traffic.popular.referrers.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/traffic/popular/referrers', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.traffic.popular.paths.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/traffic/popular/paths', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.traffic.views.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/traffic/views', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.traffic.clones.get = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/traffic/clones', [owner, repo]);
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.repos.hooks.get = function(owner, repo, id, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 2:
			url = parse('/repos/:owner/:repo/hooks', [owner, repo]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/hooks/:id', [owner, repo, id]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] GET from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._get(options);
};

endpoint.search.repositories.get = function(httpOptions) {
    var url = parse('/search/repositories');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.search.commits.get = function(httpOptions) {
    var url = parse('/search/commits');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.search.code.get = function(httpOptions) {
    var url = parse('/search/code');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.search.issues.get = function(httpOptions) {
    var url = parse('/search/issues');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.search.users.get = function(httpOptions) {
    var url = parse('/search/users');
    sys.logs.debug('[githubApp] GET from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options);
};

endpoint.gists.post = function(httpOptions) {
    var url = parse('/gists');
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.gists.forks.post = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/gists/:id/forks', [id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.git.blobs.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/blobs', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.git.commits.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/commits', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.git.refs.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/refs', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.git.tags.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/tags', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.git.trees.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/trees', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.installations.accessTokens.post = function(installationId, httpOptions) {
    if (!installationId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [installationId].');
        return;
    }
    var url = parse('/installations/:installation_id/access_tokens', [installationId]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.issues.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.issues.assignees.post = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/assignees', [owner, repo, number]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.issues.comments.post = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/comments', [owner, repo, number]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.labels.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/labels', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.issues.labels.post = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/labels', [owner, repo, number]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.milestones.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/milestones', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.markdown.post = function(httpOptions) {
    var url = parse('/markdown');
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.markdown.raw.post = function(httpOptions) {
    var url = parse('/markdown/raw');
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.orgs.teams.post = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/teams', [org]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.orgs.hooks.post = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/hooks', [org]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.orgs.hooks.pings.post = function(org, id, httpOptions) {
    if (!org || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,id].');
        return;
    }
    var url = parse('/orgs/:org/hooks/:id/pings', [org, id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.projects.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/projects', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.orgs.projects.post = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org/projects', [org]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.projects.columns.cards.post = function(columnId, httpOptions) {
    if (!columnId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [columnId].');
        return;
    }
    var url = parse('/projects/columns/:column_id/cards', [columnId]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.projects.columns.cards.moves.post = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/columns/cards/:id/moves', [id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.projects.columns.post = function(projectId, httpOptions) {
    if (!projectId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [projectId].');
        return;
    }
    var url = parse('/projects/:project_id/columns', [projectId]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.projects.columns.moves.post = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/columns/:id/moves', [id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.pulls.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.pulls.reviews.post = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/reviews', [owner, repo, number]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.pulls.reviews.events.post = function(owner, repo, number, id, httpOptions) {
    if (!owner || !repo || !number || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/reviews/:id/events', [owner, repo, number, id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.pulls.comments.post = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/comments', [owner, repo, number]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.pulls.requestedReviewers.post = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/requested_reviewers', [owner, repo, number]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.comments.reactions.post = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/comments/:id/reactions', [owner, repo, id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.issues.reactions.post = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/reactions', [owner, repo, number]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.issues.comments.reactions.post = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/comments/:id/reactions', [owner, repo, id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.pulls.comments.reactions.post = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/comments/:id/reactions', [owner, repo, id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.user.repos.post = function(httpOptions) {
    var url = parse('/user/repos');
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.branches.protection.requiredStatusChecks.contexts.post = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts', [owner, repo, branch]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.branches.protection.enforceAdmins.post = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/enforce_admins', [owner, repo, branch]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.branches.protection.restrictions.teams.post = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions/teams', [owner, repo, branch]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.branches.protection.restrictions.users.post = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions/users', [owner, repo, branch]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.commits.comments.post = function(owner, repo, sha, httpOptions) {
    if (!owner || !repo || !sha) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,sha].');
        return;
    }
    var url = parse('/repos/:owner/:repo/commits/:sha/comments', [owner, repo, sha]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.keys.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/keys', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.merges.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/merges', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.pages.builds.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pages/builds', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.releases.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.statuses.post = function(owner, repo, sha, httpOptions) {
    if (!owner || !repo || !sha) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,sha].');
        return;
    }
    var url = parse('/repos/:owner/:repo/statuses/:sha', [owner, repo, sha]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.hooks.post = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/hooks', [owner, repo]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.hooks.tests.post = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/hooks/:id/tests', [owner, repo, id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.repos.hooks.pings.post = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/hooks/:id/pings', [owner, repo, id]);
    sys.logs.debug('[githubApp] POST from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options);
};

endpoint.notifications.threads.subscription.delete = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/notifications/threads/:id/subscription', [id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.user.starred.delete = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/user/starred/:owner/:repo', [owner, repo]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.subscription.delete = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/subscription', [owner, repo]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.gists.star.delete = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/gists/:id/star', [id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.gists.delete = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/gists/:id', [id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.git.refs.delete = function(owner, repo, ref, httpOptions) {
    if (!owner || !repo || !ref) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,ref].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/refs/:ref', [owner, repo, ref]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.user.installations.repositories.delete = function(installationId, repositoryId, httpOptions) {
    if (!installationId || !repositoryId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [installationId,repositoryId].');
        return;
    }
    var url = parse('/user/installations/:installation_id/repositories/:repository_id', [installationId, repositoryId]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.issues.lock.delete = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/lock', [owner, repo, number]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.issues.assignees.delete = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/assignees', [owner, repo, number]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.issues.comments.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/comments/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.labels.delete = function(owner, repo, name, httpOptions) {
    if (!owner || !repo || !name) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,name].');
        return;
    }
    var url = parse('/repos/:owner/:repo/labels/:name', [owner, repo, name]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.issues.labels.delete = function(owner, repo, number, name, httpOptions) {
    if(!httpOptions){
        for (var i = 0 ; i < arguments.length; i++){
            if (isObject(arguments[i])){
                httpOptions = arguments[i];
                arguments[i] = undefined;
            }
        }
    }
    var url;
    switch(httpOptions ? arguments.length - 1 : arguments.length){
        case 4:
			url = parse('/repos/:owner/:repo/issues/:number/labels/:name', [owner, repo, number, name]);
			break;
		case 3:
			url = parse('/repos/:owner/:repo/issues/:number/labels', [owner, repo, number]);
			break;
		default:
            sys.logs.error('Invalid argument received.');
            return;
    }
    sys.logs.debug('[githubApp] DELETE from: ' + url);
	var options = checkHttpOptions(url, httpOptions);
	return endpoint._delete(options);
};

endpoint.repos.milestones.delete = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/milestones/:number', [owner, repo, number]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.orgs.members.delete = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/members/:username', [org, username]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.orgs.publicMembers.delete = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/public_members/:username', [org, username]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.orgs.memberships.delete = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/memberships/:username', [org, username]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.orgs.outsideCollaborators.delete = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/outside_collaborators/:username', [org, username]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.teams.delete = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/teams/:id', [id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.teams.memberships.delete = function(id, username, httpOptions) {
    if (!id || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id,username].');
        return;
    }
    var url = parse('/teams/:id/memberships/:username', [id, username]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.teams.repos.delete = function(id, owner, repo, httpOptions) {
    if (!id || !owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id,owner,repo].');
        return;
    }
    var url = parse('/teams/:id/repos/:owner/:repo', [id, owner, repo]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.orgs.hooks.delete = function(org, id, httpOptions) {
    if (!org || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,id].');
        return;
    }
    var url = parse('/orgs/:org/hooks/:id', [org, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.orgs.blocks.delete = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/blocks/:username', [org, username]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.projects.delete = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/:id', [id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.projects.columns.cards.delete = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/columns/cards/:id', [id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.projects.columns.delete = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/columns/:id', [id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.pulls.reviews.delete = function(owner, repo, number, id, httpOptions) {
    if (!owner || !repo || !number || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/reviews/:id', [owner, repo, number, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.pulls.comments.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/comments/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.pulls.requestedReviewers.delete = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/requested_reviewers', [owner, repo, number]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.reactions.delete = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/reactions/:id', [id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.delete = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo', [owner, repo]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.branches.protection.delete = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection', [owner, repo, branch]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.branches.protection.requiredStatusChecks.delete = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_status_checks', [owner, repo, branch]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.branches.protection.requiredStatusChecks.contexts.delete = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts', [owner, repo, branch]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.branches.protection.requiredPullRequestReviews.delete = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews', [owner, repo, branch]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.branches.protection.enforceAdmins.delete = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/enforce_admins', [owner, repo, branch]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.branches.protection.restrictions.delete = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions', [owner, repo, branch]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.branches.protection.restrictions.teams.delete = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions/teams', [owner, repo, branch]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.branches.protection.restrictions.users.delete = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions/users', [owner, repo, branch]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.collaborators.delete = function(owner, repo, username, httpOptions) {
    if (!owner || !repo || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,username].');
        return;
    }
    var url = parse('/repos/:owner/:repo/collaborators/:username', [owner, repo, username]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.comments.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/comments/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.contents.delete = function(owner, repo, path, httpOptions) {
    if (!owner || !repo || !path) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,path].');
        return;
    }
    var url = parse('/repos/:owner/:repo/contents/:path', [owner, repo, path]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.keys.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/keys/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.deployments.delete = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/deployments', [owner, repo]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.deployments.statuses.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/deployments/:id/statuses', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.downloads.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/downloads/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.forks.delete = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/forks', [owner, repo]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.invitations.delete = function(owner, repo, invitationId, httpOptions) {
    if (!owner || !repo || !invitationId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,invitationId].');
        return;
    }
    var url = parse('/repos/:owner/:repo/invitations/:invitation_id', [owner, repo, invitationId]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.user.repositoryInvitations.delete = function(invitationId, httpOptions) {
    if (!invitationId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [invitationId].');
        return;
    }
    var url = parse('/user/repository_invitations/:invitation_id', [invitationId]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.releases.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.releases.assets.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases/assets/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.repos.hooks.delete = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/hooks/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] DELETE from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options);
};

endpoint.notifications.threads.patch = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/notifications/threads/:id', [id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.gists.patch = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/gists/:id', [id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.git.refs.patch = function(owner, repo, ref, httpOptions) {
    if (!owner || !repo || !ref) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,ref].');
        return;
    }
    var url = parse('/repos/:owner/:repo/git/refs/:ref', [owner, repo, ref]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.issues.patch = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number', [owner, repo, number]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.issues.comments.patch = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/comments/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.labels.patch = function(owner, repo, name, httpOptions) {
    if (!owner || !repo || !name) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,name].');
        return;
    }
    var url = parse('/repos/:owner/:repo/labels/:name', [owner, repo, name]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.milestones.patch = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/milestones/:number', [owner, repo, number]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.orgs.patch = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/orgs/:org', [org]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.user.memberships.orgs.patch = function(org, httpOptions) {
    if (!org) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org].');
        return;
    }
    var url = parse('/user/memberships/orgs/:org', [org]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.teams.patch = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/teams/:id', [id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.orgs.hooks.patch = function(org, id, httpOptions) {
    if (!org || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,id].');
        return;
    }
    var url = parse('/orgs/:org/hooks/:id', [org, id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.projects.patch = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/:id', [id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.projects.columns.cards.patch = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/columns/cards/:id', [id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.projects.columns.patch = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/projects/columns/:id', [id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.pulls.patch = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number', [owner, repo, number]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.pulls.comments.patch = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/comments/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.patch = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo', [owner, repo]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.branches.protection.requiredStatusChecks.patch = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_status_checks', [owner, repo, branch]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.branches.protection.requiredPullRequestReviews.patch = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews', [owner, repo, branch]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.comments.patch = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/comments/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.invitations.patch = function(owner, repo, invitationId, httpOptions) {
    if (!owner || !repo || !invitationId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,invitationId].');
        return;
    }
    var url = parse('/repos/:owner/:repo/invitations/:invitation_id', [owner, repo, invitationId]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.user.repositoryInvitations.patch = function(invitationId, httpOptions) {
    if (!invitationId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [invitationId].');
        return;
    }
    var url = parse('/user/repository_invitations/:invitation_id', [invitationId]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.releases.patch = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.releases.assets.patch = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/releases/assets/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.repos.hooks.patch = function(owner, repo, id, httpOptions) {
    if (!owner || !repo || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/hooks/:id', [owner, repo, id]);
    sys.logs.debug('[githubApp] PATCH from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options);
};

endpoint.notifications.put = function(httpOptions) {
    var url = parse('/notifications');
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.notifications.put = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/notifications', [owner, repo]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.notifications.threads.subscription.put = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/notifications/threads/:id/subscription', [id]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.user.starred.put = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/user/starred/:owner/:repo', [owner, repo]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.subscription.put = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/subscription', [owner, repo]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.gists.star.put = function(id, httpOptions) {
    if (!id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id].');
        return;
    }
    var url = parse('/gists/:id/star', [id]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.user.installations.repositories.put = function(installationId, repositoryId, httpOptions) {
    if (!installationId || !repositoryId) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [installationId,repositoryId].');
        return;
    }
    var url = parse('/user/installations/:installation_id/repositories/:repository_id', [installationId, repositoryId]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.issues.lock.put = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/lock', [owner, repo, number]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.issues.labels.put = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/issues/:number/labels', [owner, repo, number]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.orgs.publicMembers.put = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/public_members/:username', [org, username]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.orgs.memberships.put = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/memberships/:username', [org, username]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.orgs.outsideCollaborators.put = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/outside_collaborators/:username', [org, username]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.teams.members.put = function(id, username, httpOptions) {
    if (!id || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id,username].');
        return;
    }
    var url = parse('/teams/:id/members/:username', [id, username]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.teams.memberships.put = function(id, username, httpOptions) {
    if (!id || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id,username].');
        return;
    }
    var url = parse('/teams/:id/memberships/:username', [id, username]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.teams.repos.put = function(id, org, repo, httpOptions) {
    if (!id || !org || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [id,org,repo].');
        return;
    }
    var url = parse('/teams/:id/repos/:org/:repo', [id, org, repo]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.orgs.blocks.put = function(org, username, httpOptions) {
    if (!org || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [org,username].');
        return;
    }
    var url = parse('/orgs/:org/blocks/:username', [org, username]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.pulls.merge.put = function(owner, repo, number, httpOptions) {
    if (!owner || !repo || !number) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/merge', [owner, repo, number]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.pulls.reviews.dismissals.put = function(owner, repo, number, id, httpOptions) {
    if (!owner || !repo || !number || !id) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,number,id].');
        return;
    }
    var url = parse('/repos/:owner/:repo/pulls/:number/reviews/:id/dismissals', [owner, repo, number, id]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.topics.put = function(owner, repo, httpOptions) {
    if (!owner || !repo) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo].');
        return;
    }
    var url = parse('/repos/:owner/:repo/topics', [owner, repo]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.branches.protection.put = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection', [owner, repo, branch]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.branches.protection.requiredStatusChecks.contexts.put = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts', [owner, repo, branch]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.branches.protection.restrictions.teams.put = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions/teams', [owner, repo, branch]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.branches.protection.restrictions.users.put = function(owner, repo, branch, httpOptions) {
    if (!owner || !repo || !branch) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,branch].');
        return;
    }
    var url = parse('/repos/:owner/:repo/branches/:branch/protection/restrictions/users', [owner, repo, branch]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.collaborators.put = function(owner, repo, username, httpOptions) {
    if (!owner || !repo || !username) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,username].');
        return;
    }
    var url = parse('/repos/:owner/:repo/collaborators/:username', [owner, repo, username]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

endpoint.repos.contents.put = function(owner, repo, path, httpOptions) {
    if (!owner || !repo || !path) {
        sys.logs.error('Invalid argument received. This helper should receive the following parameters as non-empty strings: [owner,repo,path].');
        return;
    }
    var url = parse('/repos/:owner/:repo/contents/:path', [owner, repo, path]);
    sys.logs.debug('[githubApp] PUT from: ' + url);
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options);
};

////////////////////////////////////
// Public API - Generic Functions //
////////////////////////////////////

endpoint.get = function(url, httpOptions, callbackData, callbacks) {
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._get(options, callbackData, callbacks);
};

endpoint.post = function(url, httpOptions, callbackData, callbacks) {
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._post(options, callbackData, callbacks);
};

endpoint.put = function(url, httpOptions, callbackData, callbacks) {
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._put(options, callbackData, callbacks);
};

endpoint.patch = function(url, httpOptions, callbackData, callbacks) {
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._patch(options, callbackData, callbacks);
};

endpoint.delete = function(url, httpOptions, callbackData, callbacks) {
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._delete(options, callbackData, callbacks);
};

endpoint.head = function(url, httpOptions, callbackData, callbacks) {
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._head(options, callbackData, callbacks);
};

endpoint.options = function(url, httpOptions, callbackData, callbacks) {
    var options = checkHttpOptions(url, httpOptions);
    return endpoint._options(options, callbackData, callbacks);
};

endpoint.utils = {};

endpoint.utils.parseTimestamp = function(dateString) {
    if (!dateString) {
        return null;
    }
    var dt = dateString.split(/[: T\-]/).map(parseFloat);
    return new Date(dt[0], dt[1] - 1, dt[2], dt[3] || 0, dt[4] || 0, dt[5] || 0, 0);
};

endpoint.utils.formatTimestamp = function(date) {
    if (!date) {
        return null;
    }
    var pad = function(number) {
        var r = String(number);
        if ( r.length === 1 ) {
            r = '0' + r;
        }
        return r;
    };
    return date.getUTCFullYear()
        + '-' + pad( date.getUTCMonth() + 1 )
        + '-' + pad( date.getUTCDate() )
        + 'T' + pad( date.getUTCHours() )
        + ':' + pad( date.getUTCMinutes() )
        + ':' + pad( date.getUTCSeconds() )
        + '.' + String( (date.getUTCMilliseconds()/1000).toFixed(3) ).slice( 2, 5 )
        + 'Z';
};

endpoint.utils.fromDateToTimestamp = function(params) {
    if (!!params) {
        return {timestamp: new Date(params).getTime()};
    }
    return null;
};

endpoint.utils.fromMillisToDate = function(params) {
    if (!!params) {
        var sdf = new Intl.DateTimeFormat('en-US', {
            year: 'numeric', month: '2-digit', day: '2-digit',
            hour: '2-digit', minute: '2-digit', second: '2-digit',
            timeZone: 'UTC'
        });
        return {date: sdf.format(new Date(parseInt(params)))};
    }
    return null;
};

///////////////////////
//  Private helpers  //
///////////////////////

var mergeJSON = function (json1, json2) {
    const result = {};
    var key;
    for (key in json1) {
        if(json1.hasOwnProperty(key)) result[key] = json1[key];
    }
    for (key in json2) {
        if(json2.hasOwnProperty(key)) result[key] = json2[key];
    }
    return result;
}

var concatQuery = function (url, key, value) {
    return url + ((!url || url.indexOf('?') < 0) ? '?' : '&') + key + "=" + value;
}

var checkHttpOptions = function (url, options) {
    options = options || {};
    if (!!url) {
        if (isObject(url)) {
            // take the 'url' parameter as the options
            options = url || {};
        } else {
            if (!!options.path || !!options.params || !!options.body) {
                // options contains the http package format
                options.path = url;
            } else {
                // create html package
                options = {
                    path: url,
                    body: options
                }
            }
        }
    }
    return options;
}

var isObject = function (obj) {
    return !!obj && stringType(obj) === '[object Object]'
}

var stringType = Function.prototype.call.bind(Object.prototype.toString)

var parse = function (str) {
    try {
        if (arguments.length > 1) {
            var args = arguments[1], i = 0;
            return str.replace(/(:(?:\w|-)+)/g, () => {
                if (typeof (args[i]) != 'string') throw new Error('Invalid type of argument: [' + args[i] + '] for url [' + str + '].');
                return args[i++];
            });
        } else {
            if (str) {
                return str;
            }
            throw new Error('No arguments nor url were received when calling the helper. Please check it\'s definition.');
        }
    } catch (err) {
        sys.logs.error('Some unexpected error happened during the parse of the url for this helper.')
        throw err;
    }
}<file_sep>---
title: GitHub App endpoint
keywords: 
last_updated: February 28, 2023
tags: []
summary: "Detailed description of the API of the GitHub App endpoint."
---

## Overview

The GitHub App endpoints allows to easily create apps for GitHub. It provides the following features:

- Management of installations
- OAuth for users
- Shortcuts to access the REST API
- Support for webhooks

In order to take advantage of this endpoint we strongly recommend to understand how GitHub Apps work and
what you can do with the REST API:

- [GitHub Apps](https://developer.github.com/apps/)
- [GitHub REST API](https://developer.github.com/v3/)

## Configuration

In order to configure the endpoint you will need to create a GitHub App. This can be done in your personal
account or under an organization. Here you can find detailed information on how to do it:

[Registering GitHub Apps](https://developer.github.com/apps/building-integrations/setting-up-and-registering-github-apps/registering-github-apps/)

Once you have created your app you will be able to configure the endpoint.

### App ID

This is the ID of your app.

### Private key

The private key can be generated in the details of your GitHub app. When you copy it you can put it
in one line and use `\n` to indicate new lines.

### Webhooks secret

This is the secret for webhooks configured in your app. It is needed to validate the authenticity of
webhooks.

### Webhooks URL

This is the URL you need to set in your GitHub app so webhooks are sent there.

### Client ID

This is the client ID for OAuth, which is needed in order to perform operations on behalf of a user. 

### Client secret

This is the client secret for OAuth, which is needed in order to perform operations on behalf of a user.

### OAuth callback

This is the OAuth callback you need to configure in your GitHub app.

## Quick start

Once your endpoint is configured, you can read an issue like this:

```js
var issue = app.endpoints.githubApp.repos.issues.get('repo-owner', 'repo-name', 123);
```

And can post a comment to the issue with this code:

```js
var newComment = app.endpoints.gitHubApp.repos.issues.comments.post('repo-owner', 'repo-name', 123, {body: 'test comment'});
```

## Javascript API

### HTTP requests

You can make `GET`, `POST`, `PUT`, `PATCH`, and `DELETE` request to the [GitHub REST API](https://developer.github.com/v3/) 
like this:

```js
var issue = app.endpoints.githubApp.get('/repos/ownerName/repoName/issues/123');
var newComment = app.endpoints.githubApp.post('/repos/ownerName/repoName/issues/123/comments', {body: 'test comment'});
```

Please take a look at the documentation of the [HTTP endpoint]({{site.baseurl}}/endpoints-http.html#javascript-api)
for more information.

### Shortcuts

The Javascript API provides shortcuts to make it easier to call the [REST API](https://developer.github.com/v3/).
For example, instead of calling manually the method `GET /repos/:owner/:repo/issues/123`, you can use the following
shortcut:

```js
var issue = app.endpoints.githubApp.repos.issues.get('owner', 'repo', 123);
```

The following rules are used to determine the shortcut signature:

- **Path sections get converted**: for example if the method is GET `~/repos/:owner/:repo/issues` 
  it is converted to `app.endpoints.gitHubApp.repo.issues.get(account, owner, repo)`. 
- **HTTP method is appended at the end of the method**: for example if the method is `GET`, you will see a method with 
  the suffix `.get(...)`. For example `GET ~/repos/:owner/:repo` will become `app.endpoints.githubApp.repo.get(owner, repo)`. 
  This is the mapping of names:
  - `GET`: `get`
  - `POST`: `create`
  - `PUT`: `update`
  - `PATCH`: `update`
  - `DELETE`: `delete`
- **Path variables become method parameters**: if the method has variables in the path, they will become parameters for 
  the method. For example `GET ~/repos/:owner/:repo` will become `app.endpoints.githubApp.repos.get(account, owner, repo)`.
- **Additional parameters or body are sent in the last param as JSON**: if the method accepts more parameters, or it 
  allows to send a body, that will be sent in the last parameter. For example the method `POST ~/repos/:owner/:repo/issues` 
  supports many query parameters, so it will become `app.endpoints.githubApp.install.repos.issues.post(account, owner, repo, {...})`.

### Utils

There are some utilities to help you work with data coming from GitHub.

#### Date time parser and formatter

```js
var date = app.endpoints.githubApp.utils.parseTimestamp(str);
var str = app.endpoints.githubApp.utils.formatTimestamp(date);
```

GitHub has timestamps with a format like this: `2013-02-12T13:22:01Z`. This two methods allow to convert
it to a `Date` object and the other way around.

## Events

### Webhook

This event is triggered every time a webhook is triggered on any of the organizations and repositories your app is 
installed.

In the listener handling webhook events, you will be able to see the body of the event in `event.data`:

```js
var body = event.data;
sys.logs.info('Event: '+JSON.stringify(body));
```

The format is as specified in [Event types & payloads](https://developer.github.com/v3/activity/events/types/).

The only difference is that we add a field called `event_name` which is what GitHub sends in the header
`X-GitHub-Event`. This way you can easily know the event type:

```js
var body = event.data;
sys.logs.info('Event name: '+body.event_name);
```

{% include links.html %}

## About SLINGR

SLINGR is a low-code rapid application development platform that accelerates development, with robust architecture for integrations and executing custom workflows and automation.

[More info about SLINGR](https://slingr.io)

## License

This endpoint is licensed under the Apache License 2.0. See the `LICENSE` file for more details.

<file_sep>/**
 * This flow step will send a request to githubApp to get all the repositories that the authenticated
 * user has explicit permission to access.
 *
 */
step.listReposForUserGithubApp = function () {

	return endpoint.user.repos.get();
};<file_sep>package io.slingr.endpoints.githubapp;

import io.slingr.endpoints.utils.Json;

import java.util.Date;

public class Token {
    private String token;
    private Date expiration;

    public Token(String token, Date expiration) {
        this.token = token;
        this.expiration = expiration;
    }

    public Token(Json json) {
        fromJson(json);
    }

    public String getToken() {
        return token;
    }

    public Date getExpiration() {
        return expiration;
    }

    public Json toJson() {
        return Json.map()
                .set("token", token)
                .set("expiration", expiration);
    }

    public void fromJson(Json json) {
        token = json.string("token");
        if (json.object("expiration") instanceof Date) {
            expiration = json.date("expiration");
        } else {
            expiration = new Date(json.longInteger("expiration"));
        }
    }
}
