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