// Signature format: (params) => Promise<Response>
// All methods in "users" resource:

getUser({ username: string })
// Returns: User profile object
// Example:
const user = await github.users.getUser({ username: 'octocat' });

getUserRepos({ username: string, per_page?: number, page?: number })
// Returns: Array of repositories
const repos = await github.users.getUserRepos({ username: 'torvalds' });

getUserGists({ username: string, per_page?: number })
// Returns: Array of gists

getUserFollowers({ username: string })
// Returns: Array of users

getUserFollowing({ username: string })
// Returns: Array of users

getUserStarred({ username: string })
// Returns: Array of starred repositories

getUserOrgs({ username: string })
// Returns: Array of organizations

getUserEvents({ username: string })
// Returns: Array of events

getUserReceivedEvents({ username: string })
// Returns: Array of received events

checkUserFollowing({ username: string, target: string })
// Returns: Boolean or empty response

// 20+ methods:

getRepo({ owner: string, repo: string })
// Returns: Repository object
const repo = await github.repos.getRepo({ owner: 'facebook', repo: 'react' });

getRepoCommits({ owner: string, repo: string, per_page?: number, page?: number, sha?: string })
// Returns: Array of commits

getRepoCommit({ owner: string, repo: string, sha: string })
// Returns: Commit object

getRepoBranches({ owner: string, repo: string })
// Returns: Array of branches

getRepoTags({ owner: string, repo: string })
// Returns: Array of tags

getRepoReleases({ owner: string, repo: string })
// Returns: Array of releases

getRepoLatestRelease({ owner: string, repo: string })
// Returns: Latest release object

getRepoContributors({ owner: string, repo: string })
// Returns: Array of contributors

getRepoLanguages({ owner: string, repo: string })
// Returns: Object with language statistics

getRepoTopics({ owner: string, repo: string })
// Returns: Array of topics

getRepoStargazers({ owner: string, repo: string })
// Returns: Array of users who starred

getRepoForks({ owner: string, repo: string })
// Returns: Array of forks

getRepoIssues({ owner: string, repo: string, state?: 'open'|'closed'|'all', per_page?: number })
// Returns: Array of issues

getRepoIssue({ owner: string, repo: string, issue_number: number })
// Returns: Issue object

getRepoPulls({ owner: string, repo: string, state?: 'open'|'closed'|'all' })
// Returns: Array of pull requests

getRepoPull({ owner: string, repo: string, pull_number: number })
// Returns: Pull request object

getRepoContents({ owner: string, repo: string, path: string, ref?: string })
// Returns: File contents

getRepoReadme({ owner: string, repo: string })
// Returns: README content

createRepoIssue(data: { title: string, body?: string, labels?: string[] }, { owner: string, repo: string })
// Returns: Created issue object

updateRepoIssue(data: { title?: string, body?: string, state?: string }, { owner: string, repo: string, issue_number: number })
// Returns: Updated issue object

createRepoPull(data: { title: string, head: string, base: string, body?: string }, { owner: string, repo: string })
// Returns: Created PR object

// 7 methods:

searchRepos({ q: string, sort?: string, order?: 'asc'|'desc', per_page?: number })
// Returns: Array of repositories

searchCode({ q: string, sort?: string, order?: 'asc'|'desc' })
// Returns: Array of code matches

searchIssues({ q: string, sort?: string, order?: 'asc'|'desc' })
// Returns: Array of issues

searchUsers({ q: string, sort?: string, order?: 'asc'|'desc' })
// Returns: Array of users

searchTopics({ q: string })
// Returns: Array of topics

searchLabels({ repository_id: number, q: string })
// Returns: Array of labels

searchCommits({ q: string, sort?: string, order?: 'asc'|'desc' })
// Returns: Array of commits

// 8 methods:

getPublicGists({})
// Returns: Array of public gists

getUserGists({ username: string })
// Returns: User's gists

getGist({ gist_id: string })
// Returns: Gist object

createGist(data: { files: Object, description?: string, public?: boolean }, {})
// Returns: Created gist

updateGist(data: { files: Object, description?: string }, { gist_id: string })
// Returns: Updated gist

deleteGist({}, { gist_id: string })
// Returns: Empty response

getGistComments({ gist_id: string })
// Returns: Array of comments

createGistComment(data: { body: string }, { gist_id: string })
// Returns: Created comment

// 7 methods:

getOrg({ org: string })
// Returns: Organization object

getOrgRepos({ org: string })
// Returns: Array of repositories

getOrgMembers({ org: string })
// Returns: Array of members

getOrgTeams({ org: string })
// Returns: Array of teams

getOrgProjects({ org: string })
// Returns: Array of projects

getOrgEvents({ org: string })
// Returns: Array of events

checkOrgMembership({ org: string, username: string })
// Returns: Boolean

// 9 methods:

getPublicEvents({})
// Returns: Array of public events

getNotifications({ all?: boolean, participating?: boolean })
// Returns: Array of notifications

