1#![allow(non_camel_case_types, dead_code)]
2
3pub mod components {
4 pub mod schemas {
5 use serde::{Serialize, Deserialize};
6 use std::collections::HashMap;
7
8 #[derive(Debug, Serialize, Deserialize)]
9 pub struct NullableSimpleUser {
10 #[serde(skip_serializing_if = "Option::is_none")]
11 name: Option<String>,
12 #[serde(skip_serializing_if = "Option::is_none")]
13 email: Option<String>,
14 login: String,
15 id: i64,
16 node_id: String,
17 avatar_url: String,
18 gravatar_id: Option<String>,
19 url: String,
20 html_url: String,
21 followers_url: String,
22 following_url: String,
23 gists_url: String,
24 starred_url: String,
25 subscriptions_url: String,
26 organizations_url: String,
27 repos_url: String,
28 events_url: String,
29 received_events_url: String,
30 #[serde(rename="type")]
31 type_: String,
32 site_admin: bool,
33 #[serde(skip_serializing_if = "Option::is_none")]
34 starred_at: Option<String>,
35 }
36
37 #[derive(Debug, Serialize, Deserialize)]
38 pub struct IntegrationPermissions {
39 #[serde(skip_serializing_if = "Option::is_none")]
40 issues: Option<String>,
41 #[serde(skip_serializing_if = "Option::is_none")]
42 checks: Option<String>,
43 #[serde(skip_serializing_if = "Option::is_none")]
44 metadata: Option<String>,
45 #[serde(skip_serializing_if = "Option::is_none")]
46 contents: Option<String>,
47 #[serde(skip_serializing_if = "Option::is_none")]
48 deployments: Option<String>,
49 }
50
51 #[derive(Debug, Serialize, Deserialize)]
52 pub struct Integration {
53 id: i64,
54 #[serde(skip_serializing_if = "Option::is_none")]
55 slug: Option<String>,
56 node_id: String,
57 owner: crate::components::schemas::NullableSimpleUser,
59 name: String,
60 description: Option<String>,
61 external_url: String,
62 html_url: String,
63 created_at: String,
64 updated_at: String,
65 permissions: IntegrationPermissions,
66 events: Vec<String>,
67 #[serde(skip_serializing_if = "Option::is_none")]
68 installations_count: Option<i64>,
69 #[serde(skip_serializing_if = "Option::is_none")]
70 client_id: Option<String>,
71 #[serde(skip_serializing_if = "Option::is_none")]
72 client_secret: Option<String>,
73 #[serde(skip_serializing_if = "Option::is_none")]
74 webhook_secret: Option<String>,
75 #[serde(skip_serializing_if = "Option::is_none")]
76 pem: Option<String>,
77 }
78
79 #[derive(Debug, Serialize, Deserialize)]
80 pub struct BasicError {
81 #[serde(skip_serializing_if = "Option::is_none")]
82 message: Option<String>,
83 #[serde(skip_serializing_if = "Option::is_none")]
84 documentation_url: Option<String>,
85 #[serde(skip_serializing_if = "Option::is_none")]
86 url: Option<String>,
87 #[serde(skip_serializing_if = "Option::is_none")]
88 status: Option<String>,
89 }
90
91 #[derive(Debug, Serialize, Deserialize)]
92 pub struct ValidationErrorSimple {
93 message: String,
94 documentation_url: String,
95 #[serde(skip_serializing_if = "Option::is_none")]
96 errors: Option<Vec<String>>,
97 }
98
99 pub type WebhookConfigUrl = String;
100
101 pub type WebhookConfigContentType = String;
102
103 pub type WebhookConfigSecret = String;
104
105 #[derive(Debug, Serialize, Deserialize)]
106 #[serde(untagged)]
107 pub enum WebhookConfigInsecureSsl {
108 String(String),
109 i64(i64),
110 }
111
112 #[derive(Debug, Serialize, Deserialize)]
113 pub struct WebhookConfig {
114 #[serde(skip_serializing_if = "Option::is_none")]
116 url: Option<crate::components::schemas::WebhookConfigUrl>,
117 #[serde(skip_serializing_if = "Option::is_none")]
119 content_type: Option<crate::components::schemas::WebhookConfigContentType>,
120 #[serde(skip_serializing_if = "Option::is_none")]
122 secret: Option<crate::components::schemas::WebhookConfigSecret>,
123 #[serde(skip_serializing_if = "Option::is_none")]
125 insecure_ssl: Option<crate::components::schemas::WebhookConfigInsecureSsl>,
126 }
127
128 #[derive(Debug, Serialize, Deserialize)]
129 pub struct HookDeliveryItem {
130 id: i64,
131 guid: String,
132 delivered_at: String,
133 redelivery: bool,
134 duration: i64,
135 status: String,
136 status_code: i64,
137 event: String,
138 action: Option<String>,
139 installation_id: Option<i64>,
140 repository_id: Option<i64>,
141 }
142
143 #[derive(Debug, Serialize, Deserialize)]
144 pub struct ScimError {
145 #[serde(skip_serializing_if = "Option::is_none")]
146 message: Option<String>,
147 #[serde(skip_serializing_if = "Option::is_none")]
148 documentation_url: Option<String>,
149 #[serde(skip_serializing_if = "Option::is_none")]
150 detail: Option<String>,
151 #[serde(skip_serializing_if = "Option::is_none")]
152 status: Option<i64>,
153 #[serde(rename="scimType", skip_serializing_if = "Option::is_none")]
154 scim_type: Option<String>,
155 #[serde(skip_serializing_if = "Option::is_none")]
156 schemas: Option<Vec<String>>,
157 }
158
159 #[derive(Debug, Serialize, Deserialize)]
161 #[serde(untagged)]
162 pub enum ValidationErrorErrorsValueOneOf {
163 String(String),
164 i64(i64),
165 Vec(Vec<String>),
166 }
167
168 #[derive(Debug, Serialize, Deserialize)]
169 pub struct ValidationErrorErrors {
170 #[serde(skip_serializing_if = "Option::is_none")]
171 resource: Option<String>,
172 #[serde(skip_serializing_if = "Option::is_none")]
173 field: Option<String>,
174 #[serde(skip_serializing_if = "Option::is_none")]
175 message: Option<String>,
176 code: String,
177 #[serde(skip_serializing_if = "Option::is_none")]
178 index: Option<i64>,
179 #[serde(skip_serializing_if = "Option::is_none")]
180 value: Option<ValidationErrorErrorsValueOneOf>,
181 }
182
183 #[derive(Debug, Serialize, Deserialize)]
184 pub struct ValidationError {
185 message: String,
186 documentation_url: String,
187 #[serde(skip_serializing_if = "Option::is_none")]
188 errors: Option<Vec<ValidationErrorErrors>>,
189 }
190
191 #[derive(Debug, Serialize, Deserialize)]
192 pub struct HookDeliveryRequestHeaders;
193
194 #[derive(Debug, Serialize, Deserialize)]
195 pub struct HookDeliveryRequestPayload;
196
197 #[derive(Debug, Serialize, Deserialize)]
198 pub struct HookDeliveryRequest {
199 headers: Option<HookDeliveryRequestHeaders>,
200 payload: Option<HookDeliveryRequestPayload>,
201 }
202
203 #[derive(Debug, Serialize, Deserialize)]
204 pub struct HookDeliveryResponseHeaders;
205
206 #[derive(Debug, Serialize, Deserialize)]
207 pub struct HookDeliveryResponse {
208 headers: Option<HookDeliveryResponseHeaders>,
209 payload: Option<String>,
210 }
211
212 #[derive(Debug, Serialize, Deserialize)]
213 pub struct HookDelivery {
214 id: i64,
215 guid: String,
216 delivered_at: String,
217 redelivery: bool,
218 duration: i64,
219 status: String,
220 status_code: i64,
221 event: String,
222 action: Option<String>,
223 installation_id: Option<i64>,
224 repository_id: Option<i64>,
225 #[serde(skip_serializing_if = "Option::is_none")]
226 url: Option<String>,
227 request: HookDeliveryRequest,
228 response: HookDeliveryResponse,
229 }
230
231 #[derive(Debug, Serialize, Deserialize)]
232 pub struct SimpleUser {
233 #[serde(skip_serializing_if = "Option::is_none")]
234 name: Option<String>,
235 #[serde(skip_serializing_if = "Option::is_none")]
236 email: Option<String>,
237 login: String,
238 id: i64,
239 node_id: String,
240 avatar_url: String,
241 gravatar_id: Option<String>,
242 url: String,
243 html_url: String,
244 followers_url: String,
245 following_url: String,
246 gists_url: String,
247 starred_url: String,
248 subscriptions_url: String,
249 organizations_url: String,
250 repos_url: String,
251 events_url: String,
252 received_events_url: String,
253 #[serde(rename="type")]
254 type_: String,
255 site_admin: bool,
256 #[serde(skip_serializing_if = "Option::is_none")]
257 starred_at: Option<String>,
258 }
259
260 #[derive(Debug, Serialize, Deserialize)]
261 pub struct Enterprise {
262 #[serde(skip_serializing_if = "Option::is_none")]
263 description: Option<String>,
264 html_url: String,
265 #[serde(skip_serializing_if = "Option::is_none")]
266 website_url: Option<String>,
267 id: i64,
268 node_id: String,
269 name: String,
270 slug: String,
271 created_at: Option<String>,
272 updated_at: Option<String>,
273 avatar_url: String,
274 }
275
276 #[derive(Debug, Serialize, Deserialize)]
277 pub struct AppPermissions {
278 #[serde(skip_serializing_if = "Option::is_none")]
279 actions: Option<String>,
280 #[serde(skip_serializing_if = "Option::is_none")]
281 administration: Option<String>,
282 #[serde(skip_serializing_if = "Option::is_none")]
283 checks: Option<String>,
284 #[serde(skip_serializing_if = "Option::is_none")]
285 content_references: Option<String>,
286 #[serde(skip_serializing_if = "Option::is_none")]
287 contents: Option<String>,
288 #[serde(skip_serializing_if = "Option::is_none")]
289 deployments: Option<String>,
290 #[serde(skip_serializing_if = "Option::is_none")]
291 environments: Option<String>,
292 #[serde(skip_serializing_if = "Option::is_none")]
293 issues: Option<String>,
294 #[serde(skip_serializing_if = "Option::is_none")]
295 metadata: Option<String>,
296 #[serde(skip_serializing_if = "Option::is_none")]
297 packages: Option<String>,
298 #[serde(skip_serializing_if = "Option::is_none")]
299 pages: Option<String>,
300 #[serde(skip_serializing_if = "Option::is_none")]
301 pull_requests: Option<String>,
302 #[serde(skip_serializing_if = "Option::is_none")]
303 repository_hooks: Option<String>,
304 #[serde(skip_serializing_if = "Option::is_none")]
305 repository_projects: Option<String>,
306 #[serde(skip_serializing_if = "Option::is_none")]
307 secret_scanning_alerts: Option<String>,
308 #[serde(skip_serializing_if = "Option::is_none")]
309 secrets: Option<String>,
310 #[serde(skip_serializing_if = "Option::is_none")]
311 security_events: Option<String>,
312 #[serde(skip_serializing_if = "Option::is_none")]
313 single_file: Option<String>,
314 #[serde(skip_serializing_if = "Option::is_none")]
315 statuses: Option<String>,
316 #[serde(skip_serializing_if = "Option::is_none")]
317 vulnerability_alerts: Option<String>,
318 #[serde(skip_serializing_if = "Option::is_none")]
319 workflows: Option<String>,
320 #[serde(skip_serializing_if = "Option::is_none")]
321 members: Option<String>,
322 #[serde(skip_serializing_if = "Option::is_none")]
323 organization_administration: Option<String>,
324 #[serde(skip_serializing_if = "Option::is_none")]
325 organization_hooks: Option<String>,
326 #[serde(skip_serializing_if = "Option::is_none")]
327 organization_plan: Option<String>,
328 #[serde(skip_serializing_if = "Option::is_none")]
329 organization_projects: Option<String>,
330 #[serde(skip_serializing_if = "Option::is_none")]
331 organization_packages: Option<String>,
332 #[serde(skip_serializing_if = "Option::is_none")]
333 organization_secrets: Option<String>,
334 #[serde(skip_serializing_if = "Option::is_none")]
335 organization_self_hosted_runners: Option<String>,
336 #[serde(skip_serializing_if = "Option::is_none")]
337 organization_user_blocking: Option<String>,
338 #[serde(skip_serializing_if = "Option::is_none")]
339 team_discussions: Option<String>,
340 }
341
342 #[derive(Debug, Serialize, Deserialize)]
344 #[serde(untagged)]
345 pub enum InstallationAccountOneOf {
346 SimpleUser(crate::components::schemas::SimpleUser),
347 Enterprise(crate::components::schemas::Enterprise),
348 }
349
350 #[derive(Debug, Serialize, Deserialize)]
351 pub struct Installation {
352 id: i64,
353 account: Option<InstallationAccountOneOf>,
354 repository_selection: String,
355 access_tokens_url: String,
356 repositories_url: String,
357 html_url: String,
358 app_id: i64,
359 target_id: i64,
360 target_type: String,
361 permissions: crate::components::schemas::AppPermissions,
363 events: Vec<String>,
364 created_at: String,
365 updated_at: String,
366 single_file_name: Option<String>,
367 #[serde(skip_serializing_if = "Option::is_none")]
368 has_multiple_single_files: Option<bool>,
369 #[serde(skip_serializing_if = "Option::is_none")]
370 single_file_paths: Option<Vec<String>>,
371 app_slug: String,
372 suspended_by: crate::components::schemas::NullableSimpleUser,
374 suspended_at: Option<String>,
375 #[serde(skip_serializing_if = "Option::is_none")]
376 contact_email: Option<String>,
377 }
378
379 #[derive(Debug, Serialize, Deserialize)]
380 pub struct NullableLicenseSimple {
381 key: String,
382 name: String,
383 url: Option<String>,
384 spdx_id: Option<String>,
385 node_id: String,
386 #[serde(skip_serializing_if = "Option::is_none")]
387 html_url: Option<String>,
388 }
389
390 #[derive(Debug, Serialize, Deserialize)]
391 pub struct RepositoryPermissions {
392 admin: bool,
393 pull: bool,
394 #[serde(skip_serializing_if = "Option::is_none")]
395 triage: Option<bool>,
396 push: bool,
397 #[serde(skip_serializing_if = "Option::is_none")]
398 maintain: Option<bool>,
399 }
400
401 #[derive(Debug, Serialize, Deserialize)]
402 pub struct RepositoryTemplateRepositoryOwner {
403 #[serde(skip_serializing_if = "Option::is_none")]
404 login: Option<String>,
405 #[serde(skip_serializing_if = "Option::is_none")]
406 id: Option<i64>,
407 #[serde(skip_serializing_if = "Option::is_none")]
408 node_id: Option<String>,
409 #[serde(skip_serializing_if = "Option::is_none")]
410 avatar_url: Option<String>,
411 #[serde(skip_serializing_if = "Option::is_none")]
412 gravatar_id: Option<String>,
413 #[serde(skip_serializing_if = "Option::is_none")]
414 url: Option<String>,
415 #[serde(skip_serializing_if = "Option::is_none")]
416 html_url: Option<String>,
417 #[serde(skip_serializing_if = "Option::is_none")]
418 followers_url: Option<String>,
419 #[serde(skip_serializing_if = "Option::is_none")]
420 following_url: Option<String>,
421 #[serde(skip_serializing_if = "Option::is_none")]
422 gists_url: Option<String>,
423 #[serde(skip_serializing_if = "Option::is_none")]
424 starred_url: Option<String>,
425 #[serde(skip_serializing_if = "Option::is_none")]
426 subscriptions_url: Option<String>,
427 #[serde(skip_serializing_if = "Option::is_none")]
428 organizations_url: Option<String>,
429 #[serde(skip_serializing_if = "Option::is_none")]
430 repos_url: Option<String>,
431 #[serde(skip_serializing_if = "Option::is_none")]
432 events_url: Option<String>,
433 #[serde(skip_serializing_if = "Option::is_none")]
434 received_events_url: Option<String>,
435 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
436 type_: Option<String>,
437 #[serde(skip_serializing_if = "Option::is_none")]
438 site_admin: Option<bool>,
439 }
440
441 #[derive(Debug, Serialize, Deserialize)]
442 pub struct RepositoryTemplateRepositoryPermissions {
443 #[serde(skip_serializing_if = "Option::is_none")]
444 admin: Option<bool>,
445 #[serde(skip_serializing_if = "Option::is_none")]
446 maintain: Option<bool>,
447 #[serde(skip_serializing_if = "Option::is_none")]
448 push: Option<bool>,
449 #[serde(skip_serializing_if = "Option::is_none")]
450 triage: Option<bool>,
451 #[serde(skip_serializing_if = "Option::is_none")]
452 pull: Option<bool>,
453 }
454
455 #[derive(Debug, Serialize, Deserialize)]
456 pub struct RepositoryTemplateRepository {
457 #[serde(skip_serializing_if = "Option::is_none")]
458 id: Option<i64>,
459 #[serde(skip_serializing_if = "Option::is_none")]
460 node_id: Option<String>,
461 #[serde(skip_serializing_if = "Option::is_none")]
462 name: Option<String>,
463 #[serde(skip_serializing_if = "Option::is_none")]
464 full_name: Option<String>,
465 #[serde(skip_serializing_if = "Option::is_none")]
466 owner: Option<RepositoryTemplateRepositoryOwner>,
467 #[serde(skip_serializing_if = "Option::is_none")]
468 private: Option<bool>,
469 #[serde(skip_serializing_if = "Option::is_none")]
470 html_url: Option<String>,
471 #[serde(skip_serializing_if = "Option::is_none")]
472 description: Option<String>,
473 #[serde(skip_serializing_if = "Option::is_none")]
474 fork: Option<bool>,
475 #[serde(skip_serializing_if = "Option::is_none")]
476 url: Option<String>,
477 #[serde(skip_serializing_if = "Option::is_none")]
478 archive_url: Option<String>,
479 #[serde(skip_serializing_if = "Option::is_none")]
480 assignees_url: Option<String>,
481 #[serde(skip_serializing_if = "Option::is_none")]
482 blobs_url: Option<String>,
483 #[serde(skip_serializing_if = "Option::is_none")]
484 branches_url: Option<String>,
485 #[serde(skip_serializing_if = "Option::is_none")]
486 collaborators_url: Option<String>,
487 #[serde(skip_serializing_if = "Option::is_none")]
488 comments_url: Option<String>,
489 #[serde(skip_serializing_if = "Option::is_none")]
490 commits_url: Option<String>,
491 #[serde(skip_serializing_if = "Option::is_none")]
492 compare_url: Option<String>,
493 #[serde(skip_serializing_if = "Option::is_none")]
494 contents_url: Option<String>,
495 #[serde(skip_serializing_if = "Option::is_none")]
496 contributors_url: Option<String>,
497 #[serde(skip_serializing_if = "Option::is_none")]
498 deployments_url: Option<String>,
499 #[serde(skip_serializing_if = "Option::is_none")]
500 downloads_url: Option<String>,
501 #[serde(skip_serializing_if = "Option::is_none")]
502 events_url: Option<String>,
503 #[serde(skip_serializing_if = "Option::is_none")]
504 forks_url: Option<String>,
505 #[serde(skip_serializing_if = "Option::is_none")]
506 git_commits_url: Option<String>,
507 #[serde(skip_serializing_if = "Option::is_none")]
508 git_refs_url: Option<String>,
509 #[serde(skip_serializing_if = "Option::is_none")]
510 git_tags_url: Option<String>,
511 #[serde(skip_serializing_if = "Option::is_none")]
512 git_url: Option<String>,
513 #[serde(skip_serializing_if = "Option::is_none")]
514 issue_comment_url: Option<String>,
515 #[serde(skip_serializing_if = "Option::is_none")]
516 issue_events_url: Option<String>,
517 #[serde(skip_serializing_if = "Option::is_none")]
518 issues_url: Option<String>,
519 #[serde(skip_serializing_if = "Option::is_none")]
520 keys_url: Option<String>,
521 #[serde(skip_serializing_if = "Option::is_none")]
522 labels_url: Option<String>,
523 #[serde(skip_serializing_if = "Option::is_none")]
524 languages_url: Option<String>,
525 #[serde(skip_serializing_if = "Option::is_none")]
526 merges_url: Option<String>,
527 #[serde(skip_serializing_if = "Option::is_none")]
528 milestones_url: Option<String>,
529 #[serde(skip_serializing_if = "Option::is_none")]
530 notifications_url: Option<String>,
531 #[serde(skip_serializing_if = "Option::is_none")]
532 pulls_url: Option<String>,
533 #[serde(skip_serializing_if = "Option::is_none")]
534 releases_url: Option<String>,
535 #[serde(skip_serializing_if = "Option::is_none")]
536 ssh_url: Option<String>,
537 #[serde(skip_serializing_if = "Option::is_none")]
538 stargazers_url: Option<String>,
539 #[serde(skip_serializing_if = "Option::is_none")]
540 statuses_url: Option<String>,
541 #[serde(skip_serializing_if = "Option::is_none")]
542 subscribers_url: Option<String>,
543 #[serde(skip_serializing_if = "Option::is_none")]
544 subscription_url: Option<String>,
545 #[serde(skip_serializing_if = "Option::is_none")]
546 tags_url: Option<String>,
547 #[serde(skip_serializing_if = "Option::is_none")]
548 teams_url: Option<String>,
549 #[serde(skip_serializing_if = "Option::is_none")]
550 trees_url: Option<String>,
551 #[serde(skip_serializing_if = "Option::is_none")]
552 clone_url: Option<String>,
553 #[serde(skip_serializing_if = "Option::is_none")]
554 mirror_url: Option<String>,
555 #[serde(skip_serializing_if = "Option::is_none")]
556 hooks_url: Option<String>,
557 #[serde(skip_serializing_if = "Option::is_none")]
558 svn_url: Option<String>,
559 #[serde(skip_serializing_if = "Option::is_none")]
560 homepage: Option<String>,
561 #[serde(skip_serializing_if = "Option::is_none")]
562 language: Option<String>,
563 #[serde(skip_serializing_if = "Option::is_none")]
564 forks_count: Option<i64>,
565 #[serde(skip_serializing_if = "Option::is_none")]
566 stargazers_count: Option<i64>,
567 #[serde(skip_serializing_if = "Option::is_none")]
568 watchers_count: Option<i64>,
569 #[serde(skip_serializing_if = "Option::is_none")]
570 size: Option<i64>,
571 #[serde(skip_serializing_if = "Option::is_none")]
572 default_branch: Option<String>,
573 #[serde(skip_serializing_if = "Option::is_none")]
574 open_issues_count: Option<i64>,
575 #[serde(skip_serializing_if = "Option::is_none")]
576 is_template: Option<bool>,
577 #[serde(skip_serializing_if = "Option::is_none")]
578 topics: Option<Vec<String>>,
579 #[serde(skip_serializing_if = "Option::is_none")]
580 has_issues: Option<bool>,
581 #[serde(skip_serializing_if = "Option::is_none")]
582 has_projects: Option<bool>,
583 #[serde(skip_serializing_if = "Option::is_none")]
584 has_wiki: Option<bool>,
585 #[serde(skip_serializing_if = "Option::is_none")]
586 has_pages: Option<bool>,
587 #[serde(skip_serializing_if = "Option::is_none")]
588 has_downloads: Option<bool>,
589 #[serde(skip_serializing_if = "Option::is_none")]
590 archived: Option<bool>,
591 #[serde(skip_serializing_if = "Option::is_none")]
592 disabled: Option<bool>,
593 #[serde(skip_serializing_if = "Option::is_none")]
594 visibility: Option<String>,
595 #[serde(skip_serializing_if = "Option::is_none")]
596 pushed_at: Option<String>,
597 #[serde(skip_serializing_if = "Option::is_none")]
598 created_at: Option<String>,
599 #[serde(skip_serializing_if = "Option::is_none")]
600 updated_at: Option<String>,
601 #[serde(skip_serializing_if = "Option::is_none")]
602 permissions: Option<RepositoryTemplateRepositoryPermissions>,
603 #[serde(skip_serializing_if = "Option::is_none")]
604 allow_rebase_merge: Option<bool>,
605 #[serde(skip_serializing_if = "Option::is_none")]
606 temp_clone_token: Option<String>,
607 #[serde(skip_serializing_if = "Option::is_none")]
608 allow_squash_merge: Option<bool>,
609 #[serde(skip_serializing_if = "Option::is_none")]
610 allow_auto_merge: Option<bool>,
611 #[serde(skip_serializing_if = "Option::is_none")]
612 delete_branch_on_merge: Option<bool>,
613 #[serde(skip_serializing_if = "Option::is_none")]
614 allow_merge_commit: Option<bool>,
615 #[serde(skip_serializing_if = "Option::is_none")]
616 subscribers_count: Option<i64>,
617 #[serde(skip_serializing_if = "Option::is_none")]
618 network_count: Option<i64>,
619 }
620
621 #[derive(Debug, Serialize, Deserialize)]
622 pub struct Repository {
623 id: i64,
624 node_id: String,
625 name: String,
626 full_name: String,
627 license: crate::components::schemas::NullableLicenseSimple,
629 #[serde(skip_serializing_if = "Option::is_none")]
631 organization: Option<crate::components::schemas::NullableSimpleUser>,
632 forks: i64,
633 #[serde(skip_serializing_if = "Option::is_none")]
634 permissions: Option<RepositoryPermissions>,
635 owner: crate::components::schemas::SimpleUser,
637 private: bool,
638 html_url: String,
639 description: Option<String>,
640 fork: bool,
641 url: String,
642 archive_url: String,
643 assignees_url: String,
644 blobs_url: String,
645 branches_url: String,
646 collaborators_url: String,
647 comments_url: String,
648 commits_url: String,
649 compare_url: String,
650 contents_url: String,
651 contributors_url: String,
652 deployments_url: String,
653 downloads_url: String,
654 events_url: String,
655 forks_url: String,
656 git_commits_url: String,
657 git_refs_url: String,
658 git_tags_url: String,
659 git_url: String,
660 issue_comment_url: String,
661 issue_events_url: String,
662 issues_url: String,
663 keys_url: String,
664 labels_url: String,
665 languages_url: String,
666 merges_url: String,
667 milestones_url: String,
668 notifications_url: String,
669 pulls_url: String,
670 releases_url: String,
671 ssh_url: String,
672 stargazers_url: String,
673 statuses_url: String,
674 subscribers_url: String,
675 subscription_url: String,
676 tags_url: String,
677 teams_url: String,
678 trees_url: String,
679 clone_url: String,
680 mirror_url: Option<String>,
681 hooks_url: String,
682 svn_url: String,
683 homepage: Option<String>,
684 language: Option<String>,
685 forks_count: i64,
686 stargazers_count: i64,
687 watchers_count: i64,
688 size: i64,
689 default_branch: String,
690 open_issues_count: i64,
691 #[serde(skip_serializing_if = "Option::is_none")]
692 is_template: Option<bool>,
693 #[serde(skip_serializing_if = "Option::is_none")]
694 topics: Option<Vec<String>>,
695 has_issues: bool,
696 has_projects: bool,
697 has_wiki: bool,
698 has_pages: bool,
699 has_downloads: bool,
700 archived: bool,
701 disabled: bool,
702 #[serde(skip_serializing_if = "Option::is_none")]
703 visibility: Option<String>,
704 pushed_at: Option<String>,
705 created_at: Option<String>,
706 updated_at: Option<String>,
707 #[serde(skip_serializing_if = "Option::is_none")]
708 allow_rebase_merge: Option<bool>,
709 #[serde(skip_serializing_if = "Option::is_none")]
710 template_repository: Option<RepositoryTemplateRepository>,
711 #[serde(skip_serializing_if = "Option::is_none")]
712 temp_clone_token: Option<String>,
713 #[serde(skip_serializing_if = "Option::is_none")]
714 allow_squash_merge: Option<bool>,
715 #[serde(skip_serializing_if = "Option::is_none")]
716 allow_auto_merge: Option<bool>,
717 #[serde(skip_serializing_if = "Option::is_none")]
718 delete_branch_on_merge: Option<bool>,
719 #[serde(skip_serializing_if = "Option::is_none")]
720 allow_merge_commit: Option<bool>,
721 #[serde(skip_serializing_if = "Option::is_none")]
722 allow_forking: Option<bool>,
723 #[serde(skip_serializing_if = "Option::is_none")]
724 subscribers_count: Option<i64>,
725 #[serde(skip_serializing_if = "Option::is_none")]
726 network_count: Option<i64>,
727 open_issues: i64,
728 watchers: i64,
729 #[serde(skip_serializing_if = "Option::is_none")]
730 master_branch: Option<String>,
731 #[serde(skip_serializing_if = "Option::is_none")]
732 starred_at: Option<String>,
733 }
734
735 #[derive(Debug, Serialize, Deserialize)]
736 pub struct InstallationToken {
737 token: String,
738 expires_at: String,
739 #[serde(skip_serializing_if = "Option::is_none")]
741 permissions: Option<crate::components::schemas::AppPermissions>,
742 #[serde(skip_serializing_if = "Option::is_none")]
743 repository_selection: Option<String>,
744 #[serde(skip_serializing_if = "Option::is_none")]
745 repositories: Option<Vec<crate::components::schemas::Repository>>,
746 #[serde(skip_serializing_if = "Option::is_none")]
747 single_file: Option<String>,
748 #[serde(skip_serializing_if = "Option::is_none")]
749 has_multiple_single_files: Option<bool>,
750 #[serde(skip_serializing_if = "Option::is_none")]
751 single_file_paths: Option<Vec<String>>,
752 }
753
754 #[derive(Debug, Serialize, Deserialize)]
755 pub struct ApplicationGrantApp {
756 client_id: String,
757 name: String,
758 url: String,
759 }
760
761 #[derive(Debug, Serialize, Deserialize)]
762 pub struct ApplicationGrant {
763 id: i64,
764 url: String,
765 app: ApplicationGrantApp,
766 created_at: String,
767 updated_at: String,
768 scopes: Vec<String>,
769 #[serde(skip_serializing_if = "Option::is_none")]
771 user: Option<crate::components::schemas::NullableSimpleUser>,
772 }
773
774 #[derive(Debug, Serialize, Deserialize)]
775 pub struct NullableScopedInstallation {
776 permissions: crate::components::schemas::AppPermissions,
778 repository_selection: String,
779 single_file_name: Option<String>,
780 #[serde(skip_serializing_if = "Option::is_none")]
781 has_multiple_single_files: Option<bool>,
782 #[serde(skip_serializing_if = "Option::is_none")]
783 single_file_paths: Option<Vec<String>>,
784 repositories_url: String,
785 account: crate::components::schemas::SimpleUser,
787 }
788
789 #[derive(Debug, Serialize, Deserialize)]
790 pub struct AuthorizationApp {
791 client_id: String,
792 name: String,
793 url: String,
794 }
795
796 #[derive(Debug, Serialize, Deserialize)]
797 pub struct Authorization {
798 id: i64,
799 url: String,
800 scopes: Option<Vec<String>>,
801 token: String,
802 token_last_eight: Option<String>,
803 hashed_token: Option<String>,
804 app: AuthorizationApp,
805 note: Option<String>,
806 note_url: Option<String>,
807 updated_at: String,
808 created_at: String,
809 fingerprint: Option<String>,
810 #[serde(skip_serializing_if = "Option::is_none")]
812 user: Option<crate::components::schemas::NullableSimpleUser>,
813 #[serde(skip_serializing_if = "Option::is_none")]
815 installation: Option<crate::components::schemas::NullableScopedInstallation>,
816 expires_at: Option<String>,
817 }
818
819 #[derive(Debug, Serialize, Deserialize)]
820 pub struct CodeOfConduct {
821 key: String,
822 name: String,
823 url: String,
824 #[serde(skip_serializing_if = "Option::is_none")]
825 body: Option<String>,
826 html_url: Option<String>,
827 }
828
829 pub type EnabledOrganizations = String;
830
831 pub type AllowedActions = String;
832
833 pub type SelectedActionsUrl = String;
834
835 #[derive(Debug, Serialize, Deserialize)]
836 pub struct ActionsEnterprisePermissions {
837 enabled_organizations: crate::components::schemas::EnabledOrganizations,
839 #[serde(skip_serializing_if = "Option::is_none")]
840 selected_organizations_url: Option<String>,
841 #[serde(skip_serializing_if = "Option::is_none")]
843 allowed_actions: Option<crate::components::schemas::AllowedActions>,
844 #[serde(skip_serializing_if = "Option::is_none")]
846 selected_actions_url: Option<crate::components::schemas::SelectedActionsUrl>,
847 }
848
849 #[derive(Debug, Serialize, Deserialize)]
850 pub struct OrganizationSimple {
851 login: String,
852 id: i64,
853 node_id: String,
854 url: String,
855 repos_url: String,
856 events_url: String,
857 hooks_url: String,
858 issues_url: String,
859 members_url: String,
860 public_members_url: String,
861 avatar_url: String,
862 description: Option<String>,
863 }
864
865 #[derive(Debug, Serialize, Deserialize)]
866 pub struct SelectedActions {
867 #[serde(skip_serializing_if = "Option::is_none")]
868 github_owned_allowed: Option<bool>,
869 #[serde(skip_serializing_if = "Option::is_none")]
870 verified_allowed: Option<bool>,
871 #[serde(skip_serializing_if = "Option::is_none")]
872 patterns_allowed: Option<Vec<String>>,
873 }
874
875 #[derive(Debug, Serialize, Deserialize)]
876 pub struct RunnerGroupsEnterprise {
877 id: i64,
878 name: String,
879 visibility: String,
880 default: bool,
881 #[serde(skip_serializing_if = "Option::is_none")]
882 selected_organizations_url: Option<String>,
883 runners_url: String,
884 allows_public_repositories: bool,
885 }
886
887 #[derive(Debug, Serialize, Deserialize)]
888 pub struct RunnerLabels {
889 #[serde(skip_serializing_if = "Option::is_none")]
890 id: Option<i64>,
891 #[serde(skip_serializing_if = "Option::is_none")]
892 name: Option<String>,
893 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
894 type_: Option<String>,
895 }
896
897 #[derive(Debug, Serialize, Deserialize)]
898 pub struct Runner {
899 id: i64,
900 name: String,
901 os: String,
902 status: String,
903 busy: bool,
904 labels: Vec<RunnerLabels>,
905 }
906
907 #[derive(Debug, Serialize, Deserialize)]
908 pub struct RunnerApplication {
909 os: String,
910 architecture: String,
911 download_url: String,
912 filename: String,
913 #[serde(skip_serializing_if = "Option::is_none")]
914 temp_download_token: Option<String>,
915 #[serde(rename="sha256_checksum", skip_serializing_if = "Option::is_none")]
916 sha_256_checksum: Option<String>,
917 }
918
919 #[derive(Debug, Serialize, Deserialize)]
920 pub struct AuthenticationTokenPermissions;
921
922 #[derive(Debug, Serialize, Deserialize)]
923 pub struct AuthenticationToken {
924 token: String,
925 expires_at: String,
926 #[serde(skip_serializing_if = "Option::is_none")]
927 permissions: Option<AuthenticationTokenPermissions>,
928 #[serde(skip_serializing_if = "Option::is_none")]
929 repositories: Option<Vec<crate::components::schemas::Repository>>,
930 #[serde(skip_serializing_if = "Option::is_none")]
931 single_file: Option<String>,
932 #[serde(skip_serializing_if = "Option::is_none")]
933 repository_selection: Option<String>,
934 }
935
936 #[derive(Debug, Serialize, Deserialize)]
937 pub struct AuditLogEventActorLocation {
938 #[serde(skip_serializing_if = "Option::is_none")]
939 country_name: Option<String>,
940 }
941
942 #[derive(Debug, Serialize, Deserialize)]
943 pub struct AuditLogEventData;
944
945 #[derive(Debug, Serialize, Deserialize)]
946 pub struct AuditLogEventConfig;
947
948 #[derive(Debug, Serialize, Deserialize)]
949 pub struct AuditLogEventConfigWas;
950
951 #[derive(Debug, Serialize, Deserialize)]
952 pub struct AuditLogEventEvents;
953
954 #[derive(Debug, Serialize, Deserialize)]
955 pub struct AuditLogEventEventsWere;
956
957 #[derive(Debug, Serialize, Deserialize)]
958 pub struct AuditLogEvent {
959 #[serde(rename="@timestamp", skip_serializing_if = "Option::is_none")]
960 timestamp: Option<i64>,
961 #[serde(skip_serializing_if = "Option::is_none")]
962 action: Option<String>,
963 #[serde(skip_serializing_if = "Option::is_none")]
964 active: Option<bool>,
965 #[serde(skip_serializing_if = "Option::is_none")]
966 active_was: Option<bool>,
967 #[serde(skip_serializing_if = "Option::is_none")]
968 actor: Option<String>,
969 #[serde(skip_serializing_if = "Option::is_none")]
970 actor_id: Option<i64>,
971 #[serde(skip_serializing_if = "Option::is_none")]
972 actor_location: Option<AuditLogEventActorLocation>,
973 #[serde(skip_serializing_if = "Option::is_none")]
974 data: Option<AuditLogEventData>,
975 #[serde(skip_serializing_if = "Option::is_none")]
976 org_id: Option<i64>,
977 #[serde(skip_serializing_if = "Option::is_none")]
978 blocked_user: Option<String>,
979 #[serde(skip_serializing_if = "Option::is_none")]
980 business: Option<String>,
981 #[serde(skip_serializing_if = "Option::is_none")]
982 config: Option<Vec<AuditLogEventConfig>>,
983 #[serde(skip_serializing_if = "Option::is_none")]
984 config_was: Option<Vec<AuditLogEventConfigWas>>,
985 #[serde(skip_serializing_if = "Option::is_none")]
986 content_type: Option<String>,
987 #[serde(skip_serializing_if = "Option::is_none")]
988 created_at: Option<i64>,
989 #[serde(skip_serializing_if = "Option::is_none")]
990 deploy_key_fingerprint: Option<String>,
991 #[serde(rename="_document_id", skip_serializing_if = "Option::is_none")]
992 document_id: Option<String>,
993 #[serde(skip_serializing_if = "Option::is_none")]
994 emoji: Option<String>,
995 #[serde(skip_serializing_if = "Option::is_none")]
996 events: Option<Vec<AuditLogEventEvents>>,
997 #[serde(skip_serializing_if = "Option::is_none")]
998 events_were: Option<Vec<AuditLogEventEventsWere>>,
999 #[serde(skip_serializing_if = "Option::is_none")]
1000 explanation: Option<String>,
1001 #[serde(skip_serializing_if = "Option::is_none")]
1002 fingerprint: Option<String>,
1003 #[serde(skip_serializing_if = "Option::is_none")]
1004 hook_id: Option<i64>,
1005 #[serde(skip_serializing_if = "Option::is_none")]
1006 limited_availability: Option<bool>,
1007 #[serde(skip_serializing_if = "Option::is_none")]
1008 message: Option<String>,
1009 #[serde(skip_serializing_if = "Option::is_none")]
1010 name: Option<String>,
1011 #[serde(skip_serializing_if = "Option::is_none")]
1012 old_user: Option<String>,
1013 #[serde(skip_serializing_if = "Option::is_none")]
1014 openssh_public_key: Option<String>,
1015 #[serde(skip_serializing_if = "Option::is_none")]
1016 org: Option<String>,
1017 #[serde(skip_serializing_if = "Option::is_none")]
1018 previous_visibility: Option<String>,
1019 #[serde(skip_serializing_if = "Option::is_none")]
1020 read_only: Option<bool>,
1021 #[serde(skip_serializing_if = "Option::is_none")]
1022 repo: Option<String>,
1023 #[serde(skip_serializing_if = "Option::is_none")]
1024 repository: Option<String>,
1025 #[serde(skip_serializing_if = "Option::is_none")]
1026 repository_public: Option<bool>,
1027 #[serde(skip_serializing_if = "Option::is_none")]
1028 target_login: Option<String>,
1029 #[serde(skip_serializing_if = "Option::is_none")]
1030 team: Option<String>,
1031 #[serde(skip_serializing_if = "Option::is_none")]
1032 transport_protocol: Option<i64>,
1033 #[serde(skip_serializing_if = "Option::is_none")]
1034 transport_protocol_name: Option<String>,
1035 #[serde(skip_serializing_if = "Option::is_none")]
1036 user: Option<String>,
1037 #[serde(skip_serializing_if = "Option::is_none")]
1038 visibility: Option<String>,
1039 }
1040
1041 #[derive(Debug, Serialize, Deserialize)]
1042 pub struct ActionsBillingUsageMinutesUsedBreakdown {
1043 #[serde(rename="UBUNTU", skip_serializing_if = "Option::is_none")]
1044 ubuntu: Option<i64>,
1045 #[serde(rename="MACOS", skip_serializing_if = "Option::is_none")]
1046 macos: Option<i64>,
1047 #[serde(rename="WINDOWS", skip_serializing_if = "Option::is_none")]
1048 windows: Option<i64>,
1049 }
1050
1051 #[derive(Debug, Serialize, Deserialize)]
1052 pub struct ActionsBillingUsage {
1053 total_minutes_used: i64,
1054 total_paid_minutes_used: i64,
1055 included_minutes: i64,
1056 minutes_used_breakdown: ActionsBillingUsageMinutesUsedBreakdown,
1057 }
1058
1059 #[derive(Debug, Serialize, Deserialize)]
1060 pub struct PackagesBillingUsage {
1061 total_gigabytes_bandwidth_used: i64,
1062 total_paid_gigabytes_bandwidth_used: i64,
1063 included_gigabytes_bandwidth: i64,
1064 }
1065
1066 #[derive(Debug, Serialize, Deserialize)]
1067 pub struct CombinedBillingUsage {
1068 days_left_in_billing_cycle: i64,
1069 estimated_paid_storage_for_month: i64,
1070 estimated_storage_for_month: i64,
1071 }
1072
1073 #[derive(Debug, Serialize, Deserialize)]
1074 pub struct Actor {
1075 id: i64,
1076 login: String,
1077 #[serde(skip_serializing_if = "Option::is_none")]
1078 display_login: Option<String>,
1079 gravatar_id: Option<String>,
1080 url: String,
1081 avatar_url: String,
1082 }
1083
1084 #[derive(Debug, Serialize, Deserialize)]
1085 pub struct NullableMilestone {
1086 url: String,
1087 html_url: String,
1088 labels_url: String,
1089 id: i64,
1090 node_id: String,
1091 number: i64,
1092 state: String,
1093 title: String,
1094 description: Option<String>,
1095 creator: crate::components::schemas::NullableSimpleUser,
1097 open_issues: i64,
1098 closed_issues: i64,
1099 created_at: String,
1100 updated_at: String,
1101 closed_at: Option<String>,
1102 due_on: Option<String>,
1103 }
1104
1105 #[derive(Debug, Serialize, Deserialize)]
1106 pub struct NullableIntegrationPermissions {
1107 #[serde(skip_serializing_if = "Option::is_none")]
1108 issues: Option<String>,
1109 #[serde(skip_serializing_if = "Option::is_none")]
1110 checks: Option<String>,
1111 #[serde(skip_serializing_if = "Option::is_none")]
1112 metadata: Option<String>,
1113 #[serde(skip_serializing_if = "Option::is_none")]
1114 contents: Option<String>,
1115 #[serde(skip_serializing_if = "Option::is_none")]
1116 deployments: Option<String>,
1117 }
1118
1119 #[derive(Debug, Serialize, Deserialize)]
1120 pub struct NullableIntegration {
1121 id: i64,
1122 #[serde(skip_serializing_if = "Option::is_none")]
1123 slug: Option<String>,
1124 node_id: String,
1125 owner: crate::components::schemas::NullableSimpleUser,
1127 name: String,
1128 description: Option<String>,
1129 external_url: String,
1130 html_url: String,
1131 created_at: String,
1132 updated_at: String,
1133 permissions: NullableIntegrationPermissions,
1134 events: Vec<String>,
1135 #[serde(skip_serializing_if = "Option::is_none")]
1136 installations_count: Option<i64>,
1137 #[serde(skip_serializing_if = "Option::is_none")]
1138 client_id: Option<String>,
1139 #[serde(skip_serializing_if = "Option::is_none")]
1140 client_secret: Option<String>,
1141 #[serde(skip_serializing_if = "Option::is_none")]
1142 webhook_secret: Option<String>,
1143 #[serde(skip_serializing_if = "Option::is_none")]
1144 pem: Option<String>,
1145 }
1146
1147 pub type AuthorAssociation = String;
1148
1149 #[derive(Debug, Serialize, Deserialize)]
1150 pub struct ReactionRollup {
1151 url: String,
1152 total_count: i64,
1153 #[serde(rename="+1")]
1154 plus_one: i64,
1155 #[serde(rename="-1")]
1156 minus_one: i64,
1157 laugh: i64,
1158 confused: i64,
1159 heart: i64,
1160 hooray: i64,
1161 eyes: i64,
1162 rocket: i64,
1163 }
1164
1165 #[derive(Debug, Serialize, Deserialize)]
1166 pub struct IssueLabels1 {
1167 #[serde(skip_serializing_if = "Option::is_none")]
1168 id: Option<i64>,
1169 #[serde(skip_serializing_if = "Option::is_none")]
1170 node_id: Option<String>,
1171 #[serde(skip_serializing_if = "Option::is_none")]
1172 url: Option<String>,
1173 #[serde(skip_serializing_if = "Option::is_none")]
1174 name: Option<String>,
1175 #[serde(skip_serializing_if = "Option::is_none")]
1176 description: Option<String>,
1177 #[serde(skip_serializing_if = "Option::is_none")]
1178 color: Option<String>,
1179 #[serde(skip_serializing_if = "Option::is_none")]
1180 default: Option<bool>,
1181 }
1182
1183 #[derive(Debug, Serialize, Deserialize)]
1185 #[serde(untagged)]
1186 pub enum IssueLabelsOneOf {
1187 String(String),
1188 IssueLabels1(IssueLabels1),
1189 }
1190
1191 #[derive(Debug, Serialize, Deserialize)]
1192 pub struct IssuePullRequest {
1193 #[serde(skip_serializing_if = "Option::is_none")]
1194 merged_at: Option<String>,
1195 diff_url: Option<String>,
1196 html_url: Option<String>,
1197 patch_url: Option<String>,
1198 url: Option<String>,
1199 }
1200
1201 #[derive(Debug, Serialize, Deserialize)]
1202 pub struct Issue {
1203 id: i64,
1204 node_id: String,
1205 url: String,
1206 repository_url: String,
1207 labels_url: String,
1208 comments_url: String,
1209 events_url: String,
1210 html_url: String,
1211 number: i64,
1212 state: String,
1213 title: String,
1214 #[serde(skip_serializing_if = "Option::is_none")]
1215 body: Option<String>,
1216 user: crate::components::schemas::NullableSimpleUser,
1218 labels: Vec<IssueLabelsOneOf>,
1219 assignee: crate::components::schemas::NullableSimpleUser,
1221 #[serde(skip_serializing_if = "Option::is_none")]
1222 assignees: Option<Vec<crate::components::schemas::SimpleUser>>,
1223 milestone: crate::components::schemas::NullableMilestone,
1225 locked: bool,
1226 #[serde(skip_serializing_if = "Option::is_none")]
1227 active_lock_reason: Option<String>,
1228 comments: i64,
1229 #[serde(skip_serializing_if = "Option::is_none")]
1230 pull_request: Option<IssuePullRequest>,
1231 closed_at: Option<String>,
1232 created_at: String,
1233 updated_at: String,
1234 #[serde(skip_serializing_if = "Option::is_none")]
1236 closed_by: Option<crate::components::schemas::NullableSimpleUser>,
1237 #[serde(skip_serializing_if = "Option::is_none")]
1238 body_html: Option<String>,
1239 #[serde(skip_serializing_if = "Option::is_none")]
1240 body_text: Option<String>,
1241 #[serde(skip_serializing_if = "Option::is_none")]
1242 timeline_url: Option<String>,
1243 #[serde(skip_serializing_if = "Option::is_none")]
1245 repository: Option<crate::components::schemas::Repository>,
1246 #[serde(skip_serializing_if = "Option::is_none")]
1248 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
1249 author_association: crate::components::schemas::AuthorAssociation,
1251 #[serde(skip_serializing_if = "Option::is_none")]
1253 reactions: Option<crate::components::schemas::ReactionRollup>,
1254 }
1255
1256 #[derive(Debug, Serialize, Deserialize)]
1257 pub struct IssueComment {
1258 id: i64,
1259 node_id: String,
1260 url: String,
1261 #[serde(skip_serializing_if = "Option::is_none")]
1262 body: Option<String>,
1263 #[serde(skip_serializing_if = "Option::is_none")]
1264 body_text: Option<String>,
1265 #[serde(skip_serializing_if = "Option::is_none")]
1266 body_html: Option<String>,
1267 html_url: String,
1268 user: crate::components::schemas::NullableSimpleUser,
1270 created_at: String,
1271 updated_at: String,
1272 issue_url: String,
1273 author_association: crate::components::schemas::AuthorAssociation,
1275 #[serde(skip_serializing_if = "Option::is_none")]
1277 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
1278 #[serde(skip_serializing_if = "Option::is_none")]
1280 reactions: Option<crate::components::schemas::ReactionRollup>,
1281 }
1282
1283 #[derive(Debug, Serialize, Deserialize)]
1284 pub struct EventRepo {
1285 id: i64,
1286 name: String,
1287 url: String,
1288 }
1289
1290 #[derive(Debug, Serialize, Deserialize)]
1291 pub struct EventPayloadPages {
1292 #[serde(skip_serializing_if = "Option::is_none")]
1293 page_name: Option<String>,
1294 #[serde(skip_serializing_if = "Option::is_none")]
1295 title: Option<String>,
1296 #[serde(skip_serializing_if = "Option::is_none")]
1297 summary: Option<String>,
1298 #[serde(skip_serializing_if = "Option::is_none")]
1299 action: Option<String>,
1300 #[serde(skip_serializing_if = "Option::is_none")]
1301 sha: Option<String>,
1302 #[serde(skip_serializing_if = "Option::is_none")]
1303 html_url: Option<String>,
1304 }
1305
1306 #[derive(Debug, Serialize, Deserialize)]
1307 pub struct EventPayload {
1308 #[serde(skip_serializing_if = "Option::is_none")]
1309 action: Option<String>,
1310 #[serde(skip_serializing_if = "Option::is_none")]
1312 issue: Option<crate::components::schemas::Issue>,
1313 #[serde(skip_serializing_if = "Option::is_none")]
1315 comment: Option<crate::components::schemas::IssueComment>,
1316 #[serde(skip_serializing_if = "Option::is_none")]
1317 pages: Option<Vec<EventPayloadPages>>,
1318 }
1319
1320 #[derive(Debug, Serialize, Deserialize)]
1321 pub struct Event {
1322 id: String,
1323 #[serde(rename="type")]
1324 type_: Option<String>,
1325 actor: crate::components::schemas::Actor,
1327 repo: EventRepo,
1328 #[serde(skip_serializing_if = "Option::is_none")]
1330 org: Option<crate::components::schemas::Actor>,
1331 payload: EventPayload,
1332 public: bool,
1333 created_at: Option<String>,
1334 }
1335
1336 #[derive(Debug, Serialize, Deserialize)]
1337 pub struct LinkWithType {
1338 href: String,
1339 #[serde(rename="type")]
1340 type_: String,
1341 }
1342
1343 #[derive(Debug, Serialize, Deserialize)]
1344 pub struct FeedLinks {
1345 timeline: crate::components::schemas::LinkWithType,
1347 user: crate::components::schemas::LinkWithType,
1349 #[serde(skip_serializing_if = "Option::is_none")]
1351 security_advisories: Option<crate::components::schemas::LinkWithType>,
1352 #[serde(skip_serializing_if = "Option::is_none")]
1354 current_user: Option<crate::components::schemas::LinkWithType>,
1355 #[serde(skip_serializing_if = "Option::is_none")]
1357 current_user_public: Option<crate::components::schemas::LinkWithType>,
1358 #[serde(skip_serializing_if = "Option::is_none")]
1360 current_user_actor: Option<crate::components::schemas::LinkWithType>,
1361 #[serde(skip_serializing_if = "Option::is_none")]
1363 current_user_organization: Option<crate::components::schemas::LinkWithType>,
1364 #[serde(skip_serializing_if = "Option::is_none")]
1365 current_user_organizations: Option<Vec<crate::components::schemas::LinkWithType>>,
1366 }
1367
1368 #[derive(Debug, Serialize, Deserialize)]
1369 pub struct Feed {
1370 timeline_url: String,
1371 user_url: String,
1372 #[serde(skip_serializing_if = "Option::is_none")]
1373 current_user_public_url: Option<String>,
1374 #[serde(skip_serializing_if = "Option::is_none")]
1375 current_user_url: Option<String>,
1376 #[serde(skip_serializing_if = "Option::is_none")]
1377 current_user_actor_url: Option<String>,
1378 #[serde(skip_serializing_if = "Option::is_none")]
1379 current_user_organization_url: Option<String>,
1380 #[serde(skip_serializing_if = "Option::is_none")]
1381 current_user_organization_urls: Option<Vec<String>>,
1382 #[serde(skip_serializing_if = "Option::is_none")]
1383 security_advisories_url: Option<String>,
1384 #[serde(rename="_links")]
1385 links: FeedLinks,
1386 }
1387
1388 #[derive(Debug, Serialize, Deserialize)]
1389 pub struct BaseGistFiles;
1390
1391 #[derive(Debug, Serialize, Deserialize)]
1392 pub struct BaseGist {
1393 url: String,
1394 forks_url: String,
1395 commits_url: String,
1396 id: String,
1397 node_id: String,
1398 git_pull_url: String,
1399 git_push_url: String,
1400 html_url: String,
1401 files: BaseGistFiles,
1402 public: bool,
1403 created_at: String,
1404 updated_at: String,
1405 description: Option<String>,
1406 comments: i64,
1407 user: crate::components::schemas::NullableSimpleUser,
1409 comments_url: String,
1410 #[serde(skip_serializing_if = "Option::is_none")]
1412 owner: Option<crate::components::schemas::SimpleUser>,
1413 #[serde(skip_serializing_if = "Option::is_none")]
1414 truncated: Option<bool>,
1415 #[serde(skip_serializing_if = "Option::is_none")]
1416 forks: Option<Vec<HashMap<String, String>>>,
1417 #[serde(skip_serializing_if = "Option::is_none")]
1418 history: Option<Vec<HashMap<String, String>>>,
1419 }
1420
1421 #[derive(Debug, Serialize, Deserialize)]
1422 pub struct PublicUserPlan {
1423 collaborators: i64,
1424 name: String,
1425 space: i64,
1426 private_repos: i64,
1427 }
1428
1429 #[derive(Debug, Serialize, Deserialize)]
1430 pub struct PublicUser {
1431 login: String,
1432 id: i64,
1433 node_id: String,
1434 avatar_url: String,
1435 gravatar_id: Option<String>,
1436 url: String,
1437 html_url: String,
1438 followers_url: String,
1439 following_url: String,
1440 gists_url: String,
1441 starred_url: String,
1442 subscriptions_url: String,
1443 organizations_url: String,
1444 repos_url: String,
1445 events_url: String,
1446 received_events_url: String,
1447 #[serde(rename="type")]
1448 type_: String,
1449 site_admin: bool,
1450 name: Option<String>,
1451 company: Option<String>,
1452 blog: Option<String>,
1453 location: Option<String>,
1454 email: Option<String>,
1455 hireable: Option<bool>,
1456 bio: Option<String>,
1457 #[serde(skip_serializing_if = "Option::is_none")]
1458 twitter_username: Option<String>,
1459 public_repos: i64,
1460 public_gists: i64,
1461 followers: i64,
1462 following: i64,
1463 created_at: String,
1464 updated_at: String,
1465 #[serde(skip_serializing_if = "Option::is_none")]
1466 plan: Option<PublicUserPlan>,
1467 #[serde(skip_serializing_if = "Option::is_none")]
1468 suspended_at: Option<String>,
1469 #[serde(skip_serializing_if = "Option::is_none")]
1470 private_gists: Option<i64>,
1471 #[serde(skip_serializing_if = "Option::is_none")]
1472 total_private_repos: Option<i64>,
1473 #[serde(skip_serializing_if = "Option::is_none")]
1474 owned_private_repos: Option<i64>,
1475 #[serde(skip_serializing_if = "Option::is_none")]
1476 disk_usage: Option<i64>,
1477 #[serde(skip_serializing_if = "Option::is_none")]
1478 collaborators: Option<i64>,
1479 }
1480
1481 #[derive(Debug, Serialize, Deserialize)]
1482 pub struct GistHistoryChangeStatus {
1483 #[serde(skip_serializing_if = "Option::is_none")]
1484 total: Option<i64>,
1485 #[serde(skip_serializing_if = "Option::is_none")]
1486 additions: Option<i64>,
1487 #[serde(skip_serializing_if = "Option::is_none")]
1488 deletions: Option<i64>,
1489 }
1490
1491 #[derive(Debug, Serialize, Deserialize)]
1492 pub struct GistHistory {
1493 #[serde(skip_serializing_if = "Option::is_none")]
1495 user: Option<crate::components::schemas::NullableSimpleUser>,
1496 #[serde(skip_serializing_if = "Option::is_none")]
1497 version: Option<String>,
1498 #[serde(skip_serializing_if = "Option::is_none")]
1499 committed_at: Option<String>,
1500 #[serde(skip_serializing_if = "Option::is_none")]
1501 change_status: Option<GistHistoryChangeStatus>,
1502 #[serde(skip_serializing_if = "Option::is_none")]
1503 url: Option<String>,
1504 }
1505
1506 #[derive(Debug, Serialize, Deserialize)]
1507 pub struct GistSimpleForks {
1508 #[serde(skip_serializing_if = "Option::is_none")]
1509 id: Option<String>,
1510 #[serde(skip_serializing_if = "Option::is_none")]
1511 url: Option<String>,
1512 #[serde(skip_serializing_if = "Option::is_none")]
1514 user: Option<crate::components::schemas::PublicUser>,
1515 #[serde(skip_serializing_if = "Option::is_none")]
1516 created_at: Option<String>,
1517 #[serde(skip_serializing_if = "Option::is_none")]
1518 updated_at: Option<String>,
1519 }
1520
1521 #[derive(Debug, Serialize, Deserialize)]
1522 pub struct GistSimpleForkOfFiles;
1523
1524 #[derive(Debug, Serialize, Deserialize)]
1525 pub struct GistSimpleForkOf {
1526 url: String,
1527 forks_url: String,
1528 commits_url: String,
1529 id: String,
1530 node_id: String,
1531 git_pull_url: String,
1532 git_push_url: String,
1533 html_url: String,
1534 files: GistSimpleForkOfFiles,
1535 public: bool,
1536 created_at: String,
1537 updated_at: String,
1538 description: Option<String>,
1539 comments: i64,
1540 user: crate::components::schemas::NullableSimpleUser,
1542 comments_url: String,
1543 #[serde(skip_serializing_if = "Option::is_none")]
1545 owner: Option<crate::components::schemas::NullableSimpleUser>,
1546 #[serde(skip_serializing_if = "Option::is_none")]
1547 truncated: Option<bool>,
1548 #[serde(skip_serializing_if = "Option::is_none")]
1549 forks: Option<Vec<HashMap<String, String>>>,
1550 #[serde(skip_serializing_if = "Option::is_none")]
1551 history: Option<Vec<HashMap<String, String>>>,
1552 }
1553
1554 #[derive(Debug, Serialize, Deserialize)]
1555 pub struct GistSimpleFiles;
1556
1557 #[derive(Debug, Serialize, Deserialize)]
1558 pub struct GistSimple {
1559 #[serde(skip_serializing_if = "Option::is_none")]
1560 forks: Option<Vec<GistSimpleForks>>,
1561 #[serde(skip_serializing_if = "Option::is_none")]
1562 history: Option<Vec<crate::components::schemas::GistHistory>>,
1563 #[serde(skip_serializing_if = "Option::is_none")]
1564 fork_of: Option<GistSimpleForkOf>,
1565 #[serde(skip_serializing_if = "Option::is_none")]
1566 url: Option<String>,
1567 #[serde(skip_serializing_if = "Option::is_none")]
1568 forks_url: Option<String>,
1569 #[serde(skip_serializing_if = "Option::is_none")]
1570 commits_url: Option<String>,
1571 #[serde(skip_serializing_if = "Option::is_none")]
1572 id: Option<String>,
1573 #[serde(skip_serializing_if = "Option::is_none")]
1574 node_id: Option<String>,
1575 #[serde(skip_serializing_if = "Option::is_none")]
1576 git_pull_url: Option<String>,
1577 #[serde(skip_serializing_if = "Option::is_none")]
1578 git_push_url: Option<String>,
1579 #[serde(skip_serializing_if = "Option::is_none")]
1580 html_url: Option<String>,
1581 #[serde(skip_serializing_if = "Option::is_none")]
1582 files: Option<GistSimpleFiles>,
1583 #[serde(skip_serializing_if = "Option::is_none")]
1584 public: Option<bool>,
1585 #[serde(skip_serializing_if = "Option::is_none")]
1586 created_at: Option<String>,
1587 #[serde(skip_serializing_if = "Option::is_none")]
1588 updated_at: Option<String>,
1589 #[serde(skip_serializing_if = "Option::is_none")]
1590 description: Option<String>,
1591 #[serde(skip_serializing_if = "Option::is_none")]
1592 comments: Option<i64>,
1593 #[serde(skip_serializing_if = "Option::is_none")]
1594 user: Option<String>,
1595 #[serde(skip_serializing_if = "Option::is_none")]
1596 comments_url: Option<String>,
1597 #[serde(skip_serializing_if = "Option::is_none")]
1599 owner: Option<crate::components::schemas::SimpleUser>,
1600 #[serde(skip_serializing_if = "Option::is_none")]
1601 truncated: Option<bool>,
1602 }
1603
1604 #[derive(Debug, Serialize, Deserialize)]
1605 pub struct GistComment {
1606 id: i64,
1607 node_id: String,
1608 url: String,
1609 body: String,
1610 user: crate::components::schemas::NullableSimpleUser,
1612 created_at: String,
1613 updated_at: String,
1614 author_association: crate::components::schemas::AuthorAssociation,
1616 }
1617
1618 #[derive(Debug, Serialize, Deserialize)]
1619 pub struct GistCommitChangeStatus {
1620 #[serde(skip_serializing_if = "Option::is_none")]
1621 total: Option<i64>,
1622 #[serde(skip_serializing_if = "Option::is_none")]
1623 additions: Option<i64>,
1624 #[serde(skip_serializing_if = "Option::is_none")]
1625 deletions: Option<i64>,
1626 }
1627
1628 #[derive(Debug, Serialize, Deserialize)]
1629 pub struct GistCommit {
1630 url: String,
1631 version: String,
1632 user: crate::components::schemas::NullableSimpleUser,
1634 change_status: GistCommitChangeStatus,
1635 committed_at: String,
1636 }
1637
1638 #[derive(Debug, Serialize, Deserialize)]
1639 pub struct GitignoreTemplate {
1640 name: String,
1641 source: String,
1642 }
1643
1644 #[derive(Debug, Serialize, Deserialize)]
1645 pub struct LicenseSimple {
1646 key: String,
1647 name: String,
1648 url: Option<String>,
1649 spdx_id: Option<String>,
1650 node_id: String,
1651 #[serde(skip_serializing_if = "Option::is_none")]
1652 html_url: Option<String>,
1653 }
1654
1655 #[derive(Debug, Serialize, Deserialize)]
1656 pub struct License {
1657 key: String,
1658 name: String,
1659 spdx_id: Option<String>,
1660 url: Option<String>,
1661 node_id: String,
1662 html_url: String,
1663 description: String,
1664 implementation: String,
1665 permissions: Vec<String>,
1666 conditions: Vec<String>,
1667 limitations: Vec<String>,
1668 body: String,
1669 featured: bool,
1670 }
1671
1672 #[derive(Debug, Serialize, Deserialize)]
1673 pub struct MarketplaceListingPlan {
1674 url: String,
1675 accounts_url: String,
1676 id: i64,
1677 number: i64,
1678 name: String,
1679 description: String,
1680 monthly_price_in_cents: i64,
1681 yearly_price_in_cents: i64,
1682 price_model: String,
1683 has_free_trial: bool,
1684 unit_name: Option<String>,
1685 state: String,
1686 bullets: Vec<String>,
1687 }
1688
1689 #[derive(Debug, Serialize, Deserialize)]
1690 pub struct MarketplacePurchaseMarketplacePendingChange {
1691 #[serde(skip_serializing_if = "Option::is_none")]
1692 is_installed: Option<bool>,
1693 #[serde(skip_serializing_if = "Option::is_none")]
1694 effective_date: Option<String>,
1695 #[serde(skip_serializing_if = "Option::is_none")]
1696 unit_count: Option<i64>,
1697 #[serde(skip_serializing_if = "Option::is_none")]
1698 id: Option<i64>,
1699 #[serde(skip_serializing_if = "Option::is_none")]
1701 plan: Option<crate::components::schemas::MarketplaceListingPlan>,
1702 }
1703
1704 #[derive(Debug, Serialize, Deserialize)]
1705 pub struct MarketplacePurchaseMarketplacePurchase {
1706 #[serde(skip_serializing_if = "Option::is_none")]
1707 billing_cycle: Option<String>,
1708 #[serde(skip_serializing_if = "Option::is_none")]
1709 next_billing_date: Option<String>,
1710 #[serde(skip_serializing_if = "Option::is_none")]
1711 is_installed: Option<bool>,
1712 #[serde(skip_serializing_if = "Option::is_none")]
1713 unit_count: Option<i64>,
1714 #[serde(skip_serializing_if = "Option::is_none")]
1715 on_free_trial: Option<bool>,
1716 #[serde(skip_serializing_if = "Option::is_none")]
1717 free_trial_ends_on: Option<String>,
1718 #[serde(skip_serializing_if = "Option::is_none")]
1719 updated_at: Option<String>,
1720 #[serde(skip_serializing_if = "Option::is_none")]
1722 plan: Option<crate::components::schemas::MarketplaceListingPlan>,
1723 }
1724
1725 #[derive(Debug, Serialize, Deserialize)]
1726 pub struct MarketplacePurchase {
1727 url: String,
1728 #[serde(rename="type")]
1729 type_: String,
1730 id: i64,
1731 login: String,
1732 #[serde(skip_serializing_if = "Option::is_none")]
1733 organization_billing_email: Option<String>,
1734 #[serde(skip_serializing_if = "Option::is_none")]
1735 email: Option<String>,
1736 #[serde(skip_serializing_if = "Option::is_none")]
1737 marketplace_pending_change: Option<MarketplacePurchaseMarketplacePendingChange>,
1738 marketplace_purchase: MarketplacePurchaseMarketplacePurchase,
1739 }
1740
1741 #[derive(Debug, Serialize, Deserialize)]
1742 pub struct ApiOverviewSshKeyFingerprints {
1743 #[serde(rename="SHA256_RSA", skip_serializing_if = "Option::is_none")]
1744 sha_256_rsa: Option<String>,
1745 #[serde(rename="SHA256_DSA", skip_serializing_if = "Option::is_none")]
1746 sha_256_dsa: Option<String>,
1747 #[serde(rename="SHA256_ECDSA", skip_serializing_if = "Option::is_none")]
1748 sha_256_ecdsa: Option<String>,
1749 #[serde(rename="SHA256_ED25519", skip_serializing_if = "Option::is_none")]
1750 sha_256_ed_25519: Option<String>,
1751 }
1752
1753 #[derive(Debug, Serialize, Deserialize)]
1754 pub struct ApiOverview {
1755 verifiable_password_authentication: bool,
1756 #[serde(skip_serializing_if = "Option::is_none")]
1757 ssh_key_fingerprints: Option<ApiOverviewSshKeyFingerprints>,
1758 #[serde(skip_serializing_if = "Option::is_none")]
1759 hooks: Option<Vec<String>>,
1760 #[serde(skip_serializing_if = "Option::is_none")]
1761 web: Option<Vec<String>>,
1762 #[serde(skip_serializing_if = "Option::is_none")]
1763 api: Option<Vec<String>>,
1764 #[serde(skip_serializing_if = "Option::is_none")]
1765 git: Option<Vec<String>>,
1766 #[serde(skip_serializing_if = "Option::is_none")]
1767 packages: Option<Vec<String>>,
1768 #[serde(skip_serializing_if = "Option::is_none")]
1769 pages: Option<Vec<String>>,
1770 #[serde(skip_serializing_if = "Option::is_none")]
1771 importer: Option<Vec<String>>,
1772 #[serde(skip_serializing_if = "Option::is_none")]
1773 actions: Option<Vec<String>>,
1774 #[serde(skip_serializing_if = "Option::is_none")]
1775 dependabot: Option<Vec<String>>,
1776 }
1777
1778 #[derive(Debug, Serialize, Deserialize)]
1779 pub struct NullableRepositoryPermissions {
1780 admin: bool,
1781 pull: bool,
1782 #[serde(skip_serializing_if = "Option::is_none")]
1783 triage: Option<bool>,
1784 push: bool,
1785 #[serde(skip_serializing_if = "Option::is_none")]
1786 maintain: Option<bool>,
1787 }
1788
1789 #[derive(Debug, Serialize, Deserialize)]
1790 pub struct NullableRepositoryTemplateRepositoryOwner {
1791 #[serde(skip_serializing_if = "Option::is_none")]
1792 login: Option<String>,
1793 #[serde(skip_serializing_if = "Option::is_none")]
1794 id: Option<i64>,
1795 #[serde(skip_serializing_if = "Option::is_none")]
1796 node_id: Option<String>,
1797 #[serde(skip_serializing_if = "Option::is_none")]
1798 avatar_url: Option<String>,
1799 #[serde(skip_serializing_if = "Option::is_none")]
1800 gravatar_id: Option<String>,
1801 #[serde(skip_serializing_if = "Option::is_none")]
1802 url: Option<String>,
1803 #[serde(skip_serializing_if = "Option::is_none")]
1804 html_url: Option<String>,
1805 #[serde(skip_serializing_if = "Option::is_none")]
1806 followers_url: Option<String>,
1807 #[serde(skip_serializing_if = "Option::is_none")]
1808 following_url: Option<String>,
1809 #[serde(skip_serializing_if = "Option::is_none")]
1810 gists_url: Option<String>,
1811 #[serde(skip_serializing_if = "Option::is_none")]
1812 starred_url: Option<String>,
1813 #[serde(skip_serializing_if = "Option::is_none")]
1814 subscriptions_url: Option<String>,
1815 #[serde(skip_serializing_if = "Option::is_none")]
1816 organizations_url: Option<String>,
1817 #[serde(skip_serializing_if = "Option::is_none")]
1818 repos_url: Option<String>,
1819 #[serde(skip_serializing_if = "Option::is_none")]
1820 events_url: Option<String>,
1821 #[serde(skip_serializing_if = "Option::is_none")]
1822 received_events_url: Option<String>,
1823 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
1824 type_: Option<String>,
1825 #[serde(skip_serializing_if = "Option::is_none")]
1826 site_admin: Option<bool>,
1827 }
1828
1829 #[derive(Debug, Serialize, Deserialize)]
1830 pub struct NullableRepositoryTemplateRepositoryPermissions {
1831 #[serde(skip_serializing_if = "Option::is_none")]
1832 admin: Option<bool>,
1833 #[serde(skip_serializing_if = "Option::is_none")]
1834 maintain: Option<bool>,
1835 #[serde(skip_serializing_if = "Option::is_none")]
1836 push: Option<bool>,
1837 #[serde(skip_serializing_if = "Option::is_none")]
1838 triage: Option<bool>,
1839 #[serde(skip_serializing_if = "Option::is_none")]
1840 pull: Option<bool>,
1841 }
1842
1843 #[derive(Debug, Serialize, Deserialize)]
1844 pub struct NullableRepositoryTemplateRepository {
1845 #[serde(skip_serializing_if = "Option::is_none")]
1846 id: Option<i64>,
1847 #[serde(skip_serializing_if = "Option::is_none")]
1848 node_id: Option<String>,
1849 #[serde(skip_serializing_if = "Option::is_none")]
1850 name: Option<String>,
1851 #[serde(skip_serializing_if = "Option::is_none")]
1852 full_name: Option<String>,
1853 #[serde(skip_serializing_if = "Option::is_none")]
1854 owner: Option<NullableRepositoryTemplateRepositoryOwner>,
1855 #[serde(skip_serializing_if = "Option::is_none")]
1856 private: Option<bool>,
1857 #[serde(skip_serializing_if = "Option::is_none")]
1858 html_url: Option<String>,
1859 #[serde(skip_serializing_if = "Option::is_none")]
1860 description: Option<String>,
1861 #[serde(skip_serializing_if = "Option::is_none")]
1862 fork: Option<bool>,
1863 #[serde(skip_serializing_if = "Option::is_none")]
1864 url: Option<String>,
1865 #[serde(skip_serializing_if = "Option::is_none")]
1866 archive_url: Option<String>,
1867 #[serde(skip_serializing_if = "Option::is_none")]
1868 assignees_url: Option<String>,
1869 #[serde(skip_serializing_if = "Option::is_none")]
1870 blobs_url: Option<String>,
1871 #[serde(skip_serializing_if = "Option::is_none")]
1872 branches_url: Option<String>,
1873 #[serde(skip_serializing_if = "Option::is_none")]
1874 collaborators_url: Option<String>,
1875 #[serde(skip_serializing_if = "Option::is_none")]
1876 comments_url: Option<String>,
1877 #[serde(skip_serializing_if = "Option::is_none")]
1878 commits_url: Option<String>,
1879 #[serde(skip_serializing_if = "Option::is_none")]
1880 compare_url: Option<String>,
1881 #[serde(skip_serializing_if = "Option::is_none")]
1882 contents_url: Option<String>,
1883 #[serde(skip_serializing_if = "Option::is_none")]
1884 contributors_url: Option<String>,
1885 #[serde(skip_serializing_if = "Option::is_none")]
1886 deployments_url: Option<String>,
1887 #[serde(skip_serializing_if = "Option::is_none")]
1888 downloads_url: Option<String>,
1889 #[serde(skip_serializing_if = "Option::is_none")]
1890 events_url: Option<String>,
1891 #[serde(skip_serializing_if = "Option::is_none")]
1892 forks_url: Option<String>,
1893 #[serde(skip_serializing_if = "Option::is_none")]
1894 git_commits_url: Option<String>,
1895 #[serde(skip_serializing_if = "Option::is_none")]
1896 git_refs_url: Option<String>,
1897 #[serde(skip_serializing_if = "Option::is_none")]
1898 git_tags_url: Option<String>,
1899 #[serde(skip_serializing_if = "Option::is_none")]
1900 git_url: Option<String>,
1901 #[serde(skip_serializing_if = "Option::is_none")]
1902 issue_comment_url: Option<String>,
1903 #[serde(skip_serializing_if = "Option::is_none")]
1904 issue_events_url: Option<String>,
1905 #[serde(skip_serializing_if = "Option::is_none")]
1906 issues_url: Option<String>,
1907 #[serde(skip_serializing_if = "Option::is_none")]
1908 keys_url: Option<String>,
1909 #[serde(skip_serializing_if = "Option::is_none")]
1910 labels_url: Option<String>,
1911 #[serde(skip_serializing_if = "Option::is_none")]
1912 languages_url: Option<String>,
1913 #[serde(skip_serializing_if = "Option::is_none")]
1914 merges_url: Option<String>,
1915 #[serde(skip_serializing_if = "Option::is_none")]
1916 milestones_url: Option<String>,
1917 #[serde(skip_serializing_if = "Option::is_none")]
1918 notifications_url: Option<String>,
1919 #[serde(skip_serializing_if = "Option::is_none")]
1920 pulls_url: Option<String>,
1921 #[serde(skip_serializing_if = "Option::is_none")]
1922 releases_url: Option<String>,
1923 #[serde(skip_serializing_if = "Option::is_none")]
1924 ssh_url: Option<String>,
1925 #[serde(skip_serializing_if = "Option::is_none")]
1926 stargazers_url: Option<String>,
1927 #[serde(skip_serializing_if = "Option::is_none")]
1928 statuses_url: Option<String>,
1929 #[serde(skip_serializing_if = "Option::is_none")]
1930 subscribers_url: Option<String>,
1931 #[serde(skip_serializing_if = "Option::is_none")]
1932 subscription_url: Option<String>,
1933 #[serde(skip_serializing_if = "Option::is_none")]
1934 tags_url: Option<String>,
1935 #[serde(skip_serializing_if = "Option::is_none")]
1936 teams_url: Option<String>,
1937 #[serde(skip_serializing_if = "Option::is_none")]
1938 trees_url: Option<String>,
1939 #[serde(skip_serializing_if = "Option::is_none")]
1940 clone_url: Option<String>,
1941 #[serde(skip_serializing_if = "Option::is_none")]
1942 mirror_url: Option<String>,
1943 #[serde(skip_serializing_if = "Option::is_none")]
1944 hooks_url: Option<String>,
1945 #[serde(skip_serializing_if = "Option::is_none")]
1946 svn_url: Option<String>,
1947 #[serde(skip_serializing_if = "Option::is_none")]
1948 homepage: Option<String>,
1949 #[serde(skip_serializing_if = "Option::is_none")]
1950 language: Option<String>,
1951 #[serde(skip_serializing_if = "Option::is_none")]
1952 forks_count: Option<i64>,
1953 #[serde(skip_serializing_if = "Option::is_none")]
1954 stargazers_count: Option<i64>,
1955 #[serde(skip_serializing_if = "Option::is_none")]
1956 watchers_count: Option<i64>,
1957 #[serde(skip_serializing_if = "Option::is_none")]
1958 size: Option<i64>,
1959 #[serde(skip_serializing_if = "Option::is_none")]
1960 default_branch: Option<String>,
1961 #[serde(skip_serializing_if = "Option::is_none")]
1962 open_issues_count: Option<i64>,
1963 #[serde(skip_serializing_if = "Option::is_none")]
1964 is_template: Option<bool>,
1965 #[serde(skip_serializing_if = "Option::is_none")]
1966 topics: Option<Vec<String>>,
1967 #[serde(skip_serializing_if = "Option::is_none")]
1968 has_issues: Option<bool>,
1969 #[serde(skip_serializing_if = "Option::is_none")]
1970 has_projects: Option<bool>,
1971 #[serde(skip_serializing_if = "Option::is_none")]
1972 has_wiki: Option<bool>,
1973 #[serde(skip_serializing_if = "Option::is_none")]
1974 has_pages: Option<bool>,
1975 #[serde(skip_serializing_if = "Option::is_none")]
1976 has_downloads: Option<bool>,
1977 #[serde(skip_serializing_if = "Option::is_none")]
1978 archived: Option<bool>,
1979 #[serde(skip_serializing_if = "Option::is_none")]
1980 disabled: Option<bool>,
1981 #[serde(skip_serializing_if = "Option::is_none")]
1982 visibility: Option<String>,
1983 #[serde(skip_serializing_if = "Option::is_none")]
1984 pushed_at: Option<String>,
1985 #[serde(skip_serializing_if = "Option::is_none")]
1986 created_at: Option<String>,
1987 #[serde(skip_serializing_if = "Option::is_none")]
1988 updated_at: Option<String>,
1989 #[serde(skip_serializing_if = "Option::is_none")]
1990 permissions: Option<NullableRepositoryTemplateRepositoryPermissions>,
1991 #[serde(skip_serializing_if = "Option::is_none")]
1992 allow_rebase_merge: Option<bool>,
1993 #[serde(skip_serializing_if = "Option::is_none")]
1994 temp_clone_token: Option<String>,
1995 #[serde(skip_serializing_if = "Option::is_none")]
1996 allow_squash_merge: Option<bool>,
1997 #[serde(skip_serializing_if = "Option::is_none")]
1998 allow_auto_merge: Option<bool>,
1999 #[serde(skip_serializing_if = "Option::is_none")]
2000 delete_branch_on_merge: Option<bool>,
2001 #[serde(skip_serializing_if = "Option::is_none")]
2002 allow_merge_commit: Option<bool>,
2003 #[serde(skip_serializing_if = "Option::is_none")]
2004 subscribers_count: Option<i64>,
2005 #[serde(skip_serializing_if = "Option::is_none")]
2006 network_count: Option<i64>,
2007 }
2008
2009 #[derive(Debug, Serialize, Deserialize)]
2010 pub struct NullableRepository {
2011 id: i64,
2012 node_id: String,
2013 name: String,
2014 full_name: String,
2015 license: crate::components::schemas::NullableLicenseSimple,
2017 #[serde(skip_serializing_if = "Option::is_none")]
2019 organization: Option<crate::components::schemas::NullableSimpleUser>,
2020 forks: i64,
2021 #[serde(skip_serializing_if = "Option::is_none")]
2022 permissions: Option<NullableRepositoryPermissions>,
2023 owner: crate::components::schemas::SimpleUser,
2025 private: bool,
2026 html_url: String,
2027 description: Option<String>,
2028 fork: bool,
2029 url: String,
2030 archive_url: String,
2031 assignees_url: String,
2032 blobs_url: String,
2033 branches_url: String,
2034 collaborators_url: String,
2035 comments_url: String,
2036 commits_url: String,
2037 compare_url: String,
2038 contents_url: String,
2039 contributors_url: String,
2040 deployments_url: String,
2041 downloads_url: String,
2042 events_url: String,
2043 forks_url: String,
2044 git_commits_url: String,
2045 git_refs_url: String,
2046 git_tags_url: String,
2047 git_url: String,
2048 issue_comment_url: String,
2049 issue_events_url: String,
2050 issues_url: String,
2051 keys_url: String,
2052 labels_url: String,
2053 languages_url: String,
2054 merges_url: String,
2055 milestones_url: String,
2056 notifications_url: String,
2057 pulls_url: String,
2058 releases_url: String,
2059 ssh_url: String,
2060 stargazers_url: String,
2061 statuses_url: String,
2062 subscribers_url: String,
2063 subscription_url: String,
2064 tags_url: String,
2065 teams_url: String,
2066 trees_url: String,
2067 clone_url: String,
2068 mirror_url: Option<String>,
2069 hooks_url: String,
2070 svn_url: String,
2071 homepage: Option<String>,
2072 language: Option<String>,
2073 forks_count: i64,
2074 stargazers_count: i64,
2075 watchers_count: i64,
2076 size: i64,
2077 default_branch: String,
2078 open_issues_count: i64,
2079 #[serde(skip_serializing_if = "Option::is_none")]
2080 is_template: Option<bool>,
2081 #[serde(skip_serializing_if = "Option::is_none")]
2082 topics: Option<Vec<String>>,
2083 has_issues: bool,
2084 has_projects: bool,
2085 has_wiki: bool,
2086 has_pages: bool,
2087 has_downloads: bool,
2088 archived: bool,
2089 disabled: bool,
2090 #[serde(skip_serializing_if = "Option::is_none")]
2091 visibility: Option<String>,
2092 pushed_at: Option<String>,
2093 created_at: Option<String>,
2094 updated_at: Option<String>,
2095 #[serde(skip_serializing_if = "Option::is_none")]
2096 allow_rebase_merge: Option<bool>,
2097 #[serde(skip_serializing_if = "Option::is_none")]
2098 template_repository: Option<NullableRepositoryTemplateRepository>,
2099 #[serde(skip_serializing_if = "Option::is_none")]
2100 temp_clone_token: Option<String>,
2101 #[serde(skip_serializing_if = "Option::is_none")]
2102 allow_squash_merge: Option<bool>,
2103 #[serde(skip_serializing_if = "Option::is_none")]
2104 allow_auto_merge: Option<bool>,
2105 #[serde(skip_serializing_if = "Option::is_none")]
2106 delete_branch_on_merge: Option<bool>,
2107 #[serde(skip_serializing_if = "Option::is_none")]
2108 allow_merge_commit: Option<bool>,
2109 #[serde(skip_serializing_if = "Option::is_none")]
2110 allow_forking: Option<bool>,
2111 #[serde(skip_serializing_if = "Option::is_none")]
2112 subscribers_count: Option<i64>,
2113 #[serde(skip_serializing_if = "Option::is_none")]
2114 network_count: Option<i64>,
2115 open_issues: i64,
2116 watchers: i64,
2117 #[serde(skip_serializing_if = "Option::is_none")]
2118 master_branch: Option<String>,
2119 #[serde(skip_serializing_if = "Option::is_none")]
2120 starred_at: Option<String>,
2121 }
2122
2123 #[derive(Debug, Serialize, Deserialize)]
2124 pub struct MinimalRepositoryPermissions {
2125 #[serde(skip_serializing_if = "Option::is_none")]
2126 admin: Option<bool>,
2127 #[serde(skip_serializing_if = "Option::is_none")]
2128 maintain: Option<bool>,
2129 #[serde(skip_serializing_if = "Option::is_none")]
2130 push: Option<bool>,
2131 #[serde(skip_serializing_if = "Option::is_none")]
2132 triage: Option<bool>,
2133 #[serde(skip_serializing_if = "Option::is_none")]
2134 pull: Option<bool>,
2135 }
2136
2137 #[derive(Debug, Serialize, Deserialize)]
2138 pub struct MinimalRepositoryLicense {
2139 #[serde(skip_serializing_if = "Option::is_none")]
2140 key: Option<String>,
2141 #[serde(skip_serializing_if = "Option::is_none")]
2142 name: Option<String>,
2143 #[serde(skip_serializing_if = "Option::is_none")]
2144 spdx_id: Option<String>,
2145 #[serde(skip_serializing_if = "Option::is_none")]
2146 url: Option<String>,
2147 #[serde(skip_serializing_if = "Option::is_none")]
2148 node_id: Option<String>,
2149 }
2150
2151 #[derive(Debug, Serialize, Deserialize)]
2152 pub struct MinimalRepository {
2153 id: i64,
2154 node_id: String,
2155 name: String,
2156 full_name: String,
2157 owner: crate::components::schemas::SimpleUser,
2159 private: bool,
2160 html_url: String,
2161 description: Option<String>,
2162 fork: bool,
2163 url: String,
2164 archive_url: String,
2165 assignees_url: String,
2166 blobs_url: String,
2167 branches_url: String,
2168 collaborators_url: String,
2169 comments_url: String,
2170 commits_url: String,
2171 compare_url: String,
2172 contents_url: String,
2173 contributors_url: String,
2174 deployments_url: String,
2175 downloads_url: String,
2176 events_url: String,
2177 forks_url: String,
2178 git_commits_url: String,
2179 git_refs_url: String,
2180 git_tags_url: String,
2181 #[serde(skip_serializing_if = "Option::is_none")]
2182 git_url: Option<String>,
2183 issue_comment_url: String,
2184 issue_events_url: String,
2185 issues_url: String,
2186 keys_url: String,
2187 labels_url: String,
2188 languages_url: String,
2189 merges_url: String,
2190 milestones_url: String,
2191 notifications_url: String,
2192 pulls_url: String,
2193 releases_url: String,
2194 #[serde(skip_serializing_if = "Option::is_none")]
2195 ssh_url: Option<String>,
2196 stargazers_url: String,
2197 statuses_url: String,
2198 subscribers_url: String,
2199 subscription_url: String,
2200 tags_url: String,
2201 teams_url: String,
2202 trees_url: String,
2203 #[serde(skip_serializing_if = "Option::is_none")]
2204 clone_url: Option<String>,
2205 #[serde(skip_serializing_if = "Option::is_none")]
2206 mirror_url: Option<String>,
2207 hooks_url: String,
2208 #[serde(skip_serializing_if = "Option::is_none")]
2209 svn_url: Option<String>,
2210 #[serde(skip_serializing_if = "Option::is_none")]
2211 homepage: Option<String>,
2212 #[serde(skip_serializing_if = "Option::is_none")]
2213 language: Option<String>,
2214 #[serde(skip_serializing_if = "Option::is_none")]
2215 forks_count: Option<i64>,
2216 #[serde(skip_serializing_if = "Option::is_none")]
2217 stargazers_count: Option<i64>,
2218 #[serde(skip_serializing_if = "Option::is_none")]
2219 watchers_count: Option<i64>,
2220 #[serde(skip_serializing_if = "Option::is_none")]
2221 size: Option<i64>,
2222 #[serde(skip_serializing_if = "Option::is_none")]
2223 default_branch: Option<String>,
2224 #[serde(skip_serializing_if = "Option::is_none")]
2225 open_issues_count: Option<i64>,
2226 #[serde(skip_serializing_if = "Option::is_none")]
2227 is_template: Option<bool>,
2228 #[serde(skip_serializing_if = "Option::is_none")]
2229 topics: Option<Vec<String>>,
2230 #[serde(skip_serializing_if = "Option::is_none")]
2231 has_issues: Option<bool>,
2232 #[serde(skip_serializing_if = "Option::is_none")]
2233 has_projects: Option<bool>,
2234 #[serde(skip_serializing_if = "Option::is_none")]
2235 has_wiki: Option<bool>,
2236 #[serde(skip_serializing_if = "Option::is_none")]
2237 has_pages: Option<bool>,
2238 #[serde(skip_serializing_if = "Option::is_none")]
2239 has_downloads: Option<bool>,
2240 #[serde(skip_serializing_if = "Option::is_none")]
2241 archived: Option<bool>,
2242 #[serde(skip_serializing_if = "Option::is_none")]
2243 disabled: Option<bool>,
2244 #[serde(skip_serializing_if = "Option::is_none")]
2245 visibility: Option<String>,
2246 #[serde(skip_serializing_if = "Option::is_none")]
2247 pushed_at: Option<String>,
2248 #[serde(skip_serializing_if = "Option::is_none")]
2249 created_at: Option<String>,
2250 #[serde(skip_serializing_if = "Option::is_none")]
2251 updated_at: Option<String>,
2252 #[serde(skip_serializing_if = "Option::is_none")]
2253 permissions: Option<MinimalRepositoryPermissions>,
2254 #[serde(skip_serializing_if = "Option::is_none")]
2255 role_name: Option<String>,
2256 #[serde(skip_serializing_if = "Option::is_none")]
2258 template_repository: Option<crate::components::schemas::NullableRepository>,
2259 #[serde(skip_serializing_if = "Option::is_none")]
2260 temp_clone_token: Option<String>,
2261 #[serde(skip_serializing_if = "Option::is_none")]
2262 delete_branch_on_merge: Option<bool>,
2263 #[serde(skip_serializing_if = "Option::is_none")]
2264 subscribers_count: Option<i64>,
2265 #[serde(skip_serializing_if = "Option::is_none")]
2266 network_count: Option<i64>,
2267 #[serde(skip_serializing_if = "Option::is_none")]
2269 code_of_conduct: Option<crate::components::schemas::CodeOfConduct>,
2270 #[serde(skip_serializing_if = "Option::is_none")]
2271 license: Option<MinimalRepositoryLicense>,
2272 #[serde(skip_serializing_if = "Option::is_none")]
2273 forks: Option<i64>,
2274 #[serde(skip_serializing_if = "Option::is_none")]
2275 open_issues: Option<i64>,
2276 #[serde(skip_serializing_if = "Option::is_none")]
2277 watchers: Option<i64>,
2278 #[serde(skip_serializing_if = "Option::is_none")]
2279 allow_forking: Option<bool>,
2280 }
2281
2282 #[derive(Debug, Serialize, Deserialize)]
2283 pub struct ThreadSubject {
2284 title: String,
2285 url: String,
2286 latest_comment_url: String,
2287 #[serde(rename="type")]
2288 type_: String,
2289 }
2290
2291 #[derive(Debug, Serialize, Deserialize)]
2292 pub struct Thread {
2293 id: String,
2294 repository: crate::components::schemas::MinimalRepository,
2296 subject: ThreadSubject,
2297 reason: String,
2298 unread: bool,
2299 updated_at: String,
2300 last_read_at: Option<String>,
2301 url: String,
2302 subscription_url: String,
2303 }
2304
2305 #[derive(Debug, Serialize, Deserialize)]
2306 pub struct ThreadSubscription {
2307 subscribed: bool,
2308 ignored: bool,
2309 reason: Option<String>,
2310 created_at: Option<String>,
2311 url: String,
2312 #[serde(skip_serializing_if = "Option::is_none")]
2313 thread_url: Option<String>,
2314 #[serde(skip_serializing_if = "Option::is_none")]
2315 repository_url: Option<String>,
2316 }
2317
2318 #[derive(Debug, Serialize, Deserialize)]
2319 pub struct OrganizationCustomRepositoryRole {
2320 id: i64,
2321 name: String,
2322 }
2323
2324 #[derive(Debug, Serialize, Deserialize)]
2325 pub struct OrganizationFullPlan {
2326 name: String,
2327 space: i64,
2328 private_repos: i64,
2329 #[serde(skip_serializing_if = "Option::is_none")]
2330 filled_seats: Option<i64>,
2331 #[serde(skip_serializing_if = "Option::is_none")]
2332 seats: Option<i64>,
2333 }
2334
2335 #[derive(Debug, Serialize, Deserialize)]
2336 pub struct OrganizationFull {
2337 login: String,
2338 id: i64,
2339 node_id: String,
2340 url: String,
2341 repos_url: String,
2342 events_url: String,
2343 hooks_url: String,
2344 issues_url: String,
2345 members_url: String,
2346 public_members_url: String,
2347 avatar_url: String,
2348 description: Option<String>,
2349 #[serde(skip_serializing_if = "Option::is_none")]
2350 name: Option<String>,
2351 #[serde(skip_serializing_if = "Option::is_none")]
2352 company: Option<String>,
2353 #[serde(skip_serializing_if = "Option::is_none")]
2354 blog: Option<String>,
2355 #[serde(skip_serializing_if = "Option::is_none")]
2356 location: Option<String>,
2357 #[serde(skip_serializing_if = "Option::is_none")]
2358 email: Option<String>,
2359 #[serde(skip_serializing_if = "Option::is_none")]
2360 twitter_username: Option<String>,
2361 #[serde(skip_serializing_if = "Option::is_none")]
2362 is_verified: Option<bool>,
2363 has_organization_projects: bool,
2364 has_repository_projects: bool,
2365 public_repos: i64,
2366 public_gists: i64,
2367 followers: i64,
2368 following: i64,
2369 html_url: String,
2370 created_at: String,
2371 #[serde(rename="type")]
2372 type_: String,
2373 #[serde(skip_serializing_if = "Option::is_none")]
2374 total_private_repos: Option<i64>,
2375 #[serde(skip_serializing_if = "Option::is_none")]
2376 owned_private_repos: Option<i64>,
2377 #[serde(skip_serializing_if = "Option::is_none")]
2378 private_gists: Option<i64>,
2379 #[serde(skip_serializing_if = "Option::is_none")]
2380 disk_usage: Option<i64>,
2381 #[serde(skip_serializing_if = "Option::is_none")]
2382 collaborators: Option<i64>,
2383 #[serde(skip_serializing_if = "Option::is_none")]
2384 billing_email: Option<String>,
2385 #[serde(skip_serializing_if = "Option::is_none")]
2386 plan: Option<OrganizationFullPlan>,
2387 #[serde(skip_serializing_if = "Option::is_none")]
2388 default_repository_permission: Option<String>,
2389 #[serde(skip_serializing_if = "Option::is_none")]
2390 members_can_create_repositories: Option<bool>,
2391 #[serde(skip_serializing_if = "Option::is_none")]
2392 two_factor_requirement_enabled: Option<bool>,
2393 #[serde(skip_serializing_if = "Option::is_none")]
2394 members_allowed_repository_creation_type: Option<String>,
2395 #[serde(skip_serializing_if = "Option::is_none")]
2396 members_can_create_public_repositories: Option<bool>,
2397 #[serde(skip_serializing_if = "Option::is_none")]
2398 members_can_create_private_repositories: Option<bool>,
2399 #[serde(skip_serializing_if = "Option::is_none")]
2400 members_can_create_internal_repositories: Option<bool>,
2401 #[serde(skip_serializing_if = "Option::is_none")]
2402 members_can_create_pages: Option<bool>,
2403 #[serde(skip_serializing_if = "Option::is_none")]
2404 members_can_create_public_pages: Option<bool>,
2405 #[serde(skip_serializing_if = "Option::is_none")]
2406 members_can_create_private_pages: Option<bool>,
2407 updated_at: String,
2408 }
2409
2410 pub type EnabledRepositories = String;
2411
2412 #[derive(Debug, Serialize, Deserialize)]
2413 pub struct ActionsOrganizationPermissions {
2414 enabled_repositories: crate::components::schemas::EnabledRepositories,
2416 #[serde(skip_serializing_if = "Option::is_none")]
2417 selected_repositories_url: Option<String>,
2418 #[serde(skip_serializing_if = "Option::is_none")]
2420 allowed_actions: Option<crate::components::schemas::AllowedActions>,
2421 #[serde(skip_serializing_if = "Option::is_none")]
2423 selected_actions_url: Option<crate::components::schemas::SelectedActionsUrl>,
2424 }
2425
2426 #[derive(Debug, Serialize, Deserialize)]
2427 pub struct RunnerGroupsOrg {
2428 id: i64,
2429 name: String,
2430 visibility: String,
2431 default: bool,
2432 #[serde(skip_serializing_if = "Option::is_none")]
2433 selected_repositories_url: Option<String>,
2434 runners_url: String,
2435 inherited: bool,
2436 #[serde(skip_serializing_if = "Option::is_none")]
2437 inherited_allows_public_repositories: Option<bool>,
2438 allows_public_repositories: bool,
2439 }
2440
2441 #[derive(Debug, Serialize, Deserialize)]
2442 pub struct OrganizationActionsSecret {
2443 name: String,
2444 created_at: String,
2445 updated_at: String,
2446 visibility: String,
2447 #[serde(skip_serializing_if = "Option::is_none")]
2448 selected_repositories_url: Option<String>,
2449 }
2450
2451 #[derive(Debug, Serialize, Deserialize)]
2452 pub struct ActionsPublicKey {
2453 key_id: String,
2454 key: String,
2455 #[serde(skip_serializing_if = "Option::is_none")]
2456 id: Option<i64>,
2457 #[serde(skip_serializing_if = "Option::is_none")]
2458 url: Option<String>,
2459 #[serde(skip_serializing_if = "Option::is_none")]
2460 title: Option<String>,
2461 #[serde(skip_serializing_if = "Option::is_none")]
2462 created_at: Option<String>,
2463 }
2464
2465 #[derive(Debug, Serialize, Deserialize)]
2466 pub struct EmptyObject;
2467
2468 #[derive(Debug, Serialize, Deserialize)]
2469 pub struct CredentialAuthorization {
2470 login: String,
2471 credential_id: i64,
2472 credential_type: String,
2473 #[serde(skip_serializing_if = "Option::is_none")]
2474 token_last_eight: Option<String>,
2475 credential_authorized_at: String,
2476 #[serde(skip_serializing_if = "Option::is_none")]
2477 scopes: Option<Vec<String>>,
2478 #[serde(skip_serializing_if = "Option::is_none")]
2479 fingerprint: Option<String>,
2480 credential_accessed_at: Option<String>,
2481 authorized_credential_id: Option<i64>,
2482 #[serde(skip_serializing_if = "Option::is_none")]
2483 authorized_credential_title: Option<String>,
2484 #[serde(skip_serializing_if = "Option::is_none")]
2485 authorized_credential_note: Option<String>,
2486 #[serde(skip_serializing_if = "Option::is_none")]
2487 authorized_credential_expires_at: Option<String>,
2488 }
2489
2490 #[derive(Debug, Serialize, Deserialize)]
2491 pub struct ExternalGroupTeams {
2492 team_id: i64,
2493 team_name: String,
2494 }
2495
2496 #[derive(Debug, Serialize, Deserialize)]
2497 pub struct ExternalGroupMembers {
2498 member_id: i64,
2499 member_login: String,
2500 member_name: String,
2501 member_email: String,
2502 }
2503
2504 #[derive(Debug, Serialize, Deserialize)]
2505 pub struct ExternalGroup {
2506 group_id: i64,
2507 group_name: String,
2508 #[serde(skip_serializing_if = "Option::is_none")]
2509 updated_at: Option<String>,
2510 teams: Vec<ExternalGroupTeams>,
2511 members: Vec<ExternalGroupMembers>,
2512 }
2513
2514 #[derive(Debug, Serialize, Deserialize)]
2515 pub struct ExternalGroupsGroups {
2516 group_id: i64,
2517 group_name: String,
2518 updated_at: String,
2519 }
2520
2521 #[derive(Debug, Serialize, Deserialize)]
2522 pub struct ExternalGroups {
2523 #[serde(skip_serializing_if = "Option::is_none")]
2524 groups: Option<Vec<ExternalGroupsGroups>>,
2525 }
2526
2527 #[derive(Debug, Serialize, Deserialize)]
2528 pub struct OrganizationInvitation {
2529 id: i64,
2530 login: Option<String>,
2531 email: Option<String>,
2532 role: String,
2533 created_at: String,
2534 #[serde(skip_serializing_if = "Option::is_none")]
2535 failed_at: Option<String>,
2536 #[serde(skip_serializing_if = "Option::is_none")]
2537 failed_reason: Option<String>,
2538 inviter: crate::components::schemas::SimpleUser,
2540 team_count: i64,
2541 node_id: String,
2542 invitation_teams_url: String,
2543 }
2544
2545 #[derive(Debug, Serialize, Deserialize)]
2546 pub struct OrgHookConfig {
2547 #[serde(skip_serializing_if = "Option::is_none")]
2548 url: Option<String>,
2549 #[serde(skip_serializing_if = "Option::is_none")]
2550 insecure_ssl: Option<String>,
2551 #[serde(skip_serializing_if = "Option::is_none")]
2552 content_type: Option<String>,
2553 #[serde(skip_serializing_if = "Option::is_none")]
2554 secret: Option<String>,
2555 }
2556
2557 #[derive(Debug, Serialize, Deserialize)]
2558 pub struct OrgHook {
2559 id: i64,
2560 url: String,
2561 ping_url: String,
2562 #[serde(skip_serializing_if = "Option::is_none")]
2563 deliveries_url: Option<String>,
2564 name: String,
2565 events: Vec<String>,
2566 active: bool,
2567 config: OrgHookConfig,
2568 updated_at: String,
2569 created_at: String,
2570 #[serde(rename="type")]
2571 type_: String,
2572 }
2573
2574 pub type InteractionGroup = String;
2575
2576 #[derive(Debug, Serialize, Deserialize)]
2577 pub struct InteractionLimitResponse {
2578 limit: crate::components::schemas::InteractionGroup,
2580 origin: String,
2581 expires_at: String,
2582 }
2583
2584 pub type InteractionExpiry = String;
2585
2586 #[derive(Debug, Serialize, Deserialize)]
2587 pub struct InteractionLimit {
2588 limit: crate::components::schemas::InteractionGroup,
2590 #[serde(skip_serializing_if = "Option::is_none")]
2592 expiry: Option<crate::components::schemas::InteractionExpiry>,
2593 }
2594
2595 #[derive(Debug, Serialize, Deserialize)]
2596 pub struct NullableTeamSimple {
2597 id: i64,
2598 node_id: String,
2599 url: String,
2600 members_url: String,
2601 name: String,
2602 description: Option<String>,
2603 permission: String,
2604 #[serde(skip_serializing_if = "Option::is_none")]
2605 privacy: Option<String>,
2606 html_url: String,
2607 repositories_url: String,
2608 slug: String,
2609 #[serde(skip_serializing_if = "Option::is_none")]
2610 ldap_dn: Option<String>,
2611 }
2612
2613 #[derive(Debug, Serialize, Deserialize)]
2614 pub struct TeamPermissions {
2615 pull: bool,
2616 triage: bool,
2617 push: bool,
2618 maintain: bool,
2619 admin: bool,
2620 }
2621
2622 #[derive(Debug, Serialize, Deserialize)]
2623 pub struct Team {
2624 id: i64,
2625 node_id: String,
2626 name: String,
2627 slug: String,
2628 description: Option<String>,
2629 #[serde(skip_serializing_if = "Option::is_none")]
2630 privacy: Option<String>,
2631 permission: String,
2632 #[serde(skip_serializing_if = "Option::is_none")]
2633 permissions: Option<TeamPermissions>,
2634 url: String,
2635 html_url: String,
2636 members_url: String,
2637 repositories_url: String,
2638 parent: crate::components::schemas::NullableTeamSimple,
2640 }
2641
2642 #[derive(Debug, Serialize, Deserialize)]
2643 pub struct OrgMembershipPermissions {
2644 can_create_repository: bool,
2645 }
2646
2647 #[derive(Debug, Serialize, Deserialize)]
2648 pub struct OrgMembership {
2649 url: String,
2650 state: String,
2651 role: String,
2652 organization_url: String,
2653 organization: crate::components::schemas::OrganizationSimple,
2655 user: crate::components::schemas::NullableSimpleUser,
2657 #[serde(skip_serializing_if = "Option::is_none")]
2658 permissions: Option<OrgMembershipPermissions>,
2659 }
2660
2661 #[derive(Debug, Serialize, Deserialize)]
2662 pub struct Migration {
2663 id: i64,
2664 owner: crate::components::schemas::NullableSimpleUser,
2666 guid: String,
2667 state: String,
2668 lock_repositories: bool,
2669 exclude_metadata: bool,
2670 exclude_git_data: bool,
2671 exclude_attachments: bool,
2672 exclude_releases: bool,
2673 exclude_owner_projects: bool,
2674 repositories: Vec<crate::components::schemas::Repository>,
2675 url: String,
2676 created_at: String,
2677 updated_at: String,
2678 node_id: String,
2679 #[serde(skip_serializing_if = "Option::is_none")]
2680 archive_url: Option<String>,
2681 #[serde(skip_serializing_if = "Option::is_none")]
2682 exclude: Option<Vec<HashMap<String, String>>>,
2683 }
2684
2685 #[derive(Debug, Serialize, Deserialize)]
2686 pub struct NullableMinimalRepositoryPermissions {
2687 #[serde(skip_serializing_if = "Option::is_none")]
2688 admin: Option<bool>,
2689 #[serde(skip_serializing_if = "Option::is_none")]
2690 maintain: Option<bool>,
2691 #[serde(skip_serializing_if = "Option::is_none")]
2692 push: Option<bool>,
2693 #[serde(skip_serializing_if = "Option::is_none")]
2694 triage: Option<bool>,
2695 #[serde(skip_serializing_if = "Option::is_none")]
2696 pull: Option<bool>,
2697 }
2698
2699 #[derive(Debug, Serialize, Deserialize)]
2700 pub struct NullableMinimalRepositoryLicense {
2701 #[serde(skip_serializing_if = "Option::is_none")]
2702 key: Option<String>,
2703 #[serde(skip_serializing_if = "Option::is_none")]
2704 name: Option<String>,
2705 #[serde(skip_serializing_if = "Option::is_none")]
2706 spdx_id: Option<String>,
2707 #[serde(skip_serializing_if = "Option::is_none")]
2708 url: Option<String>,
2709 #[serde(skip_serializing_if = "Option::is_none")]
2710 node_id: Option<String>,
2711 }
2712
2713 #[derive(Debug, Serialize, Deserialize)]
2714 pub struct NullableMinimalRepository {
2715 id: i64,
2716 node_id: String,
2717 name: String,
2718 full_name: String,
2719 owner: crate::components::schemas::SimpleUser,
2721 private: bool,
2722 html_url: String,
2723 description: Option<String>,
2724 fork: bool,
2725 url: String,
2726 archive_url: String,
2727 assignees_url: String,
2728 blobs_url: String,
2729 branches_url: String,
2730 collaborators_url: String,
2731 comments_url: String,
2732 commits_url: String,
2733 compare_url: String,
2734 contents_url: String,
2735 contributors_url: String,
2736 deployments_url: String,
2737 downloads_url: String,
2738 events_url: String,
2739 forks_url: String,
2740 git_commits_url: String,
2741 git_refs_url: String,
2742 git_tags_url: String,
2743 #[serde(skip_serializing_if = "Option::is_none")]
2744 git_url: Option<String>,
2745 issue_comment_url: String,
2746 issue_events_url: String,
2747 issues_url: String,
2748 keys_url: String,
2749 labels_url: String,
2750 languages_url: String,
2751 merges_url: String,
2752 milestones_url: String,
2753 notifications_url: String,
2754 pulls_url: String,
2755 releases_url: String,
2756 #[serde(skip_serializing_if = "Option::is_none")]
2757 ssh_url: Option<String>,
2758 stargazers_url: String,
2759 statuses_url: String,
2760 subscribers_url: String,
2761 subscription_url: String,
2762 tags_url: String,
2763 teams_url: String,
2764 trees_url: String,
2765 #[serde(skip_serializing_if = "Option::is_none")]
2766 clone_url: Option<String>,
2767 #[serde(skip_serializing_if = "Option::is_none")]
2768 mirror_url: Option<String>,
2769 hooks_url: String,
2770 #[serde(skip_serializing_if = "Option::is_none")]
2771 svn_url: Option<String>,
2772 #[serde(skip_serializing_if = "Option::is_none")]
2773 homepage: Option<String>,
2774 #[serde(skip_serializing_if = "Option::is_none")]
2775 language: Option<String>,
2776 #[serde(skip_serializing_if = "Option::is_none")]
2777 forks_count: Option<i64>,
2778 #[serde(skip_serializing_if = "Option::is_none")]
2779 stargazers_count: Option<i64>,
2780 #[serde(skip_serializing_if = "Option::is_none")]
2781 watchers_count: Option<i64>,
2782 #[serde(skip_serializing_if = "Option::is_none")]
2783 size: Option<i64>,
2784 #[serde(skip_serializing_if = "Option::is_none")]
2785 default_branch: Option<String>,
2786 #[serde(skip_serializing_if = "Option::is_none")]
2787 open_issues_count: Option<i64>,
2788 #[serde(skip_serializing_if = "Option::is_none")]
2789 is_template: Option<bool>,
2790 #[serde(skip_serializing_if = "Option::is_none")]
2791 topics: Option<Vec<String>>,
2792 #[serde(skip_serializing_if = "Option::is_none")]
2793 has_issues: Option<bool>,
2794 #[serde(skip_serializing_if = "Option::is_none")]
2795 has_projects: Option<bool>,
2796 #[serde(skip_serializing_if = "Option::is_none")]
2797 has_wiki: Option<bool>,
2798 #[serde(skip_serializing_if = "Option::is_none")]
2799 has_pages: Option<bool>,
2800 #[serde(skip_serializing_if = "Option::is_none")]
2801 has_downloads: Option<bool>,
2802 #[serde(skip_serializing_if = "Option::is_none")]
2803 archived: Option<bool>,
2804 #[serde(skip_serializing_if = "Option::is_none")]
2805 disabled: Option<bool>,
2806 #[serde(skip_serializing_if = "Option::is_none")]
2807 visibility: Option<String>,
2808 #[serde(skip_serializing_if = "Option::is_none")]
2809 pushed_at: Option<String>,
2810 #[serde(skip_serializing_if = "Option::is_none")]
2811 created_at: Option<String>,
2812 #[serde(skip_serializing_if = "Option::is_none")]
2813 updated_at: Option<String>,
2814 #[serde(skip_serializing_if = "Option::is_none")]
2815 permissions: Option<NullableMinimalRepositoryPermissions>,
2816 #[serde(skip_serializing_if = "Option::is_none")]
2817 role_name: Option<String>,
2818 #[serde(skip_serializing_if = "Option::is_none")]
2820 template_repository: Option<crate::components::schemas::NullableRepository>,
2821 #[serde(skip_serializing_if = "Option::is_none")]
2822 temp_clone_token: Option<String>,
2823 #[serde(skip_serializing_if = "Option::is_none")]
2824 delete_branch_on_merge: Option<bool>,
2825 #[serde(skip_serializing_if = "Option::is_none")]
2826 subscribers_count: Option<i64>,
2827 #[serde(skip_serializing_if = "Option::is_none")]
2828 network_count: Option<i64>,
2829 #[serde(skip_serializing_if = "Option::is_none")]
2831 code_of_conduct: Option<crate::components::schemas::CodeOfConduct>,
2832 #[serde(skip_serializing_if = "Option::is_none")]
2833 license: Option<NullableMinimalRepositoryLicense>,
2834 #[serde(skip_serializing_if = "Option::is_none")]
2835 forks: Option<i64>,
2836 #[serde(skip_serializing_if = "Option::is_none")]
2837 open_issues: Option<i64>,
2838 #[serde(skip_serializing_if = "Option::is_none")]
2839 watchers: Option<i64>,
2840 #[serde(skip_serializing_if = "Option::is_none")]
2841 allow_forking: Option<bool>,
2842 }
2843
2844 #[derive(Debug, Serialize, Deserialize)]
2845 pub struct Package {
2846 id: i64,
2847 name: String,
2848 package_type: String,
2849 url: String,
2850 html_url: String,
2851 version_count: i64,
2852 visibility: String,
2853 #[serde(skip_serializing_if = "Option::is_none")]
2855 owner: Option<crate::components::schemas::NullableSimpleUser>,
2856 #[serde(skip_serializing_if = "Option::is_none")]
2858 repository: Option<crate::components::schemas::NullableMinimalRepository>,
2859 created_at: String,
2860 updated_at: String,
2861 }
2862
2863 #[derive(Debug, Serialize, Deserialize)]
2864 pub struct PackageVersionMetadataContainer {
2865 tags: Vec<String>,
2866 }
2867
2868 #[derive(Debug, Serialize, Deserialize)]
2869 pub struct PackageVersionMetadataDocker {
2870 #[serde(skip_serializing_if = "Option::is_none")]
2871 tag: Option<Vec<String>>,
2872 }
2873
2874 #[derive(Debug, Serialize, Deserialize)]
2875 pub struct PackageVersionMetadata {
2876 package_type: String,
2877 #[serde(skip_serializing_if = "Option::is_none")]
2878 container: Option<PackageVersionMetadataContainer>,
2879 #[serde(skip_serializing_if = "Option::is_none")]
2880 docker: Option<PackageVersionMetadataDocker>,
2881 }
2882
2883 #[derive(Debug, Serialize, Deserialize)]
2884 pub struct PackageVersion {
2885 id: i64,
2886 name: String,
2887 url: String,
2888 package_html_url: String,
2889 #[serde(skip_serializing_if = "Option::is_none")]
2890 html_url: Option<String>,
2891 #[serde(skip_serializing_if = "Option::is_none")]
2892 license: Option<String>,
2893 #[serde(skip_serializing_if = "Option::is_none")]
2894 description: Option<String>,
2895 created_at: String,
2896 updated_at: String,
2897 #[serde(skip_serializing_if = "Option::is_none")]
2898 deleted_at: Option<String>,
2899 #[serde(skip_serializing_if = "Option::is_none")]
2900 metadata: Option<PackageVersionMetadata>,
2901 }
2902
2903 #[derive(Debug, Serialize, Deserialize)]
2904 pub struct Project {
2905 owner_url: String,
2906 url: String,
2907 html_url: String,
2908 columns_url: String,
2909 id: i64,
2910 node_id: String,
2911 name: String,
2912 body: Option<String>,
2913 number: i64,
2914 state: String,
2915 creator: crate::components::schemas::NullableSimpleUser,
2917 created_at: String,
2918 updated_at: String,
2919 #[serde(skip_serializing_if = "Option::is_none")]
2920 organization_permission: Option<String>,
2921 #[serde(skip_serializing_if = "Option::is_none")]
2922 private: Option<bool>,
2923 }
2924
2925 pub type AlertNumber = i64;
2926
2927 pub type AlertCreatedAt = String;
2928
2929 pub type AlertUrl = String;
2930
2931 pub type AlertHtmlUrl = String;
2932
2933 pub type SecretScanningAlertState = String;
2934
2935 pub type SecretScanningAlertResolution = HashMap<String, String>;
2936
2937 #[derive(Debug, Serialize, Deserialize)]
2938 pub struct OrganizationSecretScanningAlert {
2939 #[serde(skip_serializing_if = "Option::is_none")]
2941 number: Option<crate::components::schemas::AlertNumber>,
2942 #[serde(skip_serializing_if = "Option::is_none")]
2944 created_at: Option<crate::components::schemas::AlertCreatedAt>,
2945 #[serde(skip_serializing_if = "Option::is_none")]
2947 url: Option<crate::components::schemas::AlertUrl>,
2948 #[serde(skip_serializing_if = "Option::is_none")]
2950 html_url: Option<crate::components::schemas::AlertHtmlUrl>,
2951 #[serde(skip_serializing_if = "Option::is_none")]
2952 locations_url: Option<String>,
2953 #[serde(skip_serializing_if = "Option::is_none")]
2955 state: Option<crate::components::schemas::SecretScanningAlertState>,
2956 #[serde(skip_serializing_if = "Option::is_none")]
2958 resolution: Option<crate::components::schemas::SecretScanningAlertResolution>,
2959 #[serde(skip_serializing_if = "Option::is_none")]
2960 resolved_at: Option<String>,
2961 #[serde(skip_serializing_if = "Option::is_none")]
2963 resolved_by: Option<crate::components::schemas::NullableSimpleUser>,
2964 #[serde(skip_serializing_if = "Option::is_none")]
2965 secret_type: Option<String>,
2966 #[serde(skip_serializing_if = "Option::is_none")]
2967 secret: Option<String>,
2968 #[serde(skip_serializing_if = "Option::is_none")]
2970 repository: Option<crate::components::schemas::MinimalRepository>,
2971 }
2972
2973 #[derive(Debug, Serialize, Deserialize)]
2974 pub struct GroupMappingGroups {
2975 group_id: String,
2976 group_name: String,
2977 group_description: String,
2978 #[serde(skip_serializing_if = "Option::is_none")]
2979 status: Option<String>,
2980 #[serde(skip_serializing_if = "Option::is_none")]
2981 synced_at: Option<String>,
2982 }
2983
2984 #[derive(Debug, Serialize, Deserialize)]
2985 pub struct GroupMapping {
2986 #[serde(skip_serializing_if = "Option::is_none")]
2987 groups: Option<Vec<GroupMappingGroups>>,
2988 }
2989
2990 #[derive(Debug, Serialize, Deserialize)]
2991 pub struct TeamFull {
2992 id: i64,
2993 node_id: String,
2994 url: String,
2995 html_url: String,
2996 name: String,
2997 slug: String,
2998 description: Option<String>,
2999 #[serde(skip_serializing_if = "Option::is_none")]
3000 privacy: Option<String>,
3001 permission: String,
3002 members_url: String,
3003 repositories_url: String,
3004 #[serde(skip_serializing_if = "Option::is_none")]
3006 parent: Option<crate::components::schemas::NullableTeamSimple>,
3007 members_count: i64,
3008 repos_count: i64,
3009 created_at: String,
3010 updated_at: String,
3011 organization: crate::components::schemas::OrganizationFull,
3013 #[serde(skip_serializing_if = "Option::is_none")]
3014 ldap_dn: Option<String>,
3015 }
3016
3017 #[derive(Debug, Serialize, Deserialize)]
3018 pub struct TeamDiscussion {
3019 author: crate::components::schemas::NullableSimpleUser,
3021 body: String,
3022 body_html: String,
3023 body_version: String,
3024 comments_count: i64,
3025 comments_url: String,
3026 created_at: String,
3027 last_edited_at: Option<String>,
3028 html_url: String,
3029 node_id: String,
3030 number: i64,
3031 pinned: bool,
3032 private: bool,
3033 team_url: String,
3034 title: String,
3035 updated_at: String,
3036 url: String,
3037 #[serde(skip_serializing_if = "Option::is_none")]
3039 reactions: Option<crate::components::schemas::ReactionRollup>,
3040 }
3041
3042 #[derive(Debug, Serialize, Deserialize)]
3043 pub struct TeamDiscussionComment {
3044 author: crate::components::schemas::NullableSimpleUser,
3046 body: String,
3047 body_html: String,
3048 body_version: String,
3049 created_at: String,
3050 last_edited_at: Option<String>,
3051 discussion_url: String,
3052 html_url: String,
3053 node_id: String,
3054 number: i64,
3055 updated_at: String,
3056 url: String,
3057 #[serde(skip_serializing_if = "Option::is_none")]
3059 reactions: Option<crate::components::schemas::ReactionRollup>,
3060 }
3061
3062 #[derive(Debug, Serialize, Deserialize)]
3063 pub struct Reaction {
3064 id: i64,
3065 node_id: String,
3066 user: crate::components::schemas::NullableSimpleUser,
3068 content: String,
3069 created_at: String,
3070 }
3071
3072 #[derive(Debug, Serialize, Deserialize)]
3073 pub struct TeamMembership {
3074 url: String,
3075 role: String,
3076 state: String,
3077 }
3078
3079 #[derive(Debug, Serialize, Deserialize)]
3080 pub struct TeamProjectPermissions {
3081 read: bool,
3082 write: bool,
3083 admin: bool,
3084 }
3085
3086 #[derive(Debug, Serialize, Deserialize)]
3087 pub struct TeamProject {
3088 owner_url: String,
3089 url: String,
3090 html_url: String,
3091 columns_url: String,
3092 id: i64,
3093 node_id: String,
3094 name: String,
3095 body: Option<String>,
3096 number: i64,
3097 state: String,
3098 creator: crate::components::schemas::SimpleUser,
3100 created_at: String,
3101 updated_at: String,
3102 #[serde(skip_serializing_if = "Option::is_none")]
3103 organization_permission: Option<String>,
3104 #[serde(skip_serializing_if = "Option::is_none")]
3105 private: Option<bool>,
3106 permissions: TeamProjectPermissions,
3107 }
3108
3109 #[derive(Debug, Serialize, Deserialize)]
3110 pub struct TeamRepositoryPermissions {
3111 admin: bool,
3112 pull: bool,
3113 #[serde(skip_serializing_if = "Option::is_none")]
3114 triage: Option<bool>,
3115 push: bool,
3116 #[serde(skip_serializing_if = "Option::is_none")]
3117 maintain: Option<bool>,
3118 }
3119
3120 #[derive(Debug, Serialize, Deserialize)]
3121 pub struct TeamRepository {
3122 id: i64,
3123 node_id: String,
3124 name: String,
3125 full_name: String,
3126 license: crate::components::schemas::NullableLicenseSimple,
3128 forks: i64,
3129 #[serde(skip_serializing_if = "Option::is_none")]
3130 permissions: Option<TeamRepositoryPermissions>,
3131 #[serde(skip_serializing_if = "Option::is_none")]
3132 role_name: Option<String>,
3133 owner: crate::components::schemas::NullableSimpleUser,
3135 private: bool,
3136 html_url: String,
3137 description: Option<String>,
3138 fork: bool,
3139 url: String,
3140 archive_url: String,
3141 assignees_url: String,
3142 blobs_url: String,
3143 branches_url: String,
3144 collaborators_url: String,
3145 comments_url: String,
3146 commits_url: String,
3147 compare_url: String,
3148 contents_url: String,
3149 contributors_url: String,
3150 deployments_url: String,
3151 downloads_url: String,
3152 events_url: String,
3153 forks_url: String,
3154 git_commits_url: String,
3155 git_refs_url: String,
3156 git_tags_url: String,
3157 git_url: String,
3158 issue_comment_url: String,
3159 issue_events_url: String,
3160 issues_url: String,
3161 keys_url: String,
3162 labels_url: String,
3163 languages_url: String,
3164 merges_url: String,
3165 milestones_url: String,
3166 notifications_url: String,
3167 pulls_url: String,
3168 releases_url: String,
3169 ssh_url: String,
3170 stargazers_url: String,
3171 statuses_url: String,
3172 subscribers_url: String,
3173 subscription_url: String,
3174 tags_url: String,
3175 teams_url: String,
3176 trees_url: String,
3177 clone_url: String,
3178 mirror_url: Option<String>,
3179 hooks_url: String,
3180 svn_url: String,
3181 homepage: Option<String>,
3182 language: Option<String>,
3183 forks_count: i64,
3184 stargazers_count: i64,
3185 watchers_count: i64,
3186 size: i64,
3187 default_branch: String,
3188 open_issues_count: i64,
3189 #[serde(skip_serializing_if = "Option::is_none")]
3190 is_template: Option<bool>,
3191 #[serde(skip_serializing_if = "Option::is_none")]
3192 topics: Option<Vec<String>>,
3193 has_issues: bool,
3194 has_projects: bool,
3195 has_wiki: bool,
3196 has_pages: bool,
3197 has_downloads: bool,
3198 archived: bool,
3199 disabled: bool,
3200 #[serde(skip_serializing_if = "Option::is_none")]
3201 visibility: Option<String>,
3202 pushed_at: Option<String>,
3203 created_at: Option<String>,
3204 updated_at: Option<String>,
3205 #[serde(skip_serializing_if = "Option::is_none")]
3206 allow_rebase_merge: Option<bool>,
3207 #[serde(skip_serializing_if = "Option::is_none")]
3209 template_repository: Option<crate::components::schemas::NullableRepository>,
3210 #[serde(skip_serializing_if = "Option::is_none")]
3211 temp_clone_token: Option<String>,
3212 #[serde(skip_serializing_if = "Option::is_none")]
3213 allow_squash_merge: Option<bool>,
3214 #[serde(skip_serializing_if = "Option::is_none")]
3215 allow_auto_merge: Option<bool>,
3216 #[serde(skip_serializing_if = "Option::is_none")]
3217 delete_branch_on_merge: Option<bool>,
3218 #[serde(skip_serializing_if = "Option::is_none")]
3219 allow_merge_commit: Option<bool>,
3220 #[serde(skip_serializing_if = "Option::is_none")]
3221 allow_forking: Option<bool>,
3222 #[serde(skip_serializing_if = "Option::is_none")]
3223 subscribers_count: Option<i64>,
3224 #[serde(skip_serializing_if = "Option::is_none")]
3225 network_count: Option<i64>,
3226 open_issues: i64,
3227 watchers: i64,
3228 #[serde(skip_serializing_if = "Option::is_none")]
3229 master_branch: Option<String>,
3230 }
3231
3232 #[derive(Debug, Serialize, Deserialize)]
3233 pub struct ProjectCard {
3234 url: String,
3235 id: i64,
3236 node_id: String,
3237 note: Option<String>,
3238 creator: crate::components::schemas::NullableSimpleUser,
3240 created_at: String,
3241 updated_at: String,
3242 #[serde(skip_serializing_if = "Option::is_none")]
3243 archived: Option<bool>,
3244 #[serde(skip_serializing_if = "Option::is_none")]
3245 column_name: Option<String>,
3246 #[serde(skip_serializing_if = "Option::is_none")]
3247 project_id: Option<String>,
3248 column_url: String,
3249 #[serde(skip_serializing_if = "Option::is_none")]
3250 content_url: Option<String>,
3251 project_url: String,
3252 }
3253
3254 #[derive(Debug, Serialize, Deserialize)]
3255 pub struct ProjectColumn {
3256 url: String,
3257 project_url: String,
3258 cards_url: String,
3259 id: i64,
3260 node_id: String,
3261 name: String,
3262 created_at: String,
3263 updated_at: String,
3264 }
3265
3266 #[derive(Debug, Serialize, Deserialize)]
3267 pub struct ProjectCollaboratorPermission {
3268 permission: String,
3269 user: crate::components::schemas::NullableSimpleUser,
3271 }
3272
3273 #[derive(Debug, Serialize, Deserialize)]
3274 pub struct RateLimit {
3275 limit: i64,
3276 remaining: i64,
3277 reset: i64,
3278 used: i64,
3279 }
3280
3281 #[derive(Debug, Serialize, Deserialize)]
3282 pub struct RateLimitOverviewResources {
3283 core: crate::components::schemas::RateLimit,
3285 #[serde(skip_serializing_if = "Option::is_none")]
3287 graphql: Option<crate::components::schemas::RateLimit>,
3288 search: crate::components::schemas::RateLimit,
3290 #[serde(skip_serializing_if = "Option::is_none")]
3292 source_import: Option<crate::components::schemas::RateLimit>,
3293 #[serde(skip_serializing_if = "Option::is_none")]
3295 integration_manifest: Option<crate::components::schemas::RateLimit>,
3296 #[serde(skip_serializing_if = "Option::is_none")]
3298 code_scanning_upload: Option<crate::components::schemas::RateLimit>,
3299 #[serde(skip_serializing_if = "Option::is_none")]
3301 actions_runner_registration: Option<crate::components::schemas::RateLimit>,
3302 }
3303
3304 #[derive(Debug, Serialize, Deserialize)]
3305 pub struct RateLimitOverview {
3306 resources: RateLimitOverviewResources,
3307 rate: crate::components::schemas::RateLimit,
3309 }
3310
3311 #[derive(Debug, Serialize, Deserialize)]
3312 pub struct CodeOfConductSimple {
3313 url: String,
3314 key: String,
3315 name: String,
3316 html_url: Option<String>,
3317 }
3318
3319 #[derive(Debug, Serialize, Deserialize)]
3320 pub struct FullRepositoryPermissions {
3321 admin: bool,
3322 #[serde(skip_serializing_if = "Option::is_none")]
3323 maintain: Option<bool>,
3324 push: bool,
3325 #[serde(skip_serializing_if = "Option::is_none")]
3326 triage: Option<bool>,
3327 pull: bool,
3328 }
3329
3330 #[derive(Debug, Serialize, Deserialize)]
3331 pub struct FullRepositorySecurityAndAnalysisAdvancedSecurity {
3332 #[serde(skip_serializing_if = "Option::is_none")]
3333 status: Option<String>,
3334 }
3335
3336 #[derive(Debug, Serialize, Deserialize)]
3337 pub struct FullRepositorySecurityAndAnalysisSecretScanning {
3338 #[serde(skip_serializing_if = "Option::is_none")]
3339 status: Option<String>,
3340 }
3341
3342 #[derive(Debug, Serialize, Deserialize)]
3343 pub struct FullRepositorySecurityAndAnalysis {
3344 #[serde(skip_serializing_if = "Option::is_none")]
3345 advanced_security: Option<FullRepositorySecurityAndAnalysisAdvancedSecurity>,
3346 #[serde(skip_serializing_if = "Option::is_none")]
3347 secret_scanning: Option<FullRepositorySecurityAndAnalysisSecretScanning>,
3348 }
3349
3350 #[derive(Debug, Serialize, Deserialize)]
3351 pub struct FullRepository {
3352 id: i64,
3353 node_id: String,
3354 name: String,
3355 full_name: String,
3356 owner: crate::components::schemas::SimpleUser,
3358 private: bool,
3359 html_url: String,
3360 description: Option<String>,
3361 fork: bool,
3362 url: String,
3363 archive_url: String,
3364 assignees_url: String,
3365 blobs_url: String,
3366 branches_url: String,
3367 collaborators_url: String,
3368 comments_url: String,
3369 commits_url: String,
3370 compare_url: String,
3371 contents_url: String,
3372 contributors_url: String,
3373 deployments_url: String,
3374 downloads_url: String,
3375 events_url: String,
3376 forks_url: String,
3377 git_commits_url: String,
3378 git_refs_url: String,
3379 git_tags_url: String,
3380 git_url: String,
3381 issue_comment_url: String,
3382 issue_events_url: String,
3383 issues_url: String,
3384 keys_url: String,
3385 labels_url: String,
3386 languages_url: String,
3387 merges_url: String,
3388 milestones_url: String,
3389 notifications_url: String,
3390 pulls_url: String,
3391 releases_url: String,
3392 ssh_url: String,
3393 stargazers_url: String,
3394 statuses_url: String,
3395 subscribers_url: String,
3396 subscription_url: String,
3397 tags_url: String,
3398 teams_url: String,
3399 trees_url: String,
3400 clone_url: String,
3401 mirror_url: Option<String>,
3402 hooks_url: String,
3403 svn_url: String,
3404 homepage: Option<String>,
3405 language: Option<String>,
3406 forks_count: i64,
3407 stargazers_count: i64,
3408 watchers_count: i64,
3409 size: i64,
3410 default_branch: String,
3411 open_issues_count: i64,
3412 #[serde(skip_serializing_if = "Option::is_none")]
3413 is_template: Option<bool>,
3414 #[serde(skip_serializing_if = "Option::is_none")]
3415 topics: Option<Vec<String>>,
3416 has_issues: bool,
3417 has_projects: bool,
3418 has_wiki: bool,
3419 has_pages: bool,
3420 has_downloads: bool,
3421 archived: bool,
3422 disabled: bool,
3423 #[serde(skip_serializing_if = "Option::is_none")]
3424 visibility: Option<String>,
3425 pushed_at: String,
3426 created_at: String,
3427 updated_at: String,
3428 #[serde(skip_serializing_if = "Option::is_none")]
3429 permissions: Option<FullRepositoryPermissions>,
3430 #[serde(skip_serializing_if = "Option::is_none")]
3431 allow_rebase_merge: Option<bool>,
3432 #[serde(skip_serializing_if = "Option::is_none")]
3434 template_repository: Option<crate::components::schemas::NullableRepository>,
3435 #[serde(skip_serializing_if = "Option::is_none")]
3436 temp_clone_token: Option<String>,
3437 #[serde(skip_serializing_if = "Option::is_none")]
3438 allow_squash_merge: Option<bool>,
3439 #[serde(skip_serializing_if = "Option::is_none")]
3440 allow_auto_merge: Option<bool>,
3441 #[serde(skip_serializing_if = "Option::is_none")]
3442 delete_branch_on_merge: Option<bool>,
3443 #[serde(skip_serializing_if = "Option::is_none")]
3444 allow_merge_commit: Option<bool>,
3445 #[serde(skip_serializing_if = "Option::is_none")]
3446 allow_forking: Option<bool>,
3447 subscribers_count: i64,
3448 network_count: i64,
3449 license: crate::components::schemas::NullableLicenseSimple,
3451 #[serde(skip_serializing_if = "Option::is_none")]
3453 organization: Option<crate::components::schemas::NullableSimpleUser>,
3454 #[serde(skip_serializing_if = "Option::is_none")]
3456 parent: Option<crate::components::schemas::Repository>,
3457 #[serde(skip_serializing_if = "Option::is_none")]
3459 source: Option<crate::components::schemas::Repository>,
3460 forks: i64,
3461 #[serde(skip_serializing_if = "Option::is_none")]
3462 master_branch: Option<String>,
3463 open_issues: i64,
3464 watchers: i64,
3465 #[serde(skip_serializing_if = "Option::is_none")]
3466 anonymous_access_enabled: Option<bool>,
3467 #[serde(skip_serializing_if = "Option::is_none")]
3469 code_of_conduct: Option<crate::components::schemas::CodeOfConductSimple>,
3470 #[serde(skip_serializing_if = "Option::is_none")]
3471 security_and_analysis: Option<FullRepositorySecurityAndAnalysis>,
3472 }
3473
3474 #[derive(Debug, Serialize, Deserialize)]
3475 pub struct Artifact {
3476 id: i64,
3477 node_id: String,
3478 name: String,
3479 size_in_bytes: i64,
3480 url: String,
3481 archive_download_url: String,
3482 expired: bool,
3483 created_at: Option<String>,
3484 expires_at: Option<String>,
3485 updated_at: Option<String>,
3486 }
3487
3488 #[derive(Debug, Serialize, Deserialize)]
3489 pub struct JobSteps {
3490 status: String,
3491 conclusion: Option<String>,
3492 name: String,
3493 number: i64,
3494 #[serde(skip_serializing_if = "Option::is_none")]
3495 started_at: Option<String>,
3496 #[serde(skip_serializing_if = "Option::is_none")]
3497 completed_at: Option<String>,
3498 }
3499
3500 #[derive(Debug, Serialize, Deserialize)]
3501 pub struct Job {
3502 id: i64,
3503 run_id: i64,
3504 run_url: String,
3505 #[serde(skip_serializing_if = "Option::is_none")]
3506 run_attempt: Option<i64>,
3507 node_id: String,
3508 head_sha: String,
3509 url: String,
3510 html_url: Option<String>,
3511 status: String,
3512 conclusion: Option<String>,
3513 started_at: String,
3514 completed_at: Option<String>,
3515 name: String,
3516 #[serde(skip_serializing_if = "Option::is_none")]
3517 steps: Option<Vec<JobSteps>>,
3518 check_run_url: String,
3519 labels: Vec<String>,
3520 runner_id: Option<i64>,
3521 runner_name: Option<String>,
3522 runner_group_id: Option<i64>,
3523 runner_group_name: Option<String>,
3524 }
3525
3526 pub type ActionsEnabled = bool;
3527
3528 #[derive(Debug, Serialize, Deserialize)]
3529 pub struct ActionsRepositoryPermissions {
3530 enabled: crate::components::schemas::ActionsEnabled,
3532 #[serde(skip_serializing_if = "Option::is_none")]
3534 allowed_actions: Option<crate::components::schemas::AllowedActions>,
3535 #[serde(skip_serializing_if = "Option::is_none")]
3537 selected_actions_url: Option<crate::components::schemas::SelectedActionsUrl>,
3538 }
3539
3540 #[derive(Debug, Serialize, Deserialize)]
3541 pub struct PullRequestMinimalHeadRepo {
3542 id: i64,
3543 url: String,
3544 name: String,
3545 }
3546
3547 #[derive(Debug, Serialize, Deserialize)]
3548 pub struct PullRequestMinimalHead {
3549 #[serde(rename="ref")]
3550 ref_: String,
3551 sha: String,
3552 repo: PullRequestMinimalHeadRepo,
3553 }
3554
3555 #[derive(Debug, Serialize, Deserialize)]
3556 pub struct PullRequestMinimalBaseRepo {
3557 id: i64,
3558 url: String,
3559 name: String,
3560 }
3561
3562 #[derive(Debug, Serialize, Deserialize)]
3563 pub struct PullRequestMinimalBase {
3564 #[serde(rename="ref")]
3565 ref_: String,
3566 sha: String,
3567 repo: PullRequestMinimalBaseRepo,
3568 }
3569
3570 #[derive(Debug, Serialize, Deserialize)]
3571 pub struct PullRequestMinimal {
3572 id: i64,
3573 number: i64,
3574 url: String,
3575 head: PullRequestMinimalHead,
3576 base: PullRequestMinimalBase,
3577 }
3578
3579 #[derive(Debug, Serialize, Deserialize)]
3580 pub struct NullableSimpleCommitAuthor {
3581 name: String,
3582 email: String,
3583 }
3584
3585 #[derive(Debug, Serialize, Deserialize)]
3586 pub struct NullableSimpleCommitCommitter {
3587 name: String,
3588 email: String,
3589 }
3590
3591 #[derive(Debug, Serialize, Deserialize)]
3592 pub struct NullableSimpleCommit {
3593 id: String,
3594 tree_id: String,
3595 message: String,
3596 timestamp: String,
3597 author: Option<NullableSimpleCommitAuthor>,
3598 committer: Option<NullableSimpleCommitCommitter>,
3599 }
3600
3601 #[derive(Debug, Serialize, Deserialize)]
3602 pub struct WorkflowRun {
3603 id: i64,
3604 #[serde(skip_serializing_if = "Option::is_none")]
3605 name: Option<String>,
3606 node_id: String,
3607 #[serde(skip_serializing_if = "Option::is_none")]
3608 check_suite_id: Option<i64>,
3609 #[serde(skip_serializing_if = "Option::is_none")]
3610 check_suite_node_id: Option<String>,
3611 head_branch: Option<String>,
3612 head_sha: String,
3613 run_number: i64,
3614 #[serde(skip_serializing_if = "Option::is_none")]
3615 run_attempt: Option<i64>,
3616 event: String,
3617 status: Option<String>,
3618 conclusion: Option<String>,
3619 workflow_id: i64,
3620 url: String,
3621 html_url: String,
3622 pull_requests: Option<Vec<crate::components::schemas::PullRequestMinimal>>,
3623 created_at: String,
3624 updated_at: String,
3625 #[serde(skip_serializing_if = "Option::is_none")]
3626 run_started_at: Option<String>,
3627 jobs_url: String,
3628 logs_url: String,
3629 check_suite_url: String,
3630 artifacts_url: String,
3631 cancel_url: String,
3632 rerun_url: String,
3633 #[serde(skip_serializing_if = "Option::is_none")]
3634 previous_attempt_url: Option<String>,
3635 workflow_url: String,
3636 head_commit: crate::components::schemas::NullableSimpleCommit,
3638 repository: crate::components::schemas::MinimalRepository,
3640 head_repository: crate::components::schemas::MinimalRepository,
3642 #[serde(skip_serializing_if = "Option::is_none")]
3643 head_repository_id: Option<i64>,
3644 }
3645
3646 #[derive(Debug, Serialize, Deserialize)]
3647 pub struct EnvironmentApprovalsEnvironments {
3648 #[serde(skip_serializing_if = "Option::is_none")]
3649 id: Option<i64>,
3650 #[serde(skip_serializing_if = "Option::is_none")]
3651 node_id: Option<String>,
3652 #[serde(skip_serializing_if = "Option::is_none")]
3653 name: Option<String>,
3654 #[serde(skip_serializing_if = "Option::is_none")]
3655 url: Option<String>,
3656 #[serde(skip_serializing_if = "Option::is_none")]
3657 html_url: Option<String>,
3658 #[serde(skip_serializing_if = "Option::is_none")]
3659 created_at: Option<String>,
3660 #[serde(skip_serializing_if = "Option::is_none")]
3661 updated_at: Option<String>,
3662 }
3663
3664 #[derive(Debug, Serialize, Deserialize)]
3665 pub struct EnvironmentApprovals {
3666 environments: Vec<EnvironmentApprovalsEnvironments>,
3667 state: String,
3668 user: crate::components::schemas::SimpleUser,
3670 comment: String,
3671 }
3672
3673 pub type DeploymentReviewerType = String;
3674
3675 #[derive(Debug, Serialize, Deserialize)]
3676 pub struct PendingDeploymentEnvironment {
3677 #[serde(skip_serializing_if = "Option::is_none")]
3678 id: Option<i64>,
3679 #[serde(skip_serializing_if = "Option::is_none")]
3680 node_id: Option<String>,
3681 #[serde(skip_serializing_if = "Option::is_none")]
3682 name: Option<String>,
3683 #[serde(skip_serializing_if = "Option::is_none")]
3684 url: Option<String>,
3685 #[serde(skip_serializing_if = "Option::is_none")]
3686 html_url: Option<String>,
3687 }
3688
3689 #[derive(Debug, Serialize, Deserialize)]
3691 #[serde(untagged)]
3692 pub enum PendingDeploymentReviewersReviewerOneOf {
3693 SimpleUser(crate::components::schemas::SimpleUser),
3694 Team(crate::components::schemas::Team),
3695 }
3696
3697 #[derive(Debug, Serialize, Deserialize)]
3698 pub struct PendingDeploymentReviewers {
3699 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
3701 type_: Option<crate::components::schemas::DeploymentReviewerType>,
3702 #[serde(skip_serializing_if = "Option::is_none")]
3703 reviewer: Option<PendingDeploymentReviewersReviewerOneOf>,
3704 }
3705
3706 #[derive(Debug, Serialize, Deserialize)]
3707 pub struct PendingDeployment {
3708 environment: PendingDeploymentEnvironment,
3709 wait_timer: i64,
3710 wait_timer_started_at: Option<String>,
3711 current_user_can_approve: bool,
3712 reviewers: Vec<PendingDeploymentReviewers>,
3713 }
3714
3715 #[derive(Debug, Serialize, Deserialize)]
3716 pub struct DeploymentPayload0;
3717
3718 #[derive(Debug, Serialize, Deserialize)]
3720 #[serde(untagged)]
3721 pub enum DeploymentPayloadOneOf {
3722 DeploymentPayload0(DeploymentPayload0),
3723 String(String),
3724 }
3725
3726 #[derive(Debug, Serialize, Deserialize)]
3727 pub struct Deployment {
3728 url: String,
3729 id: i64,
3730 node_id: String,
3731 sha: String,
3732 #[serde(rename="ref")]
3733 ref_: String,
3734 task: String,
3735 payload: DeploymentPayloadOneOf,
3736 #[serde(skip_serializing_if = "Option::is_none")]
3737 original_environment: Option<String>,
3738 environment: String,
3739 description: Option<String>,
3740 creator: crate::components::schemas::NullableSimpleUser,
3742 created_at: String,
3743 updated_at: String,
3744 statuses_url: String,
3745 repository_url: String,
3746 #[serde(skip_serializing_if = "Option::is_none")]
3747 transient_environment: Option<bool>,
3748 #[serde(skip_serializing_if = "Option::is_none")]
3749 production_environment: Option<bool>,
3750 #[serde(skip_serializing_if = "Option::is_none")]
3752 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
3753 }
3754
3755 #[derive(Debug, Serialize, Deserialize)]
3756 pub struct WorkflowRunUsageBillableUbuntuJobRuns {
3757 job_id: i64,
3758 duration_ms: i64,
3759 }
3760
3761 #[derive(Debug, Serialize, Deserialize)]
3762 pub struct WorkflowRunUsageBillableUbuntu {
3763 total_ms: i64,
3764 jobs: i64,
3765 #[serde(skip_serializing_if = "Option::is_none")]
3766 job_runs: Option<Vec<WorkflowRunUsageBillableUbuntuJobRuns>>,
3767 }
3768
3769 #[derive(Debug, Serialize, Deserialize)]
3770 pub struct WorkflowRunUsageBillableMacosJobRuns {
3771 job_id: i64,
3772 duration_ms: i64,
3773 }
3774
3775 #[derive(Debug, Serialize, Deserialize)]
3776 pub struct WorkflowRunUsageBillableMacos {
3777 total_ms: i64,
3778 jobs: i64,
3779 #[serde(skip_serializing_if = "Option::is_none")]
3780 job_runs: Option<Vec<WorkflowRunUsageBillableMacosJobRuns>>,
3781 }
3782
3783 #[derive(Debug, Serialize, Deserialize)]
3784 pub struct WorkflowRunUsageBillableWindowsJobRuns {
3785 job_id: i64,
3786 duration_ms: i64,
3787 }
3788
3789 #[derive(Debug, Serialize, Deserialize)]
3790 pub struct WorkflowRunUsageBillableWindows {
3791 total_ms: i64,
3792 jobs: i64,
3793 #[serde(skip_serializing_if = "Option::is_none")]
3794 job_runs: Option<Vec<WorkflowRunUsageBillableWindowsJobRuns>>,
3795 }
3796
3797 #[derive(Debug, Serialize, Deserialize)]
3798 pub struct WorkflowRunUsageBillable {
3799 #[serde(rename="UBUNTU", skip_serializing_if = "Option::is_none")]
3800 ubuntu: Option<WorkflowRunUsageBillableUbuntu>,
3801 #[serde(rename="MACOS", skip_serializing_if = "Option::is_none")]
3802 macos: Option<WorkflowRunUsageBillableMacos>,
3803 #[serde(rename="WINDOWS", skip_serializing_if = "Option::is_none")]
3804 windows: Option<WorkflowRunUsageBillableWindows>,
3805 }
3806
3807 #[derive(Debug, Serialize, Deserialize)]
3808 pub struct WorkflowRunUsage {
3809 billable: WorkflowRunUsageBillable,
3810 #[serde(skip_serializing_if = "Option::is_none")]
3811 run_duration_ms: Option<i64>,
3812 }
3813
3814 #[derive(Debug, Serialize, Deserialize)]
3815 pub struct ActionsSecret {
3816 name: String,
3817 created_at: String,
3818 updated_at: String,
3819 }
3820
3821 #[derive(Debug, Serialize, Deserialize)]
3822 pub struct Workflow {
3823 id: i64,
3824 node_id: String,
3825 name: String,
3826 path: String,
3827 state: String,
3828 created_at: String,
3829 updated_at: String,
3830 url: String,
3831 html_url: String,
3832 badge_url: String,
3833 #[serde(skip_serializing_if = "Option::is_none")]
3834 deleted_at: Option<String>,
3835 }
3836
3837 #[derive(Debug, Serialize, Deserialize)]
3838 pub struct WorkflowUsageBillableUbuntu {
3839 #[serde(skip_serializing_if = "Option::is_none")]
3840 total_ms: Option<i64>,
3841 }
3842
3843 #[derive(Debug, Serialize, Deserialize)]
3844 pub struct WorkflowUsageBillableMacos {
3845 #[serde(skip_serializing_if = "Option::is_none")]
3846 total_ms: Option<i64>,
3847 }
3848
3849 #[derive(Debug, Serialize, Deserialize)]
3850 pub struct WorkflowUsageBillableWindows {
3851 #[serde(skip_serializing_if = "Option::is_none")]
3852 total_ms: Option<i64>,
3853 }
3854
3855 #[derive(Debug, Serialize, Deserialize)]
3856 pub struct WorkflowUsageBillable {
3857 #[serde(rename="UBUNTU", skip_serializing_if = "Option::is_none")]
3858 ubuntu: Option<WorkflowUsageBillableUbuntu>,
3859 #[serde(rename="MACOS", skip_serializing_if = "Option::is_none")]
3860 macos: Option<WorkflowUsageBillableMacos>,
3861 #[serde(rename="WINDOWS", skip_serializing_if = "Option::is_none")]
3862 windows: Option<WorkflowUsageBillableWindows>,
3863 }
3864
3865 #[derive(Debug, Serialize, Deserialize)]
3866 pub struct WorkflowUsage {
3867 billable: WorkflowUsageBillable,
3868 }
3869
3870 #[derive(Debug, Serialize, Deserialize)]
3871 pub struct Autolink {
3872 id: i64,
3873 key_prefix: String,
3874 url_template: String,
3875 }
3876
3877 #[derive(Debug, Serialize, Deserialize)]
3878 pub struct ProtectedBranchAdminEnforced {
3879 url: String,
3880 enabled: bool,
3881 }
3882
3883 #[derive(Debug, Serialize, Deserialize)]
3884 pub struct ProtectedBranchPullRequestReviewDismissalRestrictions {
3885 #[serde(skip_serializing_if = "Option::is_none")]
3886 users: Option<Vec<crate::components::schemas::SimpleUser>>,
3887 #[serde(skip_serializing_if = "Option::is_none")]
3888 teams: Option<Vec<crate::components::schemas::Team>>,
3889 #[serde(skip_serializing_if = "Option::is_none")]
3890 url: Option<String>,
3891 #[serde(skip_serializing_if = "Option::is_none")]
3892 users_url: Option<String>,
3893 #[serde(skip_serializing_if = "Option::is_none")]
3894 teams_url: Option<String>,
3895 }
3896
3897 #[derive(Debug, Serialize, Deserialize)]
3898 pub struct ProtectedBranchPullRequestReview {
3899 #[serde(skip_serializing_if = "Option::is_none")]
3900 url: Option<String>,
3901 #[serde(skip_serializing_if = "Option::is_none")]
3902 dismissal_restrictions: Option<ProtectedBranchPullRequestReviewDismissalRestrictions>,
3903 dismiss_stale_reviews: bool,
3904 require_code_owner_reviews: bool,
3905 #[serde(skip_serializing_if = "Option::is_none")]
3906 required_approving_review_count: Option<i64>,
3907 }
3908
3909 #[derive(Debug, Serialize, Deserialize)]
3910 pub struct BranchRestrictionPolicyUsers {
3911 #[serde(skip_serializing_if = "Option::is_none")]
3912 login: Option<String>,
3913 #[serde(skip_serializing_if = "Option::is_none")]
3914 id: Option<i64>,
3915 #[serde(skip_serializing_if = "Option::is_none")]
3916 node_id: Option<String>,
3917 #[serde(skip_serializing_if = "Option::is_none")]
3918 avatar_url: Option<String>,
3919 #[serde(skip_serializing_if = "Option::is_none")]
3920 gravatar_id: Option<String>,
3921 #[serde(skip_serializing_if = "Option::is_none")]
3922 url: Option<String>,
3923 #[serde(skip_serializing_if = "Option::is_none")]
3924 html_url: Option<String>,
3925 #[serde(skip_serializing_if = "Option::is_none")]
3926 followers_url: Option<String>,
3927 #[serde(skip_serializing_if = "Option::is_none")]
3928 following_url: Option<String>,
3929 #[serde(skip_serializing_if = "Option::is_none")]
3930 gists_url: Option<String>,
3931 #[serde(skip_serializing_if = "Option::is_none")]
3932 starred_url: Option<String>,
3933 #[serde(skip_serializing_if = "Option::is_none")]
3934 subscriptions_url: Option<String>,
3935 #[serde(skip_serializing_if = "Option::is_none")]
3936 organizations_url: Option<String>,
3937 #[serde(skip_serializing_if = "Option::is_none")]
3938 repos_url: Option<String>,
3939 #[serde(skip_serializing_if = "Option::is_none")]
3940 events_url: Option<String>,
3941 #[serde(skip_serializing_if = "Option::is_none")]
3942 received_events_url: Option<String>,
3943 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
3944 type_: Option<String>,
3945 #[serde(skip_serializing_if = "Option::is_none")]
3946 site_admin: Option<bool>,
3947 }
3948
3949 #[derive(Debug, Serialize, Deserialize)]
3950 pub struct BranchRestrictionPolicyTeams {
3951 #[serde(skip_serializing_if = "Option::is_none")]
3952 id: Option<i64>,
3953 #[serde(skip_serializing_if = "Option::is_none")]
3954 node_id: Option<String>,
3955 #[serde(skip_serializing_if = "Option::is_none")]
3956 url: Option<String>,
3957 #[serde(skip_serializing_if = "Option::is_none")]
3958 html_url: Option<String>,
3959 #[serde(skip_serializing_if = "Option::is_none")]
3960 name: Option<String>,
3961 #[serde(skip_serializing_if = "Option::is_none")]
3962 slug: Option<String>,
3963 #[serde(skip_serializing_if = "Option::is_none")]
3964 description: Option<String>,
3965 #[serde(skip_serializing_if = "Option::is_none")]
3966 privacy: Option<String>,
3967 #[serde(skip_serializing_if = "Option::is_none")]
3968 permission: Option<String>,
3969 #[serde(skip_serializing_if = "Option::is_none")]
3970 members_url: Option<String>,
3971 #[serde(skip_serializing_if = "Option::is_none")]
3972 repositories_url: Option<String>,
3973 #[serde(skip_serializing_if = "Option::is_none")]
3974 parent: Option<String>,
3975 }
3976
3977 #[derive(Debug, Serialize, Deserialize)]
3978 pub struct BranchRestrictionPolicyAppsOwner {
3979 #[serde(skip_serializing_if = "Option::is_none")]
3980 login: Option<String>,
3981 #[serde(skip_serializing_if = "Option::is_none")]
3982 id: Option<i64>,
3983 #[serde(skip_serializing_if = "Option::is_none")]
3984 node_id: Option<String>,
3985 #[serde(skip_serializing_if = "Option::is_none")]
3986 url: Option<String>,
3987 #[serde(skip_serializing_if = "Option::is_none")]
3988 repos_url: Option<String>,
3989 #[serde(skip_serializing_if = "Option::is_none")]
3990 events_url: Option<String>,
3991 #[serde(skip_serializing_if = "Option::is_none")]
3992 hooks_url: Option<String>,
3993 #[serde(skip_serializing_if = "Option::is_none")]
3994 issues_url: Option<String>,
3995 #[serde(skip_serializing_if = "Option::is_none")]
3996 members_url: Option<String>,
3997 #[serde(skip_serializing_if = "Option::is_none")]
3998 public_members_url: Option<String>,
3999 #[serde(skip_serializing_if = "Option::is_none")]
4000 avatar_url: Option<String>,
4001 #[serde(skip_serializing_if = "Option::is_none")]
4002 description: Option<String>,
4003 #[serde(skip_serializing_if = "Option::is_none")]
4004 gravatar_id: Option<String>,
4005 #[serde(skip_serializing_if = "Option::is_none")]
4006 html_url: Option<String>,
4007 #[serde(skip_serializing_if = "Option::is_none")]
4008 followers_url: Option<String>,
4009 #[serde(skip_serializing_if = "Option::is_none")]
4010 following_url: Option<String>,
4011 #[serde(skip_serializing_if = "Option::is_none")]
4012 gists_url: Option<String>,
4013 #[serde(skip_serializing_if = "Option::is_none")]
4014 starred_url: Option<String>,
4015 #[serde(skip_serializing_if = "Option::is_none")]
4016 subscriptions_url: Option<String>,
4017 #[serde(skip_serializing_if = "Option::is_none")]
4018 organizations_url: Option<String>,
4019 #[serde(skip_serializing_if = "Option::is_none")]
4020 received_events_url: Option<String>,
4021 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
4022 type_: Option<String>,
4023 #[serde(skip_serializing_if = "Option::is_none")]
4024 site_admin: Option<bool>,
4025 }
4026
4027 #[derive(Debug, Serialize, Deserialize)]
4028 pub struct BranchRestrictionPolicyAppsPermissions {
4029 #[serde(skip_serializing_if = "Option::is_none")]
4030 metadata: Option<String>,
4031 #[serde(skip_serializing_if = "Option::is_none")]
4032 contents: Option<String>,
4033 #[serde(skip_serializing_if = "Option::is_none")]
4034 issues: Option<String>,
4035 #[serde(skip_serializing_if = "Option::is_none")]
4036 single_file: Option<String>,
4037 }
4038
4039 #[derive(Debug, Serialize, Deserialize)]
4040 pub struct BranchRestrictionPolicyApps {
4041 #[serde(skip_serializing_if = "Option::is_none")]
4042 id: Option<i64>,
4043 #[serde(skip_serializing_if = "Option::is_none")]
4044 slug: Option<String>,
4045 #[serde(skip_serializing_if = "Option::is_none")]
4046 node_id: Option<String>,
4047 #[serde(skip_serializing_if = "Option::is_none")]
4048 owner: Option<BranchRestrictionPolicyAppsOwner>,
4049 #[serde(skip_serializing_if = "Option::is_none")]
4050 name: Option<String>,
4051 #[serde(skip_serializing_if = "Option::is_none")]
4052 description: Option<String>,
4053 #[serde(skip_serializing_if = "Option::is_none")]
4054 external_url: Option<String>,
4055 #[serde(skip_serializing_if = "Option::is_none")]
4056 html_url: Option<String>,
4057 #[serde(skip_serializing_if = "Option::is_none")]
4058 created_at: Option<String>,
4059 #[serde(skip_serializing_if = "Option::is_none")]
4060 updated_at: Option<String>,
4061 #[serde(skip_serializing_if = "Option::is_none")]
4062 permissions: Option<BranchRestrictionPolicyAppsPermissions>,
4063 #[serde(skip_serializing_if = "Option::is_none")]
4064 events: Option<Vec<String>>,
4065 }
4066
4067 #[derive(Debug, Serialize, Deserialize)]
4068 pub struct BranchRestrictionPolicy {
4069 url: String,
4070 users_url: String,
4071 teams_url: String,
4072 apps_url: String,
4073 users: Vec<BranchRestrictionPolicyUsers>,
4074 teams: Vec<BranchRestrictionPolicyTeams>,
4075 apps: Vec<BranchRestrictionPolicyApps>,
4076 }
4077
4078 #[derive(Debug, Serialize, Deserialize)]
4079 pub struct BranchProtectionRequiredStatusChecks {
4080 #[serde(skip_serializing_if = "Option::is_none")]
4081 url: Option<String>,
4082 #[serde(skip_serializing_if = "Option::is_none")]
4083 enforcement_level: Option<String>,
4084 contexts: Vec<String>,
4085 #[serde(skip_serializing_if = "Option::is_none")]
4086 contexts_url: Option<String>,
4087 #[serde(skip_serializing_if = "Option::is_none")]
4088 strict: Option<bool>,
4089 }
4090
4091 #[derive(Debug, Serialize, Deserialize)]
4092 pub struct BranchProtectionRequiredLinearHistory {
4093 #[serde(skip_serializing_if = "Option::is_none")]
4094 enabled: Option<bool>,
4095 }
4096
4097 #[derive(Debug, Serialize, Deserialize)]
4098 pub struct BranchProtectionAllowForcePushes {
4099 #[serde(skip_serializing_if = "Option::is_none")]
4100 enabled: Option<bool>,
4101 }
4102
4103 #[derive(Debug, Serialize, Deserialize)]
4104 pub struct BranchProtectionAllowDeletions {
4105 #[serde(skip_serializing_if = "Option::is_none")]
4106 enabled: Option<bool>,
4107 }
4108
4109 #[derive(Debug, Serialize, Deserialize)]
4110 pub struct BranchProtectionRequiredConversationResolution {
4111 #[serde(skip_serializing_if = "Option::is_none")]
4112 enabled: Option<bool>,
4113 }
4114
4115 #[derive(Debug, Serialize, Deserialize)]
4116 pub struct BranchProtectionRequiredSignatures {
4117 url: String,
4118 enabled: bool,
4119 }
4120
4121 #[derive(Debug, Serialize, Deserialize)]
4122 pub struct BranchProtection {
4123 #[serde(skip_serializing_if = "Option::is_none")]
4124 url: Option<String>,
4125 #[serde(skip_serializing_if = "Option::is_none")]
4126 enabled: Option<bool>,
4127 #[serde(skip_serializing_if = "Option::is_none")]
4128 required_status_checks: Option<BranchProtectionRequiredStatusChecks>,
4129 #[serde(skip_serializing_if = "Option::is_none")]
4131 enforce_admins: Option<crate::components::schemas::ProtectedBranchAdminEnforced>,
4132 #[serde(skip_serializing_if = "Option::is_none")]
4134 required_pull_request_reviews: Option<crate::components::schemas::ProtectedBranchPullRequestReview>,
4135 #[serde(skip_serializing_if = "Option::is_none")]
4137 restrictions: Option<crate::components::schemas::BranchRestrictionPolicy>,
4138 #[serde(skip_serializing_if = "Option::is_none")]
4139 required_linear_history: Option<BranchProtectionRequiredLinearHistory>,
4140 #[serde(skip_serializing_if = "Option::is_none")]
4141 allow_force_pushes: Option<BranchProtectionAllowForcePushes>,
4142 #[serde(skip_serializing_if = "Option::is_none")]
4143 allow_deletions: Option<BranchProtectionAllowDeletions>,
4144 #[serde(skip_serializing_if = "Option::is_none")]
4145 required_conversation_resolution: Option<BranchProtectionRequiredConversationResolution>,
4146 #[serde(skip_serializing_if = "Option::is_none")]
4147 name: Option<String>,
4148 #[serde(skip_serializing_if = "Option::is_none")]
4149 protection_url: Option<String>,
4150 #[serde(skip_serializing_if = "Option::is_none")]
4151 required_signatures: Option<BranchProtectionRequiredSignatures>,
4152 }
4153
4154 #[derive(Debug, Serialize, Deserialize)]
4155 pub struct ShortBranchCommit {
4156 sha: String,
4157 url: String,
4158 }
4159
4160 #[derive(Debug, Serialize, Deserialize)]
4161 pub struct ShortBranch {
4162 name: String,
4163 commit: ShortBranchCommit,
4164 protected: bool,
4165 #[serde(skip_serializing_if = "Option::is_none")]
4167 protection: Option<crate::components::schemas::BranchProtection>,
4168 #[serde(skip_serializing_if = "Option::is_none")]
4169 protection_url: Option<String>,
4170 }
4171
4172 #[derive(Debug, Serialize, Deserialize)]
4173 pub struct NullableGitUser {
4174 #[serde(skip_serializing_if = "Option::is_none")]
4175 name: Option<String>,
4176 #[serde(skip_serializing_if = "Option::is_none")]
4177 email: Option<String>,
4178 #[serde(skip_serializing_if = "Option::is_none")]
4179 date: Option<String>,
4180 }
4181
4182 #[derive(Debug, Serialize, Deserialize)]
4183 pub struct Verification {
4184 verified: bool,
4185 reason: String,
4186 payload: Option<String>,
4187 signature: Option<String>,
4188 }
4189
4190 #[derive(Debug, Serialize, Deserialize)]
4191 pub struct DiffEntry {
4192 sha: String,
4193 filename: String,
4194 status: String,
4195 additions: i64,
4196 deletions: i64,
4197 changes: i64,
4198 blob_url: String,
4199 raw_url: String,
4200 contents_url: String,
4201 #[serde(skip_serializing_if = "Option::is_none")]
4202 patch: Option<String>,
4203 #[serde(skip_serializing_if = "Option::is_none")]
4204 previous_filename: Option<String>,
4205 }
4206
4207 #[derive(Debug, Serialize, Deserialize)]
4208 pub struct CommitCommitTree {
4209 sha: String,
4210 url: String,
4211 }
4212
4213 #[derive(Debug, Serialize, Deserialize)]
4214 pub struct CommitCommit {
4215 url: String,
4216 author: crate::components::schemas::NullableGitUser,
4218 committer: crate::components::schemas::NullableGitUser,
4220 message: String,
4221 comment_count: i64,
4222 tree: CommitCommitTree,
4223 #[serde(skip_serializing_if = "Option::is_none")]
4225 verification: Option<crate::components::schemas::Verification>,
4226 }
4227
4228 #[derive(Debug, Serialize, Deserialize)]
4229 pub struct CommitParents {
4230 sha: String,
4231 url: String,
4232 #[serde(skip_serializing_if = "Option::is_none")]
4233 html_url: Option<String>,
4234 }
4235
4236 #[derive(Debug, Serialize, Deserialize)]
4237 pub struct CommitStats {
4238 #[serde(skip_serializing_if = "Option::is_none")]
4239 additions: Option<i64>,
4240 #[serde(skip_serializing_if = "Option::is_none")]
4241 deletions: Option<i64>,
4242 #[serde(skip_serializing_if = "Option::is_none")]
4243 total: Option<i64>,
4244 }
4245
4246 #[derive(Debug, Serialize, Deserialize)]
4247 pub struct Commit {
4248 url: String,
4249 sha: String,
4250 node_id: String,
4251 html_url: String,
4252 comments_url: String,
4253 commit: CommitCommit,
4254 author: crate::components::schemas::NullableSimpleUser,
4256 committer: crate::components::schemas::NullableSimpleUser,
4258 parents: Vec<CommitParents>,
4259 #[serde(skip_serializing_if = "Option::is_none")]
4260 stats: Option<CommitStats>,
4261 #[serde(skip_serializing_if = "Option::is_none")]
4262 files: Option<Vec<crate::components::schemas::DiffEntry>>,
4263 }
4264
4265 #[derive(Debug, Serialize, Deserialize)]
4266 pub struct BranchWithProtectionLinks {
4267 html: String,
4268 #[serde(rename="self")]
4269 self_: String,
4270 }
4271
4272 #[derive(Debug, Serialize, Deserialize)]
4273 pub struct BranchWithProtection {
4274 name: String,
4275 commit: crate::components::schemas::Commit,
4277 #[serde(rename="_links")]
4278 links: BranchWithProtectionLinks,
4279 protected: bool,
4280 protection: crate::components::schemas::BranchProtection,
4282 protection_url: String,
4283 #[serde(skip_serializing_if = "Option::is_none")]
4284 pattern: Option<String>,
4285 #[serde(skip_serializing_if = "Option::is_none")]
4286 required_approving_review_count: Option<i64>,
4287 }
4288
4289 #[derive(Debug, Serialize, Deserialize)]
4290 pub struct StatusCheckPolicy {
4291 url: String,
4292 strict: bool,
4293 contexts: Vec<String>,
4294 contexts_url: String,
4295 }
4296
4297 #[derive(Debug, Serialize, Deserialize)]
4298 pub struct ProtectedBranchRequiredPullRequestReviewsDismissalRestrictions {
4299 url: String,
4300 users_url: String,
4301 teams_url: String,
4302 users: Vec<crate::components::schemas::SimpleUser>,
4303 teams: Vec<crate::components::schemas::Team>,
4304 }
4305
4306 #[derive(Debug, Serialize, Deserialize)]
4307 pub struct ProtectedBranchRequiredPullRequestReviews {
4308 url: String,
4309 #[serde(skip_serializing_if = "Option::is_none")]
4310 dismiss_stale_reviews: Option<bool>,
4311 #[serde(skip_serializing_if = "Option::is_none")]
4312 require_code_owner_reviews: Option<bool>,
4313 #[serde(skip_serializing_if = "Option::is_none")]
4314 required_approving_review_count: Option<i64>,
4315 #[serde(skip_serializing_if = "Option::is_none")]
4316 dismissal_restrictions: Option<ProtectedBranchRequiredPullRequestReviewsDismissalRestrictions>,
4317 }
4318
4319 #[derive(Debug, Serialize, Deserialize)]
4320 pub struct ProtectedBranchRequiredSignatures {
4321 url: String,
4322 enabled: bool,
4323 }
4324
4325 #[derive(Debug, Serialize, Deserialize)]
4326 pub struct ProtectedBranchEnforceAdmins {
4327 url: String,
4328 enabled: bool,
4329 }
4330
4331 #[derive(Debug, Serialize, Deserialize)]
4332 pub struct ProtectedBranchRequiredLinearHistory {
4333 enabled: bool,
4334 }
4335
4336 #[derive(Debug, Serialize, Deserialize)]
4337 pub struct ProtectedBranchAllowForcePushes {
4338 enabled: bool,
4339 }
4340
4341 #[derive(Debug, Serialize, Deserialize)]
4342 pub struct ProtectedBranchAllowDeletions {
4343 enabled: bool,
4344 }
4345
4346 #[derive(Debug, Serialize, Deserialize)]
4347 pub struct ProtectedBranchRequiredConversationResolution {
4348 #[serde(skip_serializing_if = "Option::is_none")]
4349 enabled: Option<bool>,
4350 }
4351
4352 #[derive(Debug, Serialize, Deserialize)]
4353 pub struct ProtectedBranch {
4354 url: String,
4355 #[serde(skip_serializing_if = "Option::is_none")]
4357 required_status_checks: Option<crate::components::schemas::StatusCheckPolicy>,
4358 #[serde(skip_serializing_if = "Option::is_none")]
4359 required_pull_request_reviews: Option<ProtectedBranchRequiredPullRequestReviews>,
4360 #[serde(skip_serializing_if = "Option::is_none")]
4361 required_signatures: Option<ProtectedBranchRequiredSignatures>,
4362 #[serde(skip_serializing_if = "Option::is_none")]
4363 enforce_admins: Option<ProtectedBranchEnforceAdmins>,
4364 #[serde(skip_serializing_if = "Option::is_none")]
4365 required_linear_history: Option<ProtectedBranchRequiredLinearHistory>,
4366 #[serde(skip_serializing_if = "Option::is_none")]
4367 allow_force_pushes: Option<ProtectedBranchAllowForcePushes>,
4368 #[serde(skip_serializing_if = "Option::is_none")]
4369 allow_deletions: Option<ProtectedBranchAllowDeletions>,
4370 #[serde(skip_serializing_if = "Option::is_none")]
4372 restrictions: Option<crate::components::schemas::BranchRestrictionPolicy>,
4373 #[serde(skip_serializing_if = "Option::is_none")]
4374 required_conversation_resolution: Option<ProtectedBranchRequiredConversationResolution>,
4375 }
4376
4377 #[derive(Debug, Serialize, Deserialize)]
4378 pub struct DeploymentSimple {
4379 url: String,
4380 id: i64,
4381 node_id: String,
4382 task: String,
4383 #[serde(skip_serializing_if = "Option::is_none")]
4384 original_environment: Option<String>,
4385 environment: String,
4386 description: Option<String>,
4387 created_at: String,
4388 updated_at: String,
4389 statuses_url: String,
4390 repository_url: String,
4391 #[serde(skip_serializing_if = "Option::is_none")]
4392 transient_environment: Option<bool>,
4393 #[serde(skip_serializing_if = "Option::is_none")]
4394 production_environment: Option<bool>,
4395 #[serde(skip_serializing_if = "Option::is_none")]
4397 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
4398 }
4399
4400 #[derive(Debug, Serialize, Deserialize)]
4401 pub struct CheckRunOutput {
4402 title: Option<String>,
4403 summary: Option<String>,
4404 text: Option<String>,
4405 annotations_count: i64,
4406 annotations_url: String,
4407 }
4408
4409 #[derive(Debug, Serialize, Deserialize)]
4410 pub struct CheckRunCheckSuite {
4411 id: i64,
4412 }
4413
4414 #[derive(Debug, Serialize, Deserialize)]
4415 pub struct CheckRun {
4416 id: i64,
4417 head_sha: String,
4418 node_id: String,
4419 external_id: Option<String>,
4420 url: String,
4421 html_url: Option<String>,
4422 details_url: Option<String>,
4423 status: String,
4424 conclusion: Option<String>,
4425 started_at: Option<String>,
4426 completed_at: Option<String>,
4427 output: CheckRunOutput,
4428 name: String,
4429 check_suite: Option<CheckRunCheckSuite>,
4430 app: crate::components::schemas::NullableIntegration,
4432 pull_requests: Vec<crate::components::schemas::PullRequestMinimal>,
4433 #[serde(skip_serializing_if = "Option::is_none")]
4435 deployment: Option<crate::components::schemas::DeploymentSimple>,
4436 }
4437
4438 #[derive(Debug, Serialize, Deserialize)]
4439 pub struct CheckAnnotation {
4440 path: String,
4441 start_line: i64,
4442 end_line: i64,
4443 start_column: Option<i64>,
4444 end_column: Option<i64>,
4445 annotation_level: Option<String>,
4446 title: Option<String>,
4447 message: Option<String>,
4448 raw_details: Option<String>,
4449 blob_href: String,
4450 }
4451
4452 #[derive(Debug, Serialize, Deserialize)]
4453 pub struct SimpleCommitAuthor {
4454 name: String,
4455 email: String,
4456 }
4457
4458 #[derive(Debug, Serialize, Deserialize)]
4459 pub struct SimpleCommitCommitter {
4460 name: String,
4461 email: String,
4462 }
4463
4464 #[derive(Debug, Serialize, Deserialize)]
4465 pub struct SimpleCommit {
4466 id: String,
4467 tree_id: String,
4468 message: String,
4469 timestamp: String,
4470 author: Option<SimpleCommitAuthor>,
4471 committer: Option<SimpleCommitCommitter>,
4472 }
4473
4474 #[derive(Debug, Serialize, Deserialize)]
4475 pub struct CheckSuite {
4476 id: i64,
4477 node_id: String,
4478 head_branch: Option<String>,
4479 head_sha: String,
4480 status: Option<String>,
4481 conclusion: Option<String>,
4482 url: Option<String>,
4483 before: Option<String>,
4484 after: Option<String>,
4485 pull_requests: Option<Vec<crate::components::schemas::PullRequestMinimal>>,
4486 app: crate::components::schemas::NullableIntegration,
4488 repository: crate::components::schemas::MinimalRepository,
4490 created_at: Option<String>,
4491 updated_at: Option<String>,
4492 head_commit: crate::components::schemas::SimpleCommit,
4494 latest_check_runs_count: i64,
4495 check_runs_url: String,
4496 }
4497
4498 #[derive(Debug, Serialize, Deserialize)]
4499 pub struct CheckSuitePreferencePreferencesAutoTriggerChecks {
4500 app_id: i64,
4501 setting: bool,
4502 }
4503
4504 #[derive(Debug, Serialize, Deserialize)]
4505 pub struct CheckSuitePreferencePreferences {
4506 #[serde(skip_serializing_if = "Option::is_none")]
4507 auto_trigger_checks: Option<Vec<CheckSuitePreferencePreferencesAutoTriggerChecks>>,
4508 }
4509
4510 #[derive(Debug, Serialize, Deserialize)]
4511 pub struct CheckSuitePreference {
4512 preferences: CheckSuitePreferencePreferences,
4513 repository: crate::components::schemas::MinimalRepository,
4515 }
4516
4517 pub type CodeScanningAnalysisToolName = String;
4518
4519 pub type CodeScanningAnalysisToolGuid = String;
4520
4521 pub type CodeScanningRef = String;
4522
4523 pub type CodeScanningAlertState = String;
4524
4525 pub type AlertInstancesUrl = String;
4526
4527 pub type CodeScanningAlertDismissedAt = String;
4528
4529 pub type CodeScanningAlertDismissedReason = HashMap<String, String>;
4530
4531 #[derive(Debug, Serialize, Deserialize)]
4532 pub struct CodeScanningAlertRuleSummary {
4533 #[serde(skip_serializing_if = "Option::is_none")]
4534 id: Option<String>,
4535 #[serde(skip_serializing_if = "Option::is_none")]
4536 name: Option<String>,
4537 #[serde(skip_serializing_if = "Option::is_none")]
4538 severity: Option<String>,
4539 #[serde(skip_serializing_if = "Option::is_none")]
4540 description: Option<String>,
4541 }
4542
4543 pub type CodeScanningAnalysisToolVersion = String;
4544
4545 #[derive(Debug, Serialize, Deserialize)]
4546 pub struct CodeScanningAnalysisTool {
4547 #[serde(skip_serializing_if = "Option::is_none")]
4549 name: Option<crate::components::schemas::CodeScanningAnalysisToolName>,
4550 #[serde(skip_serializing_if = "Option::is_none")]
4552 version: Option<crate::components::schemas::CodeScanningAnalysisToolVersion>,
4553 #[serde(skip_serializing_if = "Option::is_none")]
4555 guid: Option<crate::components::schemas::CodeScanningAnalysisToolGuid>,
4556 }
4557
4558 pub type CodeScanningAnalysisAnalysisKey = String;
4559
4560 pub type CodeScanningAlertEnvironment = String;
4561
4562 pub type CodeScanningAnalysisCategory = String;
4563
4564 #[derive(Debug, Serialize, Deserialize)]
4565 pub struct CodeScanningAlertLocation {
4566 #[serde(skip_serializing_if = "Option::is_none")]
4567 path: Option<String>,
4568 #[serde(skip_serializing_if = "Option::is_none")]
4569 start_line: Option<i64>,
4570 #[serde(skip_serializing_if = "Option::is_none")]
4571 end_line: Option<i64>,
4572 #[serde(skip_serializing_if = "Option::is_none")]
4573 start_column: Option<i64>,
4574 #[serde(skip_serializing_if = "Option::is_none")]
4575 end_column: Option<i64>,
4576 }
4577
4578 pub type CodeScanningAlertClassification = String;
4579
4580 #[derive(Debug, Serialize, Deserialize)]
4581 pub struct CodeScanningAlertInstanceMessage {
4582 #[serde(skip_serializing_if = "Option::is_none")]
4583 text: Option<String>,
4584 }
4585
4586 #[derive(Debug, Serialize, Deserialize)]
4587 pub struct CodeScanningAlertInstance {
4588 #[serde(rename="ref", skip_serializing_if = "Option::is_none")]
4590 ref_: Option<crate::components::schemas::CodeScanningRef>,
4591 #[serde(skip_serializing_if = "Option::is_none")]
4593 analysis_key: Option<crate::components::schemas::CodeScanningAnalysisAnalysisKey>,
4594 #[serde(skip_serializing_if = "Option::is_none")]
4596 environment: Option<crate::components::schemas::CodeScanningAlertEnvironment>,
4597 #[serde(skip_serializing_if = "Option::is_none")]
4599 category: Option<crate::components::schemas::CodeScanningAnalysisCategory>,
4600 #[serde(skip_serializing_if = "Option::is_none")]
4602 state: Option<crate::components::schemas::CodeScanningAlertState>,
4603 #[serde(skip_serializing_if = "Option::is_none")]
4604 commit_sha: Option<String>,
4605 #[serde(skip_serializing_if = "Option::is_none")]
4606 message: Option<CodeScanningAlertInstanceMessage>,
4607 #[serde(skip_serializing_if = "Option::is_none")]
4609 location: Option<crate::components::schemas::CodeScanningAlertLocation>,
4610 #[serde(skip_serializing_if = "Option::is_none")]
4611 html_url: Option<String>,
4612 #[serde(skip_serializing_if = "Option::is_none")]
4613 classifications: Option<Vec<crate::components::schemas::CodeScanningAlertClassification>>,
4614 }
4615
4616 #[derive(Debug, Serialize, Deserialize)]
4617 pub struct CodeScanningAlertItems {
4618 number: crate::components::schemas::AlertNumber,
4620 created_at: crate::components::schemas::AlertCreatedAt,
4622 url: crate::components::schemas::AlertUrl,
4624 html_url: crate::components::schemas::AlertHtmlUrl,
4626 instances_url: crate::components::schemas::AlertInstancesUrl,
4628 state: crate::components::schemas::CodeScanningAlertState,
4630 dismissed_by: crate::components::schemas::NullableSimpleUser,
4632 dismissed_at: crate::components::schemas::CodeScanningAlertDismissedAt,
4634 dismissed_reason: crate::components::schemas::CodeScanningAlertDismissedReason,
4636 rule: crate::components::schemas::CodeScanningAlertRuleSummary,
4638 tool: crate::components::schemas::CodeScanningAnalysisTool,
4640 most_recent_instance: crate::components::schemas::CodeScanningAlertInstance,
4642 }
4643
4644 #[derive(Debug, Serialize, Deserialize)]
4645 pub struct CodeScanningAlertRule {
4646 #[serde(skip_serializing_if = "Option::is_none")]
4647 id: Option<String>,
4648 #[serde(skip_serializing_if = "Option::is_none")]
4649 name: Option<String>,
4650 #[serde(skip_serializing_if = "Option::is_none")]
4651 severity: Option<String>,
4652 #[serde(skip_serializing_if = "Option::is_none")]
4653 security_severity_level: Option<String>,
4654 #[serde(skip_serializing_if = "Option::is_none")]
4655 description: Option<String>,
4656 #[serde(skip_serializing_if = "Option::is_none")]
4657 full_description: Option<String>,
4658 #[serde(skip_serializing_if = "Option::is_none")]
4659 tags: Option<Vec<String>>,
4660 #[serde(skip_serializing_if = "Option::is_none")]
4661 help: Option<String>,
4662 }
4663
4664 #[derive(Debug, Serialize, Deserialize)]
4665 pub struct CodeScanningAlert {
4666 number: crate::components::schemas::AlertNumber,
4668 created_at: crate::components::schemas::AlertCreatedAt,
4670 url: crate::components::schemas::AlertUrl,
4672 html_url: crate::components::schemas::AlertHtmlUrl,
4674 instances_url: crate::components::schemas::AlertInstancesUrl,
4676 state: crate::components::schemas::CodeScanningAlertState,
4678 dismissed_by: crate::components::schemas::NullableSimpleUser,
4680 dismissed_at: crate::components::schemas::CodeScanningAlertDismissedAt,
4682 dismissed_reason: crate::components::schemas::CodeScanningAlertDismissedReason,
4684 rule: crate::components::schemas::CodeScanningAlertRule,
4686 tool: crate::components::schemas::CodeScanningAnalysisTool,
4688 most_recent_instance: crate::components::schemas::CodeScanningAlertInstance,
4690 }
4691
4692 pub type CodeScanningAlertSetState = String;
4693
4694 pub type CodeScanningAnalysisSarifId = String;
4695
4696 pub type CodeScanningAnalysisCommitSha = String;
4697
4698 pub type CodeScanningAnalysisEnvironment = String;
4699
4700 pub type CodeScanningAnalysisCreatedAt = String;
4701
4702 pub type CodeScanningAnalysisUrl = String;
4703
4704 #[derive(Debug, Serialize, Deserialize)]
4705 pub struct CodeScanningAnalysis {
4706 #[serde(rename="ref")]
4708 ref_: crate::components::schemas::CodeScanningRef,
4709 commit_sha: crate::components::schemas::CodeScanningAnalysisCommitSha,
4711 analysis_key: crate::components::schemas::CodeScanningAnalysisAnalysisKey,
4713 environment: crate::components::schemas::CodeScanningAnalysisEnvironment,
4715 #[serde(skip_serializing_if = "Option::is_none")]
4717 category: Option<crate::components::schemas::CodeScanningAnalysisCategory>,
4718 error: String,
4719 created_at: crate::components::schemas::CodeScanningAnalysisCreatedAt,
4721 results_count: i64,
4722 rules_count: i64,
4723 id: i64,
4724 url: crate::components::schemas::CodeScanningAnalysisUrl,
4726 sarif_id: crate::components::schemas::CodeScanningAnalysisSarifId,
4728 tool: crate::components::schemas::CodeScanningAnalysisTool,
4730 deletable: bool,
4731 warning: String,
4732 }
4733
4734 #[derive(Debug, Serialize, Deserialize)]
4735 pub struct CodeScanningAnalysisDeletion {
4736 next_analysis_url: Option<String>,
4737 confirm_delete_url: Option<String>,
4738 }
4739
4740 pub type CodeScanningAnalysisSarifFile = String;
4741
4742 #[derive(Debug, Serialize, Deserialize)]
4743 pub struct CodeScanningSarifsReceipt {
4744 #[serde(skip_serializing_if = "Option::is_none")]
4746 id: Option<crate::components::schemas::CodeScanningAnalysisSarifId>,
4747 #[serde(skip_serializing_if = "Option::is_none")]
4748 url: Option<String>,
4749 }
4750
4751 #[derive(Debug, Serialize, Deserialize)]
4752 pub struct CodeScanningSarifsStatus {
4753 #[serde(skip_serializing_if = "Option::is_none")]
4754 processing_status: Option<String>,
4755 #[serde(skip_serializing_if = "Option::is_none")]
4756 analyses_url: Option<String>,
4757 }
4758
4759 #[derive(Debug, Serialize, Deserialize)]
4760 pub struct NullableCodespaceMachine {
4761 name: String,
4762 display_name: String,
4763 operating_system: String,
4764 storage_in_bytes: i64,
4765 memory_in_bytes: i64,
4766 cpus: i64,
4767 }
4768
4769 #[derive(Debug, Serialize, Deserialize)]
4770 pub struct CodespaceGitStatus {
4771 #[serde(skip_serializing_if = "Option::is_none")]
4772 ahead: Option<i64>,
4773 #[serde(skip_serializing_if = "Option::is_none")]
4774 behind: Option<i64>,
4775 #[serde(skip_serializing_if = "Option::is_none")]
4776 has_unpushed_changes: Option<bool>,
4777 #[serde(skip_serializing_if = "Option::is_none")]
4778 has_uncommitted_changes: Option<bool>,
4779 #[serde(rename="ref", skip_serializing_if = "Option::is_none")]
4780 ref_: Option<String>,
4781 }
4782
4783 #[derive(Debug, Serialize, Deserialize)]
4784 pub struct Codespace {
4785 id: i64,
4786 name: String,
4787 environment_id: Option<String>,
4788 owner: crate::components::schemas::SimpleUser,
4790 billable_owner: crate::components::schemas::SimpleUser,
4792 repository: crate::components::schemas::MinimalRepository,
4794 machine: crate::components::schemas::NullableCodespaceMachine,
4796 created_at: String,
4797 updated_at: String,
4798 last_used_at: String,
4799 state: String,
4800 url: String,
4801 git_status: CodespaceGitStatus,
4802 location: String,
4803 auto_stop_delay_minutes: Option<i64>,
4804 web_url: String,
4805 machines_url: String,
4806 start_url: String,
4807 stop_url: String,
4808 pulls_url: Option<String>,
4809 recent_folders: Vec<String>,
4810 }
4811
4812 #[derive(Debug, Serialize, Deserialize)]
4813 pub struct CodespaceMachine {
4814 name: String,
4815 display_name: String,
4816 operating_system: String,
4817 storage_in_bytes: i64,
4818 memory_in_bytes: i64,
4819 cpus: i64,
4820 }
4821
4822 #[derive(Debug, Serialize, Deserialize)]
4823 pub struct CollaboratorPermissions {
4824 pull: bool,
4825 #[serde(skip_serializing_if = "Option::is_none")]
4826 triage: Option<bool>,
4827 push: bool,
4828 #[serde(skip_serializing_if = "Option::is_none")]
4829 maintain: Option<bool>,
4830 admin: bool,
4831 }
4832
4833 #[derive(Debug, Serialize, Deserialize)]
4834 pub struct Collaborator {
4835 login: String,
4836 id: i64,
4837 #[serde(skip_serializing_if = "Option::is_none")]
4838 email: Option<String>,
4839 #[serde(skip_serializing_if = "Option::is_none")]
4840 name: Option<String>,
4841 node_id: String,
4842 avatar_url: String,
4843 gravatar_id: Option<String>,
4844 url: String,
4845 html_url: String,
4846 followers_url: String,
4847 following_url: String,
4848 gists_url: String,
4849 starred_url: String,
4850 subscriptions_url: String,
4851 organizations_url: String,
4852 repos_url: String,
4853 events_url: String,
4854 received_events_url: String,
4855 #[serde(rename="type")]
4856 type_: String,
4857 site_admin: bool,
4858 #[serde(skip_serializing_if = "Option::is_none")]
4859 permissions: Option<CollaboratorPermissions>,
4860 role_name: String,
4861 }
4862
4863 #[derive(Debug, Serialize, Deserialize)]
4864 pub struct RepositoryInvitation {
4865 id: i64,
4866 repository: crate::components::schemas::MinimalRepository,
4868 invitee: crate::components::schemas::NullableSimpleUser,
4870 inviter: crate::components::schemas::NullableSimpleUser,
4872 permissions: String,
4873 created_at: String,
4874 #[serde(skip_serializing_if = "Option::is_none")]
4875 expired: Option<bool>,
4876 url: String,
4877 html_url: String,
4878 node_id: String,
4879 }
4880
4881 #[derive(Debug, Serialize, Deserialize)]
4882 pub struct NullableCollaboratorPermissions {
4883 pull: bool,
4884 #[serde(skip_serializing_if = "Option::is_none")]
4885 triage: Option<bool>,
4886 push: bool,
4887 #[serde(skip_serializing_if = "Option::is_none")]
4888 maintain: Option<bool>,
4889 admin: bool,
4890 }
4891
4892 #[derive(Debug, Serialize, Deserialize)]
4893 pub struct NullableCollaborator {
4894 login: String,
4895 id: i64,
4896 #[serde(skip_serializing_if = "Option::is_none")]
4897 email: Option<String>,
4898 #[serde(skip_serializing_if = "Option::is_none")]
4899 name: Option<String>,
4900 node_id: String,
4901 avatar_url: String,
4902 gravatar_id: Option<String>,
4903 url: String,
4904 html_url: String,
4905 followers_url: String,
4906 following_url: String,
4907 gists_url: String,
4908 starred_url: String,
4909 subscriptions_url: String,
4910 organizations_url: String,
4911 repos_url: String,
4912 events_url: String,
4913 received_events_url: String,
4914 #[serde(rename="type")]
4915 type_: String,
4916 site_admin: bool,
4917 #[serde(skip_serializing_if = "Option::is_none")]
4918 permissions: Option<NullableCollaboratorPermissions>,
4919 role_name: String,
4920 }
4921
4922 #[derive(Debug, Serialize, Deserialize)]
4923 pub struct RepositoryCollaboratorPermission {
4924 permission: String,
4925 role_name: String,
4926 user: crate::components::schemas::NullableCollaborator,
4928 }
4929
4930 #[derive(Debug, Serialize, Deserialize)]
4931 pub struct CommitComment {
4932 html_url: String,
4933 url: String,
4934 id: i64,
4935 node_id: String,
4936 body: String,
4937 path: Option<String>,
4938 position: Option<i64>,
4939 line: Option<i64>,
4940 commit_id: String,
4941 user: crate::components::schemas::NullableSimpleUser,
4943 created_at: String,
4944 updated_at: String,
4945 author_association: crate::components::schemas::AuthorAssociation,
4947 #[serde(skip_serializing_if = "Option::is_none")]
4949 reactions: Option<crate::components::schemas::ReactionRollup>,
4950 }
4951
4952 #[derive(Debug, Serialize, Deserialize)]
4953 pub struct BranchShortCommit {
4954 sha: String,
4955 url: String,
4956 }
4957
4958 #[derive(Debug, Serialize, Deserialize)]
4959 pub struct BranchShort {
4960 name: String,
4961 commit: BranchShortCommit,
4962 protected: bool,
4963 }
4964
4965 #[derive(Debug, Serialize, Deserialize)]
4966 pub struct Link {
4967 href: String,
4968 }
4969
4970 #[derive(Debug, Serialize, Deserialize)]
4971 pub struct AutoMerge {
4972 enabled_by: crate::components::schemas::SimpleUser,
4974 merge_method: String,
4975 commit_title: String,
4976 commit_message: String,
4977 }
4978
4979 #[derive(Debug, Serialize, Deserialize)]
4980 pub struct PullRequestSimpleLabels {
4981 id: i64,
4982 node_id: String,
4983 url: String,
4984 name: String,
4985 description: String,
4986 color: String,
4987 default: bool,
4988 }
4989
4990 #[derive(Debug, Serialize, Deserialize)]
4991 pub struct PullRequestSimpleHead {
4992 label: String,
4993 #[serde(rename="ref")]
4994 ref_: String,
4995 repo: crate::components::schemas::Repository,
4997 sha: String,
4998 user: crate::components::schemas::NullableSimpleUser,
5000 }
5001
5002 #[derive(Debug, Serialize, Deserialize)]
5003 pub struct PullRequestSimpleBase {
5004 label: String,
5005 #[serde(rename="ref")]
5006 ref_: String,
5007 repo: crate::components::schemas::Repository,
5009 sha: String,
5010 user: crate::components::schemas::NullableSimpleUser,
5012 }
5013
5014 #[derive(Debug, Serialize, Deserialize)]
5015 pub struct PullRequestSimpleLinks {
5016 comments: crate::components::schemas::Link,
5018 commits: crate::components::schemas::Link,
5020 statuses: crate::components::schemas::Link,
5022 html: crate::components::schemas::Link,
5024 issue: crate::components::schemas::Link,
5026 review_comments: crate::components::schemas::Link,
5028 review_comment: crate::components::schemas::Link,
5030 #[serde(rename="self")]
5032 self_: crate::components::schemas::Link,
5033 }
5034
5035 #[derive(Debug, Serialize, Deserialize)]
5036 pub struct PullRequestSimple {
5037 url: String,
5038 id: i64,
5039 node_id: String,
5040 html_url: String,
5041 diff_url: String,
5042 patch_url: String,
5043 issue_url: String,
5044 commits_url: String,
5045 review_comments_url: String,
5046 review_comment_url: String,
5047 comments_url: String,
5048 statuses_url: String,
5049 number: i64,
5050 state: String,
5051 locked: bool,
5052 title: String,
5053 user: crate::components::schemas::NullableSimpleUser,
5055 body: Option<String>,
5056 labels: Vec<PullRequestSimpleLabels>,
5057 milestone: crate::components::schemas::NullableMilestone,
5059 #[serde(skip_serializing_if = "Option::is_none")]
5060 active_lock_reason: Option<String>,
5061 created_at: String,
5062 updated_at: String,
5063 closed_at: Option<String>,
5064 merged_at: Option<String>,
5065 merge_commit_sha: Option<String>,
5066 assignee: crate::components::schemas::NullableSimpleUser,
5068 #[serde(skip_serializing_if = "Option::is_none")]
5069 assignees: Option<Vec<crate::components::schemas::SimpleUser>>,
5070 #[serde(skip_serializing_if = "Option::is_none")]
5071 requested_reviewers: Option<Vec<crate::components::schemas::SimpleUser>>,
5072 #[serde(skip_serializing_if = "Option::is_none")]
5073 requested_teams: Option<Vec<crate::components::schemas::Team>>,
5074 head: PullRequestSimpleHead,
5075 base: PullRequestSimpleBase,
5076 #[serde(rename="_links")]
5077 links: PullRequestSimpleLinks,
5078 author_association: crate::components::schemas::AuthorAssociation,
5080 auto_merge: crate::components::schemas::AutoMerge,
5082 #[serde(skip_serializing_if = "Option::is_none")]
5083 draft: Option<bool>,
5084 }
5085
5086 #[derive(Debug, Serialize, Deserialize)]
5087 pub struct SimpleCommitStatus {
5088 description: Option<String>,
5089 id: i64,
5090 node_id: String,
5091 state: String,
5092 context: String,
5093 target_url: String,
5094 #[serde(skip_serializing_if = "Option::is_none")]
5095 required: Option<bool>,
5096 avatar_url: Option<String>,
5097 url: String,
5098 created_at: String,
5099 updated_at: String,
5100 }
5101
5102 #[derive(Debug, Serialize, Deserialize)]
5103 pub struct CombinedCommitStatus {
5104 state: String,
5105 statuses: Vec<crate::components::schemas::SimpleCommitStatus>,
5106 sha: String,
5107 total_count: i64,
5108 repository: crate::components::schemas::MinimalRepository,
5110 commit_url: String,
5111 url: String,
5112 }
5113
5114 #[derive(Debug, Serialize, Deserialize)]
5115 pub struct Status {
5116 url: String,
5117 avatar_url: Option<String>,
5118 id: i64,
5119 node_id: String,
5120 state: String,
5121 description: String,
5122 target_url: String,
5123 context: String,
5124 created_at: String,
5125 updated_at: String,
5126 creator: crate::components::schemas::NullableSimpleUser,
5128 }
5129
5130 #[derive(Debug, Serialize, Deserialize)]
5131 pub struct NullableCodeOfConductSimple {
5132 url: String,
5133 key: String,
5134 name: String,
5135 html_url: Option<String>,
5136 }
5137
5138 #[derive(Debug, Serialize, Deserialize)]
5139 pub struct NullableCommunityHealthFile {
5140 url: String,
5141 html_url: String,
5142 }
5143
5144 #[derive(Debug, Serialize, Deserialize)]
5145 pub struct CommunityProfileFiles {
5146 code_of_conduct: crate::components::schemas::NullableCodeOfConductSimple,
5148 code_of_conduct_file: crate::components::schemas::NullableCommunityHealthFile,
5150 license: crate::components::schemas::NullableLicenseSimple,
5152 contributing: crate::components::schemas::NullableCommunityHealthFile,
5154 readme: crate::components::schemas::NullableCommunityHealthFile,
5156 issue_template: crate::components::schemas::NullableCommunityHealthFile,
5158 pull_request_template: crate::components::schemas::NullableCommunityHealthFile,
5160 }
5161
5162 #[derive(Debug, Serialize, Deserialize)]
5163 pub struct CommunityProfile {
5164 health_percentage: i64,
5165 description: Option<String>,
5166 documentation: Option<String>,
5167 files: CommunityProfileFiles,
5168 updated_at: Option<String>,
5169 #[serde(skip_serializing_if = "Option::is_none")]
5170 content_reports_enabled: Option<bool>,
5171 }
5172
5173 #[derive(Debug, Serialize, Deserialize)]
5174 pub struct CommitComparison {
5175 url: String,
5176 html_url: String,
5177 permalink_url: String,
5178 diff_url: String,
5179 patch_url: String,
5180 base_commit: crate::components::schemas::Commit,
5182 merge_base_commit: crate::components::schemas::Commit,
5184 status: String,
5185 ahead_by: i64,
5186 behind_by: i64,
5187 total_commits: i64,
5188 commits: Vec<crate::components::schemas::Commit>,
5189 #[serde(skip_serializing_if = "Option::is_none")]
5190 files: Option<Vec<crate::components::schemas::DiffEntry>>,
5191 }
5192
5193 #[derive(Debug, Serialize, Deserialize)]
5194 pub struct ContentReferenceAttachment {
5195 id: i64,
5196 title: String,
5197 body: String,
5198 #[serde(skip_serializing_if = "Option::is_none")]
5199 node_id: Option<String>,
5200 }
5201
5202 #[derive(Debug, Serialize, Deserialize)]
5203 pub struct ContentTreeEntriesLinks {
5204 git: Option<String>,
5205 html: Option<String>,
5206 #[serde(rename="self")]
5207 self_: String,
5208 }
5209
5210 #[derive(Debug, Serialize, Deserialize)]
5211 pub struct ContentTreeEntries {
5212 #[serde(rename="type")]
5213 type_: String,
5214 size: i64,
5215 name: String,
5216 path: String,
5217 #[serde(skip_serializing_if = "Option::is_none")]
5218 content: Option<String>,
5219 sha: String,
5220 url: String,
5221 git_url: Option<String>,
5222 html_url: Option<String>,
5223 download_url: Option<String>,
5224 #[serde(rename="_links")]
5225 links: ContentTreeEntriesLinks,
5226 }
5227
5228 #[derive(Debug, Serialize, Deserialize)]
5229 pub struct ContentTreeLinks {
5230 git: Option<String>,
5231 html: Option<String>,
5232 #[serde(rename="self")]
5233 self_: String,
5234 }
5235
5236 #[derive(Debug, Serialize, Deserialize)]
5237 pub struct ContentTree {
5238 #[serde(rename="type")]
5239 type_: String,
5240 size: i64,
5241 name: String,
5242 path: String,
5243 sha: String,
5244 url: String,
5245 git_url: Option<String>,
5246 html_url: Option<String>,
5247 download_url: Option<String>,
5248 #[serde(skip_serializing_if = "Option::is_none")]
5249 entries: Option<Vec<ContentTreeEntries>>,
5250 #[serde(rename="_links")]
5251 links: ContentTreeLinks,
5252 }
5253
5254 #[derive(Debug, Serialize, Deserialize)]
5255 pub struct ContentDirectoryArrLinks {
5256 git: Option<String>,
5257 html: Option<String>,
5258 #[serde(rename="self")]
5259 self_: String,
5260 }
5261
5262 #[derive(Debug, Serialize, Deserialize)]
5263 pub struct ContentDirectoryArr {
5264 #[serde(rename="type")]
5265 type_: String,
5266 size: i64,
5267 name: String,
5268 path: String,
5269 #[serde(skip_serializing_if = "Option::is_none")]
5270 content: Option<String>,
5271 sha: String,
5272 url: String,
5273 git_url: Option<String>,
5274 html_url: Option<String>,
5275 download_url: Option<String>,
5276 #[serde(rename="_links")]
5277 links: ContentDirectoryArrLinks,
5278 }
5279
5280 pub type ContentDirectory = Vec<ContentDirectoryArr>;
5281
5282 #[derive(Debug, Serialize, Deserialize)]
5283 pub struct ContentFileLinks {
5284 git: Option<String>,
5285 html: Option<String>,
5286 #[serde(rename="self")]
5287 self_: String,
5288 }
5289
5290 #[derive(Debug, Serialize, Deserialize)]
5291 pub struct ContentFile {
5292 #[serde(rename="type")]
5293 type_: String,
5294 encoding: String,
5295 size: i64,
5296 name: String,
5297 path: String,
5298 content: String,
5299 sha: String,
5300 url: String,
5301 git_url: Option<String>,
5302 html_url: Option<String>,
5303 download_url: Option<String>,
5304 #[serde(rename="_links")]
5305 links: ContentFileLinks,
5306 #[serde(skip_serializing_if = "Option::is_none")]
5307 target: Option<String>,
5308 #[serde(skip_serializing_if = "Option::is_none")]
5309 submodule_git_url: Option<String>,
5310 }
5311
5312 #[derive(Debug, Serialize, Deserialize)]
5313 pub struct ContentSymlinkLinks {
5314 git: Option<String>,
5315 html: Option<String>,
5316 #[serde(rename="self")]
5317 self_: String,
5318 }
5319
5320 #[derive(Debug, Serialize, Deserialize)]
5321 pub struct ContentSymlink {
5322 #[serde(rename="type")]
5323 type_: String,
5324 target: String,
5325 size: i64,
5326 name: String,
5327 path: String,
5328 sha: String,
5329 url: String,
5330 git_url: Option<String>,
5331 html_url: Option<String>,
5332 download_url: Option<String>,
5333 #[serde(rename="_links")]
5334 links: ContentSymlinkLinks,
5335 }
5336
5337 #[derive(Debug, Serialize, Deserialize)]
5338 pub struct ContentSubmoduleLinks {
5339 git: Option<String>,
5340 html: Option<String>,
5341 #[serde(rename="self")]
5342 self_: String,
5343 }
5344
5345 #[derive(Debug, Serialize, Deserialize)]
5346 pub struct ContentSubmodule {
5347 #[serde(rename="type")]
5348 type_: String,
5349 submodule_git_url: String,
5350 size: i64,
5351 name: String,
5352 path: String,
5353 sha: String,
5354 url: String,
5355 git_url: Option<String>,
5356 html_url: Option<String>,
5357 download_url: Option<String>,
5358 #[serde(rename="_links")]
5359 links: ContentSubmoduleLinks,
5360 }
5361
5362 #[derive(Debug, Serialize, Deserialize)]
5363 pub struct FileCommitContentLinks {
5364 #[serde(rename="self", skip_serializing_if = "Option::is_none")]
5365 self_: Option<String>,
5366 #[serde(skip_serializing_if = "Option::is_none")]
5367 git: Option<String>,
5368 #[serde(skip_serializing_if = "Option::is_none")]
5369 html: Option<String>,
5370 }
5371
5372 #[derive(Debug, Serialize, Deserialize)]
5373 pub struct FileCommitContent {
5374 #[serde(skip_serializing_if = "Option::is_none")]
5375 name: Option<String>,
5376 #[serde(skip_serializing_if = "Option::is_none")]
5377 path: Option<String>,
5378 #[serde(skip_serializing_if = "Option::is_none")]
5379 sha: Option<String>,
5380 #[serde(skip_serializing_if = "Option::is_none")]
5381 size: Option<i64>,
5382 #[serde(skip_serializing_if = "Option::is_none")]
5383 url: Option<String>,
5384 #[serde(skip_serializing_if = "Option::is_none")]
5385 html_url: Option<String>,
5386 #[serde(skip_serializing_if = "Option::is_none")]
5387 git_url: Option<String>,
5388 #[serde(skip_serializing_if = "Option::is_none")]
5389 download_url: Option<String>,
5390 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
5391 type_: Option<String>,
5392 #[serde(rename="_links", skip_serializing_if = "Option::is_none")]
5393 links: Option<FileCommitContentLinks>,
5394 }
5395
5396 #[derive(Debug, Serialize, Deserialize)]
5397 pub struct FileCommitCommitAuthor {
5398 #[serde(skip_serializing_if = "Option::is_none")]
5399 date: Option<String>,
5400 #[serde(skip_serializing_if = "Option::is_none")]
5401 name: Option<String>,
5402 #[serde(skip_serializing_if = "Option::is_none")]
5403 email: Option<String>,
5404 }
5405
5406 #[derive(Debug, Serialize, Deserialize)]
5407 pub struct FileCommitCommitCommitter {
5408 #[serde(skip_serializing_if = "Option::is_none")]
5409 date: Option<String>,
5410 #[serde(skip_serializing_if = "Option::is_none")]
5411 name: Option<String>,
5412 #[serde(skip_serializing_if = "Option::is_none")]
5413 email: Option<String>,
5414 }
5415
5416 #[derive(Debug, Serialize, Deserialize)]
5417 pub struct FileCommitCommitTree {
5418 #[serde(skip_serializing_if = "Option::is_none")]
5419 url: Option<String>,
5420 #[serde(skip_serializing_if = "Option::is_none")]
5421 sha: Option<String>,
5422 }
5423
5424 #[derive(Debug, Serialize, Deserialize)]
5425 pub struct FileCommitCommitParents {
5426 #[serde(skip_serializing_if = "Option::is_none")]
5427 url: Option<String>,
5428 #[serde(skip_serializing_if = "Option::is_none")]
5429 html_url: Option<String>,
5430 #[serde(skip_serializing_if = "Option::is_none")]
5431 sha: Option<String>,
5432 }
5433
5434 #[derive(Debug, Serialize, Deserialize)]
5435 pub struct FileCommitCommitVerification {
5436 #[serde(skip_serializing_if = "Option::is_none")]
5437 verified: Option<bool>,
5438 #[serde(skip_serializing_if = "Option::is_none")]
5439 reason: Option<String>,
5440 #[serde(skip_serializing_if = "Option::is_none")]
5441 signature: Option<String>,
5442 #[serde(skip_serializing_if = "Option::is_none")]
5443 payload: Option<String>,
5444 }
5445
5446 #[derive(Debug, Serialize, Deserialize)]
5447 pub struct FileCommitCommit {
5448 #[serde(skip_serializing_if = "Option::is_none")]
5449 sha: Option<String>,
5450 #[serde(skip_serializing_if = "Option::is_none")]
5451 node_id: Option<String>,
5452 #[serde(skip_serializing_if = "Option::is_none")]
5453 url: Option<String>,
5454 #[serde(skip_serializing_if = "Option::is_none")]
5455 html_url: Option<String>,
5456 #[serde(skip_serializing_if = "Option::is_none")]
5457 author: Option<FileCommitCommitAuthor>,
5458 #[serde(skip_serializing_if = "Option::is_none")]
5459 committer: Option<FileCommitCommitCommitter>,
5460 #[serde(skip_serializing_if = "Option::is_none")]
5461 message: Option<String>,
5462 #[serde(skip_serializing_if = "Option::is_none")]
5463 tree: Option<FileCommitCommitTree>,
5464 #[serde(skip_serializing_if = "Option::is_none")]
5465 parents: Option<Vec<FileCommitCommitParents>>,
5466 #[serde(skip_serializing_if = "Option::is_none")]
5467 verification: Option<FileCommitCommitVerification>,
5468 }
5469
5470 #[derive(Debug, Serialize, Deserialize)]
5471 pub struct FileCommit {
5472 content: Option<FileCommitContent>,
5473 commit: FileCommitCommit,
5474 }
5475
5476 #[derive(Debug, Serialize, Deserialize)]
5477 pub struct Contributor {
5478 #[serde(skip_serializing_if = "Option::is_none")]
5479 login: Option<String>,
5480 #[serde(skip_serializing_if = "Option::is_none")]
5481 id: Option<i64>,
5482 #[serde(skip_serializing_if = "Option::is_none")]
5483 node_id: Option<String>,
5484 #[serde(skip_serializing_if = "Option::is_none")]
5485 avatar_url: Option<String>,
5486 #[serde(skip_serializing_if = "Option::is_none")]
5487 gravatar_id: Option<String>,
5488 #[serde(skip_serializing_if = "Option::is_none")]
5489 url: Option<String>,
5490 #[serde(skip_serializing_if = "Option::is_none")]
5491 html_url: Option<String>,
5492 #[serde(skip_serializing_if = "Option::is_none")]
5493 followers_url: Option<String>,
5494 #[serde(skip_serializing_if = "Option::is_none")]
5495 following_url: Option<String>,
5496 #[serde(skip_serializing_if = "Option::is_none")]
5497 gists_url: Option<String>,
5498 #[serde(skip_serializing_if = "Option::is_none")]
5499 starred_url: Option<String>,
5500 #[serde(skip_serializing_if = "Option::is_none")]
5501 subscriptions_url: Option<String>,
5502 #[serde(skip_serializing_if = "Option::is_none")]
5503 organizations_url: Option<String>,
5504 #[serde(skip_serializing_if = "Option::is_none")]
5505 repos_url: Option<String>,
5506 #[serde(skip_serializing_if = "Option::is_none")]
5507 events_url: Option<String>,
5508 #[serde(skip_serializing_if = "Option::is_none")]
5509 received_events_url: Option<String>,
5510 #[serde(rename="type")]
5511 type_: String,
5512 #[serde(skip_serializing_if = "Option::is_none")]
5513 site_admin: Option<bool>,
5514 contributions: i64,
5515 #[serde(skip_serializing_if = "Option::is_none")]
5516 email: Option<String>,
5517 #[serde(skip_serializing_if = "Option::is_none")]
5518 name: Option<String>,
5519 }
5520
5521 #[derive(Debug, Serialize, Deserialize)]
5522 pub struct DeploymentStatus {
5523 url: String,
5524 id: i64,
5525 node_id: String,
5526 state: String,
5527 creator: crate::components::schemas::NullableSimpleUser,
5529 description: String,
5530 #[serde(skip_serializing_if = "Option::is_none")]
5531 environment: Option<String>,
5532 target_url: String,
5533 created_at: String,
5534 updated_at: String,
5535 deployment_url: String,
5536 repository_url: String,
5537 #[serde(skip_serializing_if = "Option::is_none")]
5538 environment_url: Option<String>,
5539 #[serde(skip_serializing_if = "Option::is_none")]
5540 log_url: Option<String>,
5541 #[serde(skip_serializing_if = "Option::is_none")]
5543 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
5544 }
5545
5546 pub type WaitTimer = i64;
5547
5548 #[derive(Debug, Serialize, Deserialize)]
5549 pub struct DeploymentBranchPolicy {
5550 protected_branches: bool,
5551 custom_branch_policies: bool,
5552 }
5553
5554 #[derive(Debug, Serialize, Deserialize)]
5555 pub struct EnvironmentProtectionRules0 {
5556 id: i64,
5557 node_id: String,
5558 #[serde(rename="type")]
5559 type_: String,
5560 #[serde(skip_serializing_if = "Option::is_none")]
5562 wait_timer: Option<crate::components::schemas::WaitTimer>,
5563 }
5564
5565 #[derive(Debug, Serialize, Deserialize)]
5567 #[serde(untagged)]
5568 pub enum EnvironmentProtectionRules1ReviewersReviewerOneOf {
5569 SimpleUser(crate::components::schemas::SimpleUser),
5570 Team(crate::components::schemas::Team),
5571 }
5572
5573 #[derive(Debug, Serialize, Deserialize)]
5574 pub struct EnvironmentProtectionRules1Reviewers {
5575 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
5577 type_: Option<crate::components::schemas::DeploymentReviewerType>,
5578 #[serde(skip_serializing_if = "Option::is_none")]
5579 reviewer: Option<EnvironmentProtectionRules1ReviewersReviewerOneOf>,
5580 }
5581
5582 #[derive(Debug, Serialize, Deserialize)]
5583 pub struct EnvironmentProtectionRules1 {
5584 id: i64,
5585 node_id: String,
5586 #[serde(rename="type")]
5587 type_: String,
5588 #[serde(skip_serializing_if = "Option::is_none")]
5589 reviewers: Option<Vec<EnvironmentProtectionRules1Reviewers>>,
5590 }
5591
5592 #[derive(Debug, Serialize, Deserialize)]
5593 pub struct EnvironmentProtectionRules2 {
5594 id: i64,
5595 node_id: String,
5596 #[serde(rename="type")]
5597 type_: String,
5598 }
5599
5600 #[derive(Debug, Serialize, Deserialize)]
5602 #[serde(untagged)]
5603 pub enum EnvironmentProtectionRulesOneOf {
5604 EnvironmentProtectionRules0(EnvironmentProtectionRules0),
5605 EnvironmentProtectionRules1(EnvironmentProtectionRules1),
5606 EnvironmentProtectionRules2(EnvironmentProtectionRules2),
5607 }
5608
5609 #[derive(Debug, Serialize, Deserialize)]
5610 pub struct Environment {
5611 id: i64,
5612 node_id: String,
5613 name: String,
5614 url: String,
5615 html_url: String,
5616 created_at: String,
5617 updated_at: String,
5618 #[serde(skip_serializing_if = "Option::is_none")]
5619 protection_rules: Option<Vec<EnvironmentProtectionRulesOneOf>>,
5620 #[serde(skip_serializing_if = "Option::is_none")]
5622 deployment_branch_policy: Option<crate::components::schemas::DeploymentBranchPolicy>,
5623 }
5624
5625 #[derive(Debug, Serialize, Deserialize)]
5626 pub struct ShortBlob {
5627 url: String,
5628 sha: String,
5629 }
5630
5631 #[derive(Debug, Serialize, Deserialize)]
5632 pub struct Blob {
5633 content: String,
5634 encoding: String,
5635 url: String,
5636 sha: String,
5637 size: Option<i64>,
5638 node_id: String,
5639 #[serde(skip_serializing_if = "Option::is_none")]
5640 highlighted_content: Option<String>,
5641 }
5642
5643 #[derive(Debug, Serialize, Deserialize)]
5644 pub struct GitCommitAuthor {
5645 date: String,
5646 email: String,
5647 name: String,
5648 }
5649
5650 #[derive(Debug, Serialize, Deserialize)]
5651 pub struct GitCommitCommitter {
5652 date: String,
5653 email: String,
5654 name: String,
5655 }
5656
5657 #[derive(Debug, Serialize, Deserialize)]
5658 pub struct GitCommitTree {
5659 sha: String,
5660 url: String,
5661 }
5662
5663 #[derive(Debug, Serialize, Deserialize)]
5664 pub struct GitCommitParents {
5665 sha: String,
5666 url: String,
5667 html_url: String,
5668 }
5669
5670 #[derive(Debug, Serialize, Deserialize)]
5671 pub struct GitCommitVerification {
5672 verified: bool,
5673 reason: String,
5674 signature: Option<String>,
5675 payload: Option<String>,
5676 }
5677
5678 #[derive(Debug, Serialize, Deserialize)]
5679 pub struct GitCommit {
5680 sha: String,
5681 node_id: String,
5682 url: String,
5683 author: GitCommitAuthor,
5684 committer: GitCommitCommitter,
5685 message: String,
5686 tree: GitCommitTree,
5687 parents: Vec<GitCommitParents>,
5688 verification: GitCommitVerification,
5689 html_url: String,
5690 }
5691
5692 #[derive(Debug, Serialize, Deserialize)]
5693 pub struct GitRefObject {
5694 #[serde(rename="type")]
5695 type_: String,
5696 sha: String,
5697 url: String,
5698 }
5699
5700 #[derive(Debug, Serialize, Deserialize)]
5701 pub struct GitRef {
5702 #[serde(rename="ref")]
5703 ref_: String,
5704 node_id: String,
5705 url: String,
5706 object: GitRefObject,
5707 }
5708
5709 #[derive(Debug, Serialize, Deserialize)]
5710 pub struct GitTagTagger {
5711 date: String,
5712 email: String,
5713 name: String,
5714 }
5715
5716 #[derive(Debug, Serialize, Deserialize)]
5717 pub struct GitTagObject {
5718 sha: String,
5719 #[serde(rename="type")]
5720 type_: String,
5721 url: String,
5722 }
5723
5724 #[derive(Debug, Serialize, Deserialize)]
5725 pub struct GitTag {
5726 node_id: String,
5727 tag: String,
5728 sha: String,
5729 url: String,
5730 message: String,
5731 tagger: GitTagTagger,
5732 object: GitTagObject,
5733 #[serde(skip_serializing_if = "Option::is_none")]
5735 verification: Option<crate::components::schemas::Verification>,
5736 }
5737
5738 #[derive(Debug, Serialize, Deserialize)]
5739 pub struct GitTreeTree {
5740 #[serde(skip_serializing_if = "Option::is_none")]
5741 path: Option<String>,
5742 #[serde(skip_serializing_if = "Option::is_none")]
5743 mode: Option<String>,
5744 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
5745 type_: Option<String>,
5746 #[serde(skip_serializing_if = "Option::is_none")]
5747 sha: Option<String>,
5748 #[serde(skip_serializing_if = "Option::is_none")]
5749 size: Option<i64>,
5750 #[serde(skip_serializing_if = "Option::is_none")]
5751 url: Option<String>,
5752 }
5753
5754 #[derive(Debug, Serialize, Deserialize)]
5755 pub struct GitTree {
5756 sha: String,
5757 url: String,
5758 truncated: bool,
5759 tree: Vec<GitTreeTree>,
5760 }
5761
5762 #[derive(Debug, Serialize, Deserialize)]
5763 pub struct HookResponse {
5764 code: Option<i64>,
5765 status: Option<String>,
5766 message: Option<String>,
5767 }
5768
5769 #[derive(Debug, Serialize, Deserialize)]
5770 pub struct HookConfig {
5771 #[serde(skip_serializing_if = "Option::is_none")]
5772 email: Option<String>,
5773 #[serde(skip_serializing_if = "Option::is_none")]
5774 password: Option<String>,
5775 #[serde(skip_serializing_if = "Option::is_none")]
5776 room: Option<String>,
5777 #[serde(skip_serializing_if = "Option::is_none")]
5778 subdomain: Option<String>,
5779 #[serde(skip_serializing_if = "Option::is_none")]
5781 url: Option<crate::components::schemas::WebhookConfigUrl>,
5782 #[serde(skip_serializing_if = "Option::is_none")]
5784 insecure_ssl: Option<crate::components::schemas::WebhookConfigInsecureSsl>,
5785 #[serde(skip_serializing_if = "Option::is_none")]
5787 content_type: Option<crate::components::schemas::WebhookConfigContentType>,
5788 #[serde(skip_serializing_if = "Option::is_none")]
5789 digest: Option<String>,
5790 #[serde(skip_serializing_if = "Option::is_none")]
5792 secret: Option<crate::components::schemas::WebhookConfigSecret>,
5793 #[serde(skip_serializing_if = "Option::is_none")]
5794 token: Option<String>,
5795 }
5796
5797 #[derive(Debug, Serialize, Deserialize)]
5798 pub struct Hook {
5799 #[serde(rename="type")]
5800 type_: String,
5801 id: i64,
5802 name: String,
5803 active: bool,
5804 events: Vec<String>,
5805 config: HookConfig,
5806 updated_at: String,
5807 created_at: String,
5808 url: String,
5809 test_url: String,
5810 ping_url: String,
5811 #[serde(skip_serializing_if = "Option::is_none")]
5812 deliveries_url: Option<String>,
5813 last_response: crate::components::schemas::HookResponse,
5815 }
5816
5817 #[derive(Debug, Serialize, Deserialize)]
5818 pub struct ImportProjectChoices {
5819 #[serde(skip_serializing_if = "Option::is_none")]
5820 vcs: Option<String>,
5821 #[serde(skip_serializing_if = "Option::is_none")]
5822 tfvc_project: Option<String>,
5823 #[serde(skip_serializing_if = "Option::is_none")]
5824 human_name: Option<String>,
5825 }
5826
5827 #[derive(Debug, Serialize, Deserialize)]
5828 pub struct Import {
5829 vcs: Option<String>,
5830 #[serde(skip_serializing_if = "Option::is_none")]
5831 use_lfs: Option<bool>,
5832 vcs_url: String,
5833 #[serde(skip_serializing_if = "Option::is_none")]
5834 svc_root: Option<String>,
5835 #[serde(skip_serializing_if = "Option::is_none")]
5836 tfvc_project: Option<String>,
5837 status: String,
5838 #[serde(skip_serializing_if = "Option::is_none")]
5839 status_text: Option<String>,
5840 #[serde(skip_serializing_if = "Option::is_none")]
5841 failed_step: Option<String>,
5842 #[serde(skip_serializing_if = "Option::is_none")]
5843 error_message: Option<String>,
5844 #[serde(skip_serializing_if = "Option::is_none")]
5845 import_percent: Option<i64>,
5846 #[serde(skip_serializing_if = "Option::is_none")]
5847 commit_count: Option<i64>,
5848 #[serde(skip_serializing_if = "Option::is_none")]
5849 push_percent: Option<i64>,
5850 #[serde(skip_serializing_if = "Option::is_none")]
5851 has_large_files: Option<bool>,
5852 #[serde(skip_serializing_if = "Option::is_none")]
5853 large_files_size: Option<i64>,
5854 #[serde(skip_serializing_if = "Option::is_none")]
5855 large_files_count: Option<i64>,
5856 #[serde(skip_serializing_if = "Option::is_none")]
5857 project_choices: Option<Vec<ImportProjectChoices>>,
5858 #[serde(skip_serializing_if = "Option::is_none")]
5859 message: Option<String>,
5860 #[serde(skip_serializing_if = "Option::is_none")]
5861 authors_count: Option<i64>,
5862 url: String,
5863 html_url: String,
5864 authors_url: String,
5865 repository_url: String,
5866 #[serde(skip_serializing_if = "Option::is_none")]
5867 svn_root: Option<String>,
5868 }
5869
5870 #[derive(Debug, Serialize, Deserialize)]
5871 pub struct PorterAuthor {
5872 id: i64,
5873 remote_id: String,
5874 remote_name: String,
5875 email: String,
5876 name: String,
5877 url: String,
5878 import_url: String,
5879 }
5880
5881 #[derive(Debug, Serialize, Deserialize)]
5882 pub struct PorterLargeFile {
5883 ref_name: String,
5884 path: String,
5885 oid: String,
5886 size: i64,
5887 }
5888
5889 #[derive(Debug, Serialize, Deserialize)]
5890 pub struct NullableIssueLabels1 {
5891 #[serde(skip_serializing_if = "Option::is_none")]
5892 id: Option<i64>,
5893 #[serde(skip_serializing_if = "Option::is_none")]
5894 node_id: Option<String>,
5895 #[serde(skip_serializing_if = "Option::is_none")]
5896 url: Option<String>,
5897 #[serde(skip_serializing_if = "Option::is_none")]
5898 name: Option<String>,
5899 #[serde(skip_serializing_if = "Option::is_none")]
5900 description: Option<String>,
5901 #[serde(skip_serializing_if = "Option::is_none")]
5902 color: Option<String>,
5903 #[serde(skip_serializing_if = "Option::is_none")]
5904 default: Option<bool>,
5905 }
5906
5907 #[derive(Debug, Serialize, Deserialize)]
5909 #[serde(untagged)]
5910 pub enum NullableIssueLabelsOneOf {
5911 String(String),
5912 NullableIssueLabels1(NullableIssueLabels1),
5913 }
5914
5915 #[derive(Debug, Serialize, Deserialize)]
5916 pub struct NullableIssuePullRequest {
5917 #[serde(skip_serializing_if = "Option::is_none")]
5918 merged_at: Option<String>,
5919 diff_url: Option<String>,
5920 html_url: Option<String>,
5921 patch_url: Option<String>,
5922 url: Option<String>,
5923 }
5924
5925 #[derive(Debug, Serialize, Deserialize)]
5926 pub struct NullableIssue {
5927 id: i64,
5928 node_id: String,
5929 url: String,
5930 repository_url: String,
5931 labels_url: String,
5932 comments_url: String,
5933 events_url: String,
5934 html_url: String,
5935 number: i64,
5936 state: String,
5937 title: String,
5938 #[serde(skip_serializing_if = "Option::is_none")]
5939 body: Option<String>,
5940 user: crate::components::schemas::NullableSimpleUser,
5942 labels: Vec<NullableIssueLabelsOneOf>,
5943 assignee: crate::components::schemas::NullableSimpleUser,
5945 #[serde(skip_serializing_if = "Option::is_none")]
5946 assignees: Option<Vec<crate::components::schemas::SimpleUser>>,
5947 milestone: crate::components::schemas::NullableMilestone,
5949 locked: bool,
5950 #[serde(skip_serializing_if = "Option::is_none")]
5951 active_lock_reason: Option<String>,
5952 comments: i64,
5953 #[serde(skip_serializing_if = "Option::is_none")]
5954 pull_request: Option<NullableIssuePullRequest>,
5955 closed_at: Option<String>,
5956 created_at: String,
5957 updated_at: String,
5958 #[serde(skip_serializing_if = "Option::is_none")]
5960 closed_by: Option<crate::components::schemas::NullableSimpleUser>,
5961 #[serde(skip_serializing_if = "Option::is_none")]
5962 body_html: Option<String>,
5963 #[serde(skip_serializing_if = "Option::is_none")]
5964 body_text: Option<String>,
5965 #[serde(skip_serializing_if = "Option::is_none")]
5966 timeline_url: Option<String>,
5967 #[serde(skip_serializing_if = "Option::is_none")]
5969 repository: Option<crate::components::schemas::Repository>,
5970 #[serde(skip_serializing_if = "Option::is_none")]
5972 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
5973 author_association: crate::components::schemas::AuthorAssociation,
5975 #[serde(skip_serializing_if = "Option::is_none")]
5977 reactions: Option<crate::components::schemas::ReactionRollup>,
5978 }
5979
5980 #[derive(Debug, Serialize, Deserialize)]
5981 pub struct IssueEventLabel {
5982 name: Option<String>,
5983 color: Option<String>,
5984 }
5985
5986 #[derive(Debug, Serialize, Deserialize)]
5987 pub struct IssueEventDismissedReview {
5988 state: String,
5989 review_id: i64,
5990 dismissal_message: Option<String>,
5991 #[serde(skip_serializing_if = "Option::is_none")]
5992 dismissal_commit_id: Option<String>,
5993 }
5994
5995 #[derive(Debug, Serialize, Deserialize)]
5996 pub struct IssueEventMilestone {
5997 title: String,
5998 }
5999
6000 #[derive(Debug, Serialize, Deserialize)]
6001 pub struct IssueEventProjectCard {
6002 url: String,
6003 id: i64,
6004 project_url: String,
6005 project_id: i64,
6006 column_name: String,
6007 #[serde(skip_serializing_if = "Option::is_none")]
6008 previous_column_name: Option<String>,
6009 }
6010
6011 #[derive(Debug, Serialize, Deserialize)]
6012 pub struct IssueEventRename {
6013 from: String,
6014 to: String,
6015 }
6016
6017 #[derive(Debug, Serialize, Deserialize)]
6018 pub struct IssueEvent {
6019 id: i64,
6020 node_id: String,
6021 url: String,
6022 actor: crate::components::schemas::NullableSimpleUser,
6024 event: String,
6025 commit_id: Option<String>,
6026 commit_url: Option<String>,
6027 created_at: String,
6028 #[serde(skip_serializing_if = "Option::is_none")]
6030 issue: Option<crate::components::schemas::NullableIssue>,
6031 #[serde(skip_serializing_if = "Option::is_none")]
6033 label: Option<crate::components::schemas::IssueEventLabel>,
6034 #[serde(skip_serializing_if = "Option::is_none")]
6036 assignee: Option<crate::components::schemas::NullableSimpleUser>,
6037 #[serde(skip_serializing_if = "Option::is_none")]
6039 assigner: Option<crate::components::schemas::NullableSimpleUser>,
6040 #[serde(skip_serializing_if = "Option::is_none")]
6042 review_requester: Option<crate::components::schemas::NullableSimpleUser>,
6043 #[serde(skip_serializing_if = "Option::is_none")]
6045 requested_reviewer: Option<crate::components::schemas::NullableSimpleUser>,
6046 #[serde(skip_serializing_if = "Option::is_none")]
6048 requested_team: Option<crate::components::schemas::Team>,
6049 #[serde(skip_serializing_if = "Option::is_none")]
6051 dismissed_review: Option<crate::components::schemas::IssueEventDismissedReview>,
6052 #[serde(skip_serializing_if = "Option::is_none")]
6054 milestone: Option<crate::components::schemas::IssueEventMilestone>,
6055 #[serde(skip_serializing_if = "Option::is_none")]
6057 project_card: Option<crate::components::schemas::IssueEventProjectCard>,
6058 #[serde(skip_serializing_if = "Option::is_none")]
6060 rename: Option<crate::components::schemas::IssueEventRename>,
6061 #[serde(skip_serializing_if = "Option::is_none")]
6063 author_association: Option<crate::components::schemas::AuthorAssociation>,
6064 #[serde(skip_serializing_if = "Option::is_none")]
6065 lock_reason: Option<String>,
6066 #[serde(skip_serializing_if = "Option::is_none")]
6068 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
6069 }
6070
6071 #[derive(Debug, Serialize, Deserialize)]
6072 pub struct LabeledIssueEventLabel {
6073 name: String,
6074 color: String,
6075 }
6076
6077 #[derive(Debug, Serialize, Deserialize)]
6078 pub struct LabeledIssueEvent {
6079 id: i64,
6080 node_id: String,
6081 url: String,
6082 actor: crate::components::schemas::SimpleUser,
6084 event: String,
6085 commit_id: Option<String>,
6086 commit_url: Option<String>,
6087 created_at: String,
6088 performed_via_github_app: crate::components::schemas::NullableIntegration,
6090 label: LabeledIssueEventLabel,
6091 }
6092
6093 #[derive(Debug, Serialize, Deserialize)]
6094 pub struct UnlabeledIssueEventLabel {
6095 name: String,
6096 color: String,
6097 }
6098
6099 #[derive(Debug, Serialize, Deserialize)]
6100 pub struct UnlabeledIssueEvent {
6101 id: i64,
6102 node_id: String,
6103 url: String,
6104 actor: crate::components::schemas::SimpleUser,
6106 event: String,
6107 commit_id: Option<String>,
6108 commit_url: Option<String>,
6109 created_at: String,
6110 performed_via_github_app: crate::components::schemas::NullableIntegration,
6112 label: UnlabeledIssueEventLabel,
6113 }
6114
6115 #[derive(Debug, Serialize, Deserialize)]
6116 pub struct AssignedIssueEvent {
6117 id: i64,
6118 node_id: String,
6119 url: String,
6120 actor: crate::components::schemas::SimpleUser,
6122 event: String,
6123 commit_id: Option<String>,
6124 commit_url: Option<String>,
6125 created_at: String,
6126 performed_via_github_app: crate::components::schemas::Integration,
6128 assignee: crate::components::schemas::SimpleUser,
6130 assigner: crate::components::schemas::SimpleUser,
6132 }
6133
6134 #[derive(Debug, Serialize, Deserialize)]
6135 pub struct UnassignedIssueEvent {
6136 id: i64,
6137 node_id: String,
6138 url: String,
6139 actor: crate::components::schemas::SimpleUser,
6141 event: String,
6142 commit_id: Option<String>,
6143 commit_url: Option<String>,
6144 created_at: String,
6145 performed_via_github_app: crate::components::schemas::NullableIntegration,
6147 assignee: crate::components::schemas::SimpleUser,
6149 assigner: crate::components::schemas::SimpleUser,
6151 }
6152
6153 #[derive(Debug, Serialize, Deserialize)]
6154 pub struct MilestonedIssueEventMilestone {
6155 title: String,
6156 }
6157
6158 #[derive(Debug, Serialize, Deserialize)]
6159 pub struct MilestonedIssueEvent {
6160 id: i64,
6161 node_id: String,
6162 url: String,
6163 actor: crate::components::schemas::SimpleUser,
6165 event: String,
6166 commit_id: Option<String>,
6167 commit_url: Option<String>,
6168 created_at: String,
6169 performed_via_github_app: crate::components::schemas::NullableIntegration,
6171 milestone: MilestonedIssueEventMilestone,
6172 }
6173
6174 #[derive(Debug, Serialize, Deserialize)]
6175 pub struct DemilestonedIssueEventMilestone {
6176 title: String,
6177 }
6178
6179 #[derive(Debug, Serialize, Deserialize)]
6180 pub struct DemilestonedIssueEvent {
6181 id: i64,
6182 node_id: String,
6183 url: String,
6184 actor: crate::components::schemas::SimpleUser,
6186 event: String,
6187 commit_id: Option<String>,
6188 commit_url: Option<String>,
6189 created_at: String,
6190 performed_via_github_app: crate::components::schemas::NullableIntegration,
6192 milestone: DemilestonedIssueEventMilestone,
6193 }
6194
6195 #[derive(Debug, Serialize, Deserialize)]
6196 pub struct RenamedIssueEventRename {
6197 from: String,
6198 to: String,
6199 }
6200
6201 #[derive(Debug, Serialize, Deserialize)]
6202 pub struct RenamedIssueEvent {
6203 id: i64,
6204 node_id: String,
6205 url: String,
6206 actor: crate::components::schemas::SimpleUser,
6208 event: String,
6209 commit_id: Option<String>,
6210 commit_url: Option<String>,
6211 created_at: String,
6212 performed_via_github_app: crate::components::schemas::NullableIntegration,
6214 rename: RenamedIssueEventRename,
6215 }
6216
6217 #[derive(Debug, Serialize, Deserialize)]
6218 pub struct ReviewRequestedIssueEvent {
6219 id: i64,
6220 node_id: String,
6221 url: String,
6222 actor: crate::components::schemas::SimpleUser,
6224 event: String,
6225 commit_id: Option<String>,
6226 commit_url: Option<String>,
6227 created_at: String,
6228 performed_via_github_app: crate::components::schemas::NullableIntegration,
6230 review_requester: crate::components::schemas::SimpleUser,
6232 #[serde(skip_serializing_if = "Option::is_none")]
6234 requested_team: Option<crate::components::schemas::Team>,
6235 #[serde(skip_serializing_if = "Option::is_none")]
6237 requested_reviewer: Option<crate::components::schemas::SimpleUser>,
6238 }
6239
6240 #[derive(Debug, Serialize, Deserialize)]
6241 pub struct ReviewRequestRemovedIssueEvent {
6242 id: i64,
6243 node_id: String,
6244 url: String,
6245 actor: crate::components::schemas::SimpleUser,
6247 event: String,
6248 commit_id: Option<String>,
6249 commit_url: Option<String>,
6250 created_at: String,
6251 performed_via_github_app: crate::components::schemas::NullableIntegration,
6253 review_requester: crate::components::schemas::SimpleUser,
6255 #[serde(skip_serializing_if = "Option::is_none")]
6257 requested_team: Option<crate::components::schemas::Team>,
6258 #[serde(skip_serializing_if = "Option::is_none")]
6260 requested_reviewer: Option<crate::components::schemas::SimpleUser>,
6261 }
6262
6263 #[derive(Debug, Serialize, Deserialize)]
6264 pub struct ReviewDismissedIssueEventDismissedReview {
6265 state: String,
6266 review_id: i64,
6267 dismissal_message: Option<String>,
6268 #[serde(skip_serializing_if = "Option::is_none")]
6269 dismissal_commit_id: Option<String>,
6270 }
6271
6272 #[derive(Debug, Serialize, Deserialize)]
6273 pub struct ReviewDismissedIssueEvent {
6274 id: i64,
6275 node_id: String,
6276 url: String,
6277 actor: crate::components::schemas::SimpleUser,
6279 event: String,
6280 commit_id: Option<String>,
6281 commit_url: Option<String>,
6282 created_at: String,
6283 performed_via_github_app: crate::components::schemas::NullableIntegration,
6285 dismissed_review: ReviewDismissedIssueEventDismissedReview,
6286 }
6287
6288 #[derive(Debug, Serialize, Deserialize)]
6289 pub struct LockedIssueEvent {
6290 id: i64,
6291 node_id: String,
6292 url: String,
6293 actor: crate::components::schemas::SimpleUser,
6295 event: String,
6296 commit_id: Option<String>,
6297 commit_url: Option<String>,
6298 created_at: String,
6299 performed_via_github_app: crate::components::schemas::NullableIntegration,
6301 lock_reason: Option<String>,
6302 }
6303
6304 #[derive(Debug, Serialize, Deserialize)]
6305 pub struct AddedToProjectIssueEventProjectCard {
6306 id: i64,
6307 url: String,
6308 project_id: i64,
6309 project_url: String,
6310 column_name: String,
6311 #[serde(skip_serializing_if = "Option::is_none")]
6312 previous_column_name: Option<String>,
6313 }
6314
6315 #[derive(Debug, Serialize, Deserialize)]
6316 pub struct AddedToProjectIssueEvent {
6317 id: i64,
6318 node_id: String,
6319 url: String,
6320 actor: crate::components::schemas::SimpleUser,
6322 event: String,
6323 commit_id: Option<String>,
6324 commit_url: Option<String>,
6325 created_at: String,
6326 performed_via_github_app: crate::components::schemas::NullableIntegration,
6328 #[serde(skip_serializing_if = "Option::is_none")]
6329 project_card: Option<AddedToProjectIssueEventProjectCard>,
6330 }
6331
6332 #[derive(Debug, Serialize, Deserialize)]
6333 pub struct MovedColumnInProjectIssueEventProjectCard {
6334 id: i64,
6335 url: String,
6336 project_id: i64,
6337 project_url: String,
6338 column_name: String,
6339 #[serde(skip_serializing_if = "Option::is_none")]
6340 previous_column_name: Option<String>,
6341 }
6342
6343 #[derive(Debug, Serialize, Deserialize)]
6344 pub struct MovedColumnInProjectIssueEvent {
6345 id: i64,
6346 node_id: String,
6347 url: String,
6348 actor: crate::components::schemas::SimpleUser,
6350 event: String,
6351 commit_id: Option<String>,
6352 commit_url: Option<String>,
6353 created_at: String,
6354 performed_via_github_app: crate::components::schemas::NullableIntegration,
6356 #[serde(skip_serializing_if = "Option::is_none")]
6357 project_card: Option<MovedColumnInProjectIssueEventProjectCard>,
6358 }
6359
6360 #[derive(Debug, Serialize, Deserialize)]
6361 pub struct RemovedFromProjectIssueEventProjectCard {
6362 id: i64,
6363 url: String,
6364 project_id: i64,
6365 project_url: String,
6366 column_name: String,
6367 #[serde(skip_serializing_if = "Option::is_none")]
6368 previous_column_name: Option<String>,
6369 }
6370
6371 #[derive(Debug, Serialize, Deserialize)]
6372 pub struct RemovedFromProjectIssueEvent {
6373 id: i64,
6374 node_id: String,
6375 url: String,
6376 actor: crate::components::schemas::SimpleUser,
6378 event: String,
6379 commit_id: Option<String>,
6380 commit_url: Option<String>,
6381 created_at: String,
6382 performed_via_github_app: crate::components::schemas::NullableIntegration,
6384 #[serde(skip_serializing_if = "Option::is_none")]
6385 project_card: Option<RemovedFromProjectIssueEventProjectCard>,
6386 }
6387
6388 #[derive(Debug, Serialize, Deserialize)]
6389 pub struct ConvertedNoteToIssueIssueEventProjectCard {
6390 id: i64,
6391 url: String,
6392 project_id: i64,
6393 project_url: String,
6394 column_name: String,
6395 #[serde(skip_serializing_if = "Option::is_none")]
6396 previous_column_name: Option<String>,
6397 }
6398
6399 #[derive(Debug, Serialize, Deserialize)]
6400 pub struct ConvertedNoteToIssueIssueEvent {
6401 id: i64,
6402 node_id: String,
6403 url: String,
6404 actor: crate::components::schemas::SimpleUser,
6406 event: String,
6407 commit_id: Option<String>,
6408 commit_url: Option<String>,
6409 created_at: String,
6410 performed_via_github_app: crate::components::schemas::Integration,
6412 #[serde(skip_serializing_if = "Option::is_none")]
6413 project_card: Option<ConvertedNoteToIssueIssueEventProjectCard>,
6414 }
6415
6416 #[derive(Debug, Serialize, Deserialize)]
6417 #[serde(untagged)]
6418 pub enum IssueEventForIssue {
6419 LabeledIssueEvent(crate::components::schemas::LabeledIssueEvent),
6420 UnlabeledIssueEvent(crate::components::schemas::UnlabeledIssueEvent),
6421 AssignedIssueEvent(crate::components::schemas::AssignedIssueEvent),
6422 UnassignedIssueEvent(crate::components::schemas::UnassignedIssueEvent),
6423 MilestonedIssueEvent(crate::components::schemas::MilestonedIssueEvent),
6424 DemilestonedIssueEvent(crate::components::schemas::DemilestonedIssueEvent),
6425 RenamedIssueEvent(crate::components::schemas::RenamedIssueEvent),
6426 ReviewRequestedIssueEvent(crate::components::schemas::ReviewRequestedIssueEvent),
6427 ReviewRequestRemovedIssueEvent(crate::components::schemas::ReviewRequestRemovedIssueEvent),
6428 ReviewDismissedIssueEvent(crate::components::schemas::ReviewDismissedIssueEvent),
6429 LockedIssueEvent(crate::components::schemas::LockedIssueEvent),
6430 AddedToProjectIssueEvent(crate::components::schemas::AddedToProjectIssueEvent),
6431 MovedColumnInProjectIssueEvent(crate::components::schemas::MovedColumnInProjectIssueEvent),
6432 RemovedFromProjectIssueEvent(crate::components::schemas::RemovedFromProjectIssueEvent),
6433 ConvertedNoteToIssueIssueEvent(crate::components::schemas::ConvertedNoteToIssueIssueEvent),
6434 }
6435
6436 #[derive(Debug, Serialize, Deserialize)]
6437 pub struct Label {
6438 id: i64,
6439 node_id: String,
6440 url: String,
6441 name: String,
6442 description: Option<String>,
6443 color: String,
6444 default: bool,
6445 }
6446
6447 #[derive(Debug, Serialize, Deserialize)]
6448 pub struct TimelineCommentEvent {
6449 event: String,
6450 actor: crate::components::schemas::SimpleUser,
6452 id: i64,
6453 node_id: String,
6454 url: String,
6455 #[serde(skip_serializing_if = "Option::is_none")]
6456 body: Option<String>,
6457 #[serde(skip_serializing_if = "Option::is_none")]
6458 body_text: Option<String>,
6459 #[serde(skip_serializing_if = "Option::is_none")]
6460 body_html: Option<String>,
6461 html_url: String,
6462 user: crate::components::schemas::SimpleUser,
6464 created_at: String,
6465 updated_at: String,
6466 issue_url: String,
6467 author_association: crate::components::schemas::AuthorAssociation,
6469 #[serde(skip_serializing_if = "Option::is_none")]
6471 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
6472 #[serde(skip_serializing_if = "Option::is_none")]
6474 reactions: Option<crate::components::schemas::ReactionRollup>,
6475 }
6476
6477 #[derive(Debug, Serialize, Deserialize)]
6478 pub struct TimelineCrossReferencedEventSource {
6479 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
6480 type_: Option<String>,
6481 #[serde(skip_serializing_if = "Option::is_none")]
6483 issue: Option<crate::components::schemas::Issue>,
6484 }
6485
6486 #[derive(Debug, Serialize, Deserialize)]
6487 pub struct TimelineCrossReferencedEvent {
6488 event: String,
6489 #[serde(skip_serializing_if = "Option::is_none")]
6491 actor: Option<crate::components::schemas::SimpleUser>,
6492 created_at: String,
6493 updated_at: String,
6494 source: TimelineCrossReferencedEventSource,
6495 }
6496
6497 #[derive(Debug, Serialize, Deserialize)]
6498 pub struct TimelineCommittedEventAuthor {
6499 date: String,
6500 email: String,
6501 name: String,
6502 }
6503
6504 #[derive(Debug, Serialize, Deserialize)]
6505 pub struct TimelineCommittedEventCommitter {
6506 date: String,
6507 email: String,
6508 name: String,
6509 }
6510
6511 #[derive(Debug, Serialize, Deserialize)]
6512 pub struct TimelineCommittedEventTree {
6513 sha: String,
6514 url: String,
6515 }
6516
6517 #[derive(Debug, Serialize, Deserialize)]
6518 pub struct TimelineCommittedEventParents {
6519 sha: String,
6520 url: String,
6521 html_url: String,
6522 }
6523
6524 #[derive(Debug, Serialize, Deserialize)]
6525 pub struct TimelineCommittedEventVerification {
6526 verified: bool,
6527 reason: String,
6528 signature: Option<String>,
6529 payload: Option<String>,
6530 }
6531
6532 #[derive(Debug, Serialize, Deserialize)]
6533 pub struct TimelineCommittedEvent {
6534 #[serde(skip_serializing_if = "Option::is_none")]
6535 event: Option<String>,
6536 sha: String,
6537 node_id: String,
6538 url: String,
6539 author: TimelineCommittedEventAuthor,
6540 committer: TimelineCommittedEventCommitter,
6541 message: String,
6542 tree: TimelineCommittedEventTree,
6543 parents: Vec<TimelineCommittedEventParents>,
6544 verification: TimelineCommittedEventVerification,
6545 html_url: String,
6546 }
6547
6548 #[derive(Debug, Serialize, Deserialize)]
6549 pub struct TimelineReviewedEventLinksHtml {
6550 href: String,
6551 }
6552
6553 #[derive(Debug, Serialize, Deserialize)]
6554 pub struct TimelineReviewedEventLinksPullRequest {
6555 href: String,
6556 }
6557
6558 #[derive(Debug, Serialize, Deserialize)]
6559 pub struct TimelineReviewedEventLinks {
6560 html: TimelineReviewedEventLinksHtml,
6561 pull_request: TimelineReviewedEventLinksPullRequest,
6562 }
6563
6564 #[derive(Debug, Serialize, Deserialize)]
6565 pub struct TimelineReviewedEvent {
6566 event: String,
6567 id: i64,
6568 node_id: String,
6569 user: crate::components::schemas::SimpleUser,
6571 body: Option<String>,
6572 state: String,
6573 html_url: String,
6574 pull_request_url: String,
6575 #[serde(rename="_links")]
6576 links: TimelineReviewedEventLinks,
6577 #[serde(skip_serializing_if = "Option::is_none")]
6578 submitted_at: Option<String>,
6579 commit_id: String,
6580 #[serde(skip_serializing_if = "Option::is_none")]
6581 body_html: Option<String>,
6582 #[serde(skip_serializing_if = "Option::is_none")]
6583 body_text: Option<String>,
6584 author_association: crate::components::schemas::AuthorAssociation,
6586 }
6587
6588 #[derive(Debug, Serialize, Deserialize)]
6589 pub struct PullRequestReviewCommentLinksSelf {
6590 href: String,
6591 }
6592
6593 #[derive(Debug, Serialize, Deserialize)]
6594 pub struct PullRequestReviewCommentLinksHtml {
6595 href: String,
6596 }
6597
6598 #[derive(Debug, Serialize, Deserialize)]
6599 pub struct PullRequestReviewCommentLinksPullRequest {
6600 href: String,
6601 }
6602
6603 #[derive(Debug, Serialize, Deserialize)]
6604 pub struct PullRequestReviewCommentLinks {
6605 #[serde(rename="self")]
6606 self_: PullRequestReviewCommentLinksSelf,
6607 html: PullRequestReviewCommentLinksHtml,
6608 pull_request: PullRequestReviewCommentLinksPullRequest,
6609 }
6610
6611 #[derive(Debug, Serialize, Deserialize)]
6612 pub struct PullRequestReviewComment {
6613 url: String,
6614 pull_request_review_id: Option<i64>,
6615 id: i64,
6616 node_id: String,
6617 diff_hunk: String,
6618 path: String,
6619 position: i64,
6620 original_position: i64,
6621 commit_id: String,
6622 original_commit_id: String,
6623 #[serde(skip_serializing_if = "Option::is_none")]
6624 in_reply_to_id: Option<i64>,
6625 user: crate::components::schemas::SimpleUser,
6627 body: String,
6628 created_at: String,
6629 updated_at: String,
6630 html_url: String,
6631 pull_request_url: String,
6632 author_association: crate::components::schemas::AuthorAssociation,
6634 #[serde(rename="_links")]
6635 links: PullRequestReviewCommentLinks,
6636 #[serde(skip_serializing_if = "Option::is_none")]
6637 start_line: Option<i64>,
6638 #[serde(skip_serializing_if = "Option::is_none")]
6639 original_start_line: Option<i64>,
6640 #[serde(skip_serializing_if = "Option::is_none")]
6641 start_side: Option<String>,
6642 #[serde(skip_serializing_if = "Option::is_none")]
6643 line: Option<i64>,
6644 #[serde(skip_serializing_if = "Option::is_none")]
6645 original_line: Option<i64>,
6646 #[serde(skip_serializing_if = "Option::is_none")]
6647 side: Option<String>,
6648 #[serde(skip_serializing_if = "Option::is_none")]
6650 reactions: Option<crate::components::schemas::ReactionRollup>,
6651 #[serde(skip_serializing_if = "Option::is_none")]
6652 body_html: Option<String>,
6653 #[serde(skip_serializing_if = "Option::is_none")]
6654 body_text: Option<String>,
6655 }
6656
6657 #[derive(Debug, Serialize, Deserialize)]
6658 pub struct TimelineLineCommentedEvent {
6659 #[serde(skip_serializing_if = "Option::is_none")]
6660 event: Option<String>,
6661 #[serde(skip_serializing_if = "Option::is_none")]
6662 node_id: Option<String>,
6663 #[serde(skip_serializing_if = "Option::is_none")]
6664 comments: Option<Vec<crate::components::schemas::PullRequestReviewComment>>,
6665 }
6666
6667 #[derive(Debug, Serialize, Deserialize)]
6668 pub struct TimelineCommitCommentedEvent {
6669 #[serde(skip_serializing_if = "Option::is_none")]
6670 event: Option<String>,
6671 #[serde(skip_serializing_if = "Option::is_none")]
6672 node_id: Option<String>,
6673 #[serde(skip_serializing_if = "Option::is_none")]
6674 commit_id: Option<String>,
6675 #[serde(skip_serializing_if = "Option::is_none")]
6676 comments: Option<Vec<crate::components::schemas::CommitComment>>,
6677 }
6678
6679 #[derive(Debug, Serialize, Deserialize)]
6680 pub struct TimelineAssignedIssueEvent {
6681 id: i64,
6682 node_id: String,
6683 url: String,
6684 actor: crate::components::schemas::SimpleUser,
6686 event: String,
6687 commit_id: Option<String>,
6688 commit_url: Option<String>,
6689 created_at: String,
6690 performed_via_github_app: crate::components::schemas::NullableIntegration,
6692 assignee: crate::components::schemas::SimpleUser,
6694 }
6695
6696 #[derive(Debug, Serialize, Deserialize)]
6697 pub struct TimelineUnassignedIssueEvent {
6698 id: i64,
6699 node_id: String,
6700 url: String,
6701 actor: crate::components::schemas::SimpleUser,
6703 event: String,
6704 commit_id: Option<String>,
6705 commit_url: Option<String>,
6706 created_at: String,
6707 performed_via_github_app: crate::components::schemas::NullableIntegration,
6709 assignee: crate::components::schemas::SimpleUser,
6711 }
6712
6713 #[derive(Debug, Serialize, Deserialize)]
6714 pub struct TimelineIssueEvents;
6715
6716 #[derive(Debug, Serialize, Deserialize)]
6717 pub struct DeployKey {
6718 id: i64,
6719 key: String,
6720 url: String,
6721 title: String,
6722 verified: bool,
6723 created_at: String,
6724 read_only: bool,
6725 }
6726
6727 #[derive(Debug, Serialize, Deserialize)]
6728 pub struct Language;
6729
6730 #[derive(Debug, Serialize, Deserialize)]
6731 pub struct LicenseContentLinks {
6732 git: Option<String>,
6733 html: Option<String>,
6734 #[serde(rename="self")]
6735 self_: String,
6736 }
6737
6738 #[derive(Debug, Serialize, Deserialize)]
6739 pub struct LicenseContent {
6740 name: String,
6741 path: String,
6742 sha: String,
6743 size: i64,
6744 url: String,
6745 html_url: Option<String>,
6746 git_url: Option<String>,
6747 download_url: Option<String>,
6748 #[serde(rename="type")]
6749 type_: String,
6750 content: String,
6751 encoding: String,
6752 #[serde(rename="_links")]
6753 links: LicenseContentLinks,
6754 license: crate::components::schemas::NullableLicenseSimple,
6756 }
6757
6758 #[derive(Debug, Serialize, Deserialize)]
6759 pub struct MergedUpstream {
6760 #[serde(skip_serializing_if = "Option::is_none")]
6761 message: Option<String>,
6762 #[serde(skip_serializing_if = "Option::is_none")]
6763 merge_type: Option<String>,
6764 #[serde(skip_serializing_if = "Option::is_none")]
6765 base_branch: Option<String>,
6766 }
6767
6768 #[derive(Debug, Serialize, Deserialize)]
6769 pub struct Milestone {
6770 url: String,
6771 html_url: String,
6772 labels_url: String,
6773 id: i64,
6774 node_id: String,
6775 number: i64,
6776 state: String,
6777 title: String,
6778 description: Option<String>,
6779 creator: crate::components::schemas::NullableSimpleUser,
6781 open_issues: i64,
6782 closed_issues: i64,
6783 created_at: String,
6784 updated_at: String,
6785 closed_at: Option<String>,
6786 due_on: Option<String>,
6787 }
6788
6789 #[derive(Debug, Serialize, Deserialize)]
6790 pub struct PagesSourceHash {
6791 branch: String,
6792 path: String,
6793 }
6794
6795 #[derive(Debug, Serialize, Deserialize)]
6796 pub struct PagesHttpsCertificate {
6797 state: String,
6798 description: String,
6799 domains: Vec<String>,
6800 #[serde(skip_serializing_if = "Option::is_none")]
6801 expires_at: Option<String>,
6802 }
6803
6804 #[derive(Debug, Serialize, Deserialize)]
6805 pub struct Page {
6806 url: String,
6807 status: Option<String>,
6808 cname: Option<String>,
6809 #[serde(skip_serializing_if = "Option::is_none")]
6810 protected_domain_state: Option<String>,
6811 #[serde(skip_serializing_if = "Option::is_none")]
6812 pending_domain_unverified_at: Option<String>,
6813 custom_404: bool,
6814 #[serde(skip_serializing_if = "Option::is_none")]
6815 html_url: Option<String>,
6816 #[serde(skip_serializing_if = "Option::is_none")]
6818 source: Option<crate::components::schemas::PagesSourceHash>,
6819 public: bool,
6820 #[serde(skip_serializing_if = "Option::is_none")]
6822 https_certificate: Option<crate::components::schemas::PagesHttpsCertificate>,
6823 #[serde(skip_serializing_if = "Option::is_none")]
6824 https_enforced: Option<bool>,
6825 }
6826
6827 #[derive(Debug, Serialize, Deserialize)]
6828 pub struct PageBuildError {
6829 message: Option<String>,
6830 }
6831
6832 #[derive(Debug, Serialize, Deserialize)]
6833 pub struct PageBuild {
6834 url: String,
6835 status: String,
6836 error: PageBuildError,
6837 pusher: crate::components::schemas::NullableSimpleUser,
6839 commit: String,
6840 duration: i64,
6841 created_at: String,
6842 updated_at: String,
6843 }
6844
6845 #[derive(Debug, Serialize, Deserialize)]
6846 pub struct PageBuildStatus {
6847 url: String,
6848 status: String,
6849 }
6850
6851 #[derive(Debug, Serialize, Deserialize)]
6852 pub struct PagesHealthCheckDomain {
6853 #[serde(skip_serializing_if = "Option::is_none")]
6854 host: Option<String>,
6855 #[serde(skip_serializing_if = "Option::is_none")]
6856 uri: Option<String>,
6857 #[serde(skip_serializing_if = "Option::is_none")]
6858 nameservers: Option<String>,
6859 #[serde(skip_serializing_if = "Option::is_none")]
6860 dns_resolves: Option<bool>,
6861 #[serde(skip_serializing_if = "Option::is_none")]
6862 is_proxied: Option<bool>,
6863 #[serde(skip_serializing_if = "Option::is_none")]
6864 is_cloudflare_ip: Option<bool>,
6865 #[serde(skip_serializing_if = "Option::is_none")]
6866 is_fastly_ip: Option<bool>,
6867 #[serde(skip_serializing_if = "Option::is_none")]
6868 is_old_ip_address: Option<bool>,
6869 #[serde(skip_serializing_if = "Option::is_none")]
6870 is_a_record: Option<bool>,
6871 #[serde(skip_serializing_if = "Option::is_none")]
6872 has_cname_record: Option<bool>,
6873 #[serde(skip_serializing_if = "Option::is_none")]
6874 has_mx_records_present: Option<bool>,
6875 #[serde(skip_serializing_if = "Option::is_none")]
6876 is_valid_domain: Option<bool>,
6877 #[serde(skip_serializing_if = "Option::is_none")]
6878 is_apex_domain: Option<bool>,
6879 #[serde(skip_serializing_if = "Option::is_none")]
6880 should_be_a_record: Option<bool>,
6881 #[serde(skip_serializing_if = "Option::is_none")]
6882 is_cname_to_github_user_domain: Option<bool>,
6883 #[serde(skip_serializing_if = "Option::is_none")]
6884 is_cname_to_pages_dot_github_dot_com: Option<bool>,
6885 #[serde(skip_serializing_if = "Option::is_none")]
6886 is_cname_to_fastly: Option<bool>,
6887 #[serde(skip_serializing_if = "Option::is_none")]
6888 is_pointed_to_github_pages_ip: Option<bool>,
6889 #[serde(skip_serializing_if = "Option::is_none")]
6890 is_non_github_pages_ip_present: Option<bool>,
6891 #[serde(skip_serializing_if = "Option::is_none")]
6892 is_pages_domain: Option<bool>,
6893 #[serde(skip_serializing_if = "Option::is_none")]
6894 is_served_by_pages: Option<bool>,
6895 #[serde(skip_serializing_if = "Option::is_none")]
6896 is_valid: Option<bool>,
6897 #[serde(skip_serializing_if = "Option::is_none")]
6898 reason: Option<String>,
6899 #[serde(skip_serializing_if = "Option::is_none")]
6900 responds_to_https: Option<bool>,
6901 #[serde(skip_serializing_if = "Option::is_none")]
6902 enforces_https: Option<bool>,
6903 #[serde(skip_serializing_if = "Option::is_none")]
6904 https_error: Option<String>,
6905 #[serde(skip_serializing_if = "Option::is_none")]
6906 is_https_eligible: Option<bool>,
6907 #[serde(skip_serializing_if = "Option::is_none")]
6908 caa_error: Option<String>,
6909 }
6910
6911 #[derive(Debug, Serialize, Deserialize)]
6912 pub struct PagesHealthCheckAltDomain {
6913 #[serde(skip_serializing_if = "Option::is_none")]
6914 host: Option<String>,
6915 #[serde(skip_serializing_if = "Option::is_none")]
6916 uri: Option<String>,
6917 #[serde(skip_serializing_if = "Option::is_none")]
6918 nameservers: Option<String>,
6919 #[serde(skip_serializing_if = "Option::is_none")]
6920 dns_resolves: Option<bool>,
6921 #[serde(skip_serializing_if = "Option::is_none")]
6922 is_proxied: Option<bool>,
6923 #[serde(skip_serializing_if = "Option::is_none")]
6924 is_cloudflare_ip: Option<bool>,
6925 #[serde(skip_serializing_if = "Option::is_none")]
6926 is_fastly_ip: Option<bool>,
6927 #[serde(skip_serializing_if = "Option::is_none")]
6928 is_old_ip_address: Option<bool>,
6929 #[serde(skip_serializing_if = "Option::is_none")]
6930 is_a_record: Option<bool>,
6931 #[serde(skip_serializing_if = "Option::is_none")]
6932 has_cname_record: Option<bool>,
6933 #[serde(skip_serializing_if = "Option::is_none")]
6934 has_mx_records_present: Option<bool>,
6935 #[serde(skip_serializing_if = "Option::is_none")]
6936 is_valid_domain: Option<bool>,
6937 #[serde(skip_serializing_if = "Option::is_none")]
6938 is_apex_domain: Option<bool>,
6939 #[serde(skip_serializing_if = "Option::is_none")]
6940 should_be_a_record: Option<bool>,
6941 #[serde(skip_serializing_if = "Option::is_none")]
6942 is_cname_to_github_user_domain: Option<bool>,
6943 #[serde(skip_serializing_if = "Option::is_none")]
6944 is_cname_to_pages_dot_github_dot_com: Option<bool>,
6945 #[serde(skip_serializing_if = "Option::is_none")]
6946 is_cname_to_fastly: Option<bool>,
6947 #[serde(skip_serializing_if = "Option::is_none")]
6948 is_pointed_to_github_pages_ip: Option<bool>,
6949 #[serde(skip_serializing_if = "Option::is_none")]
6950 is_non_github_pages_ip_present: Option<bool>,
6951 #[serde(skip_serializing_if = "Option::is_none")]
6952 is_pages_domain: Option<bool>,
6953 #[serde(skip_serializing_if = "Option::is_none")]
6954 is_served_by_pages: Option<bool>,
6955 #[serde(skip_serializing_if = "Option::is_none")]
6956 is_valid: Option<bool>,
6957 #[serde(skip_serializing_if = "Option::is_none")]
6958 reason: Option<String>,
6959 #[serde(skip_serializing_if = "Option::is_none")]
6960 responds_to_https: Option<bool>,
6961 #[serde(skip_serializing_if = "Option::is_none")]
6962 enforces_https: Option<bool>,
6963 #[serde(skip_serializing_if = "Option::is_none")]
6964 https_error: Option<String>,
6965 #[serde(skip_serializing_if = "Option::is_none")]
6966 is_https_eligible: Option<bool>,
6967 #[serde(skip_serializing_if = "Option::is_none")]
6968 caa_error: Option<String>,
6969 }
6970
6971 #[derive(Debug, Serialize, Deserialize)]
6972 pub struct PagesHealthCheck {
6973 #[serde(skip_serializing_if = "Option::is_none")]
6974 domain: Option<PagesHealthCheckDomain>,
6975 #[serde(skip_serializing_if = "Option::is_none")]
6976 alt_domain: Option<PagesHealthCheckAltDomain>,
6977 }
6978
6979 #[derive(Debug, Serialize, Deserialize)]
6980 pub struct TeamSimple {
6981 id: i64,
6982 node_id: String,
6983 url: String,
6984 members_url: String,
6985 name: String,
6986 description: Option<String>,
6987 permission: String,
6988 #[serde(skip_serializing_if = "Option::is_none")]
6989 privacy: Option<String>,
6990 html_url: String,
6991 repositories_url: String,
6992 slug: String,
6993 #[serde(skip_serializing_if = "Option::is_none")]
6994 ldap_dn: Option<String>,
6995 }
6996
6997 #[derive(Debug, Serialize, Deserialize)]
6998 pub struct PullRequestLabels {
6999 id: i64,
7000 node_id: String,
7001 url: String,
7002 name: String,
7003 description: Option<String>,
7004 color: String,
7005 default: bool,
7006 }
7007
7008 #[derive(Debug, Serialize, Deserialize)]
7009 pub struct PullRequestHeadRepoOwner {
7010 avatar_url: String,
7011 events_url: String,
7012 followers_url: String,
7013 following_url: String,
7014 gists_url: String,
7015 gravatar_id: Option<String>,
7016 html_url: String,
7017 id: i64,
7018 node_id: String,
7019 login: String,
7020 organizations_url: String,
7021 received_events_url: String,
7022 repos_url: String,
7023 site_admin: bool,
7024 starred_url: String,
7025 subscriptions_url: String,
7026 #[serde(rename="type")]
7027 type_: String,
7028 url: String,
7029 }
7030
7031 #[derive(Debug, Serialize, Deserialize)]
7032 pub struct PullRequestHeadRepoPermissions {
7033 admin: bool,
7034 #[serde(skip_serializing_if = "Option::is_none")]
7035 maintain: Option<bool>,
7036 push: bool,
7037 #[serde(skip_serializing_if = "Option::is_none")]
7038 triage: Option<bool>,
7039 pull: bool,
7040 }
7041
7042 #[derive(Debug, Serialize, Deserialize)]
7043 pub struct PullRequestHeadRepoLicense {
7044 key: String,
7045 name: String,
7046 url: Option<String>,
7047 spdx_id: Option<String>,
7048 node_id: String,
7049 }
7050
7051 #[derive(Debug, Serialize, Deserialize)]
7052 pub struct PullRequestHeadRepo {
7053 archive_url: String,
7054 assignees_url: String,
7055 blobs_url: String,
7056 branches_url: String,
7057 collaborators_url: String,
7058 comments_url: String,
7059 commits_url: String,
7060 compare_url: String,
7061 contents_url: String,
7062 contributors_url: String,
7063 deployments_url: String,
7064 description: Option<String>,
7065 downloads_url: String,
7066 events_url: String,
7067 fork: bool,
7068 forks_url: String,
7069 full_name: String,
7070 git_commits_url: String,
7071 git_refs_url: String,
7072 git_tags_url: String,
7073 hooks_url: String,
7074 html_url: String,
7075 id: i64,
7076 node_id: String,
7077 issue_comment_url: String,
7078 issue_events_url: String,
7079 issues_url: String,
7080 keys_url: String,
7081 labels_url: String,
7082 languages_url: String,
7083 merges_url: String,
7084 milestones_url: String,
7085 name: String,
7086 notifications_url: String,
7087 owner: PullRequestHeadRepoOwner,
7088 private: bool,
7089 pulls_url: String,
7090 releases_url: String,
7091 stargazers_url: String,
7092 statuses_url: String,
7093 subscribers_url: String,
7094 subscription_url: String,
7095 tags_url: String,
7096 teams_url: String,
7097 trees_url: String,
7098 url: String,
7099 clone_url: String,
7100 default_branch: String,
7101 forks: i64,
7102 forks_count: i64,
7103 git_url: String,
7104 has_downloads: bool,
7105 has_issues: bool,
7106 has_projects: bool,
7107 has_wiki: bool,
7108 has_pages: bool,
7109 homepage: Option<String>,
7110 language: Option<String>,
7111 #[serde(skip_serializing_if = "Option::is_none")]
7112 master_branch: Option<String>,
7113 archived: bool,
7114 disabled: bool,
7115 #[serde(skip_serializing_if = "Option::is_none")]
7116 visibility: Option<String>,
7117 mirror_url: Option<String>,
7118 open_issues: i64,
7119 open_issues_count: i64,
7120 #[serde(skip_serializing_if = "Option::is_none")]
7121 permissions: Option<PullRequestHeadRepoPermissions>,
7122 #[serde(skip_serializing_if = "Option::is_none")]
7123 temp_clone_token: Option<String>,
7124 #[serde(skip_serializing_if = "Option::is_none")]
7125 allow_merge_commit: Option<bool>,
7126 #[serde(skip_serializing_if = "Option::is_none")]
7127 allow_squash_merge: Option<bool>,
7128 #[serde(skip_serializing_if = "Option::is_none")]
7129 allow_rebase_merge: Option<bool>,
7130 license: Option<PullRequestHeadRepoLicense>,
7131 pushed_at: String,
7132 size: i64,
7133 ssh_url: String,
7134 stargazers_count: i64,
7135 svn_url: String,
7136 #[serde(skip_serializing_if = "Option::is_none")]
7137 topics: Option<Vec<String>>,
7138 watchers: i64,
7139 watchers_count: i64,
7140 created_at: String,
7141 updated_at: String,
7142 #[serde(skip_serializing_if = "Option::is_none")]
7143 allow_forking: Option<bool>,
7144 #[serde(skip_serializing_if = "Option::is_none")]
7145 is_template: Option<bool>,
7146 }
7147
7148 #[derive(Debug, Serialize, Deserialize)]
7149 pub struct PullRequestHeadUser {
7150 avatar_url: String,
7151 events_url: String,
7152 followers_url: String,
7153 following_url: String,
7154 gists_url: String,
7155 gravatar_id: Option<String>,
7156 html_url: String,
7157 id: i64,
7158 node_id: String,
7159 login: String,
7160 organizations_url: String,
7161 received_events_url: String,
7162 repos_url: String,
7163 site_admin: bool,
7164 starred_url: String,
7165 subscriptions_url: String,
7166 #[serde(rename="type")]
7167 type_: String,
7168 url: String,
7169 }
7170
7171 #[derive(Debug, Serialize, Deserialize)]
7172 pub struct PullRequestHead {
7173 label: String,
7174 #[serde(rename="ref")]
7175 ref_: String,
7176 repo: Option<PullRequestHeadRepo>,
7177 sha: String,
7178 user: PullRequestHeadUser,
7179 }
7180
7181 #[derive(Debug, Serialize, Deserialize)]
7182 pub struct PullRequestBaseRepoOwner {
7183 avatar_url: String,
7184 events_url: String,
7185 followers_url: String,
7186 following_url: String,
7187 gists_url: String,
7188 gravatar_id: Option<String>,
7189 html_url: String,
7190 id: i64,
7191 node_id: String,
7192 login: String,
7193 organizations_url: String,
7194 received_events_url: String,
7195 repos_url: String,
7196 site_admin: bool,
7197 starred_url: String,
7198 subscriptions_url: String,
7199 #[serde(rename="type")]
7200 type_: String,
7201 url: String,
7202 }
7203
7204 #[derive(Debug, Serialize, Deserialize)]
7205 pub struct PullRequestBaseRepoPermissions {
7206 admin: bool,
7207 #[serde(skip_serializing_if = "Option::is_none")]
7208 maintain: Option<bool>,
7209 push: bool,
7210 #[serde(skip_serializing_if = "Option::is_none")]
7211 triage: Option<bool>,
7212 pull: bool,
7213 }
7214
7215 #[derive(Debug, Serialize, Deserialize)]
7216 pub struct PullRequestBaseRepo {
7217 archive_url: String,
7218 assignees_url: String,
7219 blobs_url: String,
7220 branches_url: String,
7221 collaborators_url: String,
7222 comments_url: String,
7223 commits_url: String,
7224 compare_url: String,
7225 contents_url: String,
7226 contributors_url: String,
7227 deployments_url: String,
7228 description: Option<String>,
7229 downloads_url: String,
7230 events_url: String,
7231 fork: bool,
7232 forks_url: String,
7233 full_name: String,
7234 git_commits_url: String,
7235 git_refs_url: String,
7236 git_tags_url: String,
7237 hooks_url: String,
7238 html_url: String,
7239 id: i64,
7240 #[serde(skip_serializing_if = "Option::is_none")]
7241 is_template: Option<bool>,
7242 node_id: String,
7243 issue_comment_url: String,
7244 issue_events_url: String,
7245 issues_url: String,
7246 keys_url: String,
7247 labels_url: String,
7248 languages_url: String,
7249 merges_url: String,
7250 milestones_url: String,
7251 name: String,
7252 notifications_url: String,
7253 owner: PullRequestBaseRepoOwner,
7254 private: bool,
7255 pulls_url: String,
7256 releases_url: String,
7257 stargazers_url: String,
7258 statuses_url: String,
7259 subscribers_url: String,
7260 subscription_url: String,
7261 tags_url: String,
7262 teams_url: String,
7263 trees_url: String,
7264 url: String,
7265 clone_url: String,
7266 default_branch: String,
7267 forks: i64,
7268 forks_count: i64,
7269 git_url: String,
7270 has_downloads: bool,
7271 has_issues: bool,
7272 has_projects: bool,
7273 has_wiki: bool,
7274 has_pages: bool,
7275 homepage: Option<String>,
7276 language: Option<String>,
7277 #[serde(skip_serializing_if = "Option::is_none")]
7278 master_branch: Option<String>,
7279 archived: bool,
7280 disabled: bool,
7281 #[serde(skip_serializing_if = "Option::is_none")]
7282 visibility: Option<String>,
7283 mirror_url: Option<String>,
7284 open_issues: i64,
7285 open_issues_count: i64,
7286 #[serde(skip_serializing_if = "Option::is_none")]
7287 permissions: Option<PullRequestBaseRepoPermissions>,
7288 #[serde(skip_serializing_if = "Option::is_none")]
7289 temp_clone_token: Option<String>,
7290 #[serde(skip_serializing_if = "Option::is_none")]
7291 allow_merge_commit: Option<bool>,
7292 #[serde(skip_serializing_if = "Option::is_none")]
7293 allow_squash_merge: Option<bool>,
7294 #[serde(skip_serializing_if = "Option::is_none")]
7295 allow_rebase_merge: Option<bool>,
7296 license: crate::components::schemas::NullableLicenseSimple,
7298 pushed_at: String,
7299 size: i64,
7300 ssh_url: String,
7301 stargazers_count: i64,
7302 svn_url: String,
7303 #[serde(skip_serializing_if = "Option::is_none")]
7304 topics: Option<Vec<String>>,
7305 watchers: i64,
7306 watchers_count: i64,
7307 created_at: String,
7308 updated_at: String,
7309 #[serde(skip_serializing_if = "Option::is_none")]
7310 allow_forking: Option<bool>,
7311 }
7312
7313 #[derive(Debug, Serialize, Deserialize)]
7314 pub struct PullRequestBaseUser {
7315 avatar_url: String,
7316 events_url: String,
7317 followers_url: String,
7318 following_url: String,
7319 gists_url: String,
7320 gravatar_id: Option<String>,
7321 html_url: String,
7322 id: i64,
7323 node_id: String,
7324 login: String,
7325 organizations_url: String,
7326 received_events_url: String,
7327 repos_url: String,
7328 site_admin: bool,
7329 starred_url: String,
7330 subscriptions_url: String,
7331 #[serde(rename="type")]
7332 type_: String,
7333 url: String,
7334 }
7335
7336 #[derive(Debug, Serialize, Deserialize)]
7337 pub struct PullRequestBase {
7338 label: String,
7339 #[serde(rename="ref")]
7340 ref_: String,
7341 repo: PullRequestBaseRepo,
7342 sha: String,
7343 user: PullRequestBaseUser,
7344 }
7345
7346 #[derive(Debug, Serialize, Deserialize)]
7347 pub struct PullRequestLinks {
7348 comments: crate::components::schemas::Link,
7350 commits: crate::components::schemas::Link,
7352 statuses: crate::components::schemas::Link,
7354 html: crate::components::schemas::Link,
7356 issue: crate::components::schemas::Link,
7358 review_comments: crate::components::schemas::Link,
7360 review_comment: crate::components::schemas::Link,
7362 #[serde(rename="self")]
7364 self_: crate::components::schemas::Link,
7365 }
7366
7367 #[derive(Debug, Serialize, Deserialize)]
7368 pub struct PullRequest {
7369 url: String,
7370 id: i64,
7371 node_id: String,
7372 html_url: String,
7373 diff_url: String,
7374 patch_url: String,
7375 issue_url: String,
7376 commits_url: String,
7377 review_comments_url: String,
7378 review_comment_url: String,
7379 comments_url: String,
7380 statuses_url: String,
7381 number: i64,
7382 state: String,
7383 locked: bool,
7384 title: String,
7385 user: crate::components::schemas::NullableSimpleUser,
7387 body: Option<String>,
7388 labels: Vec<PullRequestLabels>,
7389 milestone: crate::components::schemas::NullableMilestone,
7391 #[serde(skip_serializing_if = "Option::is_none")]
7392 active_lock_reason: Option<String>,
7393 created_at: String,
7394 updated_at: String,
7395 closed_at: Option<String>,
7396 merged_at: Option<String>,
7397 merge_commit_sha: Option<String>,
7398 assignee: crate::components::schemas::NullableSimpleUser,
7400 #[serde(skip_serializing_if = "Option::is_none")]
7401 assignees: Option<Vec<crate::components::schemas::SimpleUser>>,
7402 #[serde(skip_serializing_if = "Option::is_none")]
7403 requested_reviewers: Option<Vec<crate::components::schemas::SimpleUser>>,
7404 #[serde(skip_serializing_if = "Option::is_none")]
7405 requested_teams: Option<Vec<crate::components::schemas::TeamSimple>>,
7406 head: PullRequestHead,
7407 base: PullRequestBase,
7408 #[serde(rename="_links")]
7409 links: PullRequestLinks,
7410 author_association: crate::components::schemas::AuthorAssociation,
7412 auto_merge: crate::components::schemas::AutoMerge,
7414 #[serde(skip_serializing_if = "Option::is_none")]
7415 draft: Option<bool>,
7416 merged: bool,
7417 mergeable: Option<bool>,
7418 #[serde(skip_serializing_if = "Option::is_none")]
7419 rebaseable: Option<bool>,
7420 mergeable_state: String,
7421 merged_by: crate::components::schemas::NullableSimpleUser,
7423 comments: i64,
7424 review_comments: i64,
7425 maintainer_can_modify: bool,
7426 commits: i64,
7427 additions: i64,
7428 deletions: i64,
7429 changed_files: i64,
7430 }
7431
7432 #[derive(Debug, Serialize, Deserialize)]
7433 pub struct PullRequestMergeResult {
7434 sha: String,
7435 merged: bool,
7436 message: String,
7437 }
7438
7439 #[derive(Debug, Serialize, Deserialize)]
7440 pub struct PullRequestReviewRequest {
7441 users: Vec<crate::components::schemas::SimpleUser>,
7442 teams: Vec<crate::components::schemas::Team>,
7443 }
7444
7445 #[derive(Debug, Serialize, Deserialize)]
7446 pub struct PullRequestReviewLinksHtml {
7447 href: String,
7448 }
7449
7450 #[derive(Debug, Serialize, Deserialize)]
7451 pub struct PullRequestReviewLinksPullRequest {
7452 href: String,
7453 }
7454
7455 #[derive(Debug, Serialize, Deserialize)]
7456 pub struct PullRequestReviewLinks {
7457 html: PullRequestReviewLinksHtml,
7458 pull_request: PullRequestReviewLinksPullRequest,
7459 }
7460
7461 #[derive(Debug, Serialize, Deserialize)]
7462 pub struct PullRequestReview {
7463 id: i64,
7464 node_id: String,
7465 user: crate::components::schemas::NullableSimpleUser,
7467 body: String,
7468 state: String,
7469 html_url: String,
7470 pull_request_url: String,
7471 #[serde(rename="_links")]
7472 links: PullRequestReviewLinks,
7473 #[serde(skip_serializing_if = "Option::is_none")]
7474 submitted_at: Option<String>,
7475 commit_id: String,
7476 #[serde(skip_serializing_if = "Option::is_none")]
7477 body_html: Option<String>,
7478 #[serde(skip_serializing_if = "Option::is_none")]
7479 body_text: Option<String>,
7480 author_association: crate::components::schemas::AuthorAssociation,
7482 }
7483
7484 #[derive(Debug, Serialize, Deserialize)]
7485 pub struct ReviewCommentLinks {
7486 #[serde(rename="self")]
7488 self_: crate::components::schemas::Link,
7489 html: crate::components::schemas::Link,
7491 pull_request: crate::components::schemas::Link,
7493 }
7494
7495 #[derive(Debug, Serialize, Deserialize)]
7496 pub struct ReviewComment {
7497 url: String,
7498 pull_request_review_id: Option<i64>,
7499 id: i64,
7500 node_id: String,
7501 diff_hunk: String,
7502 path: String,
7503 position: Option<i64>,
7504 original_position: i64,
7505 commit_id: String,
7506 original_commit_id: String,
7507 #[serde(skip_serializing_if = "Option::is_none")]
7508 in_reply_to_id: Option<i64>,
7509 user: crate::components::schemas::NullableSimpleUser,
7511 body: String,
7512 created_at: String,
7513 updated_at: String,
7514 html_url: String,
7515 pull_request_url: String,
7516 author_association: crate::components::schemas::AuthorAssociation,
7518 #[serde(rename="_links")]
7519 links: ReviewCommentLinks,
7520 #[serde(skip_serializing_if = "Option::is_none")]
7521 body_text: Option<String>,
7522 #[serde(skip_serializing_if = "Option::is_none")]
7523 body_html: Option<String>,
7524 #[serde(skip_serializing_if = "Option::is_none")]
7526 reactions: Option<crate::components::schemas::ReactionRollup>,
7527 #[serde(skip_serializing_if = "Option::is_none")]
7528 side: Option<String>,
7529 #[serde(skip_serializing_if = "Option::is_none")]
7530 start_side: Option<String>,
7531 #[serde(skip_serializing_if = "Option::is_none")]
7532 line: Option<i64>,
7533 #[serde(skip_serializing_if = "Option::is_none")]
7534 original_line: Option<i64>,
7535 #[serde(skip_serializing_if = "Option::is_none")]
7536 start_line: Option<i64>,
7537 #[serde(skip_serializing_if = "Option::is_none")]
7538 original_start_line: Option<i64>,
7539 }
7540
7541 #[derive(Debug, Serialize, Deserialize)]
7542 pub struct ReleaseAsset {
7543 url: String,
7544 browser_download_url: String,
7545 id: i64,
7546 node_id: String,
7547 name: String,
7548 label: Option<String>,
7549 state: String,
7550 content_type: String,
7551 size: i64,
7552 download_count: i64,
7553 created_at: String,
7554 updated_at: String,
7555 uploader: crate::components::schemas::NullableSimpleUser,
7557 }
7558
7559 #[derive(Debug, Serialize, Deserialize)]
7560 pub struct Release {
7561 url: String,
7562 html_url: String,
7563 assets_url: String,
7564 upload_url: String,
7565 tarball_url: Option<String>,
7566 zipball_url: Option<String>,
7567 id: i64,
7568 node_id: String,
7569 tag_name: String,
7570 target_commitish: String,
7571 name: Option<String>,
7572 #[serde(skip_serializing_if = "Option::is_none")]
7573 body: Option<String>,
7574 draft: bool,
7575 prerelease: bool,
7576 created_at: String,
7577 published_at: Option<String>,
7578 author: crate::components::schemas::SimpleUser,
7580 assets: Vec<crate::components::schemas::ReleaseAsset>,
7581 #[serde(skip_serializing_if = "Option::is_none")]
7582 body_html: Option<String>,
7583 #[serde(skip_serializing_if = "Option::is_none")]
7584 body_text: Option<String>,
7585 #[serde(skip_serializing_if = "Option::is_none")]
7586 mentions_count: Option<i64>,
7587 #[serde(skip_serializing_if = "Option::is_none")]
7588 discussion_url: Option<String>,
7589 #[serde(skip_serializing_if = "Option::is_none")]
7591 reactions: Option<crate::components::schemas::ReactionRollup>,
7592 }
7593
7594 #[derive(Debug, Serialize, Deserialize)]
7595 pub struct ReleaseNotesContent {
7596 name: String,
7597 body: String,
7598 }
7599
7600 #[derive(Debug, Serialize, Deserialize)]
7601 pub struct SecretScanningAlert {
7602 #[serde(skip_serializing_if = "Option::is_none")]
7604 number: Option<crate::components::schemas::AlertNumber>,
7605 #[serde(skip_serializing_if = "Option::is_none")]
7607 created_at: Option<crate::components::schemas::AlertCreatedAt>,
7608 #[serde(skip_serializing_if = "Option::is_none")]
7610 url: Option<crate::components::schemas::AlertUrl>,
7611 #[serde(skip_serializing_if = "Option::is_none")]
7613 html_url: Option<crate::components::schemas::AlertHtmlUrl>,
7614 #[serde(skip_serializing_if = "Option::is_none")]
7615 locations_url: Option<String>,
7616 #[serde(skip_serializing_if = "Option::is_none")]
7618 state: Option<crate::components::schemas::SecretScanningAlertState>,
7619 #[serde(skip_serializing_if = "Option::is_none")]
7621 resolution: Option<crate::components::schemas::SecretScanningAlertResolution>,
7622 #[serde(skip_serializing_if = "Option::is_none")]
7623 resolved_at: Option<String>,
7624 #[serde(skip_serializing_if = "Option::is_none")]
7626 resolved_by: Option<crate::components::schemas::NullableSimpleUser>,
7627 #[serde(skip_serializing_if = "Option::is_none")]
7628 secret_type: Option<String>,
7629 #[serde(skip_serializing_if = "Option::is_none")]
7630 secret: Option<String>,
7631 }
7632
7633 #[derive(Debug, Serialize, Deserialize)]
7634 pub struct Stargazer {
7635 starred_at: String,
7636 user: crate::components::schemas::NullableSimpleUser,
7638 }
7639
7640 pub type CodeFrequencyStat = Vec<i64>;
7641
7642 #[derive(Debug, Serialize, Deserialize)]
7643 pub struct CommitActivity {
7644 days: Vec<i64>,
7645 total: i64,
7646 week: i64,
7647 }
7648
7649 #[derive(Debug, Serialize, Deserialize)]
7650 pub struct ContributorActivityWeeks {
7651 #[serde(skip_serializing_if = "Option::is_none")]
7652 w: Option<i64>,
7653 #[serde(skip_serializing_if = "Option::is_none")]
7654 a: Option<i64>,
7655 #[serde(skip_serializing_if = "Option::is_none")]
7656 d: Option<i64>,
7657 #[serde(skip_serializing_if = "Option::is_none")]
7658 c: Option<i64>,
7659 }
7660
7661 #[derive(Debug, Serialize, Deserialize)]
7662 pub struct ContributorActivity {
7663 author: crate::components::schemas::NullableSimpleUser,
7665 total: i64,
7666 weeks: Vec<ContributorActivityWeeks>,
7667 }
7668
7669 #[derive(Debug, Serialize, Deserialize)]
7670 pub struct ParticipationStats {
7671 all: Vec<i64>,
7672 owner: Vec<i64>,
7673 }
7674
7675 #[derive(Debug, Serialize, Deserialize)]
7676 pub struct RepositorySubscription {
7677 subscribed: bool,
7678 ignored: bool,
7679 reason: Option<String>,
7680 created_at: String,
7681 url: String,
7682 repository_url: String,
7683 }
7684
7685 #[derive(Debug, Serialize, Deserialize)]
7686 pub struct TagCommit {
7687 sha: String,
7688 url: String,
7689 }
7690
7691 #[derive(Debug, Serialize, Deserialize)]
7692 pub struct Tag {
7693 name: String,
7694 commit: TagCommit,
7695 zipball_url: String,
7696 tarball_url: String,
7697 node_id: String,
7698 }
7699
7700 #[derive(Debug, Serialize, Deserialize)]
7701 pub struct Topic {
7702 names: Vec<String>,
7703 }
7704
7705 #[derive(Debug, Serialize, Deserialize)]
7706 pub struct Traffic {
7707 timestamp: String,
7708 uniques: i64,
7709 count: i64,
7710 }
7711
7712 #[derive(Debug, Serialize, Deserialize)]
7713 pub struct CloneTraffic {
7714 count: i64,
7715 uniques: i64,
7716 clones: Vec<crate::components::schemas::Traffic>,
7717 }
7718
7719 #[derive(Debug, Serialize, Deserialize)]
7720 pub struct ContentTraffic {
7721 path: String,
7722 title: String,
7723 count: i64,
7724 uniques: i64,
7725 }
7726
7727 #[derive(Debug, Serialize, Deserialize)]
7728 pub struct ReferrerTraffic {
7729 referrer: String,
7730 count: i64,
7731 uniques: i64,
7732 }
7733
7734 #[derive(Debug, Serialize, Deserialize)]
7735 pub struct ViewTraffic {
7736 count: i64,
7737 uniques: i64,
7738 views: Vec<crate::components::schemas::Traffic>,
7739 }
7740
7741 #[derive(Debug, Serialize, Deserialize)]
7742 pub struct ScimGroupListEnterpriseResourcesMembers {
7743 #[serde(skip_serializing_if = "Option::is_none")]
7744 value: Option<String>,
7745 #[serde(rename="$ref", skip_serializing_if = "Option::is_none")]
7746 ref_: Option<String>,
7747 #[serde(skip_serializing_if = "Option::is_none")]
7748 display: Option<String>,
7749 }
7750
7751 #[derive(Debug, Serialize, Deserialize)]
7752 pub struct ScimGroupListEnterpriseResourcesMeta {
7753 #[serde(rename="resourceType", skip_serializing_if = "Option::is_none")]
7754 resource_type: Option<String>,
7755 #[serde(skip_serializing_if = "Option::is_none")]
7756 created: Option<String>,
7757 #[serde(rename="lastModified", skip_serializing_if = "Option::is_none")]
7758 last_modified: Option<String>,
7759 #[serde(skip_serializing_if = "Option::is_none")]
7760 location: Option<String>,
7761 }
7762
7763 #[derive(Debug, Serialize, Deserialize)]
7764 pub struct ScimGroupListEnterpriseResources {
7765 schemas: Vec<String>,
7766 id: String,
7767 #[serde(rename="externalId", skip_serializing_if = "Option::is_none")]
7768 external_id: Option<String>,
7769 #[serde(rename="displayName", skip_serializing_if = "Option::is_none")]
7770 display_name: Option<String>,
7771 #[serde(skip_serializing_if = "Option::is_none")]
7772 members: Option<Vec<ScimGroupListEnterpriseResourcesMembers>>,
7773 #[serde(skip_serializing_if = "Option::is_none")]
7774 meta: Option<ScimGroupListEnterpriseResourcesMeta>,
7775 }
7776
7777 #[derive(Debug, Serialize, Deserialize)]
7778 pub struct ScimGroupListEnterprise {
7779 schemas: Vec<String>,
7780 #[serde(rename="totalResults")]
7781 total_results: i64,
7782 #[serde(rename="itemsPerPage")]
7783 items_per_page: i64,
7784 #[serde(rename="startIndex")]
7785 start_index: i64,
7786 #[serde(rename="Resources")]
7787 resources: Vec<ScimGroupListEnterpriseResources>,
7788 }
7789
7790 #[derive(Debug, Serialize, Deserialize)]
7791 pub struct ScimEnterpriseGroupMembers {
7792 #[serde(skip_serializing_if = "Option::is_none")]
7793 value: Option<String>,
7794 #[serde(rename="$ref", skip_serializing_if = "Option::is_none")]
7795 ref_: Option<String>,
7796 #[serde(skip_serializing_if = "Option::is_none")]
7797 display: Option<String>,
7798 }
7799
7800 #[derive(Debug, Serialize, Deserialize)]
7801 pub struct ScimEnterpriseGroupMeta {
7802 #[serde(rename="resourceType", skip_serializing_if = "Option::is_none")]
7803 resource_type: Option<String>,
7804 #[serde(skip_serializing_if = "Option::is_none")]
7805 created: Option<String>,
7806 #[serde(rename="lastModified", skip_serializing_if = "Option::is_none")]
7807 last_modified: Option<String>,
7808 #[serde(skip_serializing_if = "Option::is_none")]
7809 location: Option<String>,
7810 }
7811
7812 #[derive(Debug, Serialize, Deserialize)]
7813 pub struct ScimEnterpriseGroup {
7814 schemas: Vec<String>,
7815 id: String,
7816 #[serde(rename="externalId", skip_serializing_if = "Option::is_none")]
7817 external_id: Option<String>,
7818 #[serde(rename="displayName", skip_serializing_if = "Option::is_none")]
7819 display_name: Option<String>,
7820 #[serde(skip_serializing_if = "Option::is_none")]
7821 members: Option<Vec<ScimEnterpriseGroupMembers>>,
7822 #[serde(skip_serializing_if = "Option::is_none")]
7823 meta: Option<ScimEnterpriseGroupMeta>,
7824 }
7825
7826 #[derive(Debug, Serialize, Deserialize)]
7827 pub struct ScimUserListEnterpriseResourcesName {
7828 #[serde(rename="givenName", skip_serializing_if = "Option::is_none")]
7829 given_name: Option<String>,
7830 #[serde(rename="familyName", skip_serializing_if = "Option::is_none")]
7831 family_name: Option<String>,
7832 }
7833
7834 #[derive(Debug, Serialize, Deserialize)]
7835 pub struct ScimUserListEnterpriseResourcesEmails {
7836 #[serde(skip_serializing_if = "Option::is_none")]
7837 value: Option<String>,
7838 #[serde(skip_serializing_if = "Option::is_none")]
7839 primary: Option<bool>,
7840 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
7841 type_: Option<String>,
7842 }
7843
7844 #[derive(Debug, Serialize, Deserialize)]
7845 pub struct ScimUserListEnterpriseResourcesGroups {
7846 #[serde(skip_serializing_if = "Option::is_none")]
7847 value: Option<String>,
7848 }
7849
7850 #[derive(Debug, Serialize, Deserialize)]
7851 pub struct ScimUserListEnterpriseResourcesMeta {
7852 #[serde(rename="resourceType", skip_serializing_if = "Option::is_none")]
7853 resource_type: Option<String>,
7854 #[serde(skip_serializing_if = "Option::is_none")]
7855 created: Option<String>,
7856 #[serde(rename="lastModified", skip_serializing_if = "Option::is_none")]
7857 last_modified: Option<String>,
7858 #[serde(skip_serializing_if = "Option::is_none")]
7859 location: Option<String>,
7860 }
7861
7862 #[derive(Debug, Serialize, Deserialize)]
7863 pub struct ScimUserListEnterpriseResources {
7864 schemas: Vec<String>,
7865 id: String,
7866 #[serde(rename="externalId", skip_serializing_if = "Option::is_none")]
7867 external_id: Option<String>,
7868 #[serde(rename="userName", skip_serializing_if = "Option::is_none")]
7869 user_name: Option<String>,
7870 #[serde(skip_serializing_if = "Option::is_none")]
7871 name: Option<ScimUserListEnterpriseResourcesName>,
7872 #[serde(skip_serializing_if = "Option::is_none")]
7873 emails: Option<Vec<ScimUserListEnterpriseResourcesEmails>>,
7874 #[serde(skip_serializing_if = "Option::is_none")]
7875 groups: Option<Vec<ScimUserListEnterpriseResourcesGroups>>,
7876 #[serde(skip_serializing_if = "Option::is_none")]
7877 active: Option<bool>,
7878 #[serde(skip_serializing_if = "Option::is_none")]
7879 meta: Option<ScimUserListEnterpriseResourcesMeta>,
7880 }
7881
7882 #[derive(Debug, Serialize, Deserialize)]
7883 pub struct ScimUserListEnterprise {
7884 schemas: Vec<String>,
7885 #[serde(rename="totalResults")]
7886 total_results: i64,
7887 #[serde(rename="itemsPerPage")]
7888 items_per_page: i64,
7889 #[serde(rename="startIndex")]
7890 start_index: i64,
7891 #[serde(rename="Resources")]
7892 resources: Vec<ScimUserListEnterpriseResources>,
7893 }
7894
7895 #[derive(Debug, Serialize, Deserialize)]
7896 pub struct ScimEnterpriseUserName {
7897 #[serde(rename="givenName", skip_serializing_if = "Option::is_none")]
7898 given_name: Option<String>,
7899 #[serde(rename="familyName", skip_serializing_if = "Option::is_none")]
7900 family_name: Option<String>,
7901 }
7902
7903 #[derive(Debug, Serialize, Deserialize)]
7904 pub struct ScimEnterpriseUserEmails {
7905 #[serde(skip_serializing_if = "Option::is_none")]
7906 value: Option<String>,
7907 #[serde(rename="type", skip_serializing_if = "Option::is_none")]
7908 type_: Option<String>,
7909 #[serde(skip_serializing_if = "Option::is_none")]
7910 primary: Option<bool>,
7911 }
7912
7913 #[derive(Debug, Serialize, Deserialize)]
7914 pub struct ScimEnterpriseUserGroups {
7915 #[serde(skip_serializing_if = "Option::is_none")]
7916 value: Option<String>,
7917 }
7918
7919 #[derive(Debug, Serialize, Deserialize)]
7920 pub struct ScimEnterpriseUserMeta {
7921 #[serde(rename="resourceType", skip_serializing_if = "Option::is_none")]
7922 resource_type: Option<String>,
7923 #[serde(skip_serializing_if = "Option::is_none")]
7924 created: Option<String>,
7925 #[serde(rename="lastModified", skip_serializing_if = "Option::is_none")]
7926 last_modified: Option<String>,
7927 #[serde(skip_serializing_if = "Option::is_none")]
7928 location: Option<String>,
7929 }
7930
7931 #[derive(Debug, Serialize, Deserialize)]
7932 pub struct ScimEnterpriseUser {
7933 schemas: Vec<String>,
7934 id: String,
7935 #[serde(rename="externalId", skip_serializing_if = "Option::is_none")]
7936 external_id: Option<String>,
7937 #[serde(rename="userName", skip_serializing_if = "Option::is_none")]
7938 user_name: Option<String>,
7939 #[serde(skip_serializing_if = "Option::is_none")]
7940 name: Option<ScimEnterpriseUserName>,
7941 #[serde(skip_serializing_if = "Option::is_none")]
7942 emails: Option<Vec<ScimEnterpriseUserEmails>>,
7943 #[serde(skip_serializing_if = "Option::is_none")]
7944 groups: Option<Vec<ScimEnterpriseUserGroups>>,
7945 #[serde(skip_serializing_if = "Option::is_none")]
7946 active: Option<bool>,
7947 #[serde(skip_serializing_if = "Option::is_none")]
7948 meta: Option<ScimEnterpriseUserMeta>,
7949 }
7950
7951 #[derive(Debug, Serialize, Deserialize)]
7952 pub struct ScimUserName {
7953 #[serde(rename="givenName")]
7954 given_name: Option<String>,
7955 #[serde(rename="familyName")]
7956 family_name: Option<String>,
7957 #[serde(skip_serializing_if = "Option::is_none")]
7958 formatted: Option<String>,
7959 }
7960
7961 #[derive(Debug, Serialize, Deserialize)]
7962 pub struct ScimUserEmails {
7963 value: String,
7964 #[serde(skip_serializing_if = "Option::is_none")]
7965 primary: Option<bool>,
7966 }
7967
7968 #[derive(Debug, Serialize, Deserialize)]
7969 pub struct ScimUserMeta {
7970 #[serde(rename="resourceType", skip_serializing_if = "Option::is_none")]
7971 resource_type: Option<String>,
7972 #[serde(skip_serializing_if = "Option::is_none")]
7973 created: Option<String>,
7974 #[serde(rename="lastModified", skip_serializing_if = "Option::is_none")]
7975 last_modified: Option<String>,
7976 #[serde(skip_serializing_if = "Option::is_none")]
7977 location: Option<String>,
7978 }
7979
7980 #[derive(Debug, Serialize, Deserialize)]
7981 pub struct ScimUserOperationsValue1;
7982
7983 #[derive(Debug, Serialize, Deserialize)]
7985 #[serde(untagged)]
7986 pub enum ScimUserOperationsValueOneOf {
7987 String(String),
7988 ScimUserOperationsValue1(ScimUserOperationsValue1),
7989 Vec(Vec<HashMap<String, String>>),
7990 }
7991
7992 #[derive(Debug, Serialize, Deserialize)]
7993 pub struct ScimUserOperations {
7994 op: String,
7995 #[serde(skip_serializing_if = "Option::is_none")]
7996 path: Option<String>,
7997 #[serde(skip_serializing_if = "Option::is_none")]
7998 value: Option<ScimUserOperationsValueOneOf>,
7999 }
8000
8001 #[derive(Debug, Serialize, Deserialize)]
8002 pub struct ScimUser {
8003 schemas: Vec<String>,
8004 id: String,
8005 #[serde(rename="externalId")]
8006 external_id: Option<String>,
8007 #[serde(rename="userName")]
8008 user_name: Option<String>,
8009 #[serde(rename="displayName", skip_serializing_if = "Option::is_none")]
8010 display_name: Option<String>,
8011 name: ScimUserName,
8012 emails: Vec<ScimUserEmails>,
8013 active: bool,
8014 meta: ScimUserMeta,
8015 #[serde(skip_serializing_if = "Option::is_none")]
8016 organization_id: Option<i64>,
8017 #[serde(skip_serializing_if = "Option::is_none")]
8018 operations: Option<Vec<ScimUserOperations>>,
8019 #[serde(skip_serializing_if = "Option::is_none")]
8020 groups: Option<Vec<HashMap<String, String>>>,
8021 }
8022
8023 #[derive(Debug, Serialize, Deserialize)]
8024 pub struct ScimUserList {
8025 schemas: Vec<String>,
8026 #[serde(rename="totalResults")]
8027 total_results: i64,
8028 #[serde(rename="itemsPerPage")]
8029 items_per_page: i64,
8030 #[serde(rename="startIndex")]
8031 start_index: i64,
8032 #[serde(rename="Resources")]
8033 resources: Vec<crate::components::schemas::ScimUser>,
8034 }
8035
8036 #[derive(Debug, Serialize, Deserialize)]
8037 pub struct SearchResultTextMatchesArrMatches {
8038 #[serde(skip_serializing_if = "Option::is_none")]
8039 text: Option<String>,
8040 #[serde(skip_serializing_if = "Option::is_none")]
8041 indices: Option<Vec<i64>>,
8042 }
8043
8044 #[derive(Debug, Serialize, Deserialize)]
8045 pub struct SearchResultTextMatchesArr {
8046 #[serde(skip_serializing_if = "Option::is_none")]
8047 object_url: Option<String>,
8048 #[serde(skip_serializing_if = "Option::is_none")]
8049 object_type: Option<String>,
8050 #[serde(skip_serializing_if = "Option::is_none")]
8051 property: Option<String>,
8052 #[serde(skip_serializing_if = "Option::is_none")]
8053 fragment: Option<String>,
8054 #[serde(skip_serializing_if = "Option::is_none")]
8055 matches: Option<Vec<SearchResultTextMatchesArrMatches>>,
8056 }
8057
8058 pub type SearchResultTextMatches = Vec<SearchResultTextMatchesArr>;
8059
8060 #[derive(Debug, Serialize, Deserialize)]
8061 pub struct CodeSearchResultItem {
8062 name: String,
8063 path: String,
8064 sha: String,
8065 url: String,
8066 git_url: String,
8067 html_url: String,
8068 repository: crate::components::schemas::MinimalRepository,
8070 score: i64,
8071 #[serde(skip_serializing_if = "Option::is_none")]
8072 file_size: Option<i64>,
8073 #[serde(skip_serializing_if = "Option::is_none")]
8074 language: Option<String>,
8075 #[serde(skip_serializing_if = "Option::is_none")]
8076 last_modified_at: Option<String>,
8077 #[serde(skip_serializing_if = "Option::is_none")]
8078 line_numbers: Option<Vec<String>>,
8079 #[serde(skip_serializing_if = "Option::is_none")]
8081 text_matches: Option<crate::components::schemas::SearchResultTextMatches>,
8082 }
8083
8084 #[derive(Debug, Serialize, Deserialize)]
8085 pub struct CommitSearchResultItemCommitAuthor {
8086 name: String,
8087 email: String,
8088 date: String,
8089 }
8090
8091 #[derive(Debug, Serialize, Deserialize)]
8092 pub struct CommitSearchResultItemCommitTree {
8093 sha: String,
8094 url: String,
8095 }
8096
8097 #[derive(Debug, Serialize, Deserialize)]
8098 pub struct CommitSearchResultItemCommit {
8099 author: CommitSearchResultItemCommitAuthor,
8100 committer: crate::components::schemas::NullableGitUser,
8102 comment_count: i64,
8103 message: String,
8104 tree: CommitSearchResultItemCommitTree,
8105 url: String,
8106 #[serde(skip_serializing_if = "Option::is_none")]
8108 verification: Option<crate::components::schemas::Verification>,
8109 }
8110
8111 #[derive(Debug, Serialize, Deserialize)]
8112 pub struct CommitSearchResultItemParents {
8113 #[serde(skip_serializing_if = "Option::is_none")]
8114 url: Option<String>,
8115 #[serde(skip_serializing_if = "Option::is_none")]
8116 html_url: Option<String>,
8117 #[serde(skip_serializing_if = "Option::is_none")]
8118 sha: Option<String>,
8119 }
8120
8121 #[derive(Debug, Serialize, Deserialize)]
8122 pub struct CommitSearchResultItem {
8123 url: String,
8124 sha: String,
8125 html_url: String,
8126 comments_url: String,
8127 commit: CommitSearchResultItemCommit,
8128 author: crate::components::schemas::NullableSimpleUser,
8130 committer: crate::components::schemas::NullableGitUser,
8132 parents: Vec<CommitSearchResultItemParents>,
8133 repository: crate::components::schemas::MinimalRepository,
8135 score: i64,
8136 node_id: String,
8137 #[serde(skip_serializing_if = "Option::is_none")]
8139 text_matches: Option<crate::components::schemas::SearchResultTextMatches>,
8140 }
8141
8142 #[derive(Debug, Serialize, Deserialize)]
8143 pub struct IssueSearchResultItemLabels {
8144 #[serde(skip_serializing_if = "Option::is_none")]
8145 id: Option<i64>,
8146 #[serde(skip_serializing_if = "Option::is_none")]
8147 node_id: Option<String>,
8148 #[serde(skip_serializing_if = "Option::is_none")]
8149 url: Option<String>,
8150 #[serde(skip_serializing_if = "Option::is_none")]
8151 name: Option<String>,
8152 #[serde(skip_serializing_if = "Option::is_none")]
8153 color: Option<String>,
8154 #[serde(skip_serializing_if = "Option::is_none")]
8155 default: Option<bool>,
8156 #[serde(skip_serializing_if = "Option::is_none")]
8157 description: Option<String>,
8158 }
8159
8160 #[derive(Debug, Serialize, Deserialize)]
8161 pub struct IssueSearchResultItemPullRequest {
8162 #[serde(skip_serializing_if = "Option::is_none")]
8163 merged_at: Option<String>,
8164 diff_url: Option<String>,
8165 html_url: Option<String>,
8166 patch_url: Option<String>,
8167 url: Option<String>,
8168 }
8169
8170 #[derive(Debug, Serialize, Deserialize)]
8171 pub struct IssueSearchResultItem {
8172 url: String,
8173 repository_url: String,
8174 labels_url: String,
8175 comments_url: String,
8176 events_url: String,
8177 html_url: String,
8178 id: i64,
8179 node_id: String,
8180 number: i64,
8181 title: String,
8182 locked: bool,
8183 #[serde(skip_serializing_if = "Option::is_none")]
8184 active_lock_reason: Option<String>,
8185 #[serde(skip_serializing_if = "Option::is_none")]
8186 assignees: Option<Vec<crate::components::schemas::SimpleUser>>,
8187 user: crate::components::schemas::NullableSimpleUser,
8189 labels: Vec<IssueSearchResultItemLabels>,
8190 state: String,
8191 assignee: crate::components::schemas::NullableSimpleUser,
8193 milestone: crate::components::schemas::NullableMilestone,
8195 comments: i64,
8196 created_at: String,
8197 updated_at: String,
8198 closed_at: Option<String>,
8199 #[serde(skip_serializing_if = "Option::is_none")]
8201 text_matches: Option<crate::components::schemas::SearchResultTextMatches>,
8202 #[serde(skip_serializing_if = "Option::is_none")]
8203 pull_request: Option<IssueSearchResultItemPullRequest>,
8204 #[serde(skip_serializing_if = "Option::is_none")]
8205 body: Option<String>,
8206 score: i64,
8207 author_association: crate::components::schemas::AuthorAssociation,
8209 #[serde(skip_serializing_if = "Option::is_none")]
8210 draft: Option<bool>,
8211 #[serde(skip_serializing_if = "Option::is_none")]
8213 repository: Option<crate::components::schemas::Repository>,
8214 #[serde(skip_serializing_if = "Option::is_none")]
8215 body_html: Option<String>,
8216 #[serde(skip_serializing_if = "Option::is_none")]
8217 body_text: Option<String>,
8218 #[serde(skip_serializing_if = "Option::is_none")]
8219 timeline_url: Option<String>,
8220 #[serde(skip_serializing_if = "Option::is_none")]
8222 performed_via_github_app: Option<crate::components::schemas::NullableIntegration>,
8223 #[serde(skip_serializing_if = "Option::is_none")]
8225 reactions: Option<crate::components::schemas::ReactionRollup>,
8226 }
8227
8228 #[derive(Debug, Serialize, Deserialize)]
8229 pub struct LabelSearchResultItem {
8230 id: i64,
8231 node_id: String,
8232 url: String,
8233 name: String,
8234 color: String,
8235 default: bool,
8236 description: Option<String>,
8237 score: i64,
8238 #[serde(skip_serializing_if = "Option::is_none")]
8240 text_matches: Option<crate::components::schemas::SearchResultTextMatches>,
8241 }
8242
8243 #[derive(Debug, Serialize, Deserialize)]
8244 pub struct RepoSearchResultItemPermissions {
8245 admin: bool,
8246 #[serde(skip_serializing_if = "Option::is_none")]
8247 maintain: Option<bool>,
8248 push: bool,
8249 #[serde(skip_serializing_if = "Option::is_none")]
8250 triage: Option<bool>,
8251 pull: bool,
8252 }
8253
8254 #[derive(Debug, Serialize, Deserialize)]
8255 pub struct RepoSearchResultItem {
8256 id: i64,
8257 node_id: String,
8258 name: String,
8259 full_name: String,
8260 owner: crate::components::schemas::NullableSimpleUser,
8262 private: bool,
8263 html_url: String,
8264 description: Option<String>,
8265 fork: bool,
8266 url: String,
8267 created_at: String,
8268 updated_at: String,
8269 pushed_at: String,
8270 homepage: Option<String>,
8271 size: i64,
8272 stargazers_count: i64,
8273 watchers_count: i64,
8274 language: Option<String>,
8275 forks_count: i64,
8276 open_issues_count: i64,
8277 #[serde(skip_serializing_if = "Option::is_none")]
8278 master_branch: Option<String>,
8279 default_branch: String,
8280 score: i64,
8281 forks_url: String,
8282 keys_url: String,
8283 collaborators_url: String,
8284 teams_url: String,
8285 hooks_url: String,
8286 issue_events_url: String,
8287 events_url: String,
8288 assignees_url: String,
8289 branches_url: String,
8290 tags_url: String,
8291 blobs_url: String,
8292 git_tags_url: String,
8293 git_refs_url: String,
8294 trees_url: String,
8295 statuses_url: String,
8296 languages_url: String,
8297 stargazers_url: String,
8298 contributors_url: String,
8299 subscribers_url: String,
8300 subscription_url: String,
8301 commits_url: String,
8302 git_commits_url: String,
8303 comments_url: String,
8304 issue_comment_url: String,
8305 contents_url: String,
8306 compare_url: String,
8307 merges_url: String,
8308 archive_url: String,
8309 downloads_url: String,
8310 issues_url: String,
8311 pulls_url: String,
8312 milestones_url: String,
8313 notifications_url: String,
8314 labels_url: String,
8315 releases_url: String,
8316 deployments_url: String,
8317 git_url: String,
8318 ssh_url: String,
8319 clone_url: String,
8320 svn_url: String,
8321 forks: i64,
8322 open_issues: i64,
8323 watchers: i64,
8324 #[serde(skip_serializing_if = "Option::is_none")]
8325 topics: Option<Vec<String>>,
8326 mirror_url: Option<String>,
8327 has_issues: bool,
8328 has_projects: bool,
8329 has_pages: bool,
8330 has_wiki: bool,
8331 has_downloads: bool,
8332 archived: bool,
8333 disabled: bool,
8334 #[serde(skip_serializing_if = "Option::is_none")]
8335 visibility: Option<String>,
8336 license: crate::components::schemas::NullableLicenseSimple,
8338 #[serde(skip_serializing_if = "Option::is_none")]
8339 permissions: Option<RepoSearchResultItemPermissions>,
8340 #[serde(skip_serializing_if = "Option::is_none")]
8342 text_matches: Option<crate::components::schemas::SearchResultTextMatches>,
8343 #[serde(skip_serializing_if = "Option::is_none")]
8344 temp_clone_token: Option<String>,
8345 #[serde(skip_serializing_if = "Option::is_none")]
8346 allow_merge_commit: Option<bool>,
8347 #[serde(skip_serializing_if = "Option::is_none")]
8348 allow_squash_merge: Option<bool>,
8349 #[serde(skip_serializing_if = "Option::is_none")]
8350 allow_rebase_merge: Option<bool>,
8351 #[serde(skip_serializing_if = "Option::is_none")]
8352 allow_auto_merge: Option<bool>,
8353 #[serde(skip_serializing_if = "Option::is_none")]
8354 delete_branch_on_merge: Option<bool>,
8355 #[serde(skip_serializing_if = "Option::is_none")]
8356 allow_forking: Option<bool>,
8357 #[serde(skip_serializing_if = "Option::is_none")]
8358 is_template: Option<bool>,
8359 }
8360
8361 #[derive(Debug, Serialize, Deserialize)]
8362 pub struct TopicSearchResultItemRelatedTopicRelation {
8363 #[serde(skip_serializing_if = "Option::is_none")]
8364 id: Option<i64>,
8365 #[serde(skip_serializing_if = "Option::is_none")]
8366 name: Option<String>,
8367 #[serde(skip_serializing_if = "Option::is_none")]
8368 topic_id: Option<i64>,
8369 #[serde(skip_serializing_if = "Option::is_none")]
8370 relation_type: Option<String>,
8371 }
8372
8373 #[derive(Debug, Serialize, Deserialize)]
8374 pub struct TopicSearchResultItemRelated {
8375 #[serde(skip_serializing_if = "Option::is_none")]
8376 topic_relation: Option<TopicSearchResultItemRelatedTopicRelation>,
8377 }
8378
8379 #[derive(Debug, Serialize, Deserialize)]
8380 pub struct TopicSearchResultItemAliasesTopicRelation {
8381 #[serde(skip_serializing_if = "Option::is_none")]
8382 id: Option<i64>,
8383 #[serde(skip_serializing_if = "Option::is_none")]
8384 name: Option<String>,
8385 #[serde(skip_serializing_if = "Option::is_none")]
8386 topic_id: Option<i64>,
8387 #[serde(skip_serializing_if = "Option::is_none")]
8388 relation_type: Option<String>,
8389 }
8390
8391 #[derive(Debug, Serialize, Deserialize)]
8392 pub struct TopicSearchResultItemAliases {
8393 #[serde(skip_serializing_if = "Option::is_none")]
8394 topic_relation: Option<TopicSearchResultItemAliasesTopicRelation>,
8395 }
8396
8397 #[derive(Debug, Serialize, Deserialize)]
8398 pub struct TopicSearchResultItem {
8399 name: String,
8400 display_name: Option<String>,
8401 short_description: Option<String>,
8402 description: Option<String>,
8403 created_by: Option<String>,
8404 released: Option<String>,
8405 created_at: String,
8406 updated_at: String,
8407 featured: bool,
8408 curated: bool,
8409 score: i64,
8410 #[serde(skip_serializing_if = "Option::is_none")]
8411 repository_count: Option<i64>,
8412 #[serde(skip_serializing_if = "Option::is_none")]
8413 logo_url: Option<String>,
8414 #[serde(skip_serializing_if = "Option::is_none")]
8416 text_matches: Option<crate::components::schemas::SearchResultTextMatches>,
8417 #[serde(skip_serializing_if = "Option::is_none")]
8418 related: Option<Vec<TopicSearchResultItemRelated>>,
8419 #[serde(skip_serializing_if = "Option::is_none")]
8420 aliases: Option<Vec<TopicSearchResultItemAliases>>,
8421 }
8422
8423 #[derive(Debug, Serialize, Deserialize)]
8424 pub struct UserSearchResultItem {
8425 login: String,
8426 id: i64,
8427 node_id: String,
8428 avatar_url: String,
8429 gravatar_id: Option<String>,
8430 url: String,
8431 html_url: String,
8432 followers_url: String,
8433 subscriptions_url: String,
8434 organizations_url: String,
8435 repos_url: String,
8436 received_events_url: String,
8437 #[serde(rename="type")]
8438 type_: String,
8439 score: i64,
8440 following_url: String,
8441 gists_url: String,
8442 starred_url: String,
8443 events_url: String,
8444 #[serde(skip_serializing_if = "Option::is_none")]
8445 public_repos: Option<i64>,
8446 #[serde(skip_serializing_if = "Option::is_none")]
8447 public_gists: Option<i64>,
8448 #[serde(skip_serializing_if = "Option::is_none")]
8449 followers: Option<i64>,
8450 #[serde(skip_serializing_if = "Option::is_none")]
8451 following: Option<i64>,
8452 #[serde(skip_serializing_if = "Option::is_none")]
8453 created_at: Option<String>,
8454 #[serde(skip_serializing_if = "Option::is_none")]
8455 updated_at: Option<String>,
8456 #[serde(skip_serializing_if = "Option::is_none")]
8457 name: Option<String>,
8458 #[serde(skip_serializing_if = "Option::is_none")]
8459 bio: Option<String>,
8460 #[serde(skip_serializing_if = "Option::is_none")]
8461 email: Option<String>,
8462 #[serde(skip_serializing_if = "Option::is_none")]
8463 location: Option<String>,
8464 site_admin: bool,
8465 #[serde(skip_serializing_if = "Option::is_none")]
8466 hireable: Option<bool>,
8467 #[serde(skip_serializing_if = "Option::is_none")]
8469 text_matches: Option<crate::components::schemas::SearchResultTextMatches>,
8470 #[serde(skip_serializing_if = "Option::is_none")]
8471 blog: Option<String>,
8472 #[serde(skip_serializing_if = "Option::is_none")]
8473 company: Option<String>,
8474 #[serde(skip_serializing_if = "Option::is_none")]
8475 suspended_at: Option<String>,
8476 }
8477
8478 #[derive(Debug, Serialize, Deserialize)]
8479 pub struct PrivateUserPlan {
8480 collaborators: i64,
8481 name: String,
8482 space: i64,
8483 private_repos: i64,
8484 }
8485
8486 #[derive(Debug, Serialize, Deserialize)]
8487 pub struct PrivateUser {
8488 login: String,
8489 id: i64,
8490 node_id: String,
8491 avatar_url: String,
8492 gravatar_id: Option<String>,
8493 url: String,
8494 html_url: String,
8495 followers_url: String,
8496 following_url: String,
8497 gists_url: String,
8498 starred_url: String,
8499 subscriptions_url: String,
8500 organizations_url: String,
8501 repos_url: String,
8502 events_url: String,
8503 received_events_url: String,
8504 #[serde(rename="type")]
8505 type_: String,
8506 site_admin: bool,
8507 name: Option<String>,
8508 company: Option<String>,
8509 blog: Option<String>,
8510 location: Option<String>,
8511 email: Option<String>,
8512 hireable: Option<bool>,
8513 bio: Option<String>,
8514 #[serde(skip_serializing_if = "Option::is_none")]
8515 twitter_username: Option<String>,
8516 public_repos: i64,
8517 public_gists: i64,
8518 followers: i64,
8519 following: i64,
8520 created_at: String,
8521 updated_at: String,
8522 private_gists: i64,
8523 total_private_repos: i64,
8524 owned_private_repos: i64,
8525 disk_usage: i64,
8526 collaborators: i64,
8527 two_factor_authentication: bool,
8528 #[serde(skip_serializing_if = "Option::is_none")]
8529 plan: Option<PrivateUserPlan>,
8530 #[serde(skip_serializing_if = "Option::is_none")]
8531 suspended_at: Option<String>,
8532 #[serde(skip_serializing_if = "Option::is_none")]
8533 business_plus: Option<bool>,
8534 #[serde(skip_serializing_if = "Option::is_none")]
8535 ldap_dn: Option<String>,
8536 }
8537
8538 #[derive(Debug, Serialize, Deserialize)]
8539 pub struct CodespacesSecret {
8540 name: String,
8541 created_at: String,
8542 updated_at: String,
8543 visibility: String,
8544 selected_repositories_url: String,
8545 }
8546
8547 #[derive(Debug, Serialize, Deserialize)]
8548 pub struct CodespacesUserPublicKey {
8549 key_id: String,
8550 key: String,
8551 }
8552
8553 #[derive(Debug, Serialize, Deserialize)]
8554 pub struct Email {
8555 email: String,
8556 primary: bool,
8557 verified: bool,
8558 visibility: Option<String>,
8559 }
8560
8561 #[derive(Debug, Serialize, Deserialize)]
8562 pub struct GpgKeyEmails {
8563 #[serde(skip_serializing_if = "Option::is_none")]
8564 email: Option<String>,
8565 #[serde(skip_serializing_if = "Option::is_none")]
8566 verified: Option<bool>,
8567 }
8568
8569 #[derive(Debug, Serialize, Deserialize)]
8570 pub struct GpgKeySubkeys {
8571 #[serde(skip_serializing_if = "Option::is_none")]
8572 id: Option<i64>,
8573 #[serde(skip_serializing_if = "Option::is_none")]
8574 primary_key_id: Option<i64>,
8575 #[serde(skip_serializing_if = "Option::is_none")]
8576 key_id: Option<String>,
8577 #[serde(skip_serializing_if = "Option::is_none")]
8578 public_key: Option<String>,
8579 #[serde(skip_serializing_if = "Option::is_none")]
8580 emails: Option<Vec<HashMap<String, String>>>,
8581 #[serde(skip_serializing_if = "Option::is_none")]
8582 subkeys: Option<Vec<HashMap<String, String>>>,
8583 #[serde(skip_serializing_if = "Option::is_none")]
8584 can_sign: Option<bool>,
8585 #[serde(skip_serializing_if = "Option::is_none")]
8586 can_encrypt_comms: Option<bool>,
8587 #[serde(skip_serializing_if = "Option::is_none")]
8588 can_encrypt_storage: Option<bool>,
8589 #[serde(skip_serializing_if = "Option::is_none")]
8590 can_certify: Option<bool>,
8591 #[serde(skip_serializing_if = "Option::is_none")]
8592 created_at: Option<String>,
8593 #[serde(skip_serializing_if = "Option::is_none")]
8594 expires_at: Option<String>,
8595 #[serde(skip_serializing_if = "Option::is_none")]
8596 raw_key: Option<String>,
8597 }
8598
8599 #[derive(Debug, Serialize, Deserialize)]
8600 pub struct GpgKey {
8601 id: i64,
8602 primary_key_id: Option<i64>,
8603 key_id: String,
8604 public_key: String,
8605 emails: Vec<GpgKeyEmails>,
8606 subkeys: Vec<GpgKeySubkeys>,
8607 can_sign: bool,
8608 can_encrypt_comms: bool,
8609 can_encrypt_storage: bool,
8610 can_certify: bool,
8611 created_at: String,
8612 expires_at: Option<String>,
8613 raw_key: Option<String>,
8614 }
8615
8616 #[derive(Debug, Serialize, Deserialize)]
8617 pub struct Key {
8618 key: String,
8619 id: i64,
8620 url: String,
8621 title: String,
8622 created_at: String,
8623 verified: bool,
8624 read_only: bool,
8625 }
8626
8627 #[derive(Debug, Serialize, Deserialize)]
8628 pub struct MarketplaceAccount {
8629 url: String,
8630 id: i64,
8631 #[serde(rename="type")]
8632 type_: String,
8633 #[serde(skip_serializing_if = "Option::is_none")]
8634 node_id: Option<String>,
8635 login: String,
8636 #[serde(skip_serializing_if = "Option::is_none")]
8637 email: Option<String>,
8638 #[serde(skip_serializing_if = "Option::is_none")]
8639 organization_billing_email: Option<String>,
8640 }
8641
8642 #[derive(Debug, Serialize, Deserialize)]
8643 pub struct UserMarketplacePurchase {
8644 billing_cycle: String,
8645 next_billing_date: Option<String>,
8646 unit_count: Option<i64>,
8647 on_free_trial: bool,
8648 free_trial_ends_on: Option<String>,
8649 updated_at: Option<String>,
8650 account: crate::components::schemas::MarketplaceAccount,
8652 plan: crate::components::schemas::MarketplaceListingPlan,
8654 }
8655
8656 #[derive(Debug, Serialize, Deserialize)]
8657 pub struct StarredRepository {
8658 starred_at: String,
8659 repo: crate::components::schemas::Repository,
8661 }
8662
8663 #[derive(Debug, Serialize, Deserialize)]
8664 pub struct HovercardContexts {
8665 message: String,
8666 octicon: String,
8667 }
8668
8669 #[derive(Debug, Serialize, Deserialize)]
8670 pub struct Hovercard {
8671 contexts: Vec<HovercardContexts>,
8672 }
8673
8674 #[derive(Debug, Serialize, Deserialize)]
8675 pub struct KeySimple {
8676 id: i64,
8677 key: String,
8678 }
8679 }
8680}