1 | # @octokit/plugin-enterprise-rest/ghe-2.16
|
2 |
|
3 | ## Enterprise Administration
|
4 |
|
5 | ```js
|
6 | octokit.enterpriseAdmin.addAuthorizedSshKey(authorized_key);
|
7 | octokit.enterpriseAdmin.checkConfigurationStatus();
|
8 | octokit.enterpriseAdmin.checkMaintenanceStatus();
|
9 | octokit.enterpriseAdmin.createGlobalHook(active, config, events, name);
|
10 | octokit.enterpriseAdmin.createImpersonationOAuthToken(scopes, username);
|
11 | octokit.enterpriseAdmin.createOrg(admin, login, profile_name);
|
12 | octokit.enterpriseAdmin.createPreReceiveEnvironment(image_url, name);
|
13 | octokit.enterpriseAdmin.createPreReceiveHook(
|
14 | allow_downstream_configuration,
|
15 | enforcement,
|
16 | environment,
|
17 | name,
|
18 | script,
|
19 | script_repository
|
20 | );
|
21 | octokit.enterpriseAdmin.createUser(email, login);
|
22 | octokit.enterpriseAdmin.deleteGlobalHook(hook_id);
|
23 | octokit.enterpriseAdmin.deleteImpersonationOAuthToken(username);
|
24 | octokit.enterpriseAdmin.deletePreReceiveEnvironment(pre_receive_environment_id);
|
25 | octokit.enterpriseAdmin.deletePreReceiveHook(pre_receive_hook_id);
|
26 | octokit.enterpriseAdmin.deletePublicKey(key_ids);
|
27 | octokit.enterpriseAdmin.deleteUser(username);
|
28 | octokit.enterpriseAdmin.demoteSiteAdministratorToOrdinaryUser(username);
|
29 | octokit.enterpriseAdmin.enableOrDisableMaintenanceMode(maintenance);
|
30 | octokit.enterpriseAdmin.getGlobalHook(hook_id);
|
31 | octokit.enterpriseAdmin.getLicenseInformation();
|
32 | octokit.enterpriseAdmin.getPreReceiveEnvironment(pre_receive_environment_id);
|
33 | octokit.enterpriseAdmin.getPreReceiveEnvironmentDownloadStatus(
|
34 | downloaded_at,
|
35 | message,
|
36 | pre_receive_environment_id,
|
37 | state
|
38 | );
|
39 | octokit.enterpriseAdmin.getPreReceiveHook(pre_receive_hook_id);
|
40 | octokit.enterpriseAdmin.getPreReceiveHookForOrg(org, pre_receive_hook_id);
|
41 | octokit.enterpriseAdmin.getPreReceiveHookForRepo(
|
42 | owner,
|
43 | pre_receive_hook_id,
|
44 | repo
|
45 | );
|
46 | octokit.enterpriseAdmin.getTypeStats(type);
|
47 | octokit.enterpriseAdmin.listGlobalHooks(page, per_page);
|
48 | octokit.enterpriseAdmin.listPreReceiveEnvironments(page, per_page);
|
49 | octokit.enterpriseAdmin.listPreReceiveHooks(page, per_page);
|
50 | octokit.enterpriseAdmin.listPreReceiveHooksForOrg(org, page, per_page);
|
51 | octokit.enterpriseAdmin.listPreReceiveHooksForRepo(owner, page, per_page, repo);
|
52 | octokit.enterpriseAdmin.modifySettings(settings);
|
53 | octokit.enterpriseAdmin.pingGlobalHook(hook_id);
|
54 | octokit.enterpriseAdmin.promoteOrdinaryUserToSiteAdministrator(username);
|
55 | octokit.enterpriseAdmin.queueIndexingJob(target);
|
56 | octokit.enterpriseAdmin.removeAuthorizedSshKey(authorized_key);
|
57 | octokit.enterpriseAdmin.removeEnforcementOverridesForPreReceiveHookForOrg(
|
58 | org,
|
59 | pre_receive_hook_id
|
60 | );
|
61 | octokit.enterpriseAdmin.removeEnforcementOverridesForPreReceiveHookForRepo(
|
62 | owner,
|
63 | pre_receive_hook_id,
|
64 | repo
|
65 | );
|
66 | octokit.enterpriseAdmin.renameOrg(login, org);
|
67 | octokit.enterpriseAdmin.renameUser(login, username);
|
68 | octokit.enterpriseAdmin.retrieveAuthorizedSshKeys();
|
69 | octokit.enterpriseAdmin.retrieveSettings();
|
70 | octokit.enterpriseAdmin.startConfigurationProcess();
|
71 | octokit.enterpriseAdmin.suspendUser(reason, username);
|
72 | octokit.enterpriseAdmin.syncLdapMappingForTeam(team_id);
|
73 | octokit.enterpriseAdmin.syncLdapMappingForUser(username);
|
74 | octokit.enterpriseAdmin.triggerPreReceiveEnvironmentDownload(
|
75 | pre_receive_environment_id
|
76 | );
|
77 | octokit.enterpriseAdmin.unsuspendUser(reason, username);
|
78 | octokit.enterpriseAdmin.updateGlobalHook(active, config, events, hook_id);
|
79 | octokit.enterpriseAdmin.updateLdapMappingForTeam(ldap_dn, team_id);
|
80 | octokit.enterpriseAdmin.updateLdapMappingForUser(ldap_dn, username);
|
81 | octokit.enterpriseAdmin.updatePreReceiveEnvironment(
|
82 | image_url,
|
83 | name,
|
84 | pre_receive_environment_id
|
85 | );
|
86 | octokit.enterpriseAdmin.updatePreReceiveHook(pre_receive_hook_id);
|
87 | octokit.enterpriseAdmin.updatePreReceiveHookEnforcementForOrg(
|
88 | org,
|
89 | pre_receive_hook_id
|
90 | );
|
91 | octokit.enterpriseAdmin.updatePreReceiveHookEnforcementForRepo(
|
92 | owner,
|
93 | pre_receive_hook_id,
|
94 | repo
|
95 | );
|
96 | octokit.enterpriseAdmin.upgradeLicense(license);
|
97 | octokit.enterpriseAdmin.uploadLicenseForFirstTime(license, password, settings);
|
98 | ```
|
99 |
|
100 | ## Others
|
101 |
|
102 | ```js
|
103 | octokit.activity.checkStarringRepo(owner, repo);
|
104 | octokit.activity.deleteRepoSubscription(owner, repo);
|
105 | octokit.activity.deleteThreadSubscription(thread_id);
|
106 | octokit.activity.getRepoSubscription(owner, repo);
|
107 | octokit.activity.getThread(thread_id);
|
108 | octokit.activity.getThreadSubscription(thread_id);
|
109 | octokit.activity.listEventsForOrg(org, page, per_page, username);
|
110 | octokit.activity.listEventsForUser(page, per_page, username);
|
111 | octokit.activity.listFeeds();
|
112 | octokit.activity.listNotifications(
|
113 | all,
|
114 | before,
|
115 | page,
|
116 | participating,
|
117 | per_page,
|
118 | since
|
119 | );
|
120 | octokit.activity.listNotificationsForRepo(
|
121 | all,
|
122 | before,
|
123 | owner,
|
124 | page,
|
125 | participating,
|
126 | per_page,
|
127 | repo,
|
128 | since
|
129 | );
|
130 | octokit.activity.listPublicEvents(page, per_page);
|
131 | octokit.activity.listPublicEventsForOrg(org, page, per_page);
|
132 | octokit.activity.listPublicEventsForRepoNetwork(owner, page, per_page, repo);
|
133 | octokit.activity.listPublicEventsForUser(page, per_page, username);
|
134 | octokit.activity.listReceivedEventsForUser(page, per_page, username);
|
135 | octokit.activity.listReceivedPublicEventsForUser(page, per_page, username);
|
136 | octokit.activity.listRepoEvents(owner, page, per_page, repo);
|
137 | octokit.activity.listReposStarredByAuthenticatedUser(
|
138 | direction,
|
139 | page,
|
140 | per_page,
|
141 | sort
|
142 | );
|
143 | octokit.activity.listReposStarredByUser(
|
144 | direction,
|
145 | page,
|
146 | per_page,
|
147 | sort,
|
148 | username
|
149 | );
|
150 | octokit.activity.listReposWatchedByUser(page, per_page, username);
|
151 | octokit.activity.listStargazersForRepo(owner, page, per_page, repo);
|
152 | octokit.activity.listWatchedReposForAuthenticatedUser(page, per_page);
|
153 | octokit.activity.listWatchersForRepo(owner, page, per_page, repo);
|
154 | octokit.activity.markAsRead(last_read_at);
|
155 | octokit.activity.markNotificationsAsReadForRepo(last_read_at, owner, repo);
|
156 | octokit.activity.markThreadAsRead(thread_id);
|
157 | octokit.activity.setRepoSubscription(ignored, owner, repo, subscribed);
|
158 | octokit.activity.setThreadSubscription(ignored, thread_id);
|
159 | octokit.activity.starRepo(owner, repo);
|
160 | octokit.activity.unstarRepo(owner, repo);
|
161 | octokit.apps.addRepoToInstallation(installation_id, repository_id);
|
162 | octokit.apps.createContentAttachment(body, content_reference_id, title);
|
163 | octokit.apps.createFromManifest(code);
|
164 | octokit.apps.createInstallationToken(installation_id);
|
165 | octokit.apps.findOrgInstallation(org);
|
166 | octokit.apps.findRepoInstallation(owner, repo);
|
167 | octokit.apps.findUserInstallation(username);
|
168 | octokit.apps.getAuthenticated();
|
169 | octokit.apps.getBySlug(app_slug);
|
170 | octokit.apps.getInstallation(installation_id);
|
171 | octokit.apps.getOrgInstallation(org);
|
172 | octokit.apps.getRepoInstallation(owner, repo);
|
173 | octokit.apps.getUserInstallation(username);
|
174 | octokit.apps.listInstallationReposForAuthenticatedUser(
|
175 | installation_id,
|
176 | page,
|
177 | per_page
|
178 | );
|
179 | octokit.apps.listInstallations(page, per_page);
|
180 | octokit.apps.listInstallationsForAuthenticatedUser(page, per_page);
|
181 | octokit.apps.listRepos(page, per_page);
|
182 | octokit.apps.removeRepoFromInstallation(installation_id, repository_id);
|
183 | octokit.checks.create(
|
184 | actions,
|
185 | completed_at,
|
186 | conclusion,
|
187 | details_url,
|
188 | external_id,
|
189 | head_sha,
|
190 | name,
|
191 | output,
|
192 | owner,
|
193 | repo,
|
194 | started_at,
|
195 | status
|
196 | );
|
197 | octokit.checks.createSuite(head_sha, owner, repo);
|
198 | octokit.checks.get(check_run_id, owner, repo);
|
199 | octokit.checks.getSuite(check_suite_id, owner, repo);
|
200 | octokit.checks.listAnnotations(check_run_id, owner, page, per_page, repo);
|
201 | octokit.checks.listForRef(
|
202 | check_name,
|
203 | filter,
|
204 | owner,
|
205 | page,
|
206 | per_page,
|
207 | ref,
|
208 | repo,
|
209 | status
|
210 | );
|
211 | octokit.checks.listForSuite(
|
212 | check_name,
|
213 | check_suite_id,
|
214 | filter,
|
215 | owner,
|
216 | page,
|
217 | per_page,
|
218 | repo,
|
219 | status
|
220 | );
|
221 | octokit.checks.listSuitesForRef(
|
222 | app_id,
|
223 | check_name,
|
224 | owner,
|
225 | page,
|
226 | per_page,
|
227 | ref,
|
228 | repo
|
229 | );
|
230 | octokit.checks.rerequestSuite(check_suite_id, owner, repo);
|
231 | octokit.checks.setSuitesPreferences(auto_trigger_checks, owner, repo);
|
232 | octokit.checks.update(
|
233 | actions,
|
234 | check_run_id,
|
235 | completed_at,
|
236 | conclusion,
|
237 | details_url,
|
238 | external_id,
|
239 | name,
|
240 | output,
|
241 | owner,
|
242 | repo,
|
243 | started_at,
|
244 | status
|
245 | );
|
246 | octokit.codesOfConduct.getConductCode(key);
|
247 | octokit.codesOfConduct.getForRepo(owner, repo);
|
248 | octokit.codesOfConduct.listConductCodes();
|
249 | octokit.emojis.get();
|
250 | octokit.gists.checkIsStarred(gist_id);
|
251 | octokit.gists.create(description, files, public);
|
252 | octokit.gists.createComment(body, gist_id);
|
253 | octokit.gists.delete(gist_id);
|
254 | octokit.gists.deleteComment(comment_id, gist_id);
|
255 | octokit.gists.fork(gist_id);
|
256 | octokit.gists.get(gist_id);
|
257 | octokit.gists.getComment(comment_id, gist_id);
|
258 | octokit.gists.getRevision(gist_id, sha);
|
259 | octokit.gists.list(page, per_page, since);
|
260 | octokit.gists.listComments(gist_id, page, per_page);
|
261 | octokit.gists.listCommits(gist_id, page, per_page);
|
262 | octokit.gists.listForks(gist_id, page, per_page);
|
263 | octokit.gists.listPublic(page, per_page, since);
|
264 | octokit.gists.listPublicForUser(page, per_page, since, username);
|
265 | octokit.gists.listStarred(page, per_page, since);
|
266 | octokit.gists.star(gist_id);
|
267 | octokit.gists.unstar(gist_id);
|
268 | octokit.gists.update(description, files, gist_id);
|
269 | octokit.gists.updateComment(body, comment_id, gist_id);
|
270 | octokit.git.createBlob(content, encoding, owner, repo);
|
271 | octokit.git.createCommit(
|
272 | author,
|
273 | committer,
|
274 | message,
|
275 | owner,
|
276 | parents,
|
277 | repo,
|
278 | signature,
|
279 | tree
|
280 | );
|
281 | octokit.git.createRef(owner, ref, repo, sha);
|
282 | octokit.git.createTag(message, object, owner, repo, tag, tagger, type);
|
283 | octokit.git.createTree(base_tree, owner, repo, tree);
|
284 | octokit.git.deleteRef(owner, ref, repo);
|
285 | octokit.git.getBlob(file_sha, owner, repo);
|
286 | octokit.git.getCommit(commit_sha, owner, repo);
|
287 | octokit.git.getRef(owner, ref, repo);
|
288 | octokit.git.getTag(owner, repo, tag_sha);
|
289 | octokit.git.getTree(owner, recursive, repo, tree_sha);
|
290 | octokit.git.listRefs(namespace, owner, page, per_page, repo);
|
291 | octokit.git.updateRef(force, owner, ref, repo, sha);
|
292 | octokit.gitignore.getTemplate(name);
|
293 | octokit.gitignore.listTemplates();
|
294 | octokit.issues.addAssignees(assignees, issue_number, owner, repo);
|
295 | octokit.issues.addLabels(issue_number, labels, owner, repo);
|
296 | octokit.issues.checkAssignee(assignee, owner, repo);
|
297 | octokit.issues.create(
|
298 | assignee,
|
299 | assignees,
|
300 | body,
|
301 | labels,
|
302 | milestone,
|
303 | owner,
|
304 | repo,
|
305 | title
|
306 | );
|
307 | octokit.issues.createComment(body, issue_number, owner, repo);
|
308 | octokit.issues.createLabel(color, description, name, owner, repo);
|
309 | octokit.issues.createMilestone(description, due_on, owner, repo, state, title);
|
310 | octokit.issues.deleteComment(comment_id, owner, repo);
|
311 | octokit.issues.deleteLabel(name, owner, repo);
|
312 | octokit.issues.deleteMilestone(milestone_number, owner, repo);
|
313 | octokit.issues.get(issue_number, owner, repo);
|
314 | octokit.issues.getComment(comment_id, owner, page, per_page, repo);
|
315 | octokit.issues.getEvent(event_id, owner, repo);
|
316 | octokit.issues.getLabel(name, owner, repo);
|
317 | octokit.issues.getMilestone(milestone_number, owner, repo);
|
318 | octokit.issues.list(
|
319 | direction,
|
320 | filter,
|
321 | labels,
|
322 | page,
|
323 | per_page,
|
324 | since,
|
325 | sort,
|
326 | state
|
327 | );
|
328 | octokit.issues.listAssignees(owner, page, per_page, repo);
|
329 | octokit.issues.listComments(issue_number, owner, page, per_page, repo, since);
|
330 | octokit.issues.listCommentsForRepo(direction, owner, repo, since, sort);
|
331 | octokit.issues.listEvents(issue_number, owner, page, per_page, repo);
|
332 | octokit.issues.listEventsForRepo(owner, page, per_page, repo);
|
333 | octokit.issues.listEventsForTimeline(issue_number, owner, page, per_page, repo);
|
334 | octokit.issues.listForAuthenticatedUser(
|
335 | direction,
|
336 | filter,
|
337 | labels,
|
338 | page,
|
339 | per_page,
|
340 | since,
|
341 | sort,
|
342 | state
|
343 | );
|
344 | octokit.issues.listForOrg(
|
345 | direction,
|
346 | filter,
|
347 | labels,
|
348 | org,
|
349 | page,
|
350 | per_page,
|
351 | since,
|
352 | sort,
|
353 | state
|
354 | );
|
355 | octokit.issues.listForRepo(
|
356 | assignee,
|
357 | creator,
|
358 | direction,
|
359 | labels,
|
360 | mentioned,
|
361 | milestone,
|
362 | owner,
|
363 | page,
|
364 | per_page,
|
365 | repo,
|
366 | since,
|
367 | sort,
|
368 | state
|
369 | );
|
370 | octokit.issues.listLabelsForMilestone(
|
371 | milestone_number,
|
372 | owner,
|
373 | page,
|
374 | per_page,
|
375 | repo
|
376 | );
|
377 | octokit.issues.listLabelsForRepo(owner, page, per_page, repo);
|
378 | octokit.issues.listLabelsOnIssue(issue_number, owner, page, per_page, repo);
|
379 | octokit.issues.listMilestonesForRepo(
|
380 | direction,
|
381 | owner,
|
382 | page,
|
383 | per_page,
|
384 | repo,
|
385 | sort,
|
386 | state
|
387 | );
|
388 | octokit.issues.lock(issue_number, lock_reason, owner, repo);
|
389 | octokit.issues.removeAssignees(assignees, issue_number, owner, repo);
|
390 | octokit.issues.removeLabel(issue_number, name, owner, repo);
|
391 | octokit.issues.removeLabels(issue_number, owner, repo);
|
392 | octokit.issues.replaceLabels(issue_number, labels, owner, repo);
|
393 | octokit.issues.unlock(issue_number, owner, repo);
|
394 | octokit.issues.update(
|
395 | assignee,
|
396 | assignees,
|
397 | body,
|
398 | issue_number,
|
399 | labels,
|
400 | milestone,
|
401 | owner,
|
402 | repo,
|
403 | state,
|
404 | title
|
405 | );
|
406 | octokit.issues.updateComment(body, comment_id, owner, repo);
|
407 | octokit.issues.updateLabel(color, current_name, description, name, owner, repo);
|
408 | octokit.issues.updateMilestone(
|
409 | description,
|
410 | due_on,
|
411 | milestone_number,
|
412 | owner,
|
413 | repo,
|
414 | state,
|
415 | title
|
416 | );
|
417 | octokit.licenses.get(license);
|
418 | octokit.licenses.getForRepo(owner, repo);
|
419 | octokit.licenses.list();
|
420 | octokit.licenses.listCommonlyUsed();
|
421 | octokit.markdown.render(context, mode, text);
|
422 | octokit.markdown.renderRaw(data);
|
423 | octokit.meta.get();
|
424 | octokit.oauthAuthorizations.checkAuthorization(access_token, client_id);
|
425 | octokit.oauthAuthorizations.createAuthorization(
|
426 | client_id,
|
427 | client_secret,
|
428 | fingerprint,
|
429 | note,
|
430 | note_url,
|
431 | scopes
|
432 | );
|
433 | octokit.oauthAuthorizations.deleteAuthorization(authorization_id);
|
434 | octokit.oauthAuthorizations.deleteGrant(grant_id);
|
435 | octokit.oauthAuthorizations.getAuthorization(authorization_id);
|
436 | octokit.oauthAuthorizations.getGrant(grant_id);
|
437 | octokit.oauthAuthorizations.getOrCreateAuthorizationForApp(
|
438 | client_id,
|
439 | client_secret,
|
440 | fingerprint,
|
441 | note,
|
442 | note_url,
|
443 | scopes
|
444 | );
|
445 | octokit.oauthAuthorizations.getOrCreateAuthorizationForAppAndFingerprint(
|
446 | client_id,
|
447 | client_secret,
|
448 | fingerprint,
|
449 | note,
|
450 | note_url,
|
451 | scopes
|
452 | );
|
453 | octokit.oauthAuthorizations.getOrCreateAuthorizationForAppFingerprint(
|
454 | client_id,
|
455 | client_secret,
|
456 | fingerprint,
|
457 | note,
|
458 | note_url,
|
459 | scopes
|
460 | );
|
461 | octokit.oauthAuthorizations.listAuthorizations(page, per_page);
|
462 | octokit.oauthAuthorizations.listGrants(page, per_page);
|
463 | octokit.oauthAuthorizations.resetAuthorization(access_token, client_id);
|
464 | octokit.oauthAuthorizations.revokeAuthorizationForApplication(
|
465 | access_token,
|
466 | client_id
|
467 | );
|
468 | octokit.oauthAuthorizations.revokeGrantForApplication(access_token, client_id);
|
469 | octokit.oauthAuthorizations.updateAuthorization(
|
470 | add_scopes,
|
471 | authorization_id,
|
472 | fingerprint,
|
473 | note,
|
474 | note_url,
|
475 | remove_scopes,
|
476 | scopes
|
477 | );
|
478 | octokit.orgs.addOrUpdateMembership(org, role, username);
|
479 | octokit.orgs.checkMembership(org, username);
|
480 | octokit.orgs.checkPublicMembership(org, username);
|
481 | octokit.orgs.concealMembership(org, username);
|
482 | octokit.orgs.convertMemberToOutsideCollaborator(org, username);
|
483 | octokit.orgs.createHook(active, config, events, name, org);
|
484 | octokit.orgs.deleteHook(hook_id, org);
|
485 | octokit.orgs.get(org);
|
486 | octokit.orgs.getHook(hook_id, org);
|
487 | octokit.orgs.getMembership(org, username);
|
488 | octokit.orgs.getMembershipForAuthenticatedUser(org);
|
489 | octokit.orgs.list(page, per_page, since);
|
490 | octokit.orgs.listForAuthenticatedUser(page, per_page);
|
491 | octokit.orgs.listForUser(page, per_page, username);
|
492 | octokit.orgs.listHooks(org, page, per_page);
|
493 | octokit.orgs.listMembers(filter, org, page, per_page, role);
|
494 | octokit.orgs.listMemberships(page, per_page, state);
|
495 | octokit.orgs.listOutsideCollaborators(filter, org, page, per_page);
|
496 | octokit.orgs.listPublicMembers(org, page, per_page);
|
497 | octokit.orgs.pingHook(hook_id, org);
|
498 | octokit.orgs.publicizeMembership(org, username);
|
499 | octokit.orgs.removeMember(org, username);
|
500 | octokit.orgs.removeMembership(org, username);
|
501 | octokit.orgs.removeOutsideCollaborator(org, username);
|
502 | octokit.orgs.update(
|
503 | billing_email,
|
504 | company,
|
505 | default_repository_permission,
|
506 | description,
|
507 | email,
|
508 | has_organization_projects,
|
509 | has_repository_projects,
|
510 | location,
|
511 | members_allowed_repository_creation_type,
|
512 | members_can_create_repositories,
|
513 | name,
|
514 | org
|
515 | );
|
516 | octokit.orgs.updateHook(active, config, events, hook_id, org);
|
517 | octokit.orgs.updateMembership(org, state);
|
518 | octokit.projects.addCollaborator(permission, project_id, username);
|
519 | octokit.projects.createCard(column_id, content_id, content_type, note);
|
520 | octokit.projects.createColumn(name, project_id);
|
521 | octokit.projects.createForOrg(body, name, org);
|
522 | octokit.projects.createForRepo(body, name, owner, repo);
|
523 | octokit.projects.delete(project_id);
|
524 | octokit.projects.deleteCard(card_id);
|
525 | octokit.projects.deleteColumn(column_id);
|
526 | octokit.projects.get(page, per_page, project_id);
|
527 | octokit.projects.getCard(card_id);
|
528 | octokit.projects.getColumn(column_id);
|
529 | octokit.projects.listCards(archived_state, column_id, page, per_page);
|
530 | octokit.projects.listCollaborators(affiliation, page, per_page, project_id);
|
531 | octokit.projects.listColumns(page, per_page, project_id);
|
532 | octokit.projects.listForOrg(org, page, per_page, state);
|
533 | octokit.projects.listForRepo(owner, page, per_page, repo, state);
|
534 | octokit.projects.moveCard(card_id, column_id, position);
|
535 | octokit.projects.moveColumn(column_id, position);
|
536 | octokit.projects.removeCollaborator(project_id, username);
|
537 | octokit.projects.reviewUserPermissionLevel(project_id, username);
|
538 | octokit.projects.update(
|
539 | body,
|
540 | name,
|
541 | organization_permission,
|
542 | private,
|
543 | project_id,
|
544 | state
|
545 | );
|
546 | octokit.projects.updateCard(archived, card_id, note);
|
547 | octokit.projects.updateColumn(column_id, name);
|
548 | octokit.pulls.checkIfMerged(owner, pull_number, repo);
|
549 | octokit.pulls.create(
|
550 | base,
|
551 | body,
|
552 | head,
|
553 | maintainer_can_modify,
|
554 | owner,
|
555 | repo,
|
556 | title
|
557 | );
|
558 | octokit.pulls.createCommentReply(body, in_reply_to, owner, pull_number, repo);
|
559 | octokit.pulls.createFromIssue(
|
560 | base,
|
561 | head,
|
562 | issue,
|
563 | maintainer_can_modify,
|
564 | owner,
|
565 | repo
|
566 | );
|
567 | octokit.pulls.createReview(
|
568 | body,
|
569 | comments,
|
570 | commit_id,
|
571 | event,
|
572 | owner,
|
573 | pull_number,
|
574 | repo
|
575 | );
|
576 | octokit.pulls.createReviewRequest(
|
577 | owner,
|
578 | pull_number,
|
579 | repo,
|
580 | reviewers,
|
581 | team_reviewers
|
582 | );
|
583 | octokit.pulls.deleteComment(comment_id, owner, repo);
|
584 | octokit.pulls.deletePendingReview(owner, pull_number, repo, review_id);
|
585 | octokit.pulls.deleteReviewRequest(
|
586 | owner,
|
587 | pull_number,
|
588 | repo,
|
589 | reviewers,
|
590 | team_reviewers
|
591 | );
|
592 | octokit.pulls.dismissReview(message, owner, pull_number, repo, review_id);
|
593 | octokit.pulls.get(owner, pull_number, repo);
|
594 | octokit.pulls.getComment(comment_id, owner, repo);
|
595 | octokit.pulls.getCommentsForReview(
|
596 | owner,
|
597 | page,
|
598 | per_page,
|
599 | pull_number,
|
600 | repo,
|
601 | review_id
|
602 | );
|
603 | octokit.pulls.getReview(owner, pull_number, repo, review_id);
|
604 | octokit.pulls.list(
|
605 | base,
|
606 | direction,
|
607 | head,
|
608 | owner,
|
609 | page,
|
610 | per_page,
|
611 | repo,
|
612 | sort,
|
613 | state
|
614 | );
|
615 | octokit.pulls.listComments(
|
616 | direction,
|
617 | owner,
|
618 | page,
|
619 | per_page,
|
620 | pull_number,
|
621 | repo,
|
622 | since,
|
623 | sort
|
624 | );
|
625 | octokit.pulls.listCommentsForRepo(
|
626 | direction,
|
627 | owner,
|
628 | page,
|
629 | per_page,
|
630 | repo,
|
631 | since,
|
632 | sort
|
633 | );
|
634 | octokit.pulls.listCommits(owner, page, per_page, pull_number, repo);
|
635 | octokit.pulls.listFiles(owner, page, per_page, pull_number, repo);
|
636 | octokit.pulls.listReviewRequests(owner, page, per_page, pull_number, repo);
|
637 | octokit.pulls.listReviews(owner, page, per_page, pull_number, repo);
|
638 | octokit.pulls.merge(
|
639 | commit_message,
|
640 | commit_title,
|
641 | merge_method,
|
642 | owner,
|
643 | pull_number,
|
644 | repo,
|
645 | sha
|
646 | );
|
647 | octokit.pulls.submitReview(body, event, owner, pull_number, repo, review_id);
|
648 | octokit.pulls.update(
|
649 | base,
|
650 | body,
|
651 | maintainer_can_modify,
|
652 | owner,
|
653 | pull_number,
|
654 | repo,
|
655 | state,
|
656 | title
|
657 | );
|
658 | octokit.pulls.updateComment(body, comment_id, owner, repo);
|
659 | octokit.rateLimit.get();
|
660 | octokit.reactions.createForCommitComment(comment_id, content, owner, repo);
|
661 | octokit.reactions.createForIssue(content, issue_number, owner, repo);
|
662 | octokit.reactions.createForIssueComment(comment_id, content, owner, repo);
|
663 | octokit.reactions.createForPullRequestReviewComment(
|
664 | comment_id,
|
665 | content,
|
666 | owner,
|
667 | repo
|
668 | );
|
669 | octokit.reactions.createForTeamDiscussion(content, discussion_number, team_id);
|
670 | octokit.reactions.createForTeamDiscussionComment(
|
671 | comment_number,
|
672 | content,
|
673 | discussion_number,
|
674 | team_id
|
675 | );
|
676 | octokit.reactions.delete(reaction_id);
|
677 | octokit.reactions.listForCommitComment(
|
678 | comment_id,
|
679 | content,
|
680 | owner,
|
681 | page,
|
682 | per_page,
|
683 | repo
|
684 | );
|
685 | octokit.reactions.listForIssue(
|
686 | content,
|
687 | issue_number,
|
688 | owner,
|
689 | page,
|
690 | per_page,
|
691 | repo
|
692 | );
|
693 | octokit.reactions.listForIssueComment(
|
694 | comment_id,
|
695 | content,
|
696 | owner,
|
697 | page,
|
698 | per_page,
|
699 | repo
|
700 | );
|
701 | octokit.reactions.listForPullRequestReviewComment(
|
702 | comment_id,
|
703 | content,
|
704 | owner,
|
705 | page,
|
706 | per_page,
|
707 | repo
|
708 | );
|
709 | octokit.reactions.listForTeamDiscussion(
|
710 | content,
|
711 | discussion_number,
|
712 | page,
|
713 | per_page,
|
714 | team_id
|
715 | );
|
716 | octokit.reactions.listForTeamDiscussionComment(
|
717 | comment_number,
|
718 | content,
|
719 | discussion_number,
|
720 | page,
|
721 | per_page,
|
722 | team_id
|
723 | );
|
724 | octokit.repos.acceptInvitation(invitation_id);
|
725 | octokit.repos.addCollaborator(owner, permission, repo, username);
|
726 | octokit.repos.addDeployKey(key, owner, read_only, repo, title);
|
727 | octokit.repos.addProtectedBranchAdminEnforcement(branch, owner, repo);
|
728 | octokit.repos.addProtectedBranchRequiredSignatures(branch, owner, repo);
|
729 | octokit.repos.addProtectedBranchRequiredStatusChecksContexts(
|
730 | branch,
|
731 | contexts,
|
732 | owner,
|
733 | repo
|
734 | );
|
735 | octokit.repos.addProtectedBranchTeamRestrictions(branch, owner, repo, teams);
|
736 | octokit.repos.addProtectedBranchUserRestrictions(branch, owner, repo, users);
|
737 | octokit.repos.checkCollaborator(owner, repo, username);
|
738 | octokit.repos.compareCommits(base, head, owner, repo);
|
739 | octokit.repos.createCommitComment(
|
740 | body,
|
741 | commit_sha,
|
742 | line,
|
743 | owner,
|
744 | path,
|
745 | position,
|
746 | repo
|
747 | );
|
748 | octokit.repos.createDeployment(
|
749 | auto_merge,
|
750 | description,
|
751 | environment,
|
752 | owner,
|
753 | payload,
|
754 | production_environment,
|
755 | ref,
|
756 | repo,
|
757 | required_contexts,
|
758 | task,
|
759 | transient_environment
|
760 | );
|
761 | octokit.repos.createDeploymentStatus(
|
762 | auto_inactive,
|
763 | deployment_id,
|
764 | description,
|
765 | environment,
|
766 | environment_url,
|
767 | log_url,
|
768 | owner,
|
769 | repo,
|
770 | state,
|
771 | target_url
|
772 | );
|
773 | octokit.repos.createFile(
|
774 | author,
|
775 | branch,
|
776 | committer,
|
777 | content,
|
778 | message,
|
779 | owner,
|
780 | path,
|
781 | repo,
|
782 | sha
|
783 | );
|
784 | octokit.repos.createForAuthenticatedUser(
|
785 | allow_merge_commit,
|
786 | allow_rebase_merge,
|
787 | allow_squash_merge,
|
788 | auto_init,
|
789 | description,
|
790 | gitignore_template,
|
791 | has_issues,
|
792 | has_projects,
|
793 | has_wiki,
|
794 | homepage,
|
795 | license_template,
|
796 | name,
|
797 | private,
|
798 | team_id
|
799 | );
|
800 | octokit.repos.createFork(organization, owner, repo);
|
801 | octokit.repos.createHook(active, config, events, name, owner, repo);
|
802 | octokit.repos.createInOrg(
|
803 | allow_merge_commit,
|
804 | allow_rebase_merge,
|
805 | allow_squash_merge,
|
806 | auto_init,
|
807 | description,
|
808 | gitignore_template,
|
809 | has_issues,
|
810 | has_projects,
|
811 | has_wiki,
|
812 | homepage,
|
813 | license_template,
|
814 | name,
|
815 | org,
|
816 | private,
|
817 | team_id
|
818 | );
|
819 | octokit.repos.createOrUpdateFile(
|
820 | author,
|
821 | branch,
|
822 | committer,
|
823 | content,
|
824 | message,
|
825 | owner,
|
826 | path,
|
827 | repo,
|
828 | sha
|
829 | );
|
830 | octokit.repos.createRelease(
|
831 | body,
|
832 | draft,
|
833 | name,
|
834 | owner,
|
835 | prerelease,
|
836 | repo,
|
837 | tag_name,
|
838 | target_commitish
|
839 | );
|
840 | octokit.repos.createStatus(
|
841 | context,
|
842 | description,
|
843 | owner,
|
844 | repo,
|
845 | sha,
|
846 | state,
|
847 | target_url
|
848 | );
|
849 | octokit.repos.declineInvitation(invitation_id);
|
850 | octokit.repos.delete(owner, repo);
|
851 | octokit.repos.deleteCommitComment(comment_id, owner, repo);
|
852 | octokit.repos.deleteDownload(download_id, owner, repo);
|
853 | octokit.repos.deleteFile(
|
854 | author,
|
855 | branch,
|
856 | committer,
|
857 | message,
|
858 | owner,
|
859 | path,
|
860 | repo,
|
861 | sha
|
862 | );
|
863 | octokit.repos.deleteHook(hook_id, owner, repo);
|
864 | octokit.repos.deleteInvitation(invitation_id, owner, repo);
|
865 | octokit.repos.deleteRelease(owner, release_id, repo);
|
866 | octokit.repos.deleteReleaseAsset(asset_id, owner, repo);
|
867 | octokit.repos.get(owner, repo);
|
868 | octokit.repos.getArchiveLink(archive_format, owner, ref, repo);
|
869 | octokit.repos.getBranch(branch, owner, repo);
|
870 | octokit.repos.getBranchProtection(branch, owner, repo);
|
871 | octokit.repos.getCodeFrequencyStats(owner, repo);
|
872 | octokit.repos.getCollaboratorPermissionLevel(owner, repo, username);
|
873 | octokit.repos.getCombinedStatusForRef(owner, ref, repo);
|
874 | octokit.repos.getCommit(owner, ref, repo);
|
875 | octokit.repos.getCommitActivityStats(owner, repo);
|
876 | octokit.repos.getCommitComment(comment_id, owner, repo);
|
877 | octokit.repos.getCommitRefSha(owner, ref, repo);
|
878 | octokit.repos.getContents(owner, path, ref, repo);
|
879 | octokit.repos.getContributorsStats(owner, repo);
|
880 | octokit.repos.getDeployKey(key_id, owner, repo);
|
881 | octokit.repos.getDeployment(deployment_id, owner, repo);
|
882 | octokit.repos.getDeploymentStatus(deployment_id, owner, repo, status_id);
|
883 | octokit.repos.getDownload(download_id, owner, repo);
|
884 | octokit.repos.getHook(hook_id, owner, repo);
|
885 | octokit.repos.getLatestPagesBuild(owner, repo);
|
886 | octokit.repos.getLatestRelease(owner, repo);
|
887 | octokit.repos.getPages(owner, repo);
|
888 | octokit.repos.getPagesBuild(build_id, owner, repo);
|
889 | octokit.repos.getParticipationStats(owner, repo);
|
890 | octokit.repos.getProtectedBranchAdminEnforcement(branch, owner, repo);
|
891 | octokit.repos.getProtectedBranchPullRequestReviewEnforcement(
|
892 | branch,
|
893 | owner,
|
894 | repo
|
895 | );
|
896 | octokit.repos.getProtectedBranchRequiredSignatures(branch, owner, repo);
|
897 | octokit.repos.getProtectedBranchRequiredStatusChecks(branch, owner, repo);
|
898 | octokit.repos.getProtectedBranchRestrictions(branch, owner, repo);
|
899 | octokit.repos.getPunchCardStats(owner, repo);
|
900 | octokit.repos.getReadme(owner, ref, repo);
|
901 | octokit.repos.getRelease(owner, release_id, repo);
|
902 | octokit.repos.getReleaseAsset(asset_id, owner, repo);
|
903 | octokit.repos.getReleaseByTag(owner, repo, tag);
|
904 | octokit.repos.getTeamsWithAccessToProtectedBranch(branch, owner, repo);
|
905 | octokit.repos.getUsersWithAccessToProtectedBranch(branch, owner, repo);
|
906 | octokit.repos.list(
|
907 | affiliation,
|
908 | direction,
|
909 | page,
|
910 | per_page,
|
911 | sort,
|
912 | type,
|
913 | visibility
|
914 | );
|
915 | octokit.repos.listAssetsForRelease(owner, page, per_page, release_id, repo);
|
916 | octokit.repos.listBranches(owner, page, per_page, protected, repo);
|
917 | octokit.repos.listCollaborators(affiliation, owner, page, per_page, repo);
|
918 | octokit.repos.listCommentsForCommit(commit_sha, owner, page, per_page, repo);
|
919 | octokit.repos.listCommitComments(owner, page, per_page, repo);
|
920 | octokit.repos.listCommits(
|
921 | author,
|
922 | owner,
|
923 | page,
|
924 | path,
|
925 | per_page,
|
926 | repo,
|
927 | sha,
|
928 | since,
|
929 | until
|
930 | );
|
931 | octokit.repos.listContributors(anon, owner, page, per_page, repo);
|
932 | octokit.repos.listDeployKeys(owner, page, per_page, repo);
|
933 | octokit.repos.listDeploymentStatuses(
|
934 | deployment_id,
|
935 | owner,
|
936 | page,
|
937 | per_page,
|
938 | repo
|
939 | );
|
940 | octokit.repos.listDeployments(
|
941 | environment,
|
942 | owner,
|
943 | page,
|
944 | per_page,
|
945 | ref,
|
946 | repo,
|
947 | sha,
|
948 | task
|
949 | );
|
950 | octokit.repos.listDownloads(owner, page, per_page, repo);
|
951 | octokit.repos.listForOrg(org, page, per_page, type);
|
952 | octokit.repos.listForUser(direction, page, per_page, sort, type, username);
|
953 | octokit.repos.listForks(owner, page, per_page, repo, sort);
|
954 | octokit.repos.listHooks(owner, page, per_page, repo);
|
955 | octokit.repos.listInvitations(owner, page, per_page, repo);
|
956 | octokit.repos.listInvitationsForAuthenticatedUser(page, per_page);
|
957 | octokit.repos.listLanguages(owner, repo);
|
958 | octokit.repos.listPagesBuilds(owner, page, per_page, repo);
|
959 | octokit.repos.listProtectedBranchRequiredStatusChecksContexts(
|
960 | branch,
|
961 | owner,
|
962 | repo
|
963 | );
|
964 | octokit.repos.listProtectedBranchTeamRestrictions(branch, owner, repo);
|
965 | octokit.repos.listProtectedBranchUserRestrictions(branch, owner, repo);
|
966 | octokit.repos.listPublic(page, per_page, since, visibility);
|
967 | octokit.repos.listReleases(owner, page, per_page, repo);
|
968 | octokit.repos.listStatusesForRef(owner, page, per_page, ref, repo);
|
969 | octokit.repos.listTags(owner, page, per_page, repo);
|
970 | octokit.repos.listTeams(owner, page, per_page, repo);
|
971 | octokit.repos.listTeamsWithAccessToProtectedBranch(branch, owner, repo);
|
972 | octokit.repos.listTopics(owner, repo);
|
973 | octokit.repos.listUsersWithAccessToProtectedBranch(branch, owner, repo);
|
974 | octokit.repos.merge(base, commit_message, head, owner, repo);
|
975 | octokit.repos.pingHook(hook_id, owner, repo);
|
976 | octokit.repos.removeBranchProtection(branch, owner, repo);
|
977 | octokit.repos.removeCollaborator(owner, repo, username);
|
978 | octokit.repos.removeDeployKey(key_id, owner, repo);
|
979 | octokit.repos.removeProtectedBranchAdminEnforcement(branch, owner, repo);
|
980 | octokit.repos.removeProtectedBranchPullRequestReviewEnforcement(
|
981 | branch,
|
982 | owner,
|
983 | repo
|
984 | );
|
985 | octokit.repos.removeProtectedBranchRequiredSignatures(branch, owner, repo);
|
986 | octokit.repos.removeProtectedBranchRequiredStatusChecks(branch, owner, repo);
|
987 | octokit.repos.removeProtectedBranchRequiredStatusChecksContexts(
|
988 | branch,
|
989 | contexts,
|
990 | owner,
|
991 | repo
|
992 | );
|
993 | octokit.repos.removeProtectedBranchRestrictions(branch, owner, repo);
|
994 | octokit.repos.removeProtectedBranchTeamRestrictions(branch, owner, repo, teams);
|
995 | octokit.repos.removeProtectedBranchUserRestrictions(branch, owner, repo, users);
|
996 | octokit.repos.replaceProtectedBranchRequiredStatusChecksContexts(
|
997 | branch,
|
998 | contexts,
|
999 | owner,
|
1000 | repo
|
1001 | );
|
1002 | octokit.repos.replaceProtectedBranchTeamRestrictions(
|
1003 | branch,
|
1004 | owner,
|
1005 | repo,
|
1006 | teams
|
1007 | );
|
1008 | octokit.repos.replaceProtectedBranchUserRestrictions(
|
1009 | branch,
|
1010 | owner,
|
1011 | repo,
|
1012 | users
|
1013 | );
|
1014 | octokit.repos.replaceTopics(names, owner, repo);
|
1015 | octokit.repos.requestPageBuild(owner, repo);
|
1016 | octokit.repos.testPushHook(hook_id, owner, repo);
|
1017 | octokit.repos.transfer(new_owner, owner, repo, team_ids);
|
1018 | octokit.repos.update(
|
1019 | allow_merge_commit,
|
1020 | allow_rebase_merge,
|
1021 | allow_squash_merge,
|
1022 | anonymous_access_enabled,
|
1023 | archived,
|
1024 | default_branch,
|
1025 | description,
|
1026 | has_issues,
|
1027 | has_projects,
|
1028 | has_wiki,
|
1029 | homepage,
|
1030 | name,
|
1031 | owner,
|
1032 | private,
|
1033 | repo
|
1034 | );
|
1035 | octokit.repos.updateBranchProtection(
|
1036 | branch,
|
1037 | enforce_admins,
|
1038 | owner,
|
1039 | repo,
|
1040 | required_pull_request_reviews,
|
1041 | required_status_checks,
|
1042 | restrictions
|
1043 | );
|
1044 | octokit.repos.updateCommitComment(body, comment_id, owner, repo);
|
1045 | octokit.repos.updateFile(
|
1046 | author,
|
1047 | branch,
|
1048 | committer,
|
1049 | content,
|
1050 | message,
|
1051 | owner,
|
1052 | path,
|
1053 | repo,
|
1054 | sha
|
1055 | );
|
1056 | octokit.repos.updateHook(
|
1057 | active,
|
1058 | add_events,
|
1059 | config,
|
1060 | events,
|
1061 | hook_id,
|
1062 | owner,
|
1063 | remove_events,
|
1064 | repo
|
1065 | );
|
1066 | octokit.repos.updateInformationAboutPagesSite(owner, repo, source);
|
1067 | octokit.repos.updateInvitation(invitation_id, owner, permissions, repo);
|
1068 | octokit.repos.updateProtectedBranchPullRequestReviewEnforcement(
|
1069 | branch,
|
1070 | dismiss_stale_reviews,
|
1071 | dismissal_restrictions,
|
1072 | owner,
|
1073 | repo,
|
1074 | require_code_owner_reviews,
|
1075 | required_approving_review_count
|
1076 | );
|
1077 | octokit.repos.updateProtectedBranchRequiredStatusChecks(
|
1078 | branch,
|
1079 | contexts,
|
1080 | owner,
|
1081 | repo,
|
1082 | strict
|
1083 | );
|
1084 | octokit.repos.updateRelease(
|
1085 | body,
|
1086 | draft,
|
1087 | name,
|
1088 | owner,
|
1089 | prerelease,
|
1090 | release_id,
|
1091 | repo,
|
1092 | tag_name,
|
1093 | target_commitish
|
1094 | );
|
1095 | octokit.repos.updateReleaseAsset(asset_id, label, name, owner, repo);
|
1096 | octokit.repos.uploadReleaseAsset(file, headers, label, name, url);
|
1097 | octokit.search.code(order, page, per_page, q, sort);
|
1098 | octokit.search.commits(order, page, per_page, q, sort);
|
1099 | octokit.search.issues(order, page, per_page, q, sort);
|
1100 | octokit.search.issuesAndPullRequests(order, page, per_page, q, sort);
|
1101 | octokit.search.labels(order, q, repository_id, sort);
|
1102 | octokit.search.repos(order, page, per_page, q, sort);
|
1103 | octokit.search.topics(q);
|
1104 | octokit.search.users(order, page, per_page, q, sort);
|
1105 | octokit.teams.addMember(team_id, username);
|
1106 | octokit.teams.addOrUpdateMembership(role, team_id, username);
|
1107 | octokit.teams.addOrUpdateProject(permission, project_id, team_id);
|
1108 | octokit.teams.addOrUpdateRepo(owner, permission, repo, team_id);
|
1109 | octokit.teams.checkManagesRepo(owner, repo, team_id);
|
1110 | octokit.teams.create(
|
1111 | description,
|
1112 | ldap_dn,
|
1113 | maintainers,
|
1114 | name,
|
1115 | org,
|
1116 | parent_team_id,
|
1117 | permission,
|
1118 | privacy,
|
1119 | repo_names
|
1120 | );
|
1121 | octokit.teams.createDiscussion(body, private, team_id, title);
|
1122 | octokit.teams.createDiscussionComment(body, discussion_number, team_id);
|
1123 | octokit.teams.delete(team_id);
|
1124 | octokit.teams.deleteDiscussion(discussion_number, team_id);
|
1125 | octokit.teams.deleteDiscussionComment(
|
1126 | comment_number,
|
1127 | discussion_number,
|
1128 | team_id
|
1129 | );
|
1130 | octokit.teams.get(team_id);
|
1131 | octokit.teams.getDiscussion(discussion_number, team_id);
|
1132 | octokit.teams.getDiscussionComment(comment_number, discussion_number, team_id);
|
1133 | octokit.teams.getMember(team_id, username);
|
1134 | octokit.teams.getMembership(team_id, username);
|
1135 | octokit.teams.list(org, page, per_page);
|
1136 | octokit.teams.listChild(page, per_page, team_id);
|
1137 | octokit.teams.listDiscussionComments(
|
1138 | direction,
|
1139 | discussion_number,
|
1140 | page,
|
1141 | per_page,
|
1142 | team_id
|
1143 | );
|
1144 | octokit.teams.listDiscussions(direction, page, per_page, team_id);
|
1145 | octokit.teams.listForAuthenticatedUser(page, per_page);
|
1146 | octokit.teams.listMembers(page, per_page, role, team_id);
|
1147 | octokit.teams.listProjects(page, per_page, team_id);
|
1148 | octokit.teams.listRepos(page, per_page, team_id);
|
1149 | octokit.teams.removeMember(team_id, username);
|
1150 | octokit.teams.removeMembership(team_id, username);
|
1151 | octokit.teams.removeProject(project_id, team_id);
|
1152 | octokit.teams.removeRepo(owner, repo, team_id);
|
1153 | octokit.teams.reviewProject(project_id, team_id);
|
1154 | octokit.teams.update(
|
1155 | description,
|
1156 | name,
|
1157 | parent_team_id,
|
1158 | permission,
|
1159 | privacy,
|
1160 | team_id
|
1161 | );
|
1162 | octokit.teams.updateDiscussion(body, discussion_number, team_id, title);
|
1163 | octokit.teams.updateDiscussionComment(
|
1164 | body,
|
1165 | comment_number,
|
1166 | discussion_number,
|
1167 | team_id
|
1168 | );
|
1169 | octokit.users.addEmails(emails);
|
1170 | octokit.users.checkFollowing(username);
|
1171 | octokit.users.checkFollowingForUser(target_user, username);
|
1172 | octokit.users.createGpgKey(armored_public_key);
|
1173 | octokit.users.createPublicKey(key, title);
|
1174 | octokit.users.deleteEmails(emails);
|
1175 | octokit.users.deleteGpgKey(gpg_key_id);
|
1176 | octokit.users.deletePublicKey(key_id);
|
1177 | octokit.users.follow(username);
|
1178 | octokit.users.getAuthenticated();
|
1179 | octokit.users.getByUsername(username);
|
1180 | octokit.users.getContextForUser(subject_id, subject_type, username);
|
1181 | octokit.users.getGpgKey(gpg_key_id);
|
1182 | octokit.users.getPublicKey(key_id);
|
1183 | octokit.users.list(page, per_page, since);
|
1184 | octokit.users.listEmails(page, per_page);
|
1185 | octokit.users.listFollowersForAuthenticatedUser(page, per_page);
|
1186 | octokit.users.listFollowersForUser(page, per_page, username);
|
1187 | octokit.users.listFollowingForAuthenticatedUser(page, per_page);
|
1188 | octokit.users.listFollowingForUser(page, per_page, username);
|
1189 | octokit.users.listGpgKeys(page, per_page);
|
1190 | octokit.users.listGpgKeysForUser(page, per_page, username);
|
1191 | octokit.users.listPublicEmails(page, per_page);
|
1192 | octokit.users.listPublicKeys(page, per_page);
|
1193 | octokit.users.listPublicKeysForUser(page, per_page, username);
|
1194 | octokit.users.unfollow(username);
|
1195 | octokit.users.updateAuthenticated(
|
1196 | bio,
|
1197 | blog,
|
1198 | company,
|
1199 | email,
|
1200 | hireable,
|
1201 | location,
|
1202 | name
|
1203 | );
|
1204 | ```
|