markNotificationAsRead({}, { notification_id: string })
// Returns: Empty response

getStarred({ sort?: 'created'|'updated', direction?: 'asc'|'desc' })
// Returns: Array of starred repos

starRepo({}, { owner: string, repo: string })
// Returns: Empty response

unstarRepo({}, { owner: string, repo: string })
// Returns: Empty response

getWatching({ sort?: 'created'|'updated', direction?: 'asc'|'desc' })
// Returns: Array of watched repos

watchRepo({}, { owner: string, repo: string })
// Returns: Empty response

unwatchRepo({}, { owner: string, repo: string })
// Returns: Empty response

// 13 methods:

getAuthenticatedUser({})
// Returns: Authenticated user object

updateAuthenticatedUser(data: { name?: string, blog?: string, location?: string }, {})
// Returns: Updated user

getMyRepos({ type?: 'all'|'owner'|'public'|'private' })
// Returns: Array of repositories

getMyOrgs({})
// Returns: Array of organizations

getMyGists({})
// Returns: Array of gists

getMyFollowers({})
// Returns: Array of followers

getMyFollowing({})
// Returns: Array of users being followed

followUser({}, { username: string })
// Returns: Empty response

unfollowUser({}, { username: string })
// Returns: Empty response

getMyEmails({})
// Returns: Array of email objects

getMySSHKeys({})
// Returns: Array of SSH keys

addSSHKey(data: { title: string, key: string }, {})
// Returns: Created SSH key

deleteSSHKey({}, { key_id: number })
// Returns: Empty response

// 5 methods:

getContributorStats({ owner: string, repo: string })
// Returns: Contributor statistics

getCommitActivity({ owner: string, repo: string })
// Returns: Commit activity data

getCodeFrequency({ owner: string, repo: string })
// Returns: Code frequency data

getParticipation({ owner: string, repo: string })
// Returns: Participation data

getPunchCard({ owner: string, repo: string })
// Returns: Punch card data

// 13 methods:

getRef({ owner: string, repo: string, ref: string })
// Returns: Reference object

getRefs({ owner: string, repo: string })
// Returns: Array of references

createRef(data: { ref: string, sha: string }, { owner: string, repo: string })
// Returns: Created reference

updateRef(data: { sha: string, force?: boolean }, { owner: string, repo: string, ref: string })
// Returns: Updated reference

deleteRef({}, { owner: string, repo: string, ref: string })
// Returns: Empty response

getCommit({ owner: string, repo: string, commit_sha: string })
// Returns: Commit object

createCommit(data: { message: string, tree: string, parents: string[] }, { owner: string, repo: string })
// Returns: Created commit

getTree({ owner: string, repo: string, tree_sha: string })
// Returns: Tree object

createTree(data: { tree: Array, base_tree?: string }, { owner: string, repo: string })
// Returns: Created tree

getBlob({ owner: string, repo: string, file_sha: string })
// Returns: Blob object

createBlob(data: { content: string, encoding?: string }, { owner: string, repo: string })
// Returns: Created blob

getTag({ owner: string, repo: string, tag_sha: string })
// Returns: Tag object

createTag(data: { tag: string, sha: string, message?: string }, { owner: string, repo: string })
// Returns: Created tag

// High-level convenience methods:
github.getUser('octocat')
github.getRepository('facebook', 'react')
github.searchRepositories('language:ts stars:>1000')
github.getAuthenticatedUser()

// 10 methods:

getUser({ id: string|number })
getUserProjects({ id: string|number })
getUserSnippets({ id: string|number })
getUserEvents({ id: string|number })
getUserContributedProjects({ id: string|number })
getUserStarredProjects({ id: string|number })
getUserMemberships({ id: string|number })
getUserFollowers({ id: string|number })
getUserFollowing({ id: string|number })
getCurrentUser({})
searchUsers({ search: string })

// 15+ methods:

getProject({ id: string|number })
getProjectCommits({ id: string|number, per_page?: number })
getProjectCommit({ id: string|number, sha: string })
getProjectBranches({ id: string|number })
getProjectTags({ id: string|number })
getProjectReleases({ id: string|number })
getProjectMembers({ id: string|number })
getProjectIssues({ id: string|number, state?: 'opened'|'closed' })
getProjectIssue({ id: string|number, issue_iid: number })
getProjectMergeRequests({ id: string|number })
getProjectMergeRequest({ id: string|number, merge_request_iid: number })
getProjectContributors({ id: string|number })
getProjectLanguages({ id: string|number })
getProjectRepository({ id: string|number })
getProjectFile({ id: string|number, file_path: string })
getProjectReadme({ id: string|number })
getProjectVariables({ id: string|number })
getProjectPipelines({ id: string|number })
getProjectJobs({ id: string|number })
getProjectEnvironments({ id: string|number })
createProject(data: { name: string, description?: string }, {})
updateProject(data: { name?: string, description?: string }, { id: string|number })
deleteProject({}, { id: string|number })
createProjectIssue(data: { title: string, description?: string }, { id: string|number })
updateProjectIssue(data: { title?: string, description?: string }, { id: string|number, issue_iid: number })
createProjectMergeRequest(data: { source_branch: string, target_branch: string, title: string }, { id: string|number })
updateProjectMergeRequest(data: { title?: string, description?: string }, { id: string|number, merge_request_iid: number })
starProject({}, { id: string|number })
unstarProject({}, { id: string|number })
forkProject(data: { namespace?: string }, { id: string|number })

// 10 methods:

getGroup({ id: string|number })
getGroupProjects({ id: string|number })
getGroupMembers({ id: string|number })
getGroupSubgroups({ id: string|number })
getGroupVariables({ id: string|number })
getGroupEpics({ id: string|number })
createGroup(data: { name: string, path: string }, {})
updateGroup(data: { name?: string, description?: string }, { id: string|number })
deleteGroup({}, { id: string|number })
searchGroups({ search: string })

// 10 methods:

searchProjects({ scope: 'projects', search: string })
searchGroups({ scope: 'groups', search: string })
searchUsers({ scope: 'users', search: string })
searchSnippets({ scope: 'snippets', search: string })
searchIssues({ scope: 'issues', search: string })
searchMergeRequests({ scope: 'merge_requests', search: string })
searchMilestones({ scope: 'milestones', search: string })
searchWiki({ scope: 'wiki_blobs', search: string })
searchCommits({ scope: 'commits', search: string })
searchBlobs({ scope: 'blobs', search: string })

// 7 methods:

getPublicSnippets({})
getSnippet({ id: string|number })
getSnippetContent({ id: string|number })
createSnippet(data: { title: string, content: string, visibility?: string }, {})
updateSnippet(data: { title?: string, content?: string }, { id: string|number })
deleteSnippet({}, { id: string|number })
getUserSnippets({})

// 7 methods:

getIssues({ state?: 'opened'|'closed', per_page?: number })
getIssue({ id: string|number })
createIssue(data: { title: string, description?: string }, {})
updateIssue(data: { title?: string, description?: string }, { id: string|number })
deleteIssue({}, { id: string|number })
getIssueNotes({ id: string|number })
createIssueNote(data: { body: string }, { id: string|number })

// 10 methods:

getMergeRequests({ state?: 'opened'|'closed', per_page?: number })
getMergeRequest({ id: string|number })
createMergeRequest(data: { source_branch: string, target_branch: string, title: string }, {})
updateMergeRequest(data: { title?: string, description?: string }, { id: string|number })
deleteMergeRequest({}, { id: string|number })
acceptMergeRequest({}, { id: string|number })
getMergeRequestNotes({ id: string|number })
createMergeRequestNote(data: { body: string }, { id: string|number })
getMergeRequestCommits({ id: string|number })
getMergeRequestChanges({ id: string|number })

// 8 methods:

getPipelines({ project_id: string|number, per_page?: number })
getPipeline({ project_id: string|number, id: number })
createPipeline(data: { ref: string }, { project_id: string|number })
deletePipeline({}, { project_id: string|number, id: number })
retryPipeline({}, { project_id: string|number, id: number })
cancelPipeline({}, { project_id: string|number, id: number })
getPipelineJobs({ project_id: string|number, id: number })
getPipelineVariables({ project_id: string|number, id: number })

// 6 methods:

getEvents({})
getUserEvents({ user_id: string|number })
getProjectEvents({ project_id: string|number })
getTodos({})
markTodoAsDone({}, { id: string|number })
markAllTodosAsDone({}, {})

// 12 methods:

getCurrentUser({})
getUserProjects({})
getUserStarredProjects({})
getUserGPGKeys({})
getUserSSHKeys({})
addSSHKey(data: { title: string, key: string }, {})
deleteSSHKey({}, { key_id: number })
getUserEmails({})
addEmail(data: { email: string }, {})
deleteEmail({}, { email_id: number })
getUserMemberships({})
getUserStatus({})
setUserStatus(data: { emoji?: string, message?: string }, {})

getTrack({ id: string })
// Returns: Track object

getTracks({ ids?: string })
// Returns: Array of track objects

getTrackAudioFeatures({ id: string })
// Returns: Audio features object

getTrackAudioAnalysis({ id: string })
// Returns: Audio analysis data

getArtist({ id: string })
getArtists({ ids?: string })
getArtistAlbums({ id: string, include_groups?: string })
getArtistTopTracks({ id: string, market?: string })
getArtistRelatedArtists({ id: string })

getAlbum({ id: string })
getAlbums({ ids?: string })
getAlbumTracks({ id: string, limit?: number })

getPlaylist({ playlist_id: string })
// Returns: Playlist object

getPlaylistTracks({ playlist_id: string, limit?: number, offset?: number })
// Returns: Paginated tracks

createPlaylist(data: { name: string, description?: string, public?: boolean }, { user_id: string })
// Returns: Created playlist

updatePlaylist(data: { name?: string, description?: string, public?: boolean }, { playlist_id: string })
// Returns: Updated playlist

addTracksToPlaylist(data: { uris: string[] }, { playlist_id: string })
// Returns: Snapshot ID

removeTracksFromPlaylist(data: { tracks: Array }, { playlist_id: string })
// Returns: Snapshot ID
// Uses DELETE with body - NOW SUPPORTED!

reorderPlaylistTracks(data: { range_start: number, insert_before: number, range_length?: number }, { playlist_id: string })
// NEW METHOD - Reorder tracks in playlist
// Returns: Snapshot ID

replacePlaylistTracks(data: { uris: string[] }, { playlist_id: string })
// NEW METHOD - Replace all tracks
// Returns: Empty response

getFeaturedPlaylists({ country?: string, locale?: string })
// Returns: Featured playlists

getCategoryPlaylists({ category_id: string, country?: string })
// Returns: Playlists in category

search({ q: string, type: string, limit?: number, offset?: number })
// Returns: Search results with tracks, artists, albums, playlists

getUser({ user_id: string })
// Returns: Public profile

getUserPlaylists({ user_id: string, limit?: number })
// Returns: User's playlists

getCurrentUser({})
// Returns: Current user profile

getMyTopArtists({ time_range?: 'long_term'|'medium_term'|'short_term', limit?: number })
getMyTopTracks({ time_range?: 'long_term'|'medium_term'|'short_term', limit?: number })
getMyPlaylists({ limit?: number, offset?: number })
getMySavedTracks({ limit?: number, offset?: number })
getMySavedAlbums({ limit?: number, offset?: number })
getMySavedShows({ limit?: number, offset?: number })
getMyRecentlyPlayed({ limit?: number, before?: number, after?: number })
getFollowedArtists({ limit?: number })

saveTracks(data: { ids: string[] }, {})
// Adds tracks to "Your Library"

removeSavedTracks(data: { ids: string[] }, {})
// Removes from "Your Library"

saveAlbums(data: { ids: string[] }, {})
removeAlbums(data: { ids: string[] }, {})

followArtists(data: { ids: string[] }, {})
unfollowArtists(data: { ids: string[] }, {})

followPlaylist(data: { public?: boolean }, { playlist_id: string })
unfollowPlaylist({}, { playlist_id: string })

getPlaybackState({})
// Returns: Current playback state

getCurrentlyPlaying({})
// Returns: Currently playing track

getDevices({})
// Returns: Available devices

play(data: { context_uri?: string, uris?: string[], offset?: number, device_id?: string }, {})
// Starts/resumes playback

pause(data: { device_id?: string }, {})
// Pauses playback

next(data: { device_id?: string }, {})
// Skips to next track

previous(data: { device_id?: string }, {})
// Goes to previous track

seek(data: { position_ms: number, device_id?: string }, {})
// Seeks to position

setVolume(data: { volume_percent: number, device_id?: string }, {})
// Sets volume

setRepeat(data: { state: 'off'|'track'|'context', device_id?: string }, {})
// Sets repeat mode

setShuffle(data: { state: boolean, device_id?: string }, {})
// Toggles shuffle

transferPlayback(data: { device_ids: string[], play?: boolean }, {})
// Transfers playback

addToQueue(data: { uri: string, device_id?: string }, {})
// Adds to queue

getNewReleases({ country?: string, limit?: number })
getFeaturedPlaylists({ country?: string, locale?: string })
getCategories({ country?: string, locale?: string })
getCategory({ category_id: string, country?: string, locale?: string })
getCategoryPlaylists({ category_id: string, country?: string })
getRecommendations({ seed_artists?: string, seed_genres?: string, seed_tracks?: string })
getAvailableGenreSeeds({})

spotify.getTrack(trackId)
spotify.getArtist(artistId)
spotify.getAlbum(albumId)
spotify.getPlaylist(playlistId)
spotify.search('drake', ['artist'])
spotify.getCurrentUser()
spotify.getMyTopTracks()
spotify.play({ uris: ['spotify:track:123'] })
spotify.pausePlayback()
spotify.addTracksToPlaylist(playlistId, ['spotify:track:123'])
spotify.removeTracksFromPlaylist(playlistId, ['spotify:track:456'])
spotify.reorderPlaylistTracks(playlistId, 0, 5)
spotify.replacePlaylistTracks(playlistId, ['spotify:track:789'])

listCalendars({ showDeleted?: boolean })
getCalendarListEntry({ calendarId: string })
insertCalendarListEntry(data: { id: string }, {})
updateCalendarListEntry(data: { ...updateData }, { calendarId: string })
patchCalendarListEntry(data: { ...patchData }, { calendarId: string })
deleteCalendarListEntry({}, { calendarId: string })

getCalendar({ calendarId: string })
insertCalendar(data: { summary: string, description?: string }, {})
updateCalendar(data: { summary?: string, description?: string }, { calendarId: string })
patchCalendar(data: { ...patchData }, { calendarId: string })
deleteCalendar({}, { calendarId: string })
clearCalendar({}, { calendarId: string })

listEvents({ calendarId: string, maxResults?: number, timeMin?: string, timeMax?: string })
// Returns: Array of events

getEvent({ calendarId: string, eventId: string })
// Returns: Event object

insertEvent(data: { summary: string, start: {}, end: {}, description?: string }, { calendarId: string })
// Returns: Created event

updateEvent(data: { summary?: string, start?: {}, end?: {} }, { calendarId: string, eventId: string })
// Returns: Updated event

patchEvent(data: { ...patchData }, { calendarId: string, eventId: string })
// Returns: Patched event

deleteEvent({}, { calendarId: string, eventId: string })
// Returns: Empty response

moveEvent(data: { destination: string }, { calendarId: string, eventId: string })
// Returns: Moved event

watchEvents(data: { id: string, type: 'web_hook', address: string }, { calendarId: string })
// Returns: Watch channel

quickAddEvent(data: { text: string }, { calendarId: string })
// Returns: Created event from natural language

getEventInstances({ calendarId: string, eventId: string })
// Returns: Instances of recurring event

queryFreeBusy(data: { timeMin: string, timeMax: string, items: Array }, {})
// Returns: Free/busy information

getColors({})
// Returns: Color palette definitions

listAcl({ calendarId: string })
getAclRule({ calendarId: string, ruleId: string })
insertAclRule(data: { role: string, scope: { type: string } }, { calendarId: string })
updateAclRule(data: { role: string }, { calendarId: string, ruleId: string })
patchAclRule(data: { role?: string }, { calendarId: string, ruleId: string })
deleteAclRule({}, { calendarId: string, ruleId: string })

listSettings({})
getSetting({ setting: string })
watchSettings(data: { id: string }, {})

calendar.getCalendars()
calendar.getCalendar(calendarId)
calendar.getEvents(calendarId)
calendar.getUpcomingEvents(calendarId, 10)
calendar.getTodaysEvents(calendarId)
calendar.createEvent(calendarId, { summary: 'Meeting' })
calendar.updateEvent(calendarId, eventId, { summary: 'Updated' })
calendar.deleteEvent(calendarId, eventId)
calendar.quickAddEvent(calendarId, 'Lunch tomorrow at 12pm')
calendar.isTimeSlotBusy(calendarId, startTime, endTime)

listFiles({ pageSize?: number, q?: string, spaces?: string })
// Returns: Paginated list of files

getFile({ fileId: string })
// Returns: File metadata

createFile(data: { name: string, mimeType?: string, parents?: string[] }, {})
// Returns: Created file

updateFile(data: { name?: string, ...metadata }, { fileId: string })
// Returns: Updated file

deleteFile({}, { fileId: string })
// Returns: Empty

copyFile(data: { name: string }, { fileId: string })
// NEW - Copies file with new name

moveFile(data: { addParents: string, removeParents: string }, { fileId: string })
// NEW - Moves file to another folder

exportFile({ fileId: string, mimeType: string })
// Returns: Exported content

downloadFile({ fileId: string })
// Returns: File content

generateIds({})
// Returns: List of generated IDs

watchFile(data: { id: string, type: 'web_hook', address: string }, { fileId: string })
// Returns: Watch channel

emptyTrash({}, {})
// Returns: Empty

getFileMetadata({ fileId: string })
// Returns: File metadata

updateFileMetadata(data: { ...metadata }, { fileId: string })
// Returns: Updated metadata

listPermissions({ fileId: string })
// Returns: Array of permissions

getPermission({ fileId: string, permissionId: string })
// Returns: Permission object

createPermission(data: { type: string, role: string, emailAddress?: string }, { fileId: string })
// Returns: Created permission

updatePermission(data: { role: string }, { fileId: string, permissionId: string })
// Returns: Updated permission

deletePermission({}, { fileId: string, permissionId: string })
// Returns: Empty

listComments({ fileId: string })
getComment({ fileId: string, commentId: string })
createComment(data: { content: string }, { fileId: string })
updateComment(data: { content: string }, { fileId: string, commentId: string })
deleteComment({}, { fileId: string, commentId: string })

listReplies({ fileId: string, commentId: string })
getReply({ fileId: string, commentId: string, replyId: string })
createReply(data: { content: string }, { fileId: string, commentId: string })
updateReply(data: { content: string }, { fileId: string, commentId: string, replyId: string })
deleteReply({}, { fileId: string, commentId: string, replyId: string })

listRevisions({ fileId: string })
getRevision({ fileId: string, revisionId: string })
updateRevision(data: {...}, { fileId: string, revisionId: string })
deleteRevision({}, { fileId: string, revisionId: string })

listDrives({})
getDrive({ driveId: string })
createDrive(data: { name: string }, {})
updateDrive(data: { name?: string }, { driveId: string })
deleteDrive({}, { driveId: string })
hideDrive({}, { driveId: string })
unhideDrive({}, { driveId: string })

listChanges({ pageToken: string })
getStartPageToken({})
watchChanges(data: { id: string, type: 'web_hook', address: string }, {})

stopChannel(data: { id: string, resourceId: string }, {})

getAbout({})
// Returns: Drive storage information

drive.listFiles()
drive.getFile(fileId)
drive.createFile({ name: 'Document' })
drive.updateFile(fileId, { name: 'Updated' })
drive.deleteFile(fileId)
drive.copyFile(fileId, 'Copy Name')
drive.moveFile(fileId, parentFolderId)
drive.downloadFile(fileId)
drive.exportFile(fileId, 'application/pdf')
drive.createFolder('New Folder')
drive.getFolderContents(folderId)
drive.searchFiles('query')
drive.getFilesByName('filename')
drive.getFilesByType('image/jpeg')
drive.shareFile(fileId, 'user@example.com')
drive.getPermissions(fileId)
drive.restoreFile(fileId)  // NEW - Restore from trash

listProjects({ teamId?: string })
getProject({ projectId: string })
createProject(data: { name: string }, {})
updateProject(data: { name?: string }, { projectId: string })
deleteProject({}, { projectId: string })
getProjectDomains({ projectId: string })
getProjectEnvVars({ projectId: string })
createProjectEnvVar(data: { key: string, value: string }, { projectId: string })

listDeployments({ projectId?: string })
getDeployment({ deploymentId: string })
createDeployment(data: { name: string, project: string }, {})
// NEW - Create deployment
deleteDeployment({}, { deploymentId: string })
getDeploymentEvents({ deploymentId: string })
getDeploymentFiles({ deploymentId: string })
cancelDeployment({}, { deploymentId: string })

listDomains({})
getDomain({ domain: string })
addDomain(data: { name: string }, {})
removeDomain({}, { domain: string })
verifyDomain(data: { name: string }, {})
getDomainConfig({ domain: string })

listTeams({})
getTeam({ teamId: string })
createTeam(data: { name: string }, {})
updateTeam(data: { name?: string }, { teamId: string })
deleteTeam({}, { teamId: string })
getTeamMembers({ teamId: string })
inviteTeamMember(data: { email: string, role: string }, { teamId: string })

getUser({})
updateUser(data: { name?: string }, {})
deleteUser({}, {})
getUserEvents({})
getUserTokens({})

vercel.getProject(projectId)
vercel.listProjects(teamId)
vercel.getLatestDeployment(projectId)
vercel.getDeploymentStatus(deploymentId)
vercel.redeployProject(projectId)
vercel.getProjectAnalytics(projectId)
vercel.getDomainStatus(domain)

getCurrentUser({})
// Returns: Current user object

getUser({ userId: string })
// Returns: User object

modifyCurrentUser(data: { username?: string, avatar?: string }, {})
// Returns: Modified user

getCurrentUserGuilds({})
// Returns: Array of guild objects

getCurrentUserGuildMember({ guildId: string })
// Returns: Guild member object

leaveGuild({}, { guildId: string })
// Leaves guild

createDM(data: { recipient_id: string }, {})
// Returns: DM channel

getConnections({})
// Returns: Array of connected accounts

createGuild(data: { name: string, region?: string }, {})
getGuild({ guildId: string })
getGuildPreview({ guildId: string })
modifyGuild(data: { name?: string, icon?: string }, { guildId: string })
deleteGuild({}, { guildId: string })
getGuildChannels({ guildId: string })
createGuildChannel(data: { name: string, type: number }, { guildId: string })
modifyGuildChannelPositions(data: { moves: Array }, { guildId: string })
listActiveThreads({ guildId: string })
getGuildMember({ guildId: string, userId: string })
listGuildMembers({ guildId: string, limit?: number })
searchGuildMembers({ guildId: string, query: string })
addGuildMember(data: { access_token: string }, { guildId: string, userId: string })
modifyGuildMember(data: { nick?: string, roles?: string[] }, { guildId: string, userId: string })
modifyCurrentMember(data: { nick?: string }, { guildId: string })
addGuildMemberRole({}, { guildId: string, userId: string, roleId: string })
removeGuildMemberRole({}, { guildId: string, userId: string, roleId: string })
removeGuildMember({}, { guildId: string, userId: string })
getGuildBans({ guildId: string })
getGuildBan({ guildId: string, userId: string })
createGuildBan(data: { delete_message_seconds?: number }, { guildId: string, userId: string })
removeGuildBan({}, { guildId: string, userId: string })
getGuildRoles({ guildId: string })
createGuildRole(data: { name?: string, color?: number }, { guildId: string })
modifyGuildRolePositions(data: { moves: Array }, { guildId: string })
modifyGuildRole(data: { name?: string, color?: number }, { guildId: string, roleId: string })
deleteGuildRole({}, { guildId: string, roleId: string })
getGuildPruneCount({ guildId: string, days?: number })
beginGuildPrune(data: { days?: number }, { guildId: string })
getGuildVoiceRegions({ guildId: string })
getGuildInvites({ guildId: string })
getGuildIntegrations({ guildId: string })
deleteGuildIntegration({}, { guildId: string, integrationId: string })
getGuildWidgetSettings({ guildId: string })
modifyGuildWidget(data: { enabled?: boolean }, { guildId: string })
getGuildWidget({ guildId: string })
getGuildVanityURL({ guildId: string })
getGuildWelcomeScreen({ guildId: string })
modifyGuildWelcomeScreen(data: { ...screenData }, { guildId: string })
getGuildOnboarding({ guildId: string })
modifyGuildOnboarding(data: { ...onboardingData }, { guildId: string })
modifyCurrentUserVoiceState(data: { channel_id: string, suppress?: boolean }, { guildId: string })
modifyUserVoiceState(data: { channel_id: string }, { guildId: string, userId: string })
listScheduledEventsForGuild({ guildId: string })
createGuildScheduledEvent(data: { name: string, scheduled_start_time: string }, { guildId: string })
getGuildScheduledEvent({ guildId: string, guildScheduledEventId: string })
modifyGuildScheduledEvent(data: { name?: string }, { guildId: string, guildScheduledEventId: string })
deleteGuildScheduledEvent({}, { guildId: string, guildScheduledEventId: string })
getGuildScheduledEventUsers({ guildId: string, guildScheduledEventId: string })
getGuildTemplate({ templateCode: string })
createGuildFromTemplate(data: { name: string }, { templateCode: string })
getGuildTemplates({ guildId: string })
createGuildTemplate(data: { name: string }, { guildId: string })
syncGuildTemplate({}, { guildId: string, templateCode: string })
modifyGuildTemplate(data: { name?: string }, { guildId: string, templateCode: string })
deleteGuildTemplate({}, { guildId: string, templateCode: string })

getChannel({ channelId: string })
modifyChannel(data: { name?: string, topic?: string }, { channelId: string })
deleteChannel({}, { channelId: string })
getChannelMessages({ channelId: string, limit?: number })
getChannelMessage({ channelId: string, messageId: string })
createMessage(data: { content: string }, { channelId: string })
crosspostMessage({}, { channelId: string, messageId: string })
createReaction(data: { emoji: string }, { channelId: string, messageId: string })
deleteOwnReaction({}, { channelId: string, messageId: string, emoji: string })
deleteUserReaction({}, { channelId: string, messageId: string, emoji: string, userId: string })
getReactions({ channelId: string, messageId: string, emoji: string })
deleteAllReactions({}, { channelId: string, messageId: string })
deleteAllReactionsForEmoji({}, { channelId: string, messageId: string, emoji: string })
editMessage(data: { content?: string }, { channelId: string, messageId: string })
deleteMessage({}, { channelId: string, messageId: string })
bulkDeleteMessages(data: { messages: string[] }, { channelId: string })
editChannelPermissions(data: { allow: string, deny: string }, { channelId: string, overwriteId: string })
getChannelInvites({ channelId: string })
createChannelInvite(data: { max_age?: number, max_uses?: number }, { channelId: string })
deleteChannelPermission({}, { channelId: string, overwriteId: string })
followAnnouncementChannel(data: { webhook_channel_id: string }, { channelId: string })
triggerTypingIndicator({}, { channelId: string })
getPinnedMessages({ channelId: string })
pinMessage({}, { channelId: string, messageId: string })
unpinMessage({}, { channelId: string, messageId: string })
groupDMAddRecipient(data: { access_token: string, nick?: string }, { channelId: string, userId: string })
groupDMRemoveRecipient({}, { channelId: string, userId: string })
startThreadFromMessage(data: { name: string }, { channelId: string, messageId: string })
startThreadWithoutMessage(data: { name: string }, { channelId: string })
startThreadInForumOrMediaChannel(data: { name: string, message?: {} }, { channelId: string })
joinThread({}, { channelId: string })
addThreadMember({}, { channelId: string, userId: string })
leaveThread({}, { channelId: string })
removeThreadMember({}, { channelId: string, userId: string })
getThreadMember({ channelId: string, userId: string })
listThreadMembers({ channelId: string })
listPublicArchivedThreads({ channelId: string, before?: string })
listPrivateArchivedThreads({ channelId: string, before?: string })
listJoinedPrivateArchivedThreads({ channelId: string, before?: string })

listGuildEmojis({ guildId: string })
getGuildEmoji({ guildId: string, emojiId: string })
createGuildEmoji(data: { name: string, image: string }, { guildId: string })
modifyGuildEmoji(data: { name?: string }, { guildId: string, emojiId: string })
deleteGuildEmoji({}, { guildId: string, emojiId: string })

getInvite({ inviteCode: string })
deleteInvite({}, { inviteCode: string })

getPage({ page_id: string })
// Returns: Page object

createPage(data: { parent: {}, title: {}, properties?: {} }, {})
// Returns: Created page

updatePage(data: { properties?: {} }, { page_id: string })
// Returns: Updated page

getPageProperty({ page_id: string, property_id: string })
// Returns: Property value

getDatabase({ database_id: string })
// Returns: Database object

createDatabase(data: { parent: {}, title: {}, properties: {} }, {})
// Returns: Created database

updateDatabase(data: { title?: {}, properties?: {} }, { database_id: string })
// Returns: Updated database

queryDatabase(data: { filter?: {}, sorts?: [] }, { database_id: string })
// Returns: Query results

getBlock({ block_id: string })
// Returns: Block object

updateBlock(data: { ...blockData }, { block_id: string })
// Returns: Updated block

deleteBlock({}, { block_id: string })
// Returns: Empty

getBlockChildren({ block_id: string, start_cursor?: string, page_size?: number })
// Returns: Array of child blocks

appendBlockChildren(data: { children: Array }, { block_id: string })
// Returns: Array of appended blocks

getUser({ user_id: string })
// Returns: User object

getCurrentUser({})
// Returns: Current user

listUsers({ start_cursor?: string, page_size?: number })
// Returns: Paginated users

createComment(data: { parent: {}, rich_text: [] }, {})
// Returns: Created comment

getComments({ block_id: string, start_cursor?: string, page_size?: number })
// Returns: Paginated comments

search(data: { query: string, filter?: {}, sort?: {} }, {})
// Returns: Search results

notion.getPage(pageId)
notion.createPage({ title: 'New Page' })
notion.updatePage(pageId, { properties: {} })
notion.archivePage(pageId)
notion.getDatabase(databaseId)
notion.queryDatabase(databaseId, { filter: {} })
notion.getBlock(blockId)
notion.getBlockChildren(blockId)
notion.appendBlockChildren(blockId, [{ type: 'paragraph', paragraph: {} }])
notion.addTextBlock(blockId, 'Text content')
notion.addToDoBlock(blockId, 'Task', false)
notion.addBulletedListItem(blockId, 'Bullet point')
notion.addCodeBlock(blockId, 'const x = 1;', 'javascript')
notion.addQuoteBlock(blockId, 'Quote text')
notion.addDividerBlock(blockId)
notion.search('search term')

getPackage({ packageName: string })
// Returns: Package metadata

getPackageVersion({ packageName: string, version: string })
// Returns: Version metadata

getPackageVersions({ packageName: string })
// Returns: All versions

getPackageTarball({ packageName: string, tarball: string })
// Returns: Tarball data

searchPackages({ q: string, text?: boolean, size?: number, from?: number, quality?: number })
// Returns: Search results

getUser({ username: string })
// Returns: User profile

npm.getPackage('@remcostoeten/fync')
npm.getLatestVersion('@remcostoeten/fync')
npm.searchPackages('typescript')
npm.getPackageDownloads('@remcostoeten/fync', 'last-month')
npm.getPackageDependencies('@remcostoeten/fync')
npm.isPackageDeprecated('@remcostoeten/fync')
npm.getPackageMaintainers('@remcostoeten/fync')
npm.getPackageReadme('@remcostoeten/fync')

generatePKCE()
// Returns: { codeVerifier, codeChallenge }

getAuthorizationUrl({ scope?, state?, pkce?, ...options })
// Returns: { url, codeVerifier? }

exchangeCodeForToken(code: string, state?: string, codeVerifier?: string)
// Returns: Token response

refreshToken(refreshToken: string)
// Returns: New tokens

revokeToken(token?: string)
// Returns: Empty

getUser()
// Returns: User profile

getUserEmails()
// Returns: Array of emails

getPrimaryEmail()
// Returns: Primary email string

validateToken()
// Returns: Boolean

getTokenScopes()
// Returns: Array of scopes

getCompleteProfile()
// Returns: { user, emails, primaryEmail, scopes }

generatePKCE()
// Returns: { codeVerifier, codeChallenge }

getAuthorizationUrl({ scope?, accessType?, pkce?, ...options })
// Returns: { url, codeVerifier? }

exchangeCodeForToken(code: string, codeVerifier?: string)
// Returns: Token response

refreshToken(refreshToken: string)
// Returns: New tokens

revokeToken(token?: string)
// Returns: Empty

getUser()
// Returns: User profile

getTokenInfo()
// Returns: Token information

validateToken()
// Returns: Boolean

getTokenScopes()
// Returns: Array of scopes

hasScope(scope: string)
// Returns: Boolean

hasScopes(requiredScopes: string[])
// Returns: Boolean

getTokenExpirationTime()
// Returns: Seconds until expiration

isTokenExpired(bufferSeconds?: number)
// Returns: Boolean

getCompleteProfile()
// Returns: { user, tokenInfo, scopes }