...
1
2
3
4
5
6
7
8
9
10 package github
11
12 import (
13 "encoding/json"
14 "time"
15 )
16
17
18 func (a *AbuseRateLimitError) GetRetryAfter() time.Duration {
19 if a == nil || a.RetryAfter == nil {
20 return 0
21 }
22 return *a.RetryAfter
23 }
24
25
26 func (a *ActionsAllowed) GetGithubOwnedAllowed() bool {
27 if a == nil || a.GithubOwnedAllowed == nil {
28 return false
29 }
30 return *a.GithubOwnedAllowed
31 }
32
33
34 func (a *ActionsAllowed) GetVerifiedAllowed() bool {
35 if a == nil || a.VerifiedAllowed == nil {
36 return false
37 }
38 return *a.VerifiedAllowed
39 }
40
41
42 func (a *ActionsPermissions) GetAllowedActions() string {
43 if a == nil || a.AllowedActions == nil {
44 return ""
45 }
46 return *a.AllowedActions
47 }
48
49
50 func (a *ActionsPermissions) GetEnabledRepositories() string {
51 if a == nil || a.EnabledRepositories == nil {
52 return ""
53 }
54 return *a.EnabledRepositories
55 }
56
57
58 func (a *ActionsPermissions) GetSelectedActionsURL() string {
59 if a == nil || a.SelectedActionsURL == nil {
60 return ""
61 }
62 return *a.SelectedActionsURL
63 }
64
65
66 func (a *ActionsPermissionsRepository) GetAllowedActions() string {
67 if a == nil || a.AllowedActions == nil {
68 return ""
69 }
70 return *a.AllowedActions
71 }
72
73
74 func (a *ActionsPermissionsRepository) GetEnabled() bool {
75 if a == nil || a.Enabled == nil {
76 return false
77 }
78 return *a.Enabled
79 }
80
81
82 func (a *ActionsPermissionsRepository) GetSelectedActionsURL() string {
83 if a == nil || a.SelectedActionsURL == nil {
84 return ""
85 }
86 return *a.SelectedActionsURL
87 }
88
89
90 func (a *AdminEnforcement) GetURL() string {
91 if a == nil || a.URL == nil {
92 return ""
93 }
94 return *a.URL
95 }
96
97
98 func (a *AdminStats) GetComments() *CommentStats {
99 if a == nil {
100 return nil
101 }
102 return a.Comments
103 }
104
105
106 func (a *AdminStats) GetGists() *GistStats {
107 if a == nil {
108 return nil
109 }
110 return a.Gists
111 }
112
113
114 func (a *AdminStats) GetHooks() *HookStats {
115 if a == nil {
116 return nil
117 }
118 return a.Hooks
119 }
120
121
122 func (a *AdminStats) GetIssues() *IssueStats {
123 if a == nil {
124 return nil
125 }
126 return a.Issues
127 }
128
129
130 func (a *AdminStats) GetMilestones() *MilestoneStats {
131 if a == nil {
132 return nil
133 }
134 return a.Milestones
135 }
136
137
138 func (a *AdminStats) GetOrgs() *OrgStats {
139 if a == nil {
140 return nil
141 }
142 return a.Orgs
143 }
144
145
146 func (a *AdminStats) GetPages() *PageStats {
147 if a == nil {
148 return nil
149 }
150 return a.Pages
151 }
152
153
154 func (a *AdminStats) GetPulls() *PullStats {
155 if a == nil {
156 return nil
157 }
158 return a.Pulls
159 }
160
161
162 func (a *AdminStats) GetRepos() *RepoStats {
163 if a == nil {
164 return nil
165 }
166 return a.Repos
167 }
168
169
170 func (a *AdminStats) GetUsers() *UserStats {
171 if a == nil {
172 return nil
173 }
174 return a.Users
175 }
176
177
178 func (a *AdvancedSecurity) GetStatus() string {
179 if a == nil || a.Status == nil {
180 return ""
181 }
182 return *a.Status
183 }
184
185
186 func (a *AdvancedSecurityCommittersBreakdown) GetLastPushedDate() string {
187 if a == nil || a.LastPushedDate == nil {
188 return ""
189 }
190 return *a.LastPushedDate
191 }
192
193
194 func (a *AdvancedSecurityCommittersBreakdown) GetUserLogin() string {
195 if a == nil || a.UserLogin == nil {
196 return ""
197 }
198 return *a.UserLogin
199 }
200
201
202 func (a *AdvisoryIdentifier) GetType() string {
203 if a == nil || a.Type == nil {
204 return ""
205 }
206 return *a.Type
207 }
208
209
210 func (a *AdvisoryIdentifier) GetValue() string {
211 if a == nil || a.Value == nil {
212 return ""
213 }
214 return *a.Value
215 }
216
217
218 func (a *AdvisoryReference) GetURL() string {
219 if a == nil || a.URL == nil {
220 return ""
221 }
222 return *a.URL
223 }
224
225
226 func (a *AdvisoryVulnerability) GetFirstPatchedVersion() *FirstPatchedVersion {
227 if a == nil {
228 return nil
229 }
230 return a.FirstPatchedVersion
231 }
232
233
234 func (a *AdvisoryVulnerability) GetPackage() *VulnerabilityPackage {
235 if a == nil {
236 return nil
237 }
238 return a.Package
239 }
240
241
242 func (a *AdvisoryVulnerability) GetSeverity() string {
243 if a == nil || a.Severity == nil {
244 return ""
245 }
246 return *a.Severity
247 }
248
249
250 func (a *AdvisoryVulnerability) GetVulnerableVersionRange() string {
251 if a == nil || a.VulnerableVersionRange == nil {
252 return ""
253 }
254 return *a.VulnerableVersionRange
255 }
256
257
258 func (a *Alert) GetClosedAt() Timestamp {
259 if a == nil || a.ClosedAt == nil {
260 return Timestamp{}
261 }
262 return *a.ClosedAt
263 }
264
265
266 func (a *Alert) GetClosedBy() *User {
267 if a == nil {
268 return nil
269 }
270 return a.ClosedBy
271 }
272
273
274 func (a *Alert) GetCreatedAt() Timestamp {
275 if a == nil || a.CreatedAt == nil {
276 return Timestamp{}
277 }
278 return *a.CreatedAt
279 }
280
281
282 func (a *Alert) GetDismissedAt() Timestamp {
283 if a == nil || a.DismissedAt == nil {
284 return Timestamp{}
285 }
286 return *a.DismissedAt
287 }
288
289
290 func (a *Alert) GetDismissedBy() *User {
291 if a == nil {
292 return nil
293 }
294 return a.DismissedBy
295 }
296
297
298 func (a *Alert) GetDismissedReason() string {
299 if a == nil || a.DismissedReason == nil {
300 return ""
301 }
302 return *a.DismissedReason
303 }
304
305
306 func (a *Alert) GetFixedAt() Timestamp {
307 if a == nil || a.FixedAt == nil {
308 return Timestamp{}
309 }
310 return *a.FixedAt
311 }
312
313
314 func (a *Alert) GetHTMLURL() string {
315 if a == nil || a.HTMLURL == nil {
316 return ""
317 }
318 return *a.HTMLURL
319 }
320
321
322 func (a *Alert) GetInstancesURL() string {
323 if a == nil || a.InstancesURL == nil {
324 return ""
325 }
326 return *a.InstancesURL
327 }
328
329
330 func (a *Alert) GetMostRecentInstance() *MostRecentInstance {
331 if a == nil {
332 return nil
333 }
334 return a.MostRecentInstance
335 }
336
337
338 func (a *Alert) GetNumber() int {
339 if a == nil || a.Number == nil {
340 return 0
341 }
342 return *a.Number
343 }
344
345
346 func (a *Alert) GetRepository() *Repository {
347 if a == nil {
348 return nil
349 }
350 return a.Repository
351 }
352
353
354 func (a *Alert) GetRule() *Rule {
355 if a == nil {
356 return nil
357 }
358 return a.Rule
359 }
360
361
362 func (a *Alert) GetRuleDescription() string {
363 if a == nil || a.RuleDescription == nil {
364 return ""
365 }
366 return *a.RuleDescription
367 }
368
369
370 func (a *Alert) GetRuleID() string {
371 if a == nil || a.RuleID == nil {
372 return ""
373 }
374 return *a.RuleID
375 }
376
377
378 func (a *Alert) GetRuleSeverity() string {
379 if a == nil || a.RuleSeverity == nil {
380 return ""
381 }
382 return *a.RuleSeverity
383 }
384
385
386 func (a *Alert) GetState() string {
387 if a == nil || a.State == nil {
388 return ""
389 }
390 return *a.State
391 }
392
393
394 func (a *Alert) GetTool() *Tool {
395 if a == nil {
396 return nil
397 }
398 return a.Tool
399 }
400
401
402 func (a *Alert) GetUpdatedAt() Timestamp {
403 if a == nil || a.UpdatedAt == nil {
404 return Timestamp{}
405 }
406 return *a.UpdatedAt
407 }
408
409
410 func (a *Alert) GetURL() string {
411 if a == nil || a.URL == nil {
412 return ""
413 }
414 return *a.URL
415 }
416
417
418 func (a *AnalysesListOptions) GetRef() string {
419 if a == nil || a.Ref == nil {
420 return ""
421 }
422 return *a.Ref
423 }
424
425
426 func (a *AnalysesListOptions) GetSarifID() string {
427 if a == nil || a.SarifID == nil {
428 return ""
429 }
430 return *a.SarifID
431 }
432
433
434 func (a *APIMeta) GetSSHKeyFingerprints() map[string]string {
435 if a == nil || a.SSHKeyFingerprints == nil {
436 return map[string]string{}
437 }
438 return a.SSHKeyFingerprints
439 }
440
441
442 func (a *APIMeta) GetVerifiablePasswordAuthentication() bool {
443 if a == nil || a.VerifiablePasswordAuthentication == nil {
444 return false
445 }
446 return *a.VerifiablePasswordAuthentication
447 }
448
449
450 func (a *App) GetCreatedAt() Timestamp {
451 if a == nil || a.CreatedAt == nil {
452 return Timestamp{}
453 }
454 return *a.CreatedAt
455 }
456
457
458 func (a *App) GetDescription() string {
459 if a == nil || a.Description == nil {
460 return ""
461 }
462 return *a.Description
463 }
464
465
466 func (a *App) GetExternalURL() string {
467 if a == nil || a.ExternalURL == nil {
468 return ""
469 }
470 return *a.ExternalURL
471 }
472
473
474 func (a *App) GetHTMLURL() string {
475 if a == nil || a.HTMLURL == nil {
476 return ""
477 }
478 return *a.HTMLURL
479 }
480
481
482 func (a *App) GetID() int64 {
483 if a == nil || a.ID == nil {
484 return 0
485 }
486 return *a.ID
487 }
488
489
490 func (a *App) GetName() string {
491 if a == nil || a.Name == nil {
492 return ""
493 }
494 return *a.Name
495 }
496
497
498 func (a *App) GetNodeID() string {
499 if a == nil || a.NodeID == nil {
500 return ""
501 }
502 return *a.NodeID
503 }
504
505
506 func (a *App) GetOwner() *User {
507 if a == nil {
508 return nil
509 }
510 return a.Owner
511 }
512
513
514 func (a *App) GetPermissions() *InstallationPermissions {
515 if a == nil {
516 return nil
517 }
518 return a.Permissions
519 }
520
521
522 func (a *App) GetSlug() string {
523 if a == nil || a.Slug == nil {
524 return ""
525 }
526 return *a.Slug
527 }
528
529
530 func (a *App) GetUpdatedAt() Timestamp {
531 if a == nil || a.UpdatedAt == nil {
532 return Timestamp{}
533 }
534 return *a.UpdatedAt
535 }
536
537
538 func (a *AppConfig) GetClientID() string {
539 if a == nil || a.ClientID == nil {
540 return ""
541 }
542 return *a.ClientID
543 }
544
545
546 func (a *AppConfig) GetClientSecret() string {
547 if a == nil || a.ClientSecret == nil {
548 return ""
549 }
550 return *a.ClientSecret
551 }
552
553
554 func (a *AppConfig) GetCreatedAt() Timestamp {
555 if a == nil || a.CreatedAt == nil {
556 return Timestamp{}
557 }
558 return *a.CreatedAt
559 }
560
561
562 func (a *AppConfig) GetDescription() string {
563 if a == nil || a.Description == nil {
564 return ""
565 }
566 return *a.Description
567 }
568
569
570 func (a *AppConfig) GetExternalURL() string {
571 if a == nil || a.ExternalURL == nil {
572 return ""
573 }
574 return *a.ExternalURL
575 }
576
577
578 func (a *AppConfig) GetHTMLURL() string {
579 if a == nil || a.HTMLURL == nil {
580 return ""
581 }
582 return *a.HTMLURL
583 }
584
585
586 func (a *AppConfig) GetID() int64 {
587 if a == nil || a.ID == nil {
588 return 0
589 }
590 return *a.ID
591 }
592
593
594 func (a *AppConfig) GetName() string {
595 if a == nil || a.Name == nil {
596 return ""
597 }
598 return *a.Name
599 }
600
601
602 func (a *AppConfig) GetNodeID() string {
603 if a == nil || a.NodeID == nil {
604 return ""
605 }
606 return *a.NodeID
607 }
608
609
610 func (a *AppConfig) GetOwner() *User {
611 if a == nil {
612 return nil
613 }
614 return a.Owner
615 }
616
617
618 func (a *AppConfig) GetPEM() string {
619 if a == nil || a.PEM == nil {
620 return ""
621 }
622 return *a.PEM
623 }
624
625
626 func (a *AppConfig) GetSlug() string {
627 if a == nil || a.Slug == nil {
628 return ""
629 }
630 return *a.Slug
631 }
632
633
634 func (a *AppConfig) GetUpdatedAt() Timestamp {
635 if a == nil || a.UpdatedAt == nil {
636 return Timestamp{}
637 }
638 return *a.UpdatedAt
639 }
640
641
642 func (a *AppConfig) GetWebhookSecret() string {
643 if a == nil || a.WebhookSecret == nil {
644 return ""
645 }
646 return *a.WebhookSecret
647 }
648
649
650 func (a *Artifact) GetArchiveDownloadURL() string {
651 if a == nil || a.ArchiveDownloadURL == nil {
652 return ""
653 }
654 return *a.ArchiveDownloadURL
655 }
656
657
658 func (a *Artifact) GetCreatedAt() Timestamp {
659 if a == nil || a.CreatedAt == nil {
660 return Timestamp{}
661 }
662 return *a.CreatedAt
663 }
664
665
666 func (a *Artifact) GetExpired() bool {
667 if a == nil || a.Expired == nil {
668 return false
669 }
670 return *a.Expired
671 }
672
673
674 func (a *Artifact) GetExpiresAt() Timestamp {
675 if a == nil || a.ExpiresAt == nil {
676 return Timestamp{}
677 }
678 return *a.ExpiresAt
679 }
680
681
682 func (a *Artifact) GetID() int64 {
683 if a == nil || a.ID == nil {
684 return 0
685 }
686 return *a.ID
687 }
688
689
690 func (a *Artifact) GetName() string {
691 if a == nil || a.Name == nil {
692 return ""
693 }
694 return *a.Name
695 }
696
697
698 func (a *Artifact) GetNodeID() string {
699 if a == nil || a.NodeID == nil {
700 return ""
701 }
702 return *a.NodeID
703 }
704
705
706 func (a *Artifact) GetSizeInBytes() int64 {
707 if a == nil || a.SizeInBytes == nil {
708 return 0
709 }
710 return *a.SizeInBytes
711 }
712
713
714 func (a *ArtifactList) GetTotalCount() int64 {
715 if a == nil || a.TotalCount == nil {
716 return 0
717 }
718 return *a.TotalCount
719 }
720
721
722 func (a *Attachment) GetBody() string {
723 if a == nil || a.Body == nil {
724 return ""
725 }
726 return *a.Body
727 }
728
729
730 func (a *Attachment) GetID() int64 {
731 if a == nil || a.ID == nil {
732 return 0
733 }
734 return *a.ID
735 }
736
737
738 func (a *Attachment) GetTitle() string {
739 if a == nil || a.Title == nil {
740 return ""
741 }
742 return *a.Title
743 }
744
745
746 func (a *AuditEntry) GetAction() string {
747 if a == nil || a.Action == nil {
748 return ""
749 }
750 return *a.Action
751 }
752
753
754 func (a *AuditEntry) GetActive() bool {
755 if a == nil || a.Active == nil {
756 return false
757 }
758 return *a.Active
759 }
760
761
762 func (a *AuditEntry) GetActiveWas() bool {
763 if a == nil || a.ActiveWas == nil {
764 return false
765 }
766 return *a.ActiveWas
767 }
768
769
770 func (a *AuditEntry) GetActor() string {
771 if a == nil || a.Actor == nil {
772 return ""
773 }
774 return *a.Actor
775 }
776
777
778 func (a *AuditEntry) GetBlockedUser() string {
779 if a == nil || a.BlockedUser == nil {
780 return ""
781 }
782 return *a.BlockedUser
783 }
784
785
786 func (a *AuditEntry) GetBusiness() string {
787 if a == nil || a.Business == nil {
788 return ""
789 }
790 return *a.Business
791 }
792
793
794 func (a *AuditEntry) GetCancelledAt() Timestamp {
795 if a == nil || a.CancelledAt == nil {
796 return Timestamp{}
797 }
798 return *a.CancelledAt
799 }
800
801
802 func (a *AuditEntry) GetCompletedAt() Timestamp {
803 if a == nil || a.CompletedAt == nil {
804 return Timestamp{}
805 }
806 return *a.CompletedAt
807 }
808
809
810 func (a *AuditEntry) GetConclusion() string {
811 if a == nil || a.Conclusion == nil {
812 return ""
813 }
814 return *a.Conclusion
815 }
816
817
818 func (a *AuditEntry) GetConfig() *HookConfig {
819 if a == nil {
820 return nil
821 }
822 return a.Config
823 }
824
825
826 func (a *AuditEntry) GetConfigWas() *HookConfig {
827 if a == nil {
828 return nil
829 }
830 return a.ConfigWas
831 }
832
833
834 func (a *AuditEntry) GetContentType() string {
835 if a == nil || a.ContentType == nil {
836 return ""
837 }
838 return *a.ContentType
839 }
840
841
842 func (a *AuditEntry) GetCreatedAt() Timestamp {
843 if a == nil || a.CreatedAt == nil {
844 return Timestamp{}
845 }
846 return *a.CreatedAt
847 }
848
849
850 func (a *AuditEntry) GetDeployKeyFingerprint() string {
851 if a == nil || a.DeployKeyFingerprint == nil {
852 return ""
853 }
854 return *a.DeployKeyFingerprint
855 }
856
857
858 func (a *AuditEntry) GetDocumentID() string {
859 if a == nil || a.DocumentID == nil {
860 return ""
861 }
862 return *a.DocumentID
863 }
864
865
866 func (a *AuditEntry) GetEmoji() string {
867 if a == nil || a.Emoji == nil {
868 return ""
869 }
870 return *a.Emoji
871 }
872
873
874 func (a *AuditEntry) GetEnvironmentName() string {
875 if a == nil || a.EnvironmentName == nil {
876 return ""
877 }
878 return *a.EnvironmentName
879 }
880
881
882 func (a *AuditEntry) GetEvent() string {
883 if a == nil || a.Event == nil {
884 return ""
885 }
886 return *a.Event
887 }
888
889
890 func (a *AuditEntry) GetExplanation() string {
891 if a == nil || a.Explanation == nil {
892 return ""
893 }
894 return *a.Explanation
895 }
896
897
898 func (a *AuditEntry) GetFingerprint() string {
899 if a == nil || a.Fingerprint == nil {
900 return ""
901 }
902 return *a.Fingerprint
903 }
904
905
906 func (a *AuditEntry) GetHeadBranch() string {
907 if a == nil || a.HeadBranch == nil {
908 return ""
909 }
910 return *a.HeadBranch
911 }
912
913
914 func (a *AuditEntry) GetHeadSHA() string {
915 if a == nil || a.HeadSHA == nil {
916 return ""
917 }
918 return *a.HeadSHA
919 }
920
921
922 func (a *AuditEntry) GetHookID() int64 {
923 if a == nil || a.HookID == nil {
924 return 0
925 }
926 return *a.HookID
927 }
928
929
930 func (a *AuditEntry) GetIsHostedRunner() bool {
931 if a == nil || a.IsHostedRunner == nil {
932 return false
933 }
934 return *a.IsHostedRunner
935 }
936
937
938 func (a *AuditEntry) GetJobName() string {
939 if a == nil || a.JobName == nil {
940 return ""
941 }
942 return *a.JobName
943 }
944
945
946 func (a *AuditEntry) GetLimitedAvailability() bool {
947 if a == nil || a.LimitedAvailability == nil {
948 return false
949 }
950 return *a.LimitedAvailability
951 }
952
953
954 func (a *AuditEntry) GetMessage() string {
955 if a == nil || a.Message == nil {
956 return ""
957 }
958 return *a.Message
959 }
960
961
962 func (a *AuditEntry) GetName() string {
963 if a == nil || a.Name == nil {
964 return ""
965 }
966 return *a.Name
967 }
968
969
970 func (a *AuditEntry) GetOldUser() string {
971 if a == nil || a.OldUser == nil {
972 return ""
973 }
974 return *a.OldUser
975 }
976
977
978 func (a *AuditEntry) GetOpenSSHPublicKey() string {
979 if a == nil || a.OpenSSHPublicKey == nil {
980 return ""
981 }
982 return *a.OpenSSHPublicKey
983 }
984
985
986 func (a *AuditEntry) GetOrg() string {
987 if a == nil || a.Org == nil {
988 return ""
989 }
990 return *a.Org
991 }
992
993
994 func (a *AuditEntry) GetPreviousVisibility() string {
995 if a == nil || a.PreviousVisibility == nil {
996 return ""
997 }
998 return *a.PreviousVisibility
999 }
1000
1001
1002 func (a *AuditEntry) GetReadOnly() string {
1003 if a == nil || a.ReadOnly == nil {
1004 return ""
1005 }
1006 return *a.ReadOnly
1007 }
1008
1009
1010 func (a *AuditEntry) GetRepo() string {
1011 if a == nil || a.Repo == nil {
1012 return ""
1013 }
1014 return *a.Repo
1015 }
1016
1017
1018 func (a *AuditEntry) GetRepository() string {
1019 if a == nil || a.Repository == nil {
1020 return ""
1021 }
1022 return *a.Repository
1023 }
1024
1025
1026 func (a *AuditEntry) GetRepositoryPublic() bool {
1027 if a == nil || a.RepositoryPublic == nil {
1028 return false
1029 }
1030 return *a.RepositoryPublic
1031 }
1032
1033
1034 func (a *AuditEntry) GetRunnerGroupID() int64 {
1035 if a == nil || a.RunnerGroupID == nil {
1036 return 0
1037 }
1038 return *a.RunnerGroupID
1039 }
1040
1041
1042 func (a *AuditEntry) GetRunnerGroupName() string {
1043 if a == nil || a.RunnerGroupName == nil {
1044 return ""
1045 }
1046 return *a.RunnerGroupName
1047 }
1048
1049
1050 func (a *AuditEntry) GetRunnerID() int64 {
1051 if a == nil || a.RunnerID == nil {
1052 return 0
1053 }
1054 return *a.RunnerID
1055 }
1056
1057
1058 func (a *AuditEntry) GetRunnerName() string {
1059 if a == nil || a.RunnerName == nil {
1060 return ""
1061 }
1062 return *a.RunnerName
1063 }
1064
1065
1066 func (a *AuditEntry) GetSourceVersion() string {
1067 if a == nil || a.SourceVersion == nil {
1068 return ""
1069 }
1070 return *a.SourceVersion
1071 }
1072
1073
1074 func (a *AuditEntry) GetStartedAt() Timestamp {
1075 if a == nil || a.StartedAt == nil {
1076 return Timestamp{}
1077 }
1078 return *a.StartedAt
1079 }
1080
1081
1082 func (a *AuditEntry) GetTargetLogin() string {
1083 if a == nil || a.TargetLogin == nil {
1084 return ""
1085 }
1086 return *a.TargetLogin
1087 }
1088
1089
1090 func (a *AuditEntry) GetTargetVersion() string {
1091 if a == nil || a.TargetVersion == nil {
1092 return ""
1093 }
1094 return *a.TargetVersion
1095 }
1096
1097
1098 func (a *AuditEntry) GetTeam() string {
1099 if a == nil || a.Team == nil {
1100 return ""
1101 }
1102 return *a.Team
1103 }
1104
1105
1106 func (a *AuditEntry) GetTimestamp() Timestamp {
1107 if a == nil || a.Timestamp == nil {
1108 return Timestamp{}
1109 }
1110 return *a.Timestamp
1111 }
1112
1113
1114 func (a *AuditEntry) GetTransportProtocol() int {
1115 if a == nil || a.TransportProtocol == nil {
1116 return 0
1117 }
1118 return *a.TransportProtocol
1119 }
1120
1121
1122 func (a *AuditEntry) GetTransportProtocolName() string {
1123 if a == nil || a.TransportProtocolName == nil {
1124 return ""
1125 }
1126 return *a.TransportProtocolName
1127 }
1128
1129
1130 func (a *AuditEntry) GetTriggerID() int64 {
1131 if a == nil || a.TriggerID == nil {
1132 return 0
1133 }
1134 return *a.TriggerID
1135 }
1136
1137
1138 func (a *AuditEntry) GetUser() string {
1139 if a == nil || a.User == nil {
1140 return ""
1141 }
1142 return *a.User
1143 }
1144
1145
1146 func (a *AuditEntry) GetVisibility() string {
1147 if a == nil || a.Visibility == nil {
1148 return ""
1149 }
1150 return *a.Visibility
1151 }
1152
1153
1154 func (a *AuditEntry) GetWorkflowID() int64 {
1155 if a == nil || a.WorkflowID == nil {
1156 return 0
1157 }
1158 return *a.WorkflowID
1159 }
1160
1161
1162 func (a *AuditEntry) GetWorkflowRunID() int64 {
1163 if a == nil || a.WorkflowRunID == nil {
1164 return 0
1165 }
1166 return *a.WorkflowRunID
1167 }
1168
1169
1170 func (a *Authorization) GetApp() *AuthorizationApp {
1171 if a == nil {
1172 return nil
1173 }
1174 return a.App
1175 }
1176
1177
1178 func (a *Authorization) GetCreatedAt() Timestamp {
1179 if a == nil || a.CreatedAt == nil {
1180 return Timestamp{}
1181 }
1182 return *a.CreatedAt
1183 }
1184
1185
1186 func (a *Authorization) GetFingerprint() string {
1187 if a == nil || a.Fingerprint == nil {
1188 return ""
1189 }
1190 return *a.Fingerprint
1191 }
1192
1193
1194 func (a *Authorization) GetHashedToken() string {
1195 if a == nil || a.HashedToken == nil {
1196 return ""
1197 }
1198 return *a.HashedToken
1199 }
1200
1201
1202 func (a *Authorization) GetID() int64 {
1203 if a == nil || a.ID == nil {
1204 return 0
1205 }
1206 return *a.ID
1207 }
1208
1209
1210 func (a *Authorization) GetNote() string {
1211 if a == nil || a.Note == nil {
1212 return ""
1213 }
1214 return *a.Note
1215 }
1216
1217
1218 func (a *Authorization) GetNoteURL() string {
1219 if a == nil || a.NoteURL == nil {
1220 return ""
1221 }
1222 return *a.NoteURL
1223 }
1224
1225
1226 func (a *Authorization) GetToken() string {
1227 if a == nil || a.Token == nil {
1228 return ""
1229 }
1230 return *a.Token
1231 }
1232
1233
1234 func (a *Authorization) GetTokenLastEight() string {
1235 if a == nil || a.TokenLastEight == nil {
1236 return ""
1237 }
1238 return *a.TokenLastEight
1239 }
1240
1241
1242 func (a *Authorization) GetUpdatedAt() Timestamp {
1243 if a == nil || a.UpdatedAt == nil {
1244 return Timestamp{}
1245 }
1246 return *a.UpdatedAt
1247 }
1248
1249
1250 func (a *Authorization) GetURL() string {
1251 if a == nil || a.URL == nil {
1252 return ""
1253 }
1254 return *a.URL
1255 }
1256
1257
1258 func (a *Authorization) GetUser() *User {
1259 if a == nil {
1260 return nil
1261 }
1262 return a.User
1263 }
1264
1265
1266 func (a *AuthorizationApp) GetClientID() string {
1267 if a == nil || a.ClientID == nil {
1268 return ""
1269 }
1270 return *a.ClientID
1271 }
1272
1273
1274 func (a *AuthorizationApp) GetName() string {
1275 if a == nil || a.Name == nil {
1276 return ""
1277 }
1278 return *a.Name
1279 }
1280
1281
1282 func (a *AuthorizationApp) GetURL() string {
1283 if a == nil || a.URL == nil {
1284 return ""
1285 }
1286 return *a.URL
1287 }
1288
1289
1290 func (a *AuthorizationRequest) GetClientID() string {
1291 if a == nil || a.ClientID == nil {
1292 return ""
1293 }
1294 return *a.ClientID
1295 }
1296
1297
1298 func (a *AuthorizationRequest) GetClientSecret() string {
1299 if a == nil || a.ClientSecret == nil {
1300 return ""
1301 }
1302 return *a.ClientSecret
1303 }
1304
1305
1306 func (a *AuthorizationRequest) GetFingerprint() string {
1307 if a == nil || a.Fingerprint == nil {
1308 return ""
1309 }
1310 return *a.Fingerprint
1311 }
1312
1313
1314 func (a *AuthorizationRequest) GetNote() string {
1315 if a == nil || a.Note == nil {
1316 return ""
1317 }
1318 return *a.Note
1319 }
1320
1321
1322 func (a *AuthorizationRequest) GetNoteURL() string {
1323 if a == nil || a.NoteURL == nil {
1324 return ""
1325 }
1326 return *a.NoteURL
1327 }
1328
1329
1330 func (a *AuthorizationUpdateRequest) GetFingerprint() string {
1331 if a == nil || a.Fingerprint == nil {
1332 return ""
1333 }
1334 return *a.Fingerprint
1335 }
1336
1337
1338 func (a *AuthorizationUpdateRequest) GetNote() string {
1339 if a == nil || a.Note == nil {
1340 return ""
1341 }
1342 return *a.Note
1343 }
1344
1345
1346 func (a *AuthorizationUpdateRequest) GetNoteURL() string {
1347 if a == nil || a.NoteURL == nil {
1348 return ""
1349 }
1350 return *a.NoteURL
1351 }
1352
1353
1354 func (a *AuthorizedActorsOnly) GetFrom() bool {
1355 if a == nil || a.From == nil {
1356 return false
1357 }
1358 return *a.From
1359 }
1360
1361
1362 func (a *Autolink) GetID() int64 {
1363 if a == nil || a.ID == nil {
1364 return 0
1365 }
1366 return *a.ID
1367 }
1368
1369
1370 func (a *Autolink) GetKeyPrefix() string {
1371 if a == nil || a.KeyPrefix == nil {
1372 return ""
1373 }
1374 return *a.KeyPrefix
1375 }
1376
1377
1378 func (a *Autolink) GetURLTemplate() string {
1379 if a == nil || a.URLTemplate == nil {
1380 return ""
1381 }
1382 return *a.URLTemplate
1383 }
1384
1385
1386 func (a *AutolinkOptions) GetKeyPrefix() string {
1387 if a == nil || a.KeyPrefix == nil {
1388 return ""
1389 }
1390 return *a.KeyPrefix
1391 }
1392
1393
1394 func (a *AutolinkOptions) GetURLTemplate() string {
1395 if a == nil || a.URLTemplate == nil {
1396 return ""
1397 }
1398 return *a.URLTemplate
1399 }
1400
1401
1402 func (a *AutoTriggerCheck) GetAppID() int64 {
1403 if a == nil || a.AppID == nil {
1404 return 0
1405 }
1406 return *a.AppID
1407 }
1408
1409
1410 func (a *AutoTriggerCheck) GetSetting() bool {
1411 if a == nil || a.Setting == nil {
1412 return false
1413 }
1414 return *a.Setting
1415 }
1416
1417
1418 func (b *Blob) GetContent() string {
1419 if b == nil || b.Content == nil {
1420 return ""
1421 }
1422 return *b.Content
1423 }
1424
1425
1426 func (b *Blob) GetEncoding() string {
1427 if b == nil || b.Encoding == nil {
1428 return ""
1429 }
1430 return *b.Encoding
1431 }
1432
1433
1434 func (b *Blob) GetNodeID() string {
1435 if b == nil || b.NodeID == nil {
1436 return ""
1437 }
1438 return *b.NodeID
1439 }
1440
1441
1442 func (b *Blob) GetSHA() string {
1443 if b == nil || b.SHA == nil {
1444 return ""
1445 }
1446 return *b.SHA
1447 }
1448
1449
1450 func (b *Blob) GetSize() int {
1451 if b == nil || b.Size == nil {
1452 return 0
1453 }
1454 return *b.Size
1455 }
1456
1457
1458 func (b *Blob) GetURL() string {
1459 if b == nil || b.URL == nil {
1460 return ""
1461 }
1462 return *b.URL
1463 }
1464
1465
1466 func (b *Branch) GetCommit() *RepositoryCommit {
1467 if b == nil {
1468 return nil
1469 }
1470 return b.Commit
1471 }
1472
1473
1474 func (b *Branch) GetName() string {
1475 if b == nil || b.Name == nil {
1476 return ""
1477 }
1478 return *b.Name
1479 }
1480
1481
1482 func (b *Branch) GetProtected() bool {
1483 if b == nil || b.Protected == nil {
1484 return false
1485 }
1486 return *b.Protected
1487 }
1488
1489
1490 func (b *BranchCommit) GetCommit() *Commit {
1491 if b == nil {
1492 return nil
1493 }
1494 return b.Commit
1495 }
1496
1497
1498 func (b *BranchCommit) GetName() string {
1499 if b == nil || b.Name == nil {
1500 return ""
1501 }
1502 return *b.Name
1503 }
1504
1505
1506 func (b *BranchCommit) GetProtected() bool {
1507 if b == nil || b.Protected == nil {
1508 return false
1509 }
1510 return *b.Protected
1511 }
1512
1513
1514 func (b *BranchListOptions) GetProtected() bool {
1515 if b == nil || b.Protected == nil {
1516 return false
1517 }
1518 return *b.Protected
1519 }
1520
1521
1522 func (b *BranchPolicy) GetCustomBranchPolicies() bool {
1523 if b == nil || b.CustomBranchPolicies == nil {
1524 return false
1525 }
1526 return *b.CustomBranchPolicies
1527 }
1528
1529
1530 func (b *BranchPolicy) GetProtectedBranches() bool {
1531 if b == nil || b.ProtectedBranches == nil {
1532 return false
1533 }
1534 return *b.ProtectedBranches
1535 }
1536
1537
1538 func (b *BranchProtectionRule) GetAdminEnforced() bool {
1539 if b == nil || b.AdminEnforced == nil {
1540 return false
1541 }
1542 return *b.AdminEnforced
1543 }
1544
1545
1546 func (b *BranchProtectionRule) GetAllowDeletionsEnforcementLevel() string {
1547 if b == nil || b.AllowDeletionsEnforcementLevel == nil {
1548 return ""
1549 }
1550 return *b.AllowDeletionsEnforcementLevel
1551 }
1552
1553
1554 func (b *BranchProtectionRule) GetAllowForcePushesEnforcementLevel() string {
1555 if b == nil || b.AllowForcePushesEnforcementLevel == nil {
1556 return ""
1557 }
1558 return *b.AllowForcePushesEnforcementLevel
1559 }
1560
1561
1562 func (b *BranchProtectionRule) GetAuthorizedActorsOnly() bool {
1563 if b == nil || b.AuthorizedActorsOnly == nil {
1564 return false
1565 }
1566 return *b.AuthorizedActorsOnly
1567 }
1568
1569
1570 func (b *BranchProtectionRule) GetAuthorizedDismissalActorsOnly() bool {
1571 if b == nil || b.AuthorizedDismissalActorsOnly == nil {
1572 return false
1573 }
1574 return *b.AuthorizedDismissalActorsOnly
1575 }
1576
1577
1578 func (b *BranchProtectionRule) GetCreatedAt() Timestamp {
1579 if b == nil || b.CreatedAt == nil {
1580 return Timestamp{}
1581 }
1582 return *b.CreatedAt
1583 }
1584
1585
1586 func (b *BranchProtectionRule) GetDismissStaleReviewsOnPush() bool {
1587 if b == nil || b.DismissStaleReviewsOnPush == nil {
1588 return false
1589 }
1590 return *b.DismissStaleReviewsOnPush
1591 }
1592
1593
1594 func (b *BranchProtectionRule) GetID() int64 {
1595 if b == nil || b.ID == nil {
1596 return 0
1597 }
1598 return *b.ID
1599 }
1600
1601
1602 func (b *BranchProtectionRule) GetIgnoreApprovalsFromContributors() bool {
1603 if b == nil || b.IgnoreApprovalsFromContributors == nil {
1604 return false
1605 }
1606 return *b.IgnoreApprovalsFromContributors
1607 }
1608
1609
1610 func (b *BranchProtectionRule) GetLinearHistoryRequirementEnforcementLevel() string {
1611 if b == nil || b.LinearHistoryRequirementEnforcementLevel == nil {
1612 return ""
1613 }
1614 return *b.LinearHistoryRequirementEnforcementLevel
1615 }
1616
1617
1618 func (b *BranchProtectionRule) GetMergeQueueEnforcementLevel() string {
1619 if b == nil || b.MergeQueueEnforcementLevel == nil {
1620 return ""
1621 }
1622 return *b.MergeQueueEnforcementLevel
1623 }
1624
1625
1626 func (b *BranchProtectionRule) GetName() string {
1627 if b == nil || b.Name == nil {
1628 return ""
1629 }
1630 return *b.Name
1631 }
1632
1633
1634 func (b *BranchProtectionRule) GetPullRequestReviewsEnforcementLevel() string {
1635 if b == nil || b.PullRequestReviewsEnforcementLevel == nil {
1636 return ""
1637 }
1638 return *b.PullRequestReviewsEnforcementLevel
1639 }
1640
1641
1642 func (b *BranchProtectionRule) GetRepositoryID() int64 {
1643 if b == nil || b.RepositoryID == nil {
1644 return 0
1645 }
1646 return *b.RepositoryID
1647 }
1648
1649
1650 func (b *BranchProtectionRule) GetRequireCodeOwnerReview() bool {
1651 if b == nil || b.RequireCodeOwnerReview == nil {
1652 return false
1653 }
1654 return *b.RequireCodeOwnerReview
1655 }
1656
1657
1658 func (b *BranchProtectionRule) GetRequiredApprovingReviewCount() int {
1659 if b == nil || b.RequiredApprovingReviewCount == nil {
1660 return 0
1661 }
1662 return *b.RequiredApprovingReviewCount
1663 }
1664
1665
1666 func (b *BranchProtectionRule) GetRequiredConversationResolutionLevel() string {
1667 if b == nil || b.RequiredConversationResolutionLevel == nil {
1668 return ""
1669 }
1670 return *b.RequiredConversationResolutionLevel
1671 }
1672
1673
1674 func (b *BranchProtectionRule) GetRequiredDeploymentsEnforcementLevel() string {
1675 if b == nil || b.RequiredDeploymentsEnforcementLevel == nil {
1676 return ""
1677 }
1678 return *b.RequiredDeploymentsEnforcementLevel
1679 }
1680
1681
1682 func (b *BranchProtectionRule) GetRequiredStatusChecksEnforcementLevel() string {
1683 if b == nil || b.RequiredStatusChecksEnforcementLevel == nil {
1684 return ""
1685 }
1686 return *b.RequiredStatusChecksEnforcementLevel
1687 }
1688
1689
1690 func (b *BranchProtectionRule) GetSignatureRequirementEnforcementLevel() string {
1691 if b == nil || b.SignatureRequirementEnforcementLevel == nil {
1692 return ""
1693 }
1694 return *b.SignatureRequirementEnforcementLevel
1695 }
1696
1697
1698 func (b *BranchProtectionRule) GetStrictRequiredStatusChecksPolicy() bool {
1699 if b == nil || b.StrictRequiredStatusChecksPolicy == nil {
1700 return false
1701 }
1702 return *b.StrictRequiredStatusChecksPolicy
1703 }
1704
1705
1706 func (b *BranchProtectionRule) GetUpdatedAt() Timestamp {
1707 if b == nil || b.UpdatedAt == nil {
1708 return Timestamp{}
1709 }
1710 return *b.UpdatedAt
1711 }
1712
1713
1714 func (b *BranchProtectionRuleEvent) GetAction() string {
1715 if b == nil || b.Action == nil {
1716 return ""
1717 }
1718 return *b.Action
1719 }
1720
1721
1722 func (b *BranchProtectionRuleEvent) GetChanges() *ProtectionChanges {
1723 if b == nil {
1724 return nil
1725 }
1726 return b.Changes
1727 }
1728
1729
1730 func (b *BranchProtectionRuleEvent) GetInstallation() *Installation {
1731 if b == nil {
1732 return nil
1733 }
1734 return b.Installation
1735 }
1736
1737
1738 func (b *BranchProtectionRuleEvent) GetOrg() *Organization {
1739 if b == nil {
1740 return nil
1741 }
1742 return b.Org
1743 }
1744
1745
1746 func (b *BranchProtectionRuleEvent) GetRepo() *Repository {
1747 if b == nil {
1748 return nil
1749 }
1750 return b.Repo
1751 }
1752
1753
1754 func (b *BranchProtectionRuleEvent) GetRule() *BranchProtectionRule {
1755 if b == nil {
1756 return nil
1757 }
1758 return b.Rule
1759 }
1760
1761
1762 func (b *BranchProtectionRuleEvent) GetSender() *User {
1763 if b == nil {
1764 return nil
1765 }
1766 return b.Sender
1767 }
1768
1769
1770 func (c *CheckRun) GetApp() *App {
1771 if c == nil {
1772 return nil
1773 }
1774 return c.App
1775 }
1776
1777
1778 func (c *CheckRun) GetCheckSuite() *CheckSuite {
1779 if c == nil {
1780 return nil
1781 }
1782 return c.CheckSuite
1783 }
1784
1785
1786 func (c *CheckRun) GetCompletedAt() Timestamp {
1787 if c == nil || c.CompletedAt == nil {
1788 return Timestamp{}
1789 }
1790 return *c.CompletedAt
1791 }
1792
1793
1794 func (c *CheckRun) GetConclusion() string {
1795 if c == nil || c.Conclusion == nil {
1796 return ""
1797 }
1798 return *c.Conclusion
1799 }
1800
1801
1802 func (c *CheckRun) GetDetailsURL() string {
1803 if c == nil || c.DetailsURL == nil {
1804 return ""
1805 }
1806 return *c.DetailsURL
1807 }
1808
1809
1810 func (c *CheckRun) GetExternalID() string {
1811 if c == nil || c.ExternalID == nil {
1812 return ""
1813 }
1814 return *c.ExternalID
1815 }
1816
1817
1818 func (c *CheckRun) GetHeadSHA() string {
1819 if c == nil || c.HeadSHA == nil {
1820 return ""
1821 }
1822 return *c.HeadSHA
1823 }
1824
1825
1826 func (c *CheckRun) GetHTMLURL() string {
1827 if c == nil || c.HTMLURL == nil {
1828 return ""
1829 }
1830 return *c.HTMLURL
1831 }
1832
1833
1834 func (c *CheckRun) GetID() int64 {
1835 if c == nil || c.ID == nil {
1836 return 0
1837 }
1838 return *c.ID
1839 }
1840
1841
1842 func (c *CheckRun) GetName() string {
1843 if c == nil || c.Name == nil {
1844 return ""
1845 }
1846 return *c.Name
1847 }
1848
1849
1850 func (c *CheckRun) GetNodeID() string {
1851 if c == nil || c.NodeID == nil {
1852 return ""
1853 }
1854 return *c.NodeID
1855 }
1856
1857
1858 func (c *CheckRun) GetOutput() *CheckRunOutput {
1859 if c == nil {
1860 return nil
1861 }
1862 return c.Output
1863 }
1864
1865
1866 func (c *CheckRun) GetStartedAt() Timestamp {
1867 if c == nil || c.StartedAt == nil {
1868 return Timestamp{}
1869 }
1870 return *c.StartedAt
1871 }
1872
1873
1874 func (c *CheckRun) GetStatus() string {
1875 if c == nil || c.Status == nil {
1876 return ""
1877 }
1878 return *c.Status
1879 }
1880
1881
1882 func (c *CheckRun) GetURL() string {
1883 if c == nil || c.URL == nil {
1884 return ""
1885 }
1886 return *c.URL
1887 }
1888
1889
1890 func (c *CheckRunAnnotation) GetAnnotationLevel() string {
1891 if c == nil || c.AnnotationLevel == nil {
1892 return ""
1893 }
1894 return *c.AnnotationLevel
1895 }
1896
1897
1898 func (c *CheckRunAnnotation) GetEndColumn() int {
1899 if c == nil || c.EndColumn == nil {
1900 return 0
1901 }
1902 return *c.EndColumn
1903 }
1904
1905
1906 func (c *CheckRunAnnotation) GetEndLine() int {
1907 if c == nil || c.EndLine == nil {
1908 return 0
1909 }
1910 return *c.EndLine
1911 }
1912
1913
1914 func (c *CheckRunAnnotation) GetMessage() string {
1915 if c == nil || c.Message == nil {
1916 return ""
1917 }
1918 return *c.Message
1919 }
1920
1921
1922 func (c *CheckRunAnnotation) GetPath() string {
1923 if c == nil || c.Path == nil {
1924 return ""
1925 }
1926 return *c.Path
1927 }
1928
1929
1930 func (c *CheckRunAnnotation) GetRawDetails() string {
1931 if c == nil || c.RawDetails == nil {
1932 return ""
1933 }
1934 return *c.RawDetails
1935 }
1936
1937
1938 func (c *CheckRunAnnotation) GetStartColumn() int {
1939 if c == nil || c.StartColumn == nil {
1940 return 0
1941 }
1942 return *c.StartColumn
1943 }
1944
1945
1946 func (c *CheckRunAnnotation) GetStartLine() int {
1947 if c == nil || c.StartLine == nil {
1948 return 0
1949 }
1950 return *c.StartLine
1951 }
1952
1953
1954 func (c *CheckRunAnnotation) GetTitle() string {
1955 if c == nil || c.Title == nil {
1956 return ""
1957 }
1958 return *c.Title
1959 }
1960
1961
1962 func (c *CheckRunEvent) GetAction() string {
1963 if c == nil || c.Action == nil {
1964 return ""
1965 }
1966 return *c.Action
1967 }
1968
1969
1970 func (c *CheckRunEvent) GetCheckRun() *CheckRun {
1971 if c == nil {
1972 return nil
1973 }
1974 return c.CheckRun
1975 }
1976
1977
1978 func (c *CheckRunEvent) GetInstallation() *Installation {
1979 if c == nil {
1980 return nil
1981 }
1982 return c.Installation
1983 }
1984
1985
1986 func (c *CheckRunEvent) GetOrg() *Organization {
1987 if c == nil {
1988 return nil
1989 }
1990 return c.Org
1991 }
1992
1993
1994 func (c *CheckRunEvent) GetRepo() *Repository {
1995 if c == nil {
1996 return nil
1997 }
1998 return c.Repo
1999 }
2000
2001
2002 func (c *CheckRunEvent) GetRequestedAction() *RequestedAction {
2003 if c == nil {
2004 return nil
2005 }
2006 return c.RequestedAction
2007 }
2008
2009
2010 func (c *CheckRunEvent) GetSender() *User {
2011 if c == nil {
2012 return nil
2013 }
2014 return c.Sender
2015 }
2016
2017
2018 func (c *CheckRunImage) GetAlt() string {
2019 if c == nil || c.Alt == nil {
2020 return ""
2021 }
2022 return *c.Alt
2023 }
2024
2025
2026 func (c *CheckRunImage) GetCaption() string {
2027 if c == nil || c.Caption == nil {
2028 return ""
2029 }
2030 return *c.Caption
2031 }
2032
2033
2034 func (c *CheckRunImage) GetImageURL() string {
2035 if c == nil || c.ImageURL == nil {
2036 return ""
2037 }
2038 return *c.ImageURL
2039 }
2040
2041
2042 func (c *CheckRunOutput) GetAnnotationsCount() int {
2043 if c == nil || c.AnnotationsCount == nil {
2044 return 0
2045 }
2046 return *c.AnnotationsCount
2047 }
2048
2049
2050 func (c *CheckRunOutput) GetAnnotationsURL() string {
2051 if c == nil || c.AnnotationsURL == nil {
2052 return ""
2053 }
2054 return *c.AnnotationsURL
2055 }
2056
2057
2058 func (c *CheckRunOutput) GetSummary() string {
2059 if c == nil || c.Summary == nil {
2060 return ""
2061 }
2062 return *c.Summary
2063 }
2064
2065
2066 func (c *CheckRunOutput) GetText() string {
2067 if c == nil || c.Text == nil {
2068 return ""
2069 }
2070 return *c.Text
2071 }
2072
2073
2074 func (c *CheckRunOutput) GetTitle() string {
2075 if c == nil || c.Title == nil {
2076 return ""
2077 }
2078 return *c.Title
2079 }
2080
2081
2082 func (c *CheckSuite) GetAfterSHA() string {
2083 if c == nil || c.AfterSHA == nil {
2084 return ""
2085 }
2086 return *c.AfterSHA
2087 }
2088
2089
2090 func (c *CheckSuite) GetApp() *App {
2091 if c == nil {
2092 return nil
2093 }
2094 return c.App
2095 }
2096
2097
2098 func (c *CheckSuite) GetBeforeSHA() string {
2099 if c == nil || c.BeforeSHA == nil {
2100 return ""
2101 }
2102 return *c.BeforeSHA
2103 }
2104
2105
2106 func (c *CheckSuite) GetConclusion() string {
2107 if c == nil || c.Conclusion == nil {
2108 return ""
2109 }
2110 return *c.Conclusion
2111 }
2112
2113
2114 func (c *CheckSuite) GetCreatedAt() Timestamp {
2115 if c == nil || c.CreatedAt == nil {
2116 return Timestamp{}
2117 }
2118 return *c.CreatedAt
2119 }
2120
2121
2122 func (c *CheckSuite) GetHeadBranch() string {
2123 if c == nil || c.HeadBranch == nil {
2124 return ""
2125 }
2126 return *c.HeadBranch
2127 }
2128
2129
2130 func (c *CheckSuite) GetHeadCommit() *Commit {
2131 if c == nil {
2132 return nil
2133 }
2134 return c.HeadCommit
2135 }
2136
2137
2138 func (c *CheckSuite) GetHeadSHA() string {
2139 if c == nil || c.HeadSHA == nil {
2140 return ""
2141 }
2142 return *c.HeadSHA
2143 }
2144
2145
2146 func (c *CheckSuite) GetID() int64 {
2147 if c == nil || c.ID == nil {
2148 return 0
2149 }
2150 return *c.ID
2151 }
2152
2153
2154 func (c *CheckSuite) GetNodeID() string {
2155 if c == nil || c.NodeID == nil {
2156 return ""
2157 }
2158 return *c.NodeID
2159 }
2160
2161
2162 func (c *CheckSuite) GetRepository() *Repository {
2163 if c == nil {
2164 return nil
2165 }
2166 return c.Repository
2167 }
2168
2169
2170 func (c *CheckSuite) GetStatus() string {
2171 if c == nil || c.Status == nil {
2172 return ""
2173 }
2174 return *c.Status
2175 }
2176
2177
2178 func (c *CheckSuite) GetUpdatedAt() Timestamp {
2179 if c == nil || c.UpdatedAt == nil {
2180 return Timestamp{}
2181 }
2182 return *c.UpdatedAt
2183 }
2184
2185
2186 func (c *CheckSuite) GetURL() string {
2187 if c == nil || c.URL == nil {
2188 return ""
2189 }
2190 return *c.URL
2191 }
2192
2193
2194 func (c *CheckSuiteEvent) GetAction() string {
2195 if c == nil || c.Action == nil {
2196 return ""
2197 }
2198 return *c.Action
2199 }
2200
2201
2202 func (c *CheckSuiteEvent) GetCheckSuite() *CheckSuite {
2203 if c == nil {
2204 return nil
2205 }
2206 return c.CheckSuite
2207 }
2208
2209
2210 func (c *CheckSuiteEvent) GetInstallation() *Installation {
2211 if c == nil {
2212 return nil
2213 }
2214 return c.Installation
2215 }
2216
2217
2218 func (c *CheckSuiteEvent) GetOrg() *Organization {
2219 if c == nil {
2220 return nil
2221 }
2222 return c.Org
2223 }
2224
2225
2226 func (c *CheckSuiteEvent) GetRepo() *Repository {
2227 if c == nil {
2228 return nil
2229 }
2230 return c.Repo
2231 }
2232
2233
2234 func (c *CheckSuiteEvent) GetSender() *User {
2235 if c == nil {
2236 return nil
2237 }
2238 return c.Sender
2239 }
2240
2241
2242 func (c *CheckSuitePreferenceResults) GetPreferences() *PreferenceList {
2243 if c == nil {
2244 return nil
2245 }
2246 return c.Preferences
2247 }
2248
2249
2250 func (c *CheckSuitePreferenceResults) GetRepository() *Repository {
2251 if c == nil {
2252 return nil
2253 }
2254 return c.Repository
2255 }
2256
2257
2258 func (c *CodeOfConduct) GetBody() string {
2259 if c == nil || c.Body == nil {
2260 return ""
2261 }
2262 return *c.Body
2263 }
2264
2265
2266 func (c *CodeOfConduct) GetKey() string {
2267 if c == nil || c.Key == nil {
2268 return ""
2269 }
2270 return *c.Key
2271 }
2272
2273
2274 func (c *CodeOfConduct) GetName() string {
2275 if c == nil || c.Name == nil {
2276 return ""
2277 }
2278 return *c.Name
2279 }
2280
2281
2282 func (c *CodeOfConduct) GetURL() string {
2283 if c == nil || c.URL == nil {
2284 return ""
2285 }
2286 return *c.URL
2287 }
2288
2289
2290 func (c *CodeResult) GetHTMLURL() string {
2291 if c == nil || c.HTMLURL == nil {
2292 return ""
2293 }
2294 return *c.HTMLURL
2295 }
2296
2297
2298 func (c *CodeResult) GetName() string {
2299 if c == nil || c.Name == nil {
2300 return ""
2301 }
2302 return *c.Name
2303 }
2304
2305
2306 func (c *CodeResult) GetPath() string {
2307 if c == nil || c.Path == nil {
2308 return ""
2309 }
2310 return *c.Path
2311 }
2312
2313
2314 func (c *CodeResult) GetRepository() *Repository {
2315 if c == nil {
2316 return nil
2317 }
2318 return c.Repository
2319 }
2320
2321
2322 func (c *CodeResult) GetSHA() string {
2323 if c == nil || c.SHA == nil {
2324 return ""
2325 }
2326 return *c.SHA
2327 }
2328
2329
2330 func (c *CodeScanningAlertEvent) GetAction() string {
2331 if c == nil || c.Action == nil {
2332 return ""
2333 }
2334 return *c.Action
2335 }
2336
2337
2338 func (c *CodeScanningAlertEvent) GetAlert() *Alert {
2339 if c == nil {
2340 return nil
2341 }
2342 return c.Alert
2343 }
2344
2345
2346 func (c *CodeScanningAlertEvent) GetCommitOID() string {
2347 if c == nil || c.CommitOID == nil {
2348 return ""
2349 }
2350 return *c.CommitOID
2351 }
2352
2353
2354 func (c *CodeScanningAlertEvent) GetOrg() *Organization {
2355 if c == nil {
2356 return nil
2357 }
2358 return c.Org
2359 }
2360
2361
2362 func (c *CodeScanningAlertEvent) GetRef() string {
2363 if c == nil || c.Ref == nil {
2364 return ""
2365 }
2366 return *c.Ref
2367 }
2368
2369
2370 func (c *CodeScanningAlertEvent) GetRepo() *Repository {
2371 if c == nil {
2372 return nil
2373 }
2374 return c.Repo
2375 }
2376
2377
2378 func (c *CodeScanningAlertEvent) GetSender() *User {
2379 if c == nil {
2380 return nil
2381 }
2382 return c.Sender
2383 }
2384
2385
2386 func (c *CodeSearchResult) GetIncompleteResults() bool {
2387 if c == nil || c.IncompleteResults == nil {
2388 return false
2389 }
2390 return *c.IncompleteResults
2391 }
2392
2393
2394 func (c *CodeSearchResult) GetTotal() int {
2395 if c == nil || c.Total == nil {
2396 return 0
2397 }
2398 return *c.Total
2399 }
2400
2401
2402 func (c *CollaboratorInvitation) GetCreatedAt() Timestamp {
2403 if c == nil || c.CreatedAt == nil {
2404 return Timestamp{}
2405 }
2406 return *c.CreatedAt
2407 }
2408
2409
2410 func (c *CollaboratorInvitation) GetHTMLURL() string {
2411 if c == nil || c.HTMLURL == nil {
2412 return ""
2413 }
2414 return *c.HTMLURL
2415 }
2416
2417
2418 func (c *CollaboratorInvitation) GetID() int64 {
2419 if c == nil || c.ID == nil {
2420 return 0
2421 }
2422 return *c.ID
2423 }
2424
2425
2426 func (c *CollaboratorInvitation) GetInvitee() *User {
2427 if c == nil {
2428 return nil
2429 }
2430 return c.Invitee
2431 }
2432
2433
2434 func (c *CollaboratorInvitation) GetInviter() *User {
2435 if c == nil {
2436 return nil
2437 }
2438 return c.Inviter
2439 }
2440
2441
2442 func (c *CollaboratorInvitation) GetPermissions() string {
2443 if c == nil || c.Permissions == nil {
2444 return ""
2445 }
2446 return *c.Permissions
2447 }
2448
2449
2450 func (c *CollaboratorInvitation) GetRepo() *Repository {
2451 if c == nil {
2452 return nil
2453 }
2454 return c.Repo
2455 }
2456
2457
2458 func (c *CollaboratorInvitation) GetURL() string {
2459 if c == nil || c.URL == nil {
2460 return ""
2461 }
2462 return *c.URL
2463 }
2464
2465
2466 func (c *CombinedStatus) GetCommitURL() string {
2467 if c == nil || c.CommitURL == nil {
2468 return ""
2469 }
2470 return *c.CommitURL
2471 }
2472
2473
2474 func (c *CombinedStatus) GetName() string {
2475 if c == nil || c.Name == nil {
2476 return ""
2477 }
2478 return *c.Name
2479 }
2480
2481
2482 func (c *CombinedStatus) GetRepositoryURL() string {
2483 if c == nil || c.RepositoryURL == nil {
2484 return ""
2485 }
2486 return *c.RepositoryURL
2487 }
2488
2489
2490 func (c *CombinedStatus) GetSHA() string {
2491 if c == nil || c.SHA == nil {
2492 return ""
2493 }
2494 return *c.SHA
2495 }
2496
2497
2498 func (c *CombinedStatus) GetState() string {
2499 if c == nil || c.State == nil {
2500 return ""
2501 }
2502 return *c.State
2503 }
2504
2505
2506 func (c *CombinedStatus) GetTotalCount() int {
2507 if c == nil || c.TotalCount == nil {
2508 return 0
2509 }
2510 return *c.TotalCount
2511 }
2512
2513
2514 func (c *Comment) GetCreatedAt() time.Time {
2515 if c == nil || c.CreatedAt == nil {
2516 return time.Time{}
2517 }
2518 return *c.CreatedAt
2519 }
2520
2521
2522 func (c *CommentStats) GetTotalCommitComments() int {
2523 if c == nil || c.TotalCommitComments == nil {
2524 return 0
2525 }
2526 return *c.TotalCommitComments
2527 }
2528
2529
2530 func (c *CommentStats) GetTotalGistComments() int {
2531 if c == nil || c.TotalGistComments == nil {
2532 return 0
2533 }
2534 return *c.TotalGistComments
2535 }
2536
2537
2538 func (c *CommentStats) GetTotalIssueComments() int {
2539 if c == nil || c.TotalIssueComments == nil {
2540 return 0
2541 }
2542 return *c.TotalIssueComments
2543 }
2544
2545
2546 func (c *CommentStats) GetTotalPullRequestComments() int {
2547 if c == nil || c.TotalPullRequestComments == nil {
2548 return 0
2549 }
2550 return *c.TotalPullRequestComments
2551 }
2552
2553
2554 func (c *Commit) GetAuthor() *CommitAuthor {
2555 if c == nil {
2556 return nil
2557 }
2558 return c.Author
2559 }
2560
2561
2562 func (c *Commit) GetCommentCount() int {
2563 if c == nil || c.CommentCount == nil {
2564 return 0
2565 }
2566 return *c.CommentCount
2567 }
2568
2569
2570 func (c *Commit) GetCommitter() *CommitAuthor {
2571 if c == nil {
2572 return nil
2573 }
2574 return c.Committer
2575 }
2576
2577
2578 func (c *Commit) GetHTMLURL() string {
2579 if c == nil || c.HTMLURL == nil {
2580 return ""
2581 }
2582 return *c.HTMLURL
2583 }
2584
2585
2586 func (c *Commit) GetMessage() string {
2587 if c == nil || c.Message == nil {
2588 return ""
2589 }
2590 return *c.Message
2591 }
2592
2593
2594 func (c *Commit) GetNodeID() string {
2595 if c == nil || c.NodeID == nil {
2596 return ""
2597 }
2598 return *c.NodeID
2599 }
2600
2601
2602 func (c *Commit) GetSHA() string {
2603 if c == nil || c.SHA == nil {
2604 return ""
2605 }
2606 return *c.SHA
2607 }
2608
2609
2610 func (c *Commit) GetStats() *CommitStats {
2611 if c == nil {
2612 return nil
2613 }
2614 return c.Stats
2615 }
2616
2617
2618 func (c *Commit) GetTree() *Tree {
2619 if c == nil {
2620 return nil
2621 }
2622 return c.Tree
2623 }
2624
2625
2626 func (c *Commit) GetURL() string {
2627 if c == nil || c.URL == nil {
2628 return ""
2629 }
2630 return *c.URL
2631 }
2632
2633
2634 func (c *Commit) GetVerification() *SignatureVerification {
2635 if c == nil {
2636 return nil
2637 }
2638 return c.Verification
2639 }
2640
2641
2642 func (c *CommitAuthor) GetDate() time.Time {
2643 if c == nil || c.Date == nil {
2644 return time.Time{}
2645 }
2646 return *c.Date
2647 }
2648
2649
2650 func (c *CommitAuthor) GetEmail() string {
2651 if c == nil || c.Email == nil {
2652 return ""
2653 }
2654 return *c.Email
2655 }
2656
2657
2658 func (c *CommitAuthor) GetLogin() string {
2659 if c == nil || c.Login == nil {
2660 return ""
2661 }
2662 return *c.Login
2663 }
2664
2665
2666 func (c *CommitAuthor) GetName() string {
2667 if c == nil || c.Name == nil {
2668 return ""
2669 }
2670 return *c.Name
2671 }
2672
2673
2674 func (c *CommitCommentEvent) GetAction() string {
2675 if c == nil || c.Action == nil {
2676 return ""
2677 }
2678 return *c.Action
2679 }
2680
2681
2682 func (c *CommitCommentEvent) GetComment() *RepositoryComment {
2683 if c == nil {
2684 return nil
2685 }
2686 return c.Comment
2687 }
2688
2689
2690 func (c *CommitCommentEvent) GetInstallation() *Installation {
2691 if c == nil {
2692 return nil
2693 }
2694 return c.Installation
2695 }
2696
2697
2698 func (c *CommitCommentEvent) GetRepo() *Repository {
2699 if c == nil {
2700 return nil
2701 }
2702 return c.Repo
2703 }
2704
2705
2706 func (c *CommitCommentEvent) GetSender() *User {
2707 if c == nil {
2708 return nil
2709 }
2710 return c.Sender
2711 }
2712
2713
2714 func (c *CommitFile) GetAdditions() int {
2715 if c == nil || c.Additions == nil {
2716 return 0
2717 }
2718 return *c.Additions
2719 }
2720
2721
2722 func (c *CommitFile) GetBlobURL() string {
2723 if c == nil || c.BlobURL == nil {
2724 return ""
2725 }
2726 return *c.BlobURL
2727 }
2728
2729
2730 func (c *CommitFile) GetChanges() int {
2731 if c == nil || c.Changes == nil {
2732 return 0
2733 }
2734 return *c.Changes
2735 }
2736
2737
2738 func (c *CommitFile) GetContentsURL() string {
2739 if c == nil || c.ContentsURL == nil {
2740 return ""
2741 }
2742 return *c.ContentsURL
2743 }
2744
2745
2746 func (c *CommitFile) GetDeletions() int {
2747 if c == nil || c.Deletions == nil {
2748 return 0
2749 }
2750 return *c.Deletions
2751 }
2752
2753
2754 func (c *CommitFile) GetFilename() string {
2755 if c == nil || c.Filename == nil {
2756 return ""
2757 }
2758 return *c.Filename
2759 }
2760
2761
2762 func (c *CommitFile) GetPatch() string {
2763 if c == nil || c.Patch == nil {
2764 return ""
2765 }
2766 return *c.Patch
2767 }
2768
2769
2770 func (c *CommitFile) GetPreviousFilename() string {
2771 if c == nil || c.PreviousFilename == nil {
2772 return ""
2773 }
2774 return *c.PreviousFilename
2775 }
2776
2777
2778 func (c *CommitFile) GetRawURL() string {
2779 if c == nil || c.RawURL == nil {
2780 return ""
2781 }
2782 return *c.RawURL
2783 }
2784
2785
2786 func (c *CommitFile) GetSHA() string {
2787 if c == nil || c.SHA == nil {
2788 return ""
2789 }
2790 return *c.SHA
2791 }
2792
2793
2794 func (c *CommitFile) GetStatus() string {
2795 if c == nil || c.Status == nil {
2796 return ""
2797 }
2798 return *c.Status
2799 }
2800
2801
2802 func (c *CommitResult) GetAuthor() *User {
2803 if c == nil {
2804 return nil
2805 }
2806 return c.Author
2807 }
2808
2809
2810 func (c *CommitResult) GetCommentsURL() string {
2811 if c == nil || c.CommentsURL == nil {
2812 return ""
2813 }
2814 return *c.CommentsURL
2815 }
2816
2817
2818 func (c *CommitResult) GetCommit() *Commit {
2819 if c == nil {
2820 return nil
2821 }
2822 return c.Commit
2823 }
2824
2825
2826 func (c *CommitResult) GetCommitter() *User {
2827 if c == nil {
2828 return nil
2829 }
2830 return c.Committer
2831 }
2832
2833
2834 func (c *CommitResult) GetHTMLURL() string {
2835 if c == nil || c.HTMLURL == nil {
2836 return ""
2837 }
2838 return *c.HTMLURL
2839 }
2840
2841
2842 func (c *CommitResult) GetRepository() *Repository {
2843 if c == nil {
2844 return nil
2845 }
2846 return c.Repository
2847 }
2848
2849
2850 func (c *CommitResult) GetScore() *float64 {
2851 if c == nil {
2852 return nil
2853 }
2854 return c.Score
2855 }
2856
2857
2858 func (c *CommitResult) GetSHA() string {
2859 if c == nil || c.SHA == nil {
2860 return ""
2861 }
2862 return *c.SHA
2863 }
2864
2865
2866 func (c *CommitResult) GetURL() string {
2867 if c == nil || c.URL == nil {
2868 return ""
2869 }
2870 return *c.URL
2871 }
2872
2873
2874 func (c *CommitsComparison) GetAheadBy() int {
2875 if c == nil || c.AheadBy == nil {
2876 return 0
2877 }
2878 return *c.AheadBy
2879 }
2880
2881
2882 func (c *CommitsComparison) GetBaseCommit() *RepositoryCommit {
2883 if c == nil {
2884 return nil
2885 }
2886 return c.BaseCommit
2887 }
2888
2889
2890 func (c *CommitsComparison) GetBehindBy() int {
2891 if c == nil || c.BehindBy == nil {
2892 return 0
2893 }
2894 return *c.BehindBy
2895 }
2896
2897
2898 func (c *CommitsComparison) GetDiffURL() string {
2899 if c == nil || c.DiffURL == nil {
2900 return ""
2901 }
2902 return *c.DiffURL
2903 }
2904
2905
2906 func (c *CommitsComparison) GetHTMLURL() string {
2907 if c == nil || c.HTMLURL == nil {
2908 return ""
2909 }
2910 return *c.HTMLURL
2911 }
2912
2913
2914 func (c *CommitsComparison) GetMergeBaseCommit() *RepositoryCommit {
2915 if c == nil {
2916 return nil
2917 }
2918 return c.MergeBaseCommit
2919 }
2920
2921
2922 func (c *CommitsComparison) GetPatchURL() string {
2923 if c == nil || c.PatchURL == nil {
2924 return ""
2925 }
2926 return *c.PatchURL
2927 }
2928
2929
2930 func (c *CommitsComparison) GetPermalinkURL() string {
2931 if c == nil || c.PermalinkURL == nil {
2932 return ""
2933 }
2934 return *c.PermalinkURL
2935 }
2936
2937
2938 func (c *CommitsComparison) GetStatus() string {
2939 if c == nil || c.Status == nil {
2940 return ""
2941 }
2942 return *c.Status
2943 }
2944
2945
2946 func (c *CommitsComparison) GetTotalCommits() int {
2947 if c == nil || c.TotalCommits == nil {
2948 return 0
2949 }
2950 return *c.TotalCommits
2951 }
2952
2953
2954 func (c *CommitsComparison) GetURL() string {
2955 if c == nil || c.URL == nil {
2956 return ""
2957 }
2958 return *c.URL
2959 }
2960
2961
2962 func (c *CommitsSearchResult) GetIncompleteResults() bool {
2963 if c == nil || c.IncompleteResults == nil {
2964 return false
2965 }
2966 return *c.IncompleteResults
2967 }
2968
2969
2970 func (c *CommitsSearchResult) GetTotal() int {
2971 if c == nil || c.Total == nil {
2972 return 0
2973 }
2974 return *c.Total
2975 }
2976
2977
2978 func (c *CommitStats) GetAdditions() int {
2979 if c == nil || c.Additions == nil {
2980 return 0
2981 }
2982 return *c.Additions
2983 }
2984
2985
2986 func (c *CommitStats) GetDeletions() int {
2987 if c == nil || c.Deletions == nil {
2988 return 0
2989 }
2990 return *c.Deletions
2991 }
2992
2993
2994 func (c *CommitStats) GetTotal() int {
2995 if c == nil || c.Total == nil {
2996 return 0
2997 }
2998 return *c.Total
2999 }
3000
3001
3002 func (c *CommunityHealthFiles) GetCodeOfConduct() *Metric {
3003 if c == nil {
3004 return nil
3005 }
3006 return c.CodeOfConduct
3007 }
3008
3009
3010 func (c *CommunityHealthFiles) GetCodeOfConductFile() *Metric {
3011 if c == nil {
3012 return nil
3013 }
3014 return c.CodeOfConductFile
3015 }
3016
3017
3018 func (c *CommunityHealthFiles) GetContributing() *Metric {
3019 if c == nil {
3020 return nil
3021 }
3022 return c.Contributing
3023 }
3024
3025
3026 func (c *CommunityHealthFiles) GetIssueTemplate() *Metric {
3027 if c == nil {
3028 return nil
3029 }
3030 return c.IssueTemplate
3031 }
3032
3033
3034 func (c *CommunityHealthFiles) GetLicense() *Metric {
3035 if c == nil {
3036 return nil
3037 }
3038 return c.License
3039 }
3040
3041
3042 func (c *CommunityHealthFiles) GetPullRequestTemplate() *Metric {
3043 if c == nil {
3044 return nil
3045 }
3046 return c.PullRequestTemplate
3047 }
3048
3049
3050 func (c *CommunityHealthFiles) GetReadme() *Metric {
3051 if c == nil {
3052 return nil
3053 }
3054 return c.Readme
3055 }
3056
3057
3058 func (c *CommunityHealthMetrics) GetContentReportsEnabled() bool {
3059 if c == nil || c.ContentReportsEnabled == nil {
3060 return false
3061 }
3062 return *c.ContentReportsEnabled
3063 }
3064
3065
3066 func (c *CommunityHealthMetrics) GetDescription() string {
3067 if c == nil || c.Description == nil {
3068 return ""
3069 }
3070 return *c.Description
3071 }
3072
3073
3074 func (c *CommunityHealthMetrics) GetDocumentation() string {
3075 if c == nil || c.Documentation == nil {
3076 return ""
3077 }
3078 return *c.Documentation
3079 }
3080
3081
3082 func (c *CommunityHealthMetrics) GetFiles() *CommunityHealthFiles {
3083 if c == nil {
3084 return nil
3085 }
3086 return c.Files
3087 }
3088
3089
3090 func (c *CommunityHealthMetrics) GetHealthPercentage() int {
3091 if c == nil || c.HealthPercentage == nil {
3092 return 0
3093 }
3094 return *c.HealthPercentage
3095 }
3096
3097
3098 func (c *CommunityHealthMetrics) GetUpdatedAt() time.Time {
3099 if c == nil || c.UpdatedAt == nil {
3100 return time.Time{}
3101 }
3102 return *c.UpdatedAt
3103 }
3104
3105
3106 func (c *ContentReference) GetID() int64 {
3107 if c == nil || c.ID == nil {
3108 return 0
3109 }
3110 return *c.ID
3111 }
3112
3113
3114 func (c *ContentReference) GetNodeID() string {
3115 if c == nil || c.NodeID == nil {
3116 return ""
3117 }
3118 return *c.NodeID
3119 }
3120
3121
3122 func (c *ContentReference) GetReference() string {
3123 if c == nil || c.Reference == nil {
3124 return ""
3125 }
3126 return *c.Reference
3127 }
3128
3129
3130 func (c *ContentReferenceEvent) GetAction() string {
3131 if c == nil || c.Action == nil {
3132 return ""
3133 }
3134 return *c.Action
3135 }
3136
3137
3138 func (c *ContentReferenceEvent) GetContentReference() *ContentReference {
3139 if c == nil {
3140 return nil
3141 }
3142 return c.ContentReference
3143 }
3144
3145
3146 func (c *ContentReferenceEvent) GetInstallation() *Installation {
3147 if c == nil {
3148 return nil
3149 }
3150 return c.Installation
3151 }
3152
3153
3154 func (c *ContentReferenceEvent) GetRepo() *Repository {
3155 if c == nil {
3156 return nil
3157 }
3158 return c.Repo
3159 }
3160
3161
3162 func (c *ContentReferenceEvent) GetSender() *User {
3163 if c == nil {
3164 return nil
3165 }
3166 return c.Sender
3167 }
3168
3169
3170 func (c *Contributor) GetAvatarURL() string {
3171 if c == nil || c.AvatarURL == nil {
3172 return ""
3173 }
3174 return *c.AvatarURL
3175 }
3176
3177
3178 func (c *Contributor) GetContributions() int {
3179 if c == nil || c.Contributions == nil {
3180 return 0
3181 }
3182 return *c.Contributions
3183 }
3184
3185
3186 func (c *Contributor) GetEmail() string {
3187 if c == nil || c.Email == nil {
3188 return ""
3189 }
3190 return *c.Email
3191 }
3192
3193
3194 func (c *Contributor) GetEventsURL() string {
3195 if c == nil || c.EventsURL == nil {
3196 return ""
3197 }
3198 return *c.EventsURL
3199 }
3200
3201
3202 func (c *Contributor) GetFollowersURL() string {
3203 if c == nil || c.FollowersURL == nil {
3204 return ""
3205 }
3206 return *c.FollowersURL
3207 }
3208
3209
3210 func (c *Contributor) GetFollowingURL() string {
3211 if c == nil || c.FollowingURL == nil {
3212 return ""
3213 }
3214 return *c.FollowingURL
3215 }
3216
3217
3218 func (c *Contributor) GetGistsURL() string {
3219 if c == nil || c.GistsURL == nil {
3220 return ""
3221 }
3222 return *c.GistsURL
3223 }
3224
3225
3226 func (c *Contributor) GetGravatarID() string {
3227 if c == nil || c.GravatarID == nil {
3228 return ""
3229 }
3230 return *c.GravatarID
3231 }
3232
3233
3234 func (c *Contributor) GetHTMLURL() string {
3235 if c == nil || c.HTMLURL == nil {
3236 return ""
3237 }
3238 return *c.HTMLURL
3239 }
3240
3241
3242 func (c *Contributor) GetID() int64 {
3243 if c == nil || c.ID == nil {
3244 return 0
3245 }
3246 return *c.ID
3247 }
3248
3249
3250 func (c *Contributor) GetLogin() string {
3251 if c == nil || c.Login == nil {
3252 return ""
3253 }
3254 return *c.Login
3255 }
3256
3257
3258 func (c *Contributor) GetName() string {
3259 if c == nil || c.Name == nil {
3260 return ""
3261 }
3262 return *c.Name
3263 }
3264
3265
3266 func (c *Contributor) GetNodeID() string {
3267 if c == nil || c.NodeID == nil {
3268 return ""
3269 }
3270 return *c.NodeID
3271 }
3272
3273
3274 func (c *Contributor) GetOrganizationsURL() string {
3275 if c == nil || c.OrganizationsURL == nil {
3276 return ""
3277 }
3278 return *c.OrganizationsURL
3279 }
3280
3281
3282 func (c *Contributor) GetReceivedEventsURL() string {
3283 if c == nil || c.ReceivedEventsURL == nil {
3284 return ""
3285 }
3286 return *c.ReceivedEventsURL
3287 }
3288
3289
3290 func (c *Contributor) GetReposURL() string {
3291 if c == nil || c.ReposURL == nil {
3292 return ""
3293 }
3294 return *c.ReposURL
3295 }
3296
3297
3298 func (c *Contributor) GetSiteAdmin() bool {
3299 if c == nil || c.SiteAdmin == nil {
3300 return false
3301 }
3302 return *c.SiteAdmin
3303 }
3304
3305
3306 func (c *Contributor) GetStarredURL() string {
3307 if c == nil || c.StarredURL == nil {
3308 return ""
3309 }
3310 return *c.StarredURL
3311 }
3312
3313
3314 func (c *Contributor) GetSubscriptionsURL() string {
3315 if c == nil || c.SubscriptionsURL == nil {
3316 return ""
3317 }
3318 return *c.SubscriptionsURL
3319 }
3320
3321
3322 func (c *Contributor) GetType() string {
3323 if c == nil || c.Type == nil {
3324 return ""
3325 }
3326 return *c.Type
3327 }
3328
3329
3330 func (c *Contributor) GetURL() string {
3331 if c == nil || c.URL == nil {
3332 return ""
3333 }
3334 return *c.URL
3335 }
3336
3337
3338 func (c *ContributorStats) GetAuthor() *Contributor {
3339 if c == nil {
3340 return nil
3341 }
3342 return c.Author
3343 }
3344
3345
3346 func (c *ContributorStats) GetTotal() int {
3347 if c == nil || c.Total == nil {
3348 return 0
3349 }
3350 return *c.Total
3351 }
3352
3353
3354 func (c *CreateCheckRunOptions) GetCompletedAt() Timestamp {
3355 if c == nil || c.CompletedAt == nil {
3356 return Timestamp{}
3357 }
3358 return *c.CompletedAt
3359 }
3360
3361
3362 func (c *CreateCheckRunOptions) GetConclusion() string {
3363 if c == nil || c.Conclusion == nil {
3364 return ""
3365 }
3366 return *c.Conclusion
3367 }
3368
3369
3370 func (c *CreateCheckRunOptions) GetDetailsURL() string {
3371 if c == nil || c.DetailsURL == nil {
3372 return ""
3373 }
3374 return *c.DetailsURL
3375 }
3376
3377
3378 func (c *CreateCheckRunOptions) GetExternalID() string {
3379 if c == nil || c.ExternalID == nil {
3380 return ""
3381 }
3382 return *c.ExternalID
3383 }
3384
3385
3386 func (c *CreateCheckRunOptions) GetOutput() *CheckRunOutput {
3387 if c == nil {
3388 return nil
3389 }
3390 return c.Output
3391 }
3392
3393
3394 func (c *CreateCheckRunOptions) GetStartedAt() Timestamp {
3395 if c == nil || c.StartedAt == nil {
3396 return Timestamp{}
3397 }
3398 return *c.StartedAt
3399 }
3400
3401
3402 func (c *CreateCheckRunOptions) GetStatus() string {
3403 if c == nil || c.Status == nil {
3404 return ""
3405 }
3406 return *c.Status
3407 }
3408
3409
3410 func (c *CreateCheckSuiteOptions) GetHeadBranch() string {
3411 if c == nil || c.HeadBranch == nil {
3412 return ""
3413 }
3414 return *c.HeadBranch
3415 }
3416
3417
3418 func (c *CreateEvent) GetDescription() string {
3419 if c == nil || c.Description == nil {
3420 return ""
3421 }
3422 return *c.Description
3423 }
3424
3425
3426 func (c *CreateEvent) GetInstallation() *Installation {
3427 if c == nil {
3428 return nil
3429 }
3430 return c.Installation
3431 }
3432
3433
3434 func (c *CreateEvent) GetMasterBranch() string {
3435 if c == nil || c.MasterBranch == nil {
3436 return ""
3437 }
3438 return *c.MasterBranch
3439 }
3440
3441
3442 func (c *CreateEvent) GetOrg() *Organization {
3443 if c == nil {
3444 return nil
3445 }
3446 return c.Org
3447 }
3448
3449
3450 func (c *CreateEvent) GetPusherType() string {
3451 if c == nil || c.PusherType == nil {
3452 return ""
3453 }
3454 return *c.PusherType
3455 }
3456
3457
3458 func (c *CreateEvent) GetRef() string {
3459 if c == nil || c.Ref == nil {
3460 return ""
3461 }
3462 return *c.Ref
3463 }
3464
3465
3466 func (c *CreateEvent) GetRefType() string {
3467 if c == nil || c.RefType == nil {
3468 return ""
3469 }
3470 return *c.RefType
3471 }
3472
3473
3474 func (c *CreateEvent) GetRepo() *Repository {
3475 if c == nil {
3476 return nil
3477 }
3478 return c.Repo
3479 }
3480
3481
3482 func (c *CreateEvent) GetSender() *User {
3483 if c == nil {
3484 return nil
3485 }
3486 return c.Sender
3487 }
3488
3489
3490 func (c *CreateOrgInvitationOptions) GetEmail() string {
3491 if c == nil || c.Email == nil {
3492 return ""
3493 }
3494 return *c.Email
3495 }
3496
3497
3498 func (c *CreateOrgInvitationOptions) GetInviteeID() int64 {
3499 if c == nil || c.InviteeID == nil {
3500 return 0
3501 }
3502 return *c.InviteeID
3503 }
3504
3505
3506 func (c *CreateOrgInvitationOptions) GetRole() string {
3507 if c == nil || c.Role == nil {
3508 return ""
3509 }
3510 return *c.Role
3511 }
3512
3513
3514 func (c *CreateRunnerGroupRequest) GetAllowsPublicRepositories() bool {
3515 if c == nil || c.AllowsPublicRepositories == nil {
3516 return false
3517 }
3518 return *c.AllowsPublicRepositories
3519 }
3520
3521
3522 func (c *CreateRunnerGroupRequest) GetName() string {
3523 if c == nil || c.Name == nil {
3524 return ""
3525 }
3526 return *c.Name
3527 }
3528
3529
3530 func (c *CreateRunnerGroupRequest) GetVisibility() string {
3531 if c == nil || c.Visibility == nil {
3532 return ""
3533 }
3534 return *c.Visibility
3535 }
3536
3537
3538 func (c *CreateUpdateEnvironment) GetDeploymentBranchPolicy() *BranchPolicy {
3539 if c == nil {
3540 return nil
3541 }
3542 return c.DeploymentBranchPolicy
3543 }
3544
3545
3546 func (c *CreateUpdateEnvironment) GetWaitTimer() int {
3547 if c == nil || c.WaitTimer == nil {
3548 return 0
3549 }
3550 return *c.WaitTimer
3551 }
3552
3553
3554 func (c *CreateUserProjectOptions) GetBody() string {
3555 if c == nil || c.Body == nil {
3556 return ""
3557 }
3558 return *c.Body
3559 }
3560
3561
3562 func (c *CustomRepoRoles) GetID() int64 {
3563 if c == nil || c.ID == nil {
3564 return 0
3565 }
3566 return *c.ID
3567 }
3568
3569
3570 func (c *CustomRepoRoles) GetName() string {
3571 if c == nil || c.Name == nil {
3572 return ""
3573 }
3574 return *c.Name
3575 }
3576
3577
3578 func (d *DeleteEvent) GetInstallation() *Installation {
3579 if d == nil {
3580 return nil
3581 }
3582 return d.Installation
3583 }
3584
3585
3586 func (d *DeleteEvent) GetPusherType() string {
3587 if d == nil || d.PusherType == nil {
3588 return ""
3589 }
3590 return *d.PusherType
3591 }
3592
3593
3594 func (d *DeleteEvent) GetRef() string {
3595 if d == nil || d.Ref == nil {
3596 return ""
3597 }
3598 return *d.Ref
3599 }
3600
3601
3602 func (d *DeleteEvent) GetRefType() string {
3603 if d == nil || d.RefType == nil {
3604 return ""
3605 }
3606 return *d.RefType
3607 }
3608
3609
3610 func (d *DeleteEvent) GetRepo() *Repository {
3611 if d == nil {
3612 return nil
3613 }
3614 return d.Repo
3615 }
3616
3617
3618 func (d *DeleteEvent) GetSender() *User {
3619 if d == nil {
3620 return nil
3621 }
3622 return d.Sender
3623 }
3624
3625
3626 func (d *DeployKeyEvent) GetAction() string {
3627 if d == nil || d.Action == nil {
3628 return ""
3629 }
3630 return *d.Action
3631 }
3632
3633
3634 func (d *DeployKeyEvent) GetInstallation() *Installation {
3635 if d == nil {
3636 return nil
3637 }
3638 return d.Installation
3639 }
3640
3641
3642 func (d *DeployKeyEvent) GetKey() *Key {
3643 if d == nil {
3644 return nil
3645 }
3646 return d.Key
3647 }
3648
3649
3650 func (d *DeployKeyEvent) GetOrganization() *Organization {
3651 if d == nil {
3652 return nil
3653 }
3654 return d.Organization
3655 }
3656
3657
3658 func (d *DeployKeyEvent) GetRepo() *Repository {
3659 if d == nil {
3660 return nil
3661 }
3662 return d.Repo
3663 }
3664
3665
3666 func (d *DeployKeyEvent) GetSender() *User {
3667 if d == nil {
3668 return nil
3669 }
3670 return d.Sender
3671 }
3672
3673
3674 func (d *Deployment) GetCreatedAt() Timestamp {
3675 if d == nil || d.CreatedAt == nil {
3676 return Timestamp{}
3677 }
3678 return *d.CreatedAt
3679 }
3680
3681
3682 func (d *Deployment) GetCreator() *User {
3683 if d == nil {
3684 return nil
3685 }
3686 return d.Creator
3687 }
3688
3689
3690 func (d *Deployment) GetDescription() string {
3691 if d == nil || d.Description == nil {
3692 return ""
3693 }
3694 return *d.Description
3695 }
3696
3697
3698 func (d *Deployment) GetEnvironment() string {
3699 if d == nil || d.Environment == nil {
3700 return ""
3701 }
3702 return *d.Environment
3703 }
3704
3705
3706 func (d *Deployment) GetID() int64 {
3707 if d == nil || d.ID == nil {
3708 return 0
3709 }
3710 return *d.ID
3711 }
3712
3713
3714 func (d *Deployment) GetNodeID() string {
3715 if d == nil || d.NodeID == nil {
3716 return ""
3717 }
3718 return *d.NodeID
3719 }
3720
3721
3722 func (d *Deployment) GetRef() string {
3723 if d == nil || d.Ref == nil {
3724 return ""
3725 }
3726 return *d.Ref
3727 }
3728
3729
3730 func (d *Deployment) GetRepositoryURL() string {
3731 if d == nil || d.RepositoryURL == nil {
3732 return ""
3733 }
3734 return *d.RepositoryURL
3735 }
3736
3737
3738 func (d *Deployment) GetSHA() string {
3739 if d == nil || d.SHA == nil {
3740 return ""
3741 }
3742 return *d.SHA
3743 }
3744
3745
3746 func (d *Deployment) GetStatusesURL() string {
3747 if d == nil || d.StatusesURL == nil {
3748 return ""
3749 }
3750 return *d.StatusesURL
3751 }
3752
3753
3754 func (d *Deployment) GetTask() string {
3755 if d == nil || d.Task == nil {
3756 return ""
3757 }
3758 return *d.Task
3759 }
3760
3761
3762 func (d *Deployment) GetUpdatedAt() Timestamp {
3763 if d == nil || d.UpdatedAt == nil {
3764 return Timestamp{}
3765 }
3766 return *d.UpdatedAt
3767 }
3768
3769
3770 func (d *Deployment) GetURL() string {
3771 if d == nil || d.URL == nil {
3772 return ""
3773 }
3774 return *d.URL
3775 }
3776
3777
3778 func (d *DeploymentEvent) GetDeployment() *Deployment {
3779 if d == nil {
3780 return nil
3781 }
3782 return d.Deployment
3783 }
3784
3785
3786 func (d *DeploymentEvent) GetInstallation() *Installation {
3787 if d == nil {
3788 return nil
3789 }
3790 return d.Installation
3791 }
3792
3793
3794 func (d *DeploymentEvent) GetRepo() *Repository {
3795 if d == nil {
3796 return nil
3797 }
3798 return d.Repo
3799 }
3800
3801
3802 func (d *DeploymentEvent) GetSender() *User {
3803 if d == nil {
3804 return nil
3805 }
3806 return d.Sender
3807 }
3808
3809
3810 func (d *DeploymentRequest) GetAutoMerge() bool {
3811 if d == nil || d.AutoMerge == nil {
3812 return false
3813 }
3814 return *d.AutoMerge
3815 }
3816
3817
3818 func (d *DeploymentRequest) GetDescription() string {
3819 if d == nil || d.Description == nil {
3820 return ""
3821 }
3822 return *d.Description
3823 }
3824
3825
3826 func (d *DeploymentRequest) GetEnvironment() string {
3827 if d == nil || d.Environment == nil {
3828 return ""
3829 }
3830 return *d.Environment
3831 }
3832
3833
3834 func (d *DeploymentRequest) GetProductionEnvironment() bool {
3835 if d == nil || d.ProductionEnvironment == nil {
3836 return false
3837 }
3838 return *d.ProductionEnvironment
3839 }
3840
3841
3842 func (d *DeploymentRequest) GetRef() string {
3843 if d == nil || d.Ref == nil {
3844 return ""
3845 }
3846 return *d.Ref
3847 }
3848
3849
3850 func (d *DeploymentRequest) GetRequiredContexts() []string {
3851 if d == nil || d.RequiredContexts == nil {
3852 return nil
3853 }
3854 return *d.RequiredContexts
3855 }
3856
3857
3858 func (d *DeploymentRequest) GetTask() string {
3859 if d == nil || d.Task == nil {
3860 return ""
3861 }
3862 return *d.Task
3863 }
3864
3865
3866 func (d *DeploymentRequest) GetTransientEnvironment() bool {
3867 if d == nil || d.TransientEnvironment == nil {
3868 return false
3869 }
3870 return *d.TransientEnvironment
3871 }
3872
3873
3874 func (d *DeploymentStatus) GetCreatedAt() Timestamp {
3875 if d == nil || d.CreatedAt == nil {
3876 return Timestamp{}
3877 }
3878 return *d.CreatedAt
3879 }
3880
3881
3882 func (d *DeploymentStatus) GetCreator() *User {
3883 if d == nil {
3884 return nil
3885 }
3886 return d.Creator
3887 }
3888
3889
3890 func (d *DeploymentStatus) GetDeploymentURL() string {
3891 if d == nil || d.DeploymentURL == nil {
3892 return ""
3893 }
3894 return *d.DeploymentURL
3895 }
3896
3897
3898 func (d *DeploymentStatus) GetDescription() string {
3899 if d == nil || d.Description == nil {
3900 return ""
3901 }
3902 return *d.Description
3903 }
3904
3905
3906 func (d *DeploymentStatus) GetEnvironment() string {
3907 if d == nil || d.Environment == nil {
3908 return ""
3909 }
3910 return *d.Environment
3911 }
3912
3913
3914 func (d *DeploymentStatus) GetEnvironmentURL() string {
3915 if d == nil || d.EnvironmentURL == nil {
3916 return ""
3917 }
3918 return *d.EnvironmentURL
3919 }
3920
3921
3922 func (d *DeploymentStatus) GetID() int64 {
3923 if d == nil || d.ID == nil {
3924 return 0
3925 }
3926 return *d.ID
3927 }
3928
3929
3930 func (d *DeploymentStatus) GetLogURL() string {
3931 if d == nil || d.LogURL == nil {
3932 return ""
3933 }
3934 return *d.LogURL
3935 }
3936
3937
3938 func (d *DeploymentStatus) GetNodeID() string {
3939 if d == nil || d.NodeID == nil {
3940 return ""
3941 }
3942 return *d.NodeID
3943 }
3944
3945
3946 func (d *DeploymentStatus) GetRepositoryURL() string {
3947 if d == nil || d.RepositoryURL == nil {
3948 return ""
3949 }
3950 return *d.RepositoryURL
3951 }
3952
3953
3954 func (d *DeploymentStatus) GetState() string {
3955 if d == nil || d.State == nil {
3956 return ""
3957 }
3958 return *d.State
3959 }
3960
3961
3962 func (d *DeploymentStatus) GetTargetURL() string {
3963 if d == nil || d.TargetURL == nil {
3964 return ""
3965 }
3966 return *d.TargetURL
3967 }
3968
3969
3970 func (d *DeploymentStatus) GetUpdatedAt() Timestamp {
3971 if d == nil || d.UpdatedAt == nil {
3972 return Timestamp{}
3973 }
3974 return *d.UpdatedAt
3975 }
3976
3977
3978 func (d *DeploymentStatus) GetURL() string {
3979 if d == nil || d.URL == nil {
3980 return ""
3981 }
3982 return *d.URL
3983 }
3984
3985
3986 func (d *DeploymentStatusEvent) GetDeployment() *Deployment {
3987 if d == nil {
3988 return nil
3989 }
3990 return d.Deployment
3991 }
3992
3993
3994 func (d *DeploymentStatusEvent) GetDeploymentStatus() *DeploymentStatus {
3995 if d == nil {
3996 return nil
3997 }
3998 return d.DeploymentStatus
3999 }
4000
4001
4002 func (d *DeploymentStatusEvent) GetInstallation() *Installation {
4003 if d == nil {
4004 return nil
4005 }
4006 return d.Installation
4007 }
4008
4009
4010 func (d *DeploymentStatusEvent) GetRepo() *Repository {
4011 if d == nil {
4012 return nil
4013 }
4014 return d.Repo
4015 }
4016
4017
4018 func (d *DeploymentStatusEvent) GetSender() *User {
4019 if d == nil {
4020 return nil
4021 }
4022 return d.Sender
4023 }
4024
4025
4026 func (d *DeploymentStatusRequest) GetAutoInactive() bool {
4027 if d == nil || d.AutoInactive == nil {
4028 return false
4029 }
4030 return *d.AutoInactive
4031 }
4032
4033
4034 func (d *DeploymentStatusRequest) GetDescription() string {
4035 if d == nil || d.Description == nil {
4036 return ""
4037 }
4038 return *d.Description
4039 }
4040
4041
4042 func (d *DeploymentStatusRequest) GetEnvironment() string {
4043 if d == nil || d.Environment == nil {
4044 return ""
4045 }
4046 return *d.Environment
4047 }
4048
4049
4050 func (d *DeploymentStatusRequest) GetEnvironmentURL() string {
4051 if d == nil || d.EnvironmentURL == nil {
4052 return ""
4053 }
4054 return *d.EnvironmentURL
4055 }
4056
4057
4058 func (d *DeploymentStatusRequest) GetLogURL() string {
4059 if d == nil || d.LogURL == nil {
4060 return ""
4061 }
4062 return *d.LogURL
4063 }
4064
4065
4066 func (d *DeploymentStatusRequest) GetState() string {
4067 if d == nil || d.State == nil {
4068 return ""
4069 }
4070 return *d.State
4071 }
4072
4073
4074 func (d *Discussion) GetActiveLockReason() string {
4075 if d == nil || d.ActiveLockReason == nil {
4076 return ""
4077 }
4078 return *d.ActiveLockReason
4079 }
4080
4081
4082 func (d *Discussion) GetAnswerChosenAt() Timestamp {
4083 if d == nil || d.AnswerChosenAt == nil {
4084 return Timestamp{}
4085 }
4086 return *d.AnswerChosenAt
4087 }
4088
4089
4090 func (d *Discussion) GetAnswerChosenBy() string {
4091 if d == nil || d.AnswerChosenBy == nil {
4092 return ""
4093 }
4094 return *d.AnswerChosenBy
4095 }
4096
4097
4098 func (d *Discussion) GetAnswerHTMLURL() string {
4099 if d == nil || d.AnswerHTMLURL == nil {
4100 return ""
4101 }
4102 return *d.AnswerHTMLURL
4103 }
4104
4105
4106 func (d *Discussion) GetAuthorAssociation() string {
4107 if d == nil || d.AuthorAssociation == nil {
4108 return ""
4109 }
4110 return *d.AuthorAssociation
4111 }
4112
4113
4114 func (d *Discussion) GetBody() string {
4115 if d == nil || d.Body == nil {
4116 return ""
4117 }
4118 return *d.Body
4119 }
4120
4121
4122 func (d *Discussion) GetComments() int {
4123 if d == nil || d.Comments == nil {
4124 return 0
4125 }
4126 return *d.Comments
4127 }
4128
4129
4130 func (d *Discussion) GetCreatedAt() Timestamp {
4131 if d == nil || d.CreatedAt == nil {
4132 return Timestamp{}
4133 }
4134 return *d.CreatedAt
4135 }
4136
4137
4138 func (d *Discussion) GetDiscussionCategory() *DiscussionCategory {
4139 if d == nil {
4140 return nil
4141 }
4142 return d.DiscussionCategory
4143 }
4144
4145
4146 func (d *Discussion) GetHTMLURL() string {
4147 if d == nil || d.HTMLURL == nil {
4148 return ""
4149 }
4150 return *d.HTMLURL
4151 }
4152
4153
4154 func (d *Discussion) GetID() int64 {
4155 if d == nil || d.ID == nil {
4156 return 0
4157 }
4158 return *d.ID
4159 }
4160
4161
4162 func (d *Discussion) GetLocked() bool {
4163 if d == nil || d.Locked == nil {
4164 return false
4165 }
4166 return *d.Locked
4167 }
4168
4169
4170 func (d *Discussion) GetNodeID() string {
4171 if d == nil || d.NodeID == nil {
4172 return ""
4173 }
4174 return *d.NodeID
4175 }
4176
4177
4178 func (d *Discussion) GetNumber() int {
4179 if d == nil || d.Number == nil {
4180 return 0
4181 }
4182 return *d.Number
4183 }
4184
4185
4186 func (d *Discussion) GetRepositoryURL() string {
4187 if d == nil || d.RepositoryURL == nil {
4188 return ""
4189 }
4190 return *d.RepositoryURL
4191 }
4192
4193
4194 func (d *Discussion) GetState() string {
4195 if d == nil || d.State == nil {
4196 return ""
4197 }
4198 return *d.State
4199 }
4200
4201
4202 func (d *Discussion) GetTitle() string {
4203 if d == nil || d.Title == nil {
4204 return ""
4205 }
4206 return *d.Title
4207 }
4208
4209
4210 func (d *Discussion) GetUpdatedAt() Timestamp {
4211 if d == nil || d.UpdatedAt == nil {
4212 return Timestamp{}
4213 }
4214 return *d.UpdatedAt
4215 }
4216
4217
4218 func (d *Discussion) GetUser() *User {
4219 if d == nil {
4220 return nil
4221 }
4222 return d.User
4223 }
4224
4225
4226 func (d *DiscussionCategory) GetCreatedAt() Timestamp {
4227 if d == nil || d.CreatedAt == nil {
4228 return Timestamp{}
4229 }
4230 return *d.CreatedAt
4231 }
4232
4233
4234 func (d *DiscussionCategory) GetDescription() string {
4235 if d == nil || d.Description == nil {
4236 return ""
4237 }
4238 return *d.Description
4239 }
4240
4241
4242 func (d *DiscussionCategory) GetEmoji() string {
4243 if d == nil || d.Emoji == nil {
4244 return ""
4245 }
4246 return *d.Emoji
4247 }
4248
4249
4250 func (d *DiscussionCategory) GetID() int64 {
4251 if d == nil || d.ID == nil {
4252 return 0
4253 }
4254 return *d.ID
4255 }
4256
4257
4258 func (d *DiscussionCategory) GetIsAnswerable() bool {
4259 if d == nil || d.IsAnswerable == nil {
4260 return false
4261 }
4262 return *d.IsAnswerable
4263 }
4264
4265
4266 func (d *DiscussionCategory) GetName() string {
4267 if d == nil || d.Name == nil {
4268 return ""
4269 }
4270 return *d.Name
4271 }
4272
4273
4274 func (d *DiscussionCategory) GetNodeID() string {
4275 if d == nil || d.NodeID == nil {
4276 return ""
4277 }
4278 return *d.NodeID
4279 }
4280
4281
4282 func (d *DiscussionCategory) GetRepositoryID() int64 {
4283 if d == nil || d.RepositoryID == nil {
4284 return 0
4285 }
4286 return *d.RepositoryID
4287 }
4288
4289
4290 func (d *DiscussionCategory) GetSlug() string {
4291 if d == nil || d.Slug == nil {
4292 return ""
4293 }
4294 return *d.Slug
4295 }
4296
4297
4298 func (d *DiscussionCategory) GetUpdatedAt() Timestamp {
4299 if d == nil || d.UpdatedAt == nil {
4300 return Timestamp{}
4301 }
4302 return *d.UpdatedAt
4303 }
4304
4305
4306 func (d *DiscussionComment) GetAuthor() *User {
4307 if d == nil {
4308 return nil
4309 }
4310 return d.Author
4311 }
4312
4313
4314 func (d *DiscussionComment) GetBody() string {
4315 if d == nil || d.Body == nil {
4316 return ""
4317 }
4318 return *d.Body
4319 }
4320
4321
4322 func (d *DiscussionComment) GetBodyHTML() string {
4323 if d == nil || d.BodyHTML == nil {
4324 return ""
4325 }
4326 return *d.BodyHTML
4327 }
4328
4329
4330 func (d *DiscussionComment) GetBodyVersion() string {
4331 if d == nil || d.BodyVersion == nil {
4332 return ""
4333 }
4334 return *d.BodyVersion
4335 }
4336
4337
4338 func (d *DiscussionComment) GetCreatedAt() Timestamp {
4339 if d == nil || d.CreatedAt == nil {
4340 return Timestamp{}
4341 }
4342 return *d.CreatedAt
4343 }
4344
4345
4346 func (d *DiscussionComment) GetDiscussionURL() string {
4347 if d == nil || d.DiscussionURL == nil {
4348 return ""
4349 }
4350 return *d.DiscussionURL
4351 }
4352
4353
4354 func (d *DiscussionComment) GetHTMLURL() string {
4355 if d == nil || d.HTMLURL == nil {
4356 return ""
4357 }
4358 return *d.HTMLURL
4359 }
4360
4361
4362 func (d *DiscussionComment) GetLastEditedAt() Timestamp {
4363 if d == nil || d.LastEditedAt == nil {
4364 return Timestamp{}
4365 }
4366 return *d.LastEditedAt
4367 }
4368
4369
4370 func (d *DiscussionComment) GetNodeID() string {
4371 if d == nil || d.NodeID == nil {
4372 return ""
4373 }
4374 return *d.NodeID
4375 }
4376
4377
4378 func (d *DiscussionComment) GetNumber() int {
4379 if d == nil || d.Number == nil {
4380 return 0
4381 }
4382 return *d.Number
4383 }
4384
4385
4386 func (d *DiscussionComment) GetReactions() *Reactions {
4387 if d == nil {
4388 return nil
4389 }
4390 return d.Reactions
4391 }
4392
4393
4394 func (d *DiscussionComment) GetUpdatedAt() Timestamp {
4395 if d == nil || d.UpdatedAt == nil {
4396 return Timestamp{}
4397 }
4398 return *d.UpdatedAt
4399 }
4400
4401
4402 func (d *DiscussionComment) GetURL() string {
4403 if d == nil || d.URL == nil {
4404 return ""
4405 }
4406 return *d.URL
4407 }
4408
4409
4410 func (d *DiscussionEvent) GetAction() string {
4411 if d == nil || d.Action == nil {
4412 return ""
4413 }
4414 return *d.Action
4415 }
4416
4417
4418 func (d *DiscussionEvent) GetDiscussion() *Discussion {
4419 if d == nil {
4420 return nil
4421 }
4422 return d.Discussion
4423 }
4424
4425
4426 func (d *DiscussionEvent) GetInstallation() *Installation {
4427 if d == nil {
4428 return nil
4429 }
4430 return d.Installation
4431 }
4432
4433
4434 func (d *DiscussionEvent) GetOrg() *Organization {
4435 if d == nil {
4436 return nil
4437 }
4438 return d.Org
4439 }
4440
4441
4442 func (d *DiscussionEvent) GetRepo() *Repository {
4443 if d == nil {
4444 return nil
4445 }
4446 return d.Repo
4447 }
4448
4449
4450 func (d *DiscussionEvent) GetSender() *User {
4451 if d == nil {
4452 return nil
4453 }
4454 return d.Sender
4455 }
4456
4457
4458 func (d *DismissalRestrictionsRequest) GetTeams() []string {
4459 if d == nil || d.Teams == nil {
4460 return nil
4461 }
4462 return *d.Teams
4463 }
4464
4465
4466 func (d *DismissalRestrictionsRequest) GetUsers() []string {
4467 if d == nil || d.Users == nil {
4468 return nil
4469 }
4470 return *d.Users
4471 }
4472
4473
4474 func (d *DismissedReview) GetDismissalCommitID() string {
4475 if d == nil || d.DismissalCommitID == nil {
4476 return ""
4477 }
4478 return *d.DismissalCommitID
4479 }
4480
4481
4482 func (d *DismissedReview) GetDismissalMessage() string {
4483 if d == nil || d.DismissalMessage == nil {
4484 return ""
4485 }
4486 return *d.DismissalMessage
4487 }
4488
4489
4490 func (d *DismissedReview) GetReviewID() int64 {
4491 if d == nil || d.ReviewID == nil {
4492 return 0
4493 }
4494 return *d.ReviewID
4495 }
4496
4497
4498 func (d *DismissedReview) GetState() string {
4499 if d == nil || d.State == nil {
4500 return ""
4501 }
4502 return *d.State
4503 }
4504
4505
4506 func (d *DispatchRequestOptions) GetClientPayload() json.RawMessage {
4507 if d == nil || d.ClientPayload == nil {
4508 return json.RawMessage{}
4509 }
4510 return *d.ClientPayload
4511 }
4512
4513
4514 func (d *DraftReviewComment) GetBody() string {
4515 if d == nil || d.Body == nil {
4516 return ""
4517 }
4518 return *d.Body
4519 }
4520
4521
4522 func (d *DraftReviewComment) GetLine() int {
4523 if d == nil || d.Line == nil {
4524 return 0
4525 }
4526 return *d.Line
4527 }
4528
4529
4530 func (d *DraftReviewComment) GetPath() string {
4531 if d == nil || d.Path == nil {
4532 return ""
4533 }
4534 return *d.Path
4535 }
4536
4537
4538 func (d *DraftReviewComment) GetPosition() int {
4539 if d == nil || d.Position == nil {
4540 return 0
4541 }
4542 return *d.Position
4543 }
4544
4545
4546 func (d *DraftReviewComment) GetSide() string {
4547 if d == nil || d.Side == nil {
4548 return ""
4549 }
4550 return *d.Side
4551 }
4552
4553
4554 func (d *DraftReviewComment) GetStartLine() int {
4555 if d == nil || d.StartLine == nil {
4556 return 0
4557 }
4558 return *d.StartLine
4559 }
4560
4561
4562 func (d *DraftReviewComment) GetStartSide() string {
4563 if d == nil || d.StartSide == nil {
4564 return ""
4565 }
4566 return *d.StartSide
4567 }
4568
4569
4570 func (e *EditBase) GetRef() *EditRef {
4571 if e == nil {
4572 return nil
4573 }
4574 return e.Ref
4575 }
4576
4577
4578 func (e *EditBase) GetSHA() *EditSHA {
4579 if e == nil {
4580 return nil
4581 }
4582 return e.SHA
4583 }
4584
4585
4586 func (e *EditBody) GetFrom() string {
4587 if e == nil || e.From == nil {
4588 return ""
4589 }
4590 return *e.From
4591 }
4592
4593
4594 func (e *EditChange) GetBase() *EditBase {
4595 if e == nil {
4596 return nil
4597 }
4598 return e.Base
4599 }
4600
4601
4602 func (e *EditChange) GetBody() *EditBody {
4603 if e == nil {
4604 return nil
4605 }
4606 return e.Body
4607 }
4608
4609
4610 func (e *EditChange) GetRepo() *EditRepo {
4611 if e == nil {
4612 return nil
4613 }
4614 return e.Repo
4615 }
4616
4617
4618 func (e *EditChange) GetTitle() *EditTitle {
4619 if e == nil {
4620 return nil
4621 }
4622 return e.Title
4623 }
4624
4625
4626 func (e *EditRef) GetFrom() string {
4627 if e == nil || e.From == nil {
4628 return ""
4629 }
4630 return *e.From
4631 }
4632
4633
4634 func (e *EditRepo) GetName() *RepoName {
4635 if e == nil {
4636 return nil
4637 }
4638 return e.Name
4639 }
4640
4641
4642 func (e *EditSHA) GetFrom() string {
4643 if e == nil || e.From == nil {
4644 return ""
4645 }
4646 return *e.From
4647 }
4648
4649
4650 func (e *EditTitle) GetFrom() string {
4651 if e == nil || e.From == nil {
4652 return ""
4653 }
4654 return *e.From
4655 }
4656
4657
4658 func (e *Enterprise) GetAvatarURL() string {
4659 if e == nil || e.AvatarURL == nil {
4660 return ""
4661 }
4662 return *e.AvatarURL
4663 }
4664
4665
4666 func (e *Enterprise) GetCreatedAt() Timestamp {
4667 if e == nil || e.CreatedAt == nil {
4668 return Timestamp{}
4669 }
4670 return *e.CreatedAt
4671 }
4672
4673
4674 func (e *Enterprise) GetDescription() string {
4675 if e == nil || e.Description == nil {
4676 return ""
4677 }
4678 return *e.Description
4679 }
4680
4681
4682 func (e *Enterprise) GetHTMLURL() string {
4683 if e == nil || e.HTMLURL == nil {
4684 return ""
4685 }
4686 return *e.HTMLURL
4687 }
4688
4689
4690 func (e *Enterprise) GetID() int {
4691 if e == nil || e.ID == nil {
4692 return 0
4693 }
4694 return *e.ID
4695 }
4696
4697
4698 func (e *Enterprise) GetName() string {
4699 if e == nil || e.Name == nil {
4700 return ""
4701 }
4702 return *e.Name
4703 }
4704
4705
4706 func (e *Enterprise) GetNodeID() string {
4707 if e == nil || e.NodeID == nil {
4708 return ""
4709 }
4710 return *e.NodeID
4711 }
4712
4713
4714 func (e *Enterprise) GetSlug() string {
4715 if e == nil || e.Slug == nil {
4716 return ""
4717 }
4718 return *e.Slug
4719 }
4720
4721
4722 func (e *Enterprise) GetUpdatedAt() Timestamp {
4723 if e == nil || e.UpdatedAt == nil {
4724 return Timestamp{}
4725 }
4726 return *e.UpdatedAt
4727 }
4728
4729
4730 func (e *Enterprise) GetWebsiteURL() string {
4731 if e == nil || e.WebsiteURL == nil {
4732 return ""
4733 }
4734 return *e.WebsiteURL
4735 }
4736
4737
4738 func (e *Environment) GetCreatedAt() Timestamp {
4739 if e == nil || e.CreatedAt == nil {
4740 return Timestamp{}
4741 }
4742 return *e.CreatedAt
4743 }
4744
4745
4746 func (e *Environment) GetDeploymentBranchPolicy() *BranchPolicy {
4747 if e == nil {
4748 return nil
4749 }
4750 return e.DeploymentBranchPolicy
4751 }
4752
4753
4754 func (e *Environment) GetEnvironmentName() string {
4755 if e == nil || e.EnvironmentName == nil {
4756 return ""
4757 }
4758 return *e.EnvironmentName
4759 }
4760
4761
4762 func (e *Environment) GetHTMLURL() string {
4763 if e == nil || e.HTMLURL == nil {
4764 return ""
4765 }
4766 return *e.HTMLURL
4767 }
4768
4769
4770 func (e *Environment) GetID() int64 {
4771 if e == nil || e.ID == nil {
4772 return 0
4773 }
4774 return *e.ID
4775 }
4776
4777
4778 func (e *Environment) GetName() string {
4779 if e == nil || e.Name == nil {
4780 return ""
4781 }
4782 return *e.Name
4783 }
4784
4785
4786 func (e *Environment) GetNodeID() string {
4787 if e == nil || e.NodeID == nil {
4788 return ""
4789 }
4790 return *e.NodeID
4791 }
4792
4793
4794 func (e *Environment) GetOwner() string {
4795 if e == nil || e.Owner == nil {
4796 return ""
4797 }
4798 return *e.Owner
4799 }
4800
4801
4802 func (e *Environment) GetRepo() string {
4803 if e == nil || e.Repo == nil {
4804 return ""
4805 }
4806 return *e.Repo
4807 }
4808
4809
4810 func (e *Environment) GetUpdatedAt() Timestamp {
4811 if e == nil || e.UpdatedAt == nil {
4812 return Timestamp{}
4813 }
4814 return *e.UpdatedAt
4815 }
4816
4817
4818 func (e *Environment) GetURL() string {
4819 if e == nil || e.URL == nil {
4820 return ""
4821 }
4822 return *e.URL
4823 }
4824
4825
4826 func (e *Environment) GetWaitTimer() int {
4827 if e == nil || e.WaitTimer == nil {
4828 return 0
4829 }
4830 return *e.WaitTimer
4831 }
4832
4833
4834 func (e *EnvResponse) GetTotalCount() int {
4835 if e == nil || e.TotalCount == nil {
4836 return 0
4837 }
4838 return *e.TotalCount
4839 }
4840
4841
4842 func (e *EnvReviewers) GetID() int64 {
4843 if e == nil || e.ID == nil {
4844 return 0
4845 }
4846 return *e.ID
4847 }
4848
4849
4850 func (e *EnvReviewers) GetType() string {
4851 if e == nil || e.Type == nil {
4852 return ""
4853 }
4854 return *e.Type
4855 }
4856
4857
4858 func (e *ErrorBlock) GetCreatedAt() Timestamp {
4859 if e == nil || e.CreatedAt == nil {
4860 return Timestamp{}
4861 }
4862 return *e.CreatedAt
4863 }
4864
4865
4866 func (e *ErrorResponse) GetBlock() *ErrorBlock {
4867 if e == nil {
4868 return nil
4869 }
4870 return e.Block
4871 }
4872
4873
4874 func (e *Event) GetActor() *User {
4875 if e == nil {
4876 return nil
4877 }
4878 return e.Actor
4879 }
4880
4881
4882 func (e *Event) GetCreatedAt() time.Time {
4883 if e == nil || e.CreatedAt == nil {
4884 return time.Time{}
4885 }
4886 return *e.CreatedAt
4887 }
4888
4889
4890 func (e *Event) GetID() string {
4891 if e == nil || e.ID == nil {
4892 return ""
4893 }
4894 return *e.ID
4895 }
4896
4897
4898 func (e *Event) GetOrg() *Organization {
4899 if e == nil {
4900 return nil
4901 }
4902 return e.Org
4903 }
4904
4905
4906 func (e *Event) GetPublic() bool {
4907 if e == nil || e.Public == nil {
4908 return false
4909 }
4910 return *e.Public
4911 }
4912
4913
4914 func (e *Event) GetRawPayload() json.RawMessage {
4915 if e == nil || e.RawPayload == nil {
4916 return json.RawMessage{}
4917 }
4918 return *e.RawPayload
4919 }
4920
4921
4922 func (e *Event) GetRepo() *Repository {
4923 if e == nil {
4924 return nil
4925 }
4926 return e.Repo
4927 }
4928
4929
4930 func (e *Event) GetType() string {
4931 if e == nil || e.Type == nil {
4932 return ""
4933 }
4934 return *e.Type
4935 }
4936
4937
4938 func (e *ExternalGroup) GetGroupID() int64 {
4939 if e == nil || e.GroupID == nil {
4940 return 0
4941 }
4942 return *e.GroupID
4943 }
4944
4945
4946 func (e *ExternalGroup) GetGroupName() string {
4947 if e == nil || e.GroupName == nil {
4948 return ""
4949 }
4950 return *e.GroupName
4951 }
4952
4953
4954 func (e *ExternalGroup) GetUpdatedAt() Timestamp {
4955 if e == nil || e.UpdatedAt == nil {
4956 return Timestamp{}
4957 }
4958 return *e.UpdatedAt
4959 }
4960
4961
4962 func (e *ExternalGroupMember) GetMemberEmail() string {
4963 if e == nil || e.MemberEmail == nil {
4964 return ""
4965 }
4966 return *e.MemberEmail
4967 }
4968
4969
4970 func (e *ExternalGroupMember) GetMemberID() int64 {
4971 if e == nil || e.MemberID == nil {
4972 return 0
4973 }
4974 return *e.MemberID
4975 }
4976
4977
4978 func (e *ExternalGroupMember) GetMemberLogin() string {
4979 if e == nil || e.MemberLogin == nil {
4980 return ""
4981 }
4982 return *e.MemberLogin
4983 }
4984
4985
4986 func (e *ExternalGroupMember) GetMemberName() string {
4987 if e == nil || e.MemberName == nil {
4988 return ""
4989 }
4990 return *e.MemberName
4991 }
4992
4993
4994 func (e *ExternalGroupTeam) GetTeamID() int64 {
4995 if e == nil || e.TeamID == nil {
4996 return 0
4997 }
4998 return *e.TeamID
4999 }
5000
5001
5002 func (e *ExternalGroupTeam) GetTeamName() string {
5003 if e == nil || e.TeamName == nil {
5004 return ""
5005 }
5006 return *e.TeamName
5007 }
5008
5009
5010 func (f *FeedLink) GetHRef() string {
5011 if f == nil || f.HRef == nil {
5012 return ""
5013 }
5014 return *f.HRef
5015 }
5016
5017
5018 func (f *FeedLink) GetType() string {
5019 if f == nil || f.Type == nil {
5020 return ""
5021 }
5022 return *f.Type
5023 }
5024
5025
5026 func (f *FeedLinks) GetCurrentUser() *FeedLink {
5027 if f == nil {
5028 return nil
5029 }
5030 return f.CurrentUser
5031 }
5032
5033
5034 func (f *FeedLinks) GetCurrentUserActor() *FeedLink {
5035 if f == nil {
5036 return nil
5037 }
5038 return f.CurrentUserActor
5039 }
5040
5041
5042 func (f *FeedLinks) GetCurrentUserOrganization() *FeedLink {
5043 if f == nil {
5044 return nil
5045 }
5046 return f.CurrentUserOrganization
5047 }
5048
5049
5050 func (f *FeedLinks) GetCurrentUserPublic() *FeedLink {
5051 if f == nil {
5052 return nil
5053 }
5054 return f.CurrentUserPublic
5055 }
5056
5057
5058 func (f *FeedLinks) GetTimeline() *FeedLink {
5059 if f == nil {
5060 return nil
5061 }
5062 return f.Timeline
5063 }
5064
5065
5066 func (f *FeedLinks) GetUser() *FeedLink {
5067 if f == nil {
5068 return nil
5069 }
5070 return f.User
5071 }
5072
5073
5074 func (f *Feeds) GetCurrentUserActorURL() string {
5075 if f == nil || f.CurrentUserActorURL == nil {
5076 return ""
5077 }
5078 return *f.CurrentUserActorURL
5079 }
5080
5081
5082 func (f *Feeds) GetCurrentUserOrganizationURL() string {
5083 if f == nil || f.CurrentUserOrganizationURL == nil {
5084 return ""
5085 }
5086 return *f.CurrentUserOrganizationURL
5087 }
5088
5089
5090 func (f *Feeds) GetCurrentUserPublicURL() string {
5091 if f == nil || f.CurrentUserPublicURL == nil {
5092 return ""
5093 }
5094 return *f.CurrentUserPublicURL
5095 }
5096
5097
5098 func (f *Feeds) GetCurrentUserURL() string {
5099 if f == nil || f.CurrentUserURL == nil {
5100 return ""
5101 }
5102 return *f.CurrentUserURL
5103 }
5104
5105
5106 func (f *Feeds) GetLinks() *FeedLinks {
5107 if f == nil {
5108 return nil
5109 }
5110 return f.Links
5111 }
5112
5113
5114 func (f *Feeds) GetTimelineURL() string {
5115 if f == nil || f.TimelineURL == nil {
5116 return ""
5117 }
5118 return *f.TimelineURL
5119 }
5120
5121
5122 func (f *Feeds) GetUserURL() string {
5123 if f == nil || f.UserURL == nil {
5124 return ""
5125 }
5126 return *f.UserURL
5127 }
5128
5129
5130 func (f *FirstPatchedVersion) GetIdentifier() string {
5131 if f == nil || f.Identifier == nil {
5132 return ""
5133 }
5134 return *f.Identifier
5135 }
5136
5137
5138 func (f *ForkEvent) GetForkee() *Repository {
5139 if f == nil {
5140 return nil
5141 }
5142 return f.Forkee
5143 }
5144
5145
5146 func (f *ForkEvent) GetInstallation() *Installation {
5147 if f == nil {
5148 return nil
5149 }
5150 return f.Installation
5151 }
5152
5153
5154 func (f *ForkEvent) GetRepo() *Repository {
5155 if f == nil {
5156 return nil
5157 }
5158 return f.Repo
5159 }
5160
5161
5162 func (f *ForkEvent) GetSender() *User {
5163 if f == nil {
5164 return nil
5165 }
5166 return f.Sender
5167 }
5168
5169
5170 func (g *GenerateNotesOptions) GetPreviousTagName() string {
5171 if g == nil || g.PreviousTagName == nil {
5172 return ""
5173 }
5174 return *g.PreviousTagName
5175 }
5176
5177
5178 func (g *GenerateNotesOptions) GetTargetCommitish() string {
5179 if g == nil || g.TargetCommitish == nil {
5180 return ""
5181 }
5182 return *g.TargetCommitish
5183 }
5184
5185
5186 func (g *GetAuditLogOptions) GetInclude() string {
5187 if g == nil || g.Include == nil {
5188 return ""
5189 }
5190 return *g.Include
5191 }
5192
5193
5194 func (g *GetAuditLogOptions) GetOrder() string {
5195 if g == nil || g.Order == nil {
5196 return ""
5197 }
5198 return *g.Order
5199 }
5200
5201
5202 func (g *GetAuditLogOptions) GetPhrase() string {
5203 if g == nil || g.Phrase == nil {
5204 return ""
5205 }
5206 return *g.Phrase
5207 }
5208
5209
5210 func (g *Gist) GetComments() int {
5211 if g == nil || g.Comments == nil {
5212 return 0
5213 }
5214 return *g.Comments
5215 }
5216
5217
5218 func (g *Gist) GetCreatedAt() time.Time {
5219 if g == nil || g.CreatedAt == nil {
5220 return time.Time{}
5221 }
5222 return *g.CreatedAt
5223 }
5224
5225
5226 func (g *Gist) GetDescription() string {
5227 if g == nil || g.Description == nil {
5228 return ""
5229 }
5230 return *g.Description
5231 }
5232
5233
5234 func (g *Gist) GetFiles() map[GistFilename]GistFile {
5235 if g == nil || g.Files == nil {
5236 return map[GistFilename]GistFile{}
5237 }
5238 return g.Files
5239 }
5240
5241
5242 func (g *Gist) GetGitPullURL() string {
5243 if g == nil || g.GitPullURL == nil {
5244 return ""
5245 }
5246 return *g.GitPullURL
5247 }
5248
5249
5250 func (g *Gist) GetGitPushURL() string {
5251 if g == nil || g.GitPushURL == nil {
5252 return ""
5253 }
5254 return *g.GitPushURL
5255 }
5256
5257
5258 func (g *Gist) GetHTMLURL() string {
5259 if g == nil || g.HTMLURL == nil {
5260 return ""
5261 }
5262 return *g.HTMLURL
5263 }
5264
5265
5266 func (g *Gist) GetID() string {
5267 if g == nil || g.ID == nil {
5268 return ""
5269 }
5270 return *g.ID
5271 }
5272
5273
5274 func (g *Gist) GetNodeID() string {
5275 if g == nil || g.NodeID == nil {
5276 return ""
5277 }
5278 return *g.NodeID
5279 }
5280
5281
5282 func (g *Gist) GetOwner() *User {
5283 if g == nil {
5284 return nil
5285 }
5286 return g.Owner
5287 }
5288
5289
5290 func (g *Gist) GetPublic() bool {
5291 if g == nil || g.Public == nil {
5292 return false
5293 }
5294 return *g.Public
5295 }
5296
5297
5298 func (g *Gist) GetUpdatedAt() time.Time {
5299 if g == nil || g.UpdatedAt == nil {
5300 return time.Time{}
5301 }
5302 return *g.UpdatedAt
5303 }
5304
5305
5306 func (g *GistComment) GetBody() string {
5307 if g == nil || g.Body == nil {
5308 return ""
5309 }
5310 return *g.Body
5311 }
5312
5313
5314 func (g *GistComment) GetCreatedAt() time.Time {
5315 if g == nil || g.CreatedAt == nil {
5316 return time.Time{}
5317 }
5318 return *g.CreatedAt
5319 }
5320
5321
5322 func (g *GistComment) GetID() int64 {
5323 if g == nil || g.ID == nil {
5324 return 0
5325 }
5326 return *g.ID
5327 }
5328
5329
5330 func (g *GistComment) GetURL() string {
5331 if g == nil || g.URL == nil {
5332 return ""
5333 }
5334 return *g.URL
5335 }
5336
5337
5338 func (g *GistComment) GetUser() *User {
5339 if g == nil {
5340 return nil
5341 }
5342 return g.User
5343 }
5344
5345
5346 func (g *GistCommit) GetChangeStatus() *CommitStats {
5347 if g == nil {
5348 return nil
5349 }
5350 return g.ChangeStatus
5351 }
5352
5353
5354 func (g *GistCommit) GetCommittedAt() Timestamp {
5355 if g == nil || g.CommittedAt == nil {
5356 return Timestamp{}
5357 }
5358 return *g.CommittedAt
5359 }
5360
5361
5362 func (g *GistCommit) GetNodeID() string {
5363 if g == nil || g.NodeID == nil {
5364 return ""
5365 }
5366 return *g.NodeID
5367 }
5368
5369
5370 func (g *GistCommit) GetURL() string {
5371 if g == nil || g.URL == nil {
5372 return ""
5373 }
5374 return *g.URL
5375 }
5376
5377
5378 func (g *GistCommit) GetUser() *User {
5379 if g == nil {
5380 return nil
5381 }
5382 return g.User
5383 }
5384
5385
5386 func (g *GistCommit) GetVersion() string {
5387 if g == nil || g.Version == nil {
5388 return ""
5389 }
5390 return *g.Version
5391 }
5392
5393
5394 func (g *GistFile) GetContent() string {
5395 if g == nil || g.Content == nil {
5396 return ""
5397 }
5398 return *g.Content
5399 }
5400
5401
5402 func (g *GistFile) GetFilename() string {
5403 if g == nil || g.Filename == nil {
5404 return ""
5405 }
5406 return *g.Filename
5407 }
5408
5409
5410 func (g *GistFile) GetLanguage() string {
5411 if g == nil || g.Language == nil {
5412 return ""
5413 }
5414 return *g.Language
5415 }
5416
5417
5418 func (g *GistFile) GetRawURL() string {
5419 if g == nil || g.RawURL == nil {
5420 return ""
5421 }
5422 return *g.RawURL
5423 }
5424
5425
5426 func (g *GistFile) GetSize() int {
5427 if g == nil || g.Size == nil {
5428 return 0
5429 }
5430 return *g.Size
5431 }
5432
5433
5434 func (g *GistFile) GetType() string {
5435 if g == nil || g.Type == nil {
5436 return ""
5437 }
5438 return *g.Type
5439 }
5440
5441
5442 func (g *GistFork) GetCreatedAt() Timestamp {
5443 if g == nil || g.CreatedAt == nil {
5444 return Timestamp{}
5445 }
5446 return *g.CreatedAt
5447 }
5448
5449
5450 func (g *GistFork) GetID() string {
5451 if g == nil || g.ID == nil {
5452 return ""
5453 }
5454 return *g.ID
5455 }
5456
5457
5458 func (g *GistFork) GetNodeID() string {
5459 if g == nil || g.NodeID == nil {
5460 return ""
5461 }
5462 return *g.NodeID
5463 }
5464
5465
5466 func (g *GistFork) GetUpdatedAt() Timestamp {
5467 if g == nil || g.UpdatedAt == nil {
5468 return Timestamp{}
5469 }
5470 return *g.UpdatedAt
5471 }
5472
5473
5474 func (g *GistFork) GetURL() string {
5475 if g == nil || g.URL == nil {
5476 return ""
5477 }
5478 return *g.URL
5479 }
5480
5481
5482 func (g *GistFork) GetUser() *User {
5483 if g == nil {
5484 return nil
5485 }
5486 return g.User
5487 }
5488
5489
5490 func (g *GistStats) GetPrivateGists() int {
5491 if g == nil || g.PrivateGists == nil {
5492 return 0
5493 }
5494 return *g.PrivateGists
5495 }
5496
5497
5498 func (g *GistStats) GetPublicGists() int {
5499 if g == nil || g.PublicGists == nil {
5500 return 0
5501 }
5502 return *g.PublicGists
5503 }
5504
5505
5506 func (g *GistStats) GetTotalGists() int {
5507 if g == nil || g.TotalGists == nil {
5508 return 0
5509 }
5510 return *g.TotalGists
5511 }
5512
5513
5514 func (g *GitHubAppAuthorizationEvent) GetAction() string {
5515 if g == nil || g.Action == nil {
5516 return ""
5517 }
5518 return *g.Action
5519 }
5520
5521
5522 func (g *GitHubAppAuthorizationEvent) GetInstallation() *Installation {
5523 if g == nil {
5524 return nil
5525 }
5526 return g.Installation
5527 }
5528
5529
5530 func (g *GitHubAppAuthorizationEvent) GetSender() *User {
5531 if g == nil {
5532 return nil
5533 }
5534 return g.Sender
5535 }
5536
5537
5538 func (g *Gitignore) GetName() string {
5539 if g == nil || g.Name == nil {
5540 return ""
5541 }
5542 return *g.Name
5543 }
5544
5545
5546 func (g *Gitignore) GetSource() string {
5547 if g == nil || g.Source == nil {
5548 return ""
5549 }
5550 return *g.Source
5551 }
5552
5553
5554 func (g *GitObject) GetSHA() string {
5555 if g == nil || g.SHA == nil {
5556 return ""
5557 }
5558 return *g.SHA
5559 }
5560
5561
5562 func (g *GitObject) GetType() string {
5563 if g == nil || g.Type == nil {
5564 return ""
5565 }
5566 return *g.Type
5567 }
5568
5569
5570 func (g *GitObject) GetURL() string {
5571 if g == nil || g.URL == nil {
5572 return ""
5573 }
5574 return *g.URL
5575 }
5576
5577
5578 func (g *GollumEvent) GetInstallation() *Installation {
5579 if g == nil {
5580 return nil
5581 }
5582 return g.Installation
5583 }
5584
5585
5586 func (g *GollumEvent) GetRepo() *Repository {
5587 if g == nil {
5588 return nil
5589 }
5590 return g.Repo
5591 }
5592
5593
5594 func (g *GollumEvent) GetSender() *User {
5595 if g == nil {
5596 return nil
5597 }
5598 return g.Sender
5599 }
5600
5601
5602 func (g *GPGEmail) GetEmail() string {
5603 if g == nil || g.Email == nil {
5604 return ""
5605 }
5606 return *g.Email
5607 }
5608
5609
5610 func (g *GPGEmail) GetVerified() bool {
5611 if g == nil || g.Verified == nil {
5612 return false
5613 }
5614 return *g.Verified
5615 }
5616
5617
5618 func (g *GPGKey) GetCanCertify() bool {
5619 if g == nil || g.CanCertify == nil {
5620 return false
5621 }
5622 return *g.CanCertify
5623 }
5624
5625
5626 func (g *GPGKey) GetCanEncryptComms() bool {
5627 if g == nil || g.CanEncryptComms == nil {
5628 return false
5629 }
5630 return *g.CanEncryptComms
5631 }
5632
5633
5634 func (g *GPGKey) GetCanEncryptStorage() bool {
5635 if g == nil || g.CanEncryptStorage == nil {
5636 return false
5637 }
5638 return *g.CanEncryptStorage
5639 }
5640
5641
5642 func (g *GPGKey) GetCanSign() bool {
5643 if g == nil || g.CanSign == nil {
5644 return false
5645 }
5646 return *g.CanSign
5647 }
5648
5649
5650 func (g *GPGKey) GetCreatedAt() time.Time {
5651 if g == nil || g.CreatedAt == nil {
5652 return time.Time{}
5653 }
5654 return *g.CreatedAt
5655 }
5656
5657
5658 func (g *GPGKey) GetExpiresAt() time.Time {
5659 if g == nil || g.ExpiresAt == nil {
5660 return time.Time{}
5661 }
5662 return *g.ExpiresAt
5663 }
5664
5665
5666 func (g *GPGKey) GetID() int64 {
5667 if g == nil || g.ID == nil {
5668 return 0
5669 }
5670 return *g.ID
5671 }
5672
5673
5674 func (g *GPGKey) GetKeyID() string {
5675 if g == nil || g.KeyID == nil {
5676 return ""
5677 }
5678 return *g.KeyID
5679 }
5680
5681
5682 func (g *GPGKey) GetPrimaryKeyID() int64 {
5683 if g == nil || g.PrimaryKeyID == nil {
5684 return 0
5685 }
5686 return *g.PrimaryKeyID
5687 }
5688
5689
5690 func (g *GPGKey) GetPublicKey() string {
5691 if g == nil || g.PublicKey == nil {
5692 return ""
5693 }
5694 return *g.PublicKey
5695 }
5696
5697
5698 func (g *GPGKey) GetRawKey() string {
5699 if g == nil || g.RawKey == nil {
5700 return ""
5701 }
5702 return *g.RawKey
5703 }
5704
5705
5706 func (g *Grant) GetApp() *AuthorizationApp {
5707 if g == nil {
5708 return nil
5709 }
5710 return g.App
5711 }
5712
5713
5714 func (g *Grant) GetCreatedAt() Timestamp {
5715 if g == nil || g.CreatedAt == nil {
5716 return Timestamp{}
5717 }
5718 return *g.CreatedAt
5719 }
5720
5721
5722 func (g *Grant) GetID() int64 {
5723 if g == nil || g.ID == nil {
5724 return 0
5725 }
5726 return *g.ID
5727 }
5728
5729
5730 func (g *Grant) GetUpdatedAt() Timestamp {
5731 if g == nil || g.UpdatedAt == nil {
5732 return Timestamp{}
5733 }
5734 return *g.UpdatedAt
5735 }
5736
5737
5738 func (g *Grant) GetURL() string {
5739 if g == nil || g.URL == nil {
5740 return ""
5741 }
5742 return *g.URL
5743 }
5744
5745
5746 func (h *HeadCommit) GetAuthor() *CommitAuthor {
5747 if h == nil {
5748 return nil
5749 }
5750 return h.Author
5751 }
5752
5753
5754 func (h *HeadCommit) GetCommitter() *CommitAuthor {
5755 if h == nil {
5756 return nil
5757 }
5758 return h.Committer
5759 }
5760
5761
5762 func (h *HeadCommit) GetDistinct() bool {
5763 if h == nil || h.Distinct == nil {
5764 return false
5765 }
5766 return *h.Distinct
5767 }
5768
5769
5770 func (h *HeadCommit) GetID() string {
5771 if h == nil || h.ID == nil {
5772 return ""
5773 }
5774 return *h.ID
5775 }
5776
5777
5778 func (h *HeadCommit) GetMessage() string {
5779 if h == nil || h.Message == nil {
5780 return ""
5781 }
5782 return *h.Message
5783 }
5784
5785
5786 func (h *HeadCommit) GetSHA() string {
5787 if h == nil || h.SHA == nil {
5788 return ""
5789 }
5790 return *h.SHA
5791 }
5792
5793
5794 func (h *HeadCommit) GetTimestamp() Timestamp {
5795 if h == nil || h.Timestamp == nil {
5796 return Timestamp{}
5797 }
5798 return *h.Timestamp
5799 }
5800
5801
5802 func (h *HeadCommit) GetTreeID() string {
5803 if h == nil || h.TreeID == nil {
5804 return ""
5805 }
5806 return *h.TreeID
5807 }
5808
5809
5810 func (h *HeadCommit) GetURL() string {
5811 if h == nil || h.URL == nil {
5812 return ""
5813 }
5814 return *h.URL
5815 }
5816
5817
5818 func (h *Hook) GetActive() bool {
5819 if h == nil || h.Active == nil {
5820 return false
5821 }
5822 return *h.Active
5823 }
5824
5825
5826 func (h *Hook) GetCreatedAt() time.Time {
5827 if h == nil || h.CreatedAt == nil {
5828 return time.Time{}
5829 }
5830 return *h.CreatedAt
5831 }
5832
5833
5834 func (h *Hook) GetID() int64 {
5835 if h == nil || h.ID == nil {
5836 return 0
5837 }
5838 return *h.ID
5839 }
5840
5841
5842 func (h *Hook) GetName() string {
5843 if h == nil || h.Name == nil {
5844 return ""
5845 }
5846 return *h.Name
5847 }
5848
5849
5850 func (h *Hook) GetPingURL() string {
5851 if h == nil || h.PingURL == nil {
5852 return ""
5853 }
5854 return *h.PingURL
5855 }
5856
5857
5858 func (h *Hook) GetTestURL() string {
5859 if h == nil || h.TestURL == nil {
5860 return ""
5861 }
5862 return *h.TestURL
5863 }
5864
5865
5866 func (h *Hook) GetType() string {
5867 if h == nil || h.Type == nil {
5868 return ""
5869 }
5870 return *h.Type
5871 }
5872
5873
5874 func (h *Hook) GetUpdatedAt() time.Time {
5875 if h == nil || h.UpdatedAt == nil {
5876 return time.Time{}
5877 }
5878 return *h.UpdatedAt
5879 }
5880
5881
5882 func (h *Hook) GetURL() string {
5883 if h == nil || h.URL == nil {
5884 return ""
5885 }
5886 return *h.URL
5887 }
5888
5889
5890 func (h *HookConfig) GetContentType() string {
5891 if h == nil || h.ContentType == nil {
5892 return ""
5893 }
5894 return *h.ContentType
5895 }
5896
5897
5898 func (h *HookConfig) GetInsecureSSL() string {
5899 if h == nil || h.InsecureSSL == nil {
5900 return ""
5901 }
5902 return *h.InsecureSSL
5903 }
5904
5905
5906 func (h *HookConfig) GetSecret() string {
5907 if h == nil || h.Secret == nil {
5908 return ""
5909 }
5910 return *h.Secret
5911 }
5912
5913
5914 func (h *HookConfig) GetURL() string {
5915 if h == nil || h.URL == nil {
5916 return ""
5917 }
5918 return *h.URL
5919 }
5920
5921
5922 func (h *HookDelivery) GetAction() string {
5923 if h == nil || h.Action == nil {
5924 return ""
5925 }
5926 return *h.Action
5927 }
5928
5929
5930 func (h *HookDelivery) GetDeliveredAt() Timestamp {
5931 if h == nil || h.DeliveredAt == nil {
5932 return Timestamp{}
5933 }
5934 return *h.DeliveredAt
5935 }
5936
5937
5938 func (h *HookDelivery) GetDuration() *float64 {
5939 if h == nil {
5940 return nil
5941 }
5942 return h.Duration
5943 }
5944
5945
5946 func (h *HookDelivery) GetEvent() string {
5947 if h == nil || h.Event == nil {
5948 return ""
5949 }
5950 return *h.Event
5951 }
5952
5953
5954 func (h *HookDelivery) GetGUID() string {
5955 if h == nil || h.GUID == nil {
5956 return ""
5957 }
5958 return *h.GUID
5959 }
5960
5961
5962 func (h *HookDelivery) GetID() int64 {
5963 if h == nil || h.ID == nil {
5964 return 0
5965 }
5966 return *h.ID
5967 }
5968
5969
5970 func (h *HookDelivery) GetInstallationID() int64 {
5971 if h == nil || h.InstallationID == nil {
5972 return 0
5973 }
5974 return *h.InstallationID
5975 }
5976
5977
5978 func (h *HookDelivery) GetRedelivery() bool {
5979 if h == nil || h.Redelivery == nil {
5980 return false
5981 }
5982 return *h.Redelivery
5983 }
5984
5985
5986 func (h *HookDelivery) GetRepositoryID() int64 {
5987 if h == nil || h.RepositoryID == nil {
5988 return 0
5989 }
5990 return *h.RepositoryID
5991 }
5992
5993
5994 func (h *HookDelivery) GetRequest() *HookRequest {
5995 if h == nil {
5996 return nil
5997 }
5998 return h.Request
5999 }
6000
6001
6002 func (h *HookDelivery) GetResponse() *HookResponse {
6003 if h == nil {
6004 return nil
6005 }
6006 return h.Response
6007 }
6008
6009
6010 func (h *HookDelivery) GetStatus() string {
6011 if h == nil || h.Status == nil {
6012 return ""
6013 }
6014 return *h.Status
6015 }
6016
6017
6018 func (h *HookDelivery) GetStatusCode() int {
6019 if h == nil || h.StatusCode == nil {
6020 return 0
6021 }
6022 return *h.StatusCode
6023 }
6024
6025
6026 func (h *HookRequest) GetHeaders() map[string]string {
6027 if h == nil || h.Headers == nil {
6028 return map[string]string{}
6029 }
6030 return h.Headers
6031 }
6032
6033
6034 func (h *HookRequest) GetRawPayload() json.RawMessage {
6035 if h == nil || h.RawPayload == nil {
6036 return json.RawMessage{}
6037 }
6038 return *h.RawPayload
6039 }
6040
6041
6042 func (h *HookResponse) GetHeaders() map[string]string {
6043 if h == nil || h.Headers == nil {
6044 return map[string]string{}
6045 }
6046 return h.Headers
6047 }
6048
6049
6050 func (h *HookResponse) GetRawPayload() json.RawMessage {
6051 if h == nil || h.RawPayload == nil {
6052 return json.RawMessage{}
6053 }
6054 return *h.RawPayload
6055 }
6056
6057
6058 func (h *HookStats) GetActiveHooks() int {
6059 if h == nil || h.ActiveHooks == nil {
6060 return 0
6061 }
6062 return *h.ActiveHooks
6063 }
6064
6065
6066 func (h *HookStats) GetInactiveHooks() int {
6067 if h == nil || h.InactiveHooks == nil {
6068 return 0
6069 }
6070 return *h.InactiveHooks
6071 }
6072
6073
6074 func (h *HookStats) GetTotalHooks() int {
6075 if h == nil || h.TotalHooks == nil {
6076 return 0
6077 }
6078 return *h.TotalHooks
6079 }
6080
6081
6082 func (i *IDPGroup) GetGroupDescription() string {
6083 if i == nil || i.GroupDescription == nil {
6084 return ""
6085 }
6086 return *i.GroupDescription
6087 }
6088
6089
6090 func (i *IDPGroup) GetGroupID() string {
6091 if i == nil || i.GroupID == nil {
6092 return ""
6093 }
6094 return *i.GroupID
6095 }
6096
6097
6098 func (i *IDPGroup) GetGroupName() string {
6099 if i == nil || i.GroupName == nil {
6100 return ""
6101 }
6102 return *i.GroupName
6103 }
6104
6105
6106 func (i *Import) GetAuthorsCount() int {
6107 if i == nil || i.AuthorsCount == nil {
6108 return 0
6109 }
6110 return *i.AuthorsCount
6111 }
6112
6113
6114 func (i *Import) GetAuthorsURL() string {
6115 if i == nil || i.AuthorsURL == nil {
6116 return ""
6117 }
6118 return *i.AuthorsURL
6119 }
6120
6121
6122 func (i *Import) GetCommitCount() int {
6123 if i == nil || i.CommitCount == nil {
6124 return 0
6125 }
6126 return *i.CommitCount
6127 }
6128
6129
6130 func (i *Import) GetFailedStep() string {
6131 if i == nil || i.FailedStep == nil {
6132 return ""
6133 }
6134 return *i.FailedStep
6135 }
6136
6137
6138 func (i *Import) GetHasLargeFiles() bool {
6139 if i == nil || i.HasLargeFiles == nil {
6140 return false
6141 }
6142 return *i.HasLargeFiles
6143 }
6144
6145
6146 func (i *Import) GetHTMLURL() string {
6147 if i == nil || i.HTMLURL == nil {
6148 return ""
6149 }
6150 return *i.HTMLURL
6151 }
6152
6153
6154 func (i *Import) GetHumanName() string {
6155 if i == nil || i.HumanName == nil {
6156 return ""
6157 }
6158 return *i.HumanName
6159 }
6160
6161
6162 func (i *Import) GetLargeFilesCount() int {
6163 if i == nil || i.LargeFilesCount == nil {
6164 return 0
6165 }
6166 return *i.LargeFilesCount
6167 }
6168
6169
6170 func (i *Import) GetLargeFilesSize() int {
6171 if i == nil || i.LargeFilesSize == nil {
6172 return 0
6173 }
6174 return *i.LargeFilesSize
6175 }
6176
6177
6178 func (i *Import) GetMessage() string {
6179 if i == nil || i.Message == nil {
6180 return ""
6181 }
6182 return *i.Message
6183 }
6184
6185
6186 func (i *Import) GetPercent() int {
6187 if i == nil || i.Percent == nil {
6188 return 0
6189 }
6190 return *i.Percent
6191 }
6192
6193
6194 func (i *Import) GetPushPercent() int {
6195 if i == nil || i.PushPercent == nil {
6196 return 0
6197 }
6198 return *i.PushPercent
6199 }
6200
6201
6202 func (i *Import) GetRepositoryURL() string {
6203 if i == nil || i.RepositoryURL == nil {
6204 return ""
6205 }
6206 return *i.RepositoryURL
6207 }
6208
6209
6210 func (i *Import) GetStatus() string {
6211 if i == nil || i.Status == nil {
6212 return ""
6213 }
6214 return *i.Status
6215 }
6216
6217
6218 func (i *Import) GetStatusText() string {
6219 if i == nil || i.StatusText == nil {
6220 return ""
6221 }
6222 return *i.StatusText
6223 }
6224
6225
6226 func (i *Import) GetTFVCProject() string {
6227 if i == nil || i.TFVCProject == nil {
6228 return ""
6229 }
6230 return *i.TFVCProject
6231 }
6232
6233
6234 func (i *Import) GetURL() string {
6235 if i == nil || i.URL == nil {
6236 return ""
6237 }
6238 return *i.URL
6239 }
6240
6241
6242 func (i *Import) GetUseLFS() string {
6243 if i == nil || i.UseLFS == nil {
6244 return ""
6245 }
6246 return *i.UseLFS
6247 }
6248
6249
6250 func (i *Import) GetVCS() string {
6251 if i == nil || i.VCS == nil {
6252 return ""
6253 }
6254 return *i.VCS
6255 }
6256
6257
6258 func (i *Import) GetVCSPassword() string {
6259 if i == nil || i.VCSPassword == nil {
6260 return ""
6261 }
6262 return *i.VCSPassword
6263 }
6264
6265
6266 func (i *Import) GetVCSURL() string {
6267 if i == nil || i.VCSURL == nil {
6268 return ""
6269 }
6270 return *i.VCSURL
6271 }
6272
6273
6274 func (i *Import) GetVCSUsername() string {
6275 if i == nil || i.VCSUsername == nil {
6276 return ""
6277 }
6278 return *i.VCSUsername
6279 }
6280
6281
6282 func (i *Installation) GetAccessTokensURL() string {
6283 if i == nil || i.AccessTokensURL == nil {
6284 return ""
6285 }
6286 return *i.AccessTokensURL
6287 }
6288
6289
6290 func (i *Installation) GetAccount() *User {
6291 if i == nil {
6292 return nil
6293 }
6294 return i.Account
6295 }
6296
6297
6298 func (i *Installation) GetAppID() int64 {
6299 if i == nil || i.AppID == nil {
6300 return 0
6301 }
6302 return *i.AppID
6303 }
6304
6305
6306 func (i *Installation) GetAppSlug() string {
6307 if i == nil || i.AppSlug == nil {
6308 return ""
6309 }
6310 return *i.AppSlug
6311 }
6312
6313
6314 func (i *Installation) GetCreatedAt() Timestamp {
6315 if i == nil || i.CreatedAt == nil {
6316 return Timestamp{}
6317 }
6318 return *i.CreatedAt
6319 }
6320
6321
6322 func (i *Installation) GetHasMultipleSingleFiles() bool {
6323 if i == nil || i.HasMultipleSingleFiles == nil {
6324 return false
6325 }
6326 return *i.HasMultipleSingleFiles
6327 }
6328
6329
6330 func (i *Installation) GetHTMLURL() string {
6331 if i == nil || i.HTMLURL == nil {
6332 return ""
6333 }
6334 return *i.HTMLURL
6335 }
6336
6337
6338 func (i *Installation) GetID() int64 {
6339 if i == nil || i.ID == nil {
6340 return 0
6341 }
6342 return *i.ID
6343 }
6344
6345
6346 func (i *Installation) GetNodeID() string {
6347 if i == nil || i.NodeID == nil {
6348 return ""
6349 }
6350 return *i.NodeID
6351 }
6352
6353
6354 func (i *Installation) GetPermissions() *InstallationPermissions {
6355 if i == nil {
6356 return nil
6357 }
6358 return i.Permissions
6359 }
6360
6361
6362 func (i *Installation) GetRepositoriesURL() string {
6363 if i == nil || i.RepositoriesURL == nil {
6364 return ""
6365 }
6366 return *i.RepositoriesURL
6367 }
6368
6369
6370 func (i *Installation) GetRepositorySelection() string {
6371 if i == nil || i.RepositorySelection == nil {
6372 return ""
6373 }
6374 return *i.RepositorySelection
6375 }
6376
6377
6378 func (i *Installation) GetSingleFileName() string {
6379 if i == nil || i.SingleFileName == nil {
6380 return ""
6381 }
6382 return *i.SingleFileName
6383 }
6384
6385
6386 func (i *Installation) GetSuspendedAt() Timestamp {
6387 if i == nil || i.SuspendedAt == nil {
6388 return Timestamp{}
6389 }
6390 return *i.SuspendedAt
6391 }
6392
6393
6394 func (i *Installation) GetSuspendedBy() *User {
6395 if i == nil {
6396 return nil
6397 }
6398 return i.SuspendedBy
6399 }
6400
6401
6402 func (i *Installation) GetTargetID() int64 {
6403 if i == nil || i.TargetID == nil {
6404 return 0
6405 }
6406 return *i.TargetID
6407 }
6408
6409
6410 func (i *Installation) GetTargetType() string {
6411 if i == nil || i.TargetType == nil {
6412 return ""
6413 }
6414 return *i.TargetType
6415 }
6416
6417
6418 func (i *Installation) GetUpdatedAt() Timestamp {
6419 if i == nil || i.UpdatedAt == nil {
6420 return Timestamp{}
6421 }
6422 return *i.UpdatedAt
6423 }
6424
6425
6426 func (i *InstallationEvent) GetAction() string {
6427 if i == nil || i.Action == nil {
6428 return ""
6429 }
6430 return *i.Action
6431 }
6432
6433
6434 func (i *InstallationEvent) GetInstallation() *Installation {
6435 if i == nil {
6436 return nil
6437 }
6438 return i.Installation
6439 }
6440
6441
6442 func (i *InstallationEvent) GetSender() *User {
6443 if i == nil {
6444 return nil
6445 }
6446 return i.Sender
6447 }
6448
6449
6450 func (i *InstallationPermissions) GetActions() string {
6451 if i == nil || i.Actions == nil {
6452 return ""
6453 }
6454 return *i.Actions
6455 }
6456
6457
6458 func (i *InstallationPermissions) GetAdministration() string {
6459 if i == nil || i.Administration == nil {
6460 return ""
6461 }
6462 return *i.Administration
6463 }
6464
6465
6466 func (i *InstallationPermissions) GetBlocking() string {
6467 if i == nil || i.Blocking == nil {
6468 return ""
6469 }
6470 return *i.Blocking
6471 }
6472
6473
6474 func (i *InstallationPermissions) GetChecks() string {
6475 if i == nil || i.Checks == nil {
6476 return ""
6477 }
6478 return *i.Checks
6479 }
6480
6481
6482 func (i *InstallationPermissions) GetContentReferences() string {
6483 if i == nil || i.ContentReferences == nil {
6484 return ""
6485 }
6486 return *i.ContentReferences
6487 }
6488
6489
6490 func (i *InstallationPermissions) GetContents() string {
6491 if i == nil || i.Contents == nil {
6492 return ""
6493 }
6494 return *i.Contents
6495 }
6496
6497
6498 func (i *InstallationPermissions) GetDeployments() string {
6499 if i == nil || i.Deployments == nil {
6500 return ""
6501 }
6502 return *i.Deployments
6503 }
6504
6505
6506 func (i *InstallationPermissions) GetEmails() string {
6507 if i == nil || i.Emails == nil {
6508 return ""
6509 }
6510 return *i.Emails
6511 }
6512
6513
6514 func (i *InstallationPermissions) GetEnvironments() string {
6515 if i == nil || i.Environments == nil {
6516 return ""
6517 }
6518 return *i.Environments
6519 }
6520
6521
6522 func (i *InstallationPermissions) GetFollowers() string {
6523 if i == nil || i.Followers == nil {
6524 return ""
6525 }
6526 return *i.Followers
6527 }
6528
6529
6530 func (i *InstallationPermissions) GetIssues() string {
6531 if i == nil || i.Issues == nil {
6532 return ""
6533 }
6534 return *i.Issues
6535 }
6536
6537
6538 func (i *InstallationPermissions) GetMembers() string {
6539 if i == nil || i.Members == nil {
6540 return ""
6541 }
6542 return *i.Members
6543 }
6544
6545
6546 func (i *InstallationPermissions) GetMetadata() string {
6547 if i == nil || i.Metadata == nil {
6548 return ""
6549 }
6550 return *i.Metadata
6551 }
6552
6553
6554 func (i *InstallationPermissions) GetOrganizationAdministration() string {
6555 if i == nil || i.OrganizationAdministration == nil {
6556 return ""
6557 }
6558 return *i.OrganizationAdministration
6559 }
6560
6561
6562 func (i *InstallationPermissions) GetOrganizationHooks() string {
6563 if i == nil || i.OrganizationHooks == nil {
6564 return ""
6565 }
6566 return *i.OrganizationHooks
6567 }
6568
6569
6570 func (i *InstallationPermissions) GetOrganizationPlan() string {
6571 if i == nil || i.OrganizationPlan == nil {
6572 return ""
6573 }
6574 return *i.OrganizationPlan
6575 }
6576
6577
6578 func (i *InstallationPermissions) GetOrganizationPreReceiveHooks() string {
6579 if i == nil || i.OrganizationPreReceiveHooks == nil {
6580 return ""
6581 }
6582 return *i.OrganizationPreReceiveHooks
6583 }
6584
6585
6586 func (i *InstallationPermissions) GetOrganizationProjects() string {
6587 if i == nil || i.OrganizationProjects == nil {
6588 return ""
6589 }
6590 return *i.OrganizationProjects
6591 }
6592
6593
6594 func (i *InstallationPermissions) GetOrganizationSecrets() string {
6595 if i == nil || i.OrganizationSecrets == nil {
6596 return ""
6597 }
6598 return *i.OrganizationSecrets
6599 }
6600
6601
6602 func (i *InstallationPermissions) GetOrganizationSelfHostedRunners() string {
6603 if i == nil || i.OrganizationSelfHostedRunners == nil {
6604 return ""
6605 }
6606 return *i.OrganizationSelfHostedRunners
6607 }
6608
6609
6610 func (i *InstallationPermissions) GetOrganizationUserBlocking() string {
6611 if i == nil || i.OrganizationUserBlocking == nil {
6612 return ""
6613 }
6614 return *i.OrganizationUserBlocking
6615 }
6616
6617
6618 func (i *InstallationPermissions) GetPackages() string {
6619 if i == nil || i.Packages == nil {
6620 return ""
6621 }
6622 return *i.Packages
6623 }
6624
6625
6626 func (i *InstallationPermissions) GetPages() string {
6627 if i == nil || i.Pages == nil {
6628 return ""
6629 }
6630 return *i.Pages
6631 }
6632
6633
6634 func (i *InstallationPermissions) GetPullRequests() string {
6635 if i == nil || i.PullRequests == nil {
6636 return ""
6637 }
6638 return *i.PullRequests
6639 }
6640
6641
6642 func (i *InstallationPermissions) GetRepositoryHooks() string {
6643 if i == nil || i.RepositoryHooks == nil {
6644 return ""
6645 }
6646 return *i.RepositoryHooks
6647 }
6648
6649
6650 func (i *InstallationPermissions) GetRepositoryPreReceiveHooks() string {
6651 if i == nil || i.RepositoryPreReceiveHooks == nil {
6652 return ""
6653 }
6654 return *i.RepositoryPreReceiveHooks
6655 }
6656
6657
6658 func (i *InstallationPermissions) GetRepositoryProjects() string {
6659 if i == nil || i.RepositoryProjects == nil {
6660 return ""
6661 }
6662 return *i.RepositoryProjects
6663 }
6664
6665
6666 func (i *InstallationPermissions) GetSecrets() string {
6667 if i == nil || i.Secrets == nil {
6668 return ""
6669 }
6670 return *i.Secrets
6671 }
6672
6673
6674 func (i *InstallationPermissions) GetSecretScanningAlerts() string {
6675 if i == nil || i.SecretScanningAlerts == nil {
6676 return ""
6677 }
6678 return *i.SecretScanningAlerts
6679 }
6680
6681
6682 func (i *InstallationPermissions) GetSecurityEvents() string {
6683 if i == nil || i.SecurityEvents == nil {
6684 return ""
6685 }
6686 return *i.SecurityEvents
6687 }
6688
6689
6690 func (i *InstallationPermissions) GetSingleFile() string {
6691 if i == nil || i.SingleFile == nil {
6692 return ""
6693 }
6694 return *i.SingleFile
6695 }
6696
6697
6698 func (i *InstallationPermissions) GetStatuses() string {
6699 if i == nil || i.Statuses == nil {
6700 return ""
6701 }
6702 return *i.Statuses
6703 }
6704
6705
6706 func (i *InstallationPermissions) GetTeamDiscussions() string {
6707 if i == nil || i.TeamDiscussions == nil {
6708 return ""
6709 }
6710 return *i.TeamDiscussions
6711 }
6712
6713
6714 func (i *InstallationPermissions) GetVulnerabilityAlerts() string {
6715 if i == nil || i.VulnerabilityAlerts == nil {
6716 return ""
6717 }
6718 return *i.VulnerabilityAlerts
6719 }
6720
6721
6722 func (i *InstallationPermissions) GetWorkflows() string {
6723 if i == nil || i.Workflows == nil {
6724 return ""
6725 }
6726 return *i.Workflows
6727 }
6728
6729
6730 func (i *InstallationRepositoriesEvent) GetAction() string {
6731 if i == nil || i.Action == nil {
6732 return ""
6733 }
6734 return *i.Action
6735 }
6736
6737
6738 func (i *InstallationRepositoriesEvent) GetInstallation() *Installation {
6739 if i == nil {
6740 return nil
6741 }
6742 return i.Installation
6743 }
6744
6745
6746 func (i *InstallationRepositoriesEvent) GetRepositorySelection() string {
6747 if i == nil || i.RepositorySelection == nil {
6748 return ""
6749 }
6750 return *i.RepositorySelection
6751 }
6752
6753
6754 func (i *InstallationRepositoriesEvent) GetSender() *User {
6755 if i == nil {
6756 return nil
6757 }
6758 return i.Sender
6759 }
6760
6761
6762 func (i *InstallationToken) GetExpiresAt() time.Time {
6763 if i == nil || i.ExpiresAt == nil {
6764 return time.Time{}
6765 }
6766 return *i.ExpiresAt
6767 }
6768
6769
6770 func (i *InstallationToken) GetPermissions() *InstallationPermissions {
6771 if i == nil {
6772 return nil
6773 }
6774 return i.Permissions
6775 }
6776
6777
6778 func (i *InstallationToken) GetToken() string {
6779 if i == nil || i.Token == nil {
6780 return ""
6781 }
6782 return *i.Token
6783 }
6784
6785
6786 func (i *InstallationTokenOptions) GetPermissions() *InstallationPermissions {
6787 if i == nil {
6788 return nil
6789 }
6790 return i.Permissions
6791 }
6792
6793
6794 func (i *InteractionRestriction) GetExpiresAt() Timestamp {
6795 if i == nil || i.ExpiresAt == nil {
6796 return Timestamp{}
6797 }
6798 return *i.ExpiresAt
6799 }
6800
6801
6802 func (i *InteractionRestriction) GetLimit() string {
6803 if i == nil || i.Limit == nil {
6804 return ""
6805 }
6806 return *i.Limit
6807 }
6808
6809
6810 func (i *InteractionRestriction) GetOrigin() string {
6811 if i == nil || i.Origin == nil {
6812 return ""
6813 }
6814 return *i.Origin
6815 }
6816
6817
6818 func (i *Invitation) GetCreatedAt() time.Time {
6819 if i == nil || i.CreatedAt == nil {
6820 return time.Time{}
6821 }
6822 return *i.CreatedAt
6823 }
6824
6825
6826 func (i *Invitation) GetEmail() string {
6827 if i == nil || i.Email == nil {
6828 return ""
6829 }
6830 return *i.Email
6831 }
6832
6833
6834 func (i *Invitation) GetFailedAt() Timestamp {
6835 if i == nil || i.FailedAt == nil {
6836 return Timestamp{}
6837 }
6838 return *i.FailedAt
6839 }
6840
6841
6842 func (i *Invitation) GetFailedReason() string {
6843 if i == nil || i.FailedReason == nil {
6844 return ""
6845 }
6846 return *i.FailedReason
6847 }
6848
6849
6850 func (i *Invitation) GetID() int64 {
6851 if i == nil || i.ID == nil {
6852 return 0
6853 }
6854 return *i.ID
6855 }
6856
6857
6858 func (i *Invitation) GetInvitationTeamURL() string {
6859 if i == nil || i.InvitationTeamURL == nil {
6860 return ""
6861 }
6862 return *i.InvitationTeamURL
6863 }
6864
6865
6866 func (i *Invitation) GetInviter() *User {
6867 if i == nil {
6868 return nil
6869 }
6870 return i.Inviter
6871 }
6872
6873
6874 func (i *Invitation) GetLogin() string {
6875 if i == nil || i.Login == nil {
6876 return ""
6877 }
6878 return *i.Login
6879 }
6880
6881
6882 func (i *Invitation) GetNodeID() string {
6883 if i == nil || i.NodeID == nil {
6884 return ""
6885 }
6886 return *i.NodeID
6887 }
6888
6889
6890 func (i *Invitation) GetRole() string {
6891 if i == nil || i.Role == nil {
6892 return ""
6893 }
6894 return *i.Role
6895 }
6896
6897
6898 func (i *Invitation) GetTeamCount() int {
6899 if i == nil || i.TeamCount == nil {
6900 return 0
6901 }
6902 return *i.TeamCount
6903 }
6904
6905
6906 func (i *Issue) GetActiveLockReason() string {
6907 if i == nil || i.ActiveLockReason == nil {
6908 return ""
6909 }
6910 return *i.ActiveLockReason
6911 }
6912
6913
6914 func (i *Issue) GetAssignee() *User {
6915 if i == nil {
6916 return nil
6917 }
6918 return i.Assignee
6919 }
6920
6921
6922 func (i *Issue) GetAuthorAssociation() string {
6923 if i == nil || i.AuthorAssociation == nil {
6924 return ""
6925 }
6926 return *i.AuthorAssociation
6927 }
6928
6929
6930 func (i *Issue) GetBody() string {
6931 if i == nil || i.Body == nil {
6932 return ""
6933 }
6934 return *i.Body
6935 }
6936
6937
6938 func (i *Issue) GetClosedAt() time.Time {
6939 if i == nil || i.ClosedAt == nil {
6940 return time.Time{}
6941 }
6942 return *i.ClosedAt
6943 }
6944
6945
6946 func (i *Issue) GetClosedBy() *User {
6947 if i == nil {
6948 return nil
6949 }
6950 return i.ClosedBy
6951 }
6952
6953
6954 func (i *Issue) GetComments() int {
6955 if i == nil || i.Comments == nil {
6956 return 0
6957 }
6958 return *i.Comments
6959 }
6960
6961
6962 func (i *Issue) GetCommentsURL() string {
6963 if i == nil || i.CommentsURL == nil {
6964 return ""
6965 }
6966 return *i.CommentsURL
6967 }
6968
6969
6970 func (i *Issue) GetCreatedAt() time.Time {
6971 if i == nil || i.CreatedAt == nil {
6972 return time.Time{}
6973 }
6974 return *i.CreatedAt
6975 }
6976
6977
6978 func (i *Issue) GetEventsURL() string {
6979 if i == nil || i.EventsURL == nil {
6980 return ""
6981 }
6982 return *i.EventsURL
6983 }
6984
6985
6986 func (i *Issue) GetHTMLURL() string {
6987 if i == nil || i.HTMLURL == nil {
6988 return ""
6989 }
6990 return *i.HTMLURL
6991 }
6992
6993
6994 func (i *Issue) GetID() int64 {
6995 if i == nil || i.ID == nil {
6996 return 0
6997 }
6998 return *i.ID
6999 }
7000
7001
7002 func (i *Issue) GetLabelsURL() string {
7003 if i == nil || i.LabelsURL == nil {
7004 return ""
7005 }
7006 return *i.LabelsURL
7007 }
7008
7009
7010 func (i *Issue) GetLocked() bool {
7011 if i == nil || i.Locked == nil {
7012 return false
7013 }
7014 return *i.Locked
7015 }
7016
7017
7018 func (i *Issue) GetMilestone() *Milestone {
7019 if i == nil {
7020 return nil
7021 }
7022 return i.Milestone
7023 }
7024
7025
7026 func (i *Issue) GetNodeID() string {
7027 if i == nil || i.NodeID == nil {
7028 return ""
7029 }
7030 return *i.NodeID
7031 }
7032
7033
7034 func (i *Issue) GetNumber() int {
7035 if i == nil || i.Number == nil {
7036 return 0
7037 }
7038 return *i.Number
7039 }
7040
7041
7042 func (i *Issue) GetPullRequestLinks() *PullRequestLinks {
7043 if i == nil {
7044 return nil
7045 }
7046 return i.PullRequestLinks
7047 }
7048
7049
7050 func (i *Issue) GetReactions() *Reactions {
7051 if i == nil {
7052 return nil
7053 }
7054 return i.Reactions
7055 }
7056
7057
7058 func (i *Issue) GetRepository() *Repository {
7059 if i == nil {
7060 return nil
7061 }
7062 return i.Repository
7063 }
7064
7065
7066 func (i *Issue) GetRepositoryURL() string {
7067 if i == nil || i.RepositoryURL == nil {
7068 return ""
7069 }
7070 return *i.RepositoryURL
7071 }
7072
7073
7074 func (i *Issue) GetState() string {
7075 if i == nil || i.State == nil {
7076 return ""
7077 }
7078 return *i.State
7079 }
7080
7081
7082 func (i *Issue) GetTitle() string {
7083 if i == nil || i.Title == nil {
7084 return ""
7085 }
7086 return *i.Title
7087 }
7088
7089
7090 func (i *Issue) GetUpdatedAt() time.Time {
7091 if i == nil || i.UpdatedAt == nil {
7092 return time.Time{}
7093 }
7094 return *i.UpdatedAt
7095 }
7096
7097
7098 func (i *Issue) GetURL() string {
7099 if i == nil || i.URL == nil {
7100 return ""
7101 }
7102 return *i.URL
7103 }
7104
7105
7106 func (i *Issue) GetUser() *User {
7107 if i == nil {
7108 return nil
7109 }
7110 return i.User
7111 }
7112
7113
7114 func (i *IssueComment) GetAuthorAssociation() string {
7115 if i == nil || i.AuthorAssociation == nil {
7116 return ""
7117 }
7118 return *i.AuthorAssociation
7119 }
7120
7121
7122 func (i *IssueComment) GetBody() string {
7123 if i == nil || i.Body == nil {
7124 return ""
7125 }
7126 return *i.Body
7127 }
7128
7129
7130 func (i *IssueComment) GetCreatedAt() time.Time {
7131 if i == nil || i.CreatedAt == nil {
7132 return time.Time{}
7133 }
7134 return *i.CreatedAt
7135 }
7136
7137
7138 func (i *IssueComment) GetHTMLURL() string {
7139 if i == nil || i.HTMLURL == nil {
7140 return ""
7141 }
7142 return *i.HTMLURL
7143 }
7144
7145
7146 func (i *IssueComment) GetID() int64 {
7147 if i == nil || i.ID == nil {
7148 return 0
7149 }
7150 return *i.ID
7151 }
7152
7153
7154 func (i *IssueComment) GetIssueURL() string {
7155 if i == nil || i.IssueURL == nil {
7156 return ""
7157 }
7158 return *i.IssueURL
7159 }
7160
7161
7162 func (i *IssueComment) GetNodeID() string {
7163 if i == nil || i.NodeID == nil {
7164 return ""
7165 }
7166 return *i.NodeID
7167 }
7168
7169
7170 func (i *IssueComment) GetReactions() *Reactions {
7171 if i == nil {
7172 return nil
7173 }
7174 return i.Reactions
7175 }
7176
7177
7178 func (i *IssueComment) GetUpdatedAt() time.Time {
7179 if i == nil || i.UpdatedAt == nil {
7180 return time.Time{}
7181 }
7182 return *i.UpdatedAt
7183 }
7184
7185
7186 func (i *IssueComment) GetURL() string {
7187 if i == nil || i.URL == nil {
7188 return ""
7189 }
7190 return *i.URL
7191 }
7192
7193
7194 func (i *IssueComment) GetUser() *User {
7195 if i == nil {
7196 return nil
7197 }
7198 return i.User
7199 }
7200
7201
7202 func (i *IssueCommentEvent) GetAction() string {
7203 if i == nil || i.Action == nil {
7204 return ""
7205 }
7206 return *i.Action
7207 }
7208
7209
7210 func (i *IssueCommentEvent) GetChanges() *EditChange {
7211 if i == nil {
7212 return nil
7213 }
7214 return i.Changes
7215 }
7216
7217
7218 func (i *IssueCommentEvent) GetComment() *IssueComment {
7219 if i == nil {
7220 return nil
7221 }
7222 return i.Comment
7223 }
7224
7225
7226 func (i *IssueCommentEvent) GetInstallation() *Installation {
7227 if i == nil {
7228 return nil
7229 }
7230 return i.Installation
7231 }
7232
7233
7234 func (i *IssueCommentEvent) GetIssue() *Issue {
7235 if i == nil {
7236 return nil
7237 }
7238 return i.Issue
7239 }
7240
7241
7242 func (i *IssueCommentEvent) GetOrganization() *Organization {
7243 if i == nil {
7244 return nil
7245 }
7246 return i.Organization
7247 }
7248
7249
7250 func (i *IssueCommentEvent) GetRepo() *Repository {
7251 if i == nil {
7252 return nil
7253 }
7254 return i.Repo
7255 }
7256
7257
7258 func (i *IssueCommentEvent) GetSender() *User {
7259 if i == nil {
7260 return nil
7261 }
7262 return i.Sender
7263 }
7264
7265
7266 func (i *IssueEvent) GetActor() *User {
7267 if i == nil {
7268 return nil
7269 }
7270 return i.Actor
7271 }
7272
7273
7274 func (i *IssueEvent) GetAssignee() *User {
7275 if i == nil {
7276 return nil
7277 }
7278 return i.Assignee
7279 }
7280
7281
7282 func (i *IssueEvent) GetAssigner() *User {
7283 if i == nil {
7284 return nil
7285 }
7286 return i.Assigner
7287 }
7288
7289
7290 func (i *IssueEvent) GetCommitID() string {
7291 if i == nil || i.CommitID == nil {
7292 return ""
7293 }
7294 return *i.CommitID
7295 }
7296
7297
7298 func (i *IssueEvent) GetCreatedAt() time.Time {
7299 if i == nil || i.CreatedAt == nil {
7300 return time.Time{}
7301 }
7302 return *i.CreatedAt
7303 }
7304
7305
7306 func (i *IssueEvent) GetDismissedReview() *DismissedReview {
7307 if i == nil {
7308 return nil
7309 }
7310 return i.DismissedReview
7311 }
7312
7313
7314 func (i *IssueEvent) GetEvent() string {
7315 if i == nil || i.Event == nil {
7316 return ""
7317 }
7318 return *i.Event
7319 }
7320
7321
7322 func (i *IssueEvent) GetID() int64 {
7323 if i == nil || i.ID == nil {
7324 return 0
7325 }
7326 return *i.ID
7327 }
7328
7329
7330 func (i *IssueEvent) GetIssue() *Issue {
7331 if i == nil {
7332 return nil
7333 }
7334 return i.Issue
7335 }
7336
7337
7338 func (i *IssueEvent) GetLabel() *Label {
7339 if i == nil {
7340 return nil
7341 }
7342 return i.Label
7343 }
7344
7345
7346 func (i *IssueEvent) GetLockReason() string {
7347 if i == nil || i.LockReason == nil {
7348 return ""
7349 }
7350 return *i.LockReason
7351 }
7352
7353
7354 func (i *IssueEvent) GetMilestone() *Milestone {
7355 if i == nil {
7356 return nil
7357 }
7358 return i.Milestone
7359 }
7360
7361
7362 func (i *IssueEvent) GetProjectCard() *ProjectCard {
7363 if i == nil {
7364 return nil
7365 }
7366 return i.ProjectCard
7367 }
7368
7369
7370 func (i *IssueEvent) GetRename() *Rename {
7371 if i == nil {
7372 return nil
7373 }
7374 return i.Rename
7375 }
7376
7377
7378 func (i *IssueEvent) GetRequestedReviewer() *User {
7379 if i == nil {
7380 return nil
7381 }
7382 return i.RequestedReviewer
7383 }
7384
7385
7386 func (i *IssueEvent) GetReviewRequester() *User {
7387 if i == nil {
7388 return nil
7389 }
7390 return i.ReviewRequester
7391 }
7392
7393
7394 func (i *IssueEvent) GetURL() string {
7395 if i == nil || i.URL == nil {
7396 return ""
7397 }
7398 return *i.URL
7399 }
7400
7401
7402 func (i *IssueImport) GetAssignee() string {
7403 if i == nil || i.Assignee == nil {
7404 return ""
7405 }
7406 return *i.Assignee
7407 }
7408
7409
7410 func (i *IssueImport) GetClosed() bool {
7411 if i == nil || i.Closed == nil {
7412 return false
7413 }
7414 return *i.Closed
7415 }
7416
7417
7418 func (i *IssueImport) GetClosedAt() time.Time {
7419 if i == nil || i.ClosedAt == nil {
7420 return time.Time{}
7421 }
7422 return *i.ClosedAt
7423 }
7424
7425
7426 func (i *IssueImport) GetCreatedAt() time.Time {
7427 if i == nil || i.CreatedAt == nil {
7428 return time.Time{}
7429 }
7430 return *i.CreatedAt
7431 }
7432
7433
7434 func (i *IssueImport) GetMilestone() int {
7435 if i == nil || i.Milestone == nil {
7436 return 0
7437 }
7438 return *i.Milestone
7439 }
7440
7441
7442 func (i *IssueImport) GetUpdatedAt() time.Time {
7443 if i == nil || i.UpdatedAt == nil {
7444 return time.Time{}
7445 }
7446 return *i.UpdatedAt
7447 }
7448
7449
7450 func (i *IssueImportError) GetCode() string {
7451 if i == nil || i.Code == nil {
7452 return ""
7453 }
7454 return *i.Code
7455 }
7456
7457
7458 func (i *IssueImportError) GetField() string {
7459 if i == nil || i.Field == nil {
7460 return ""
7461 }
7462 return *i.Field
7463 }
7464
7465
7466 func (i *IssueImportError) GetLocation() string {
7467 if i == nil || i.Location == nil {
7468 return ""
7469 }
7470 return *i.Location
7471 }
7472
7473
7474 func (i *IssueImportError) GetResource() string {
7475 if i == nil || i.Resource == nil {
7476 return ""
7477 }
7478 return *i.Resource
7479 }
7480
7481
7482 func (i *IssueImportError) GetValue() string {
7483 if i == nil || i.Value == nil {
7484 return ""
7485 }
7486 return *i.Value
7487 }
7488
7489
7490 func (i *IssueImportResponse) GetCreatedAt() time.Time {
7491 if i == nil || i.CreatedAt == nil {
7492 return time.Time{}
7493 }
7494 return *i.CreatedAt
7495 }
7496
7497
7498 func (i *IssueImportResponse) GetDocumentationURL() string {
7499 if i == nil || i.DocumentationURL == nil {
7500 return ""
7501 }
7502 return *i.DocumentationURL
7503 }
7504
7505
7506 func (i *IssueImportResponse) GetID() int {
7507 if i == nil || i.ID == nil {
7508 return 0
7509 }
7510 return *i.ID
7511 }
7512
7513
7514 func (i *IssueImportResponse) GetImportIssuesURL() string {
7515 if i == nil || i.ImportIssuesURL == nil {
7516 return ""
7517 }
7518 return *i.ImportIssuesURL
7519 }
7520
7521
7522 func (i *IssueImportResponse) GetMessage() string {
7523 if i == nil || i.Message == nil {
7524 return ""
7525 }
7526 return *i.Message
7527 }
7528
7529
7530 func (i *IssueImportResponse) GetRepositoryURL() string {
7531 if i == nil || i.RepositoryURL == nil {
7532 return ""
7533 }
7534 return *i.RepositoryURL
7535 }
7536
7537
7538 func (i *IssueImportResponse) GetStatus() string {
7539 if i == nil || i.Status == nil {
7540 return ""
7541 }
7542 return *i.Status
7543 }
7544
7545
7546 func (i *IssueImportResponse) GetUpdatedAt() time.Time {
7547 if i == nil || i.UpdatedAt == nil {
7548 return time.Time{}
7549 }
7550 return *i.UpdatedAt
7551 }
7552
7553
7554 func (i *IssueImportResponse) GetURL() string {
7555 if i == nil || i.URL == nil {
7556 return ""
7557 }
7558 return *i.URL
7559 }
7560
7561
7562 func (i *IssueListCommentsOptions) GetDirection() string {
7563 if i == nil || i.Direction == nil {
7564 return ""
7565 }
7566 return *i.Direction
7567 }
7568
7569
7570 func (i *IssueListCommentsOptions) GetSince() time.Time {
7571 if i == nil || i.Since == nil {
7572 return time.Time{}
7573 }
7574 return *i.Since
7575 }
7576
7577
7578 func (i *IssueListCommentsOptions) GetSort() string {
7579 if i == nil || i.Sort == nil {
7580 return ""
7581 }
7582 return *i.Sort
7583 }
7584
7585
7586 func (i *IssueRequest) GetAssignee() string {
7587 if i == nil || i.Assignee == nil {
7588 return ""
7589 }
7590 return *i.Assignee
7591 }
7592
7593
7594 func (i *IssueRequest) GetAssignees() []string {
7595 if i == nil || i.Assignees == nil {
7596 return nil
7597 }
7598 return *i.Assignees
7599 }
7600
7601
7602 func (i *IssueRequest) GetBody() string {
7603 if i == nil || i.Body == nil {
7604 return ""
7605 }
7606 return *i.Body
7607 }
7608
7609
7610 func (i *IssueRequest) GetLabels() []string {
7611 if i == nil || i.Labels == nil {
7612 return nil
7613 }
7614 return *i.Labels
7615 }
7616
7617
7618 func (i *IssueRequest) GetMilestone() int {
7619 if i == nil || i.Milestone == nil {
7620 return 0
7621 }
7622 return *i.Milestone
7623 }
7624
7625
7626 func (i *IssueRequest) GetState() string {
7627 if i == nil || i.State == nil {
7628 return ""
7629 }
7630 return *i.State
7631 }
7632
7633
7634 func (i *IssueRequest) GetTitle() string {
7635 if i == nil || i.Title == nil {
7636 return ""
7637 }
7638 return *i.Title
7639 }
7640
7641
7642 func (i *IssuesEvent) GetAction() string {
7643 if i == nil || i.Action == nil {
7644 return ""
7645 }
7646 return *i.Action
7647 }
7648
7649
7650 func (i *IssuesEvent) GetAssignee() *User {
7651 if i == nil {
7652 return nil
7653 }
7654 return i.Assignee
7655 }
7656
7657
7658 func (i *IssuesEvent) GetChanges() *EditChange {
7659 if i == nil {
7660 return nil
7661 }
7662 return i.Changes
7663 }
7664
7665
7666 func (i *IssuesEvent) GetInstallation() *Installation {
7667 if i == nil {
7668 return nil
7669 }
7670 return i.Installation
7671 }
7672
7673
7674 func (i *IssuesEvent) GetIssue() *Issue {
7675 if i == nil {
7676 return nil
7677 }
7678 return i.Issue
7679 }
7680
7681
7682 func (i *IssuesEvent) GetLabel() *Label {
7683 if i == nil {
7684 return nil
7685 }
7686 return i.Label
7687 }
7688
7689
7690 func (i *IssuesEvent) GetRepo() *Repository {
7691 if i == nil {
7692 return nil
7693 }
7694 return i.Repo
7695 }
7696
7697
7698 func (i *IssuesEvent) GetSender() *User {
7699 if i == nil {
7700 return nil
7701 }
7702 return i.Sender
7703 }
7704
7705
7706 func (i *IssuesSearchResult) GetIncompleteResults() bool {
7707 if i == nil || i.IncompleteResults == nil {
7708 return false
7709 }
7710 return *i.IncompleteResults
7711 }
7712
7713
7714 func (i *IssuesSearchResult) GetTotal() int {
7715 if i == nil || i.Total == nil {
7716 return 0
7717 }
7718 return *i.Total
7719 }
7720
7721
7722 func (i *IssueStats) GetClosedIssues() int {
7723 if i == nil || i.ClosedIssues == nil {
7724 return 0
7725 }
7726 return *i.ClosedIssues
7727 }
7728
7729
7730 func (i *IssueStats) GetOpenIssues() int {
7731 if i == nil || i.OpenIssues == nil {
7732 return 0
7733 }
7734 return *i.OpenIssues
7735 }
7736
7737
7738 func (i *IssueStats) GetTotalIssues() int {
7739 if i == nil || i.TotalIssues == nil {
7740 return 0
7741 }
7742 return *i.TotalIssues
7743 }
7744
7745
7746 func (j *Jobs) GetTotalCount() int {
7747 if j == nil || j.TotalCount == nil {
7748 return 0
7749 }
7750 return *j.TotalCount
7751 }
7752
7753
7754 func (k *Key) GetCreatedAt() Timestamp {
7755 if k == nil || k.CreatedAt == nil {
7756 return Timestamp{}
7757 }
7758 return *k.CreatedAt
7759 }
7760
7761
7762 func (k *Key) GetID() int64 {
7763 if k == nil || k.ID == nil {
7764 return 0
7765 }
7766 return *k.ID
7767 }
7768
7769
7770 func (k *Key) GetKey() string {
7771 if k == nil || k.Key == nil {
7772 return ""
7773 }
7774 return *k.Key
7775 }
7776
7777
7778 func (k *Key) GetReadOnly() bool {
7779 if k == nil || k.ReadOnly == nil {
7780 return false
7781 }
7782 return *k.ReadOnly
7783 }
7784
7785
7786 func (k *Key) GetTitle() string {
7787 if k == nil || k.Title == nil {
7788 return ""
7789 }
7790 return *k.Title
7791 }
7792
7793
7794 func (k *Key) GetURL() string {
7795 if k == nil || k.URL == nil {
7796 return ""
7797 }
7798 return *k.URL
7799 }
7800
7801
7802 func (k *Key) GetVerified() bool {
7803 if k == nil || k.Verified == nil {
7804 return false
7805 }
7806 return *k.Verified
7807 }
7808
7809
7810 func (l *Label) GetColor() string {
7811 if l == nil || l.Color == nil {
7812 return ""
7813 }
7814 return *l.Color
7815 }
7816
7817
7818 func (l *Label) GetDefault() bool {
7819 if l == nil || l.Default == nil {
7820 return false
7821 }
7822 return *l.Default
7823 }
7824
7825
7826 func (l *Label) GetDescription() string {
7827 if l == nil || l.Description == nil {
7828 return ""
7829 }
7830 return *l.Description
7831 }
7832
7833
7834 func (l *Label) GetID() int64 {
7835 if l == nil || l.ID == nil {
7836 return 0
7837 }
7838 return *l.ID
7839 }
7840
7841
7842 func (l *Label) GetName() string {
7843 if l == nil || l.Name == nil {
7844 return ""
7845 }
7846 return *l.Name
7847 }
7848
7849
7850 func (l *Label) GetNodeID() string {
7851 if l == nil || l.NodeID == nil {
7852 return ""
7853 }
7854 return *l.NodeID
7855 }
7856
7857
7858 func (l *Label) GetURL() string {
7859 if l == nil || l.URL == nil {
7860 return ""
7861 }
7862 return *l.URL
7863 }
7864
7865
7866 func (l *LabelEvent) GetAction() string {
7867 if l == nil || l.Action == nil {
7868 return ""
7869 }
7870 return *l.Action
7871 }
7872
7873
7874 func (l *LabelEvent) GetChanges() *EditChange {
7875 if l == nil {
7876 return nil
7877 }
7878 return l.Changes
7879 }
7880
7881
7882 func (l *LabelEvent) GetInstallation() *Installation {
7883 if l == nil {
7884 return nil
7885 }
7886 return l.Installation
7887 }
7888
7889
7890 func (l *LabelEvent) GetLabel() *Label {
7891 if l == nil {
7892 return nil
7893 }
7894 return l.Label
7895 }
7896
7897
7898 func (l *LabelEvent) GetOrg() *Organization {
7899 if l == nil {
7900 return nil
7901 }
7902 return l.Org
7903 }
7904
7905
7906 func (l *LabelEvent) GetRepo() *Repository {
7907 if l == nil {
7908 return nil
7909 }
7910 return l.Repo
7911 }
7912
7913
7914 func (l *LabelEvent) GetSender() *User {
7915 if l == nil {
7916 return nil
7917 }
7918 return l.Sender
7919 }
7920
7921
7922 func (l *LabelResult) GetColor() string {
7923 if l == nil || l.Color == nil {
7924 return ""
7925 }
7926 return *l.Color
7927 }
7928
7929
7930 func (l *LabelResult) GetDefault() bool {
7931 if l == nil || l.Default == nil {
7932 return false
7933 }
7934 return *l.Default
7935 }
7936
7937
7938 func (l *LabelResult) GetDescription() string {
7939 if l == nil || l.Description == nil {
7940 return ""
7941 }
7942 return *l.Description
7943 }
7944
7945
7946 func (l *LabelResult) GetID() int64 {
7947 if l == nil || l.ID == nil {
7948 return 0
7949 }
7950 return *l.ID
7951 }
7952
7953
7954 func (l *LabelResult) GetName() string {
7955 if l == nil || l.Name == nil {
7956 return ""
7957 }
7958 return *l.Name
7959 }
7960
7961
7962 func (l *LabelResult) GetScore() *float64 {
7963 if l == nil {
7964 return nil
7965 }
7966 return l.Score
7967 }
7968
7969
7970 func (l *LabelResult) GetURL() string {
7971 if l == nil || l.URL == nil {
7972 return ""
7973 }
7974 return *l.URL
7975 }
7976
7977
7978 func (l *LabelsSearchResult) GetIncompleteResults() bool {
7979 if l == nil || l.IncompleteResults == nil {
7980 return false
7981 }
7982 return *l.IncompleteResults
7983 }
7984
7985
7986 func (l *LabelsSearchResult) GetTotal() int {
7987 if l == nil || l.Total == nil {
7988 return 0
7989 }
7990 return *l.Total
7991 }
7992
7993
7994 func (l *LargeFile) GetOID() string {
7995 if l == nil || l.OID == nil {
7996 return ""
7997 }
7998 return *l.OID
7999 }
8000
8001
8002 func (l *LargeFile) GetPath() string {
8003 if l == nil || l.Path == nil {
8004 return ""
8005 }
8006 return *l.Path
8007 }
8008
8009
8010 func (l *LargeFile) GetRefName() string {
8011 if l == nil || l.RefName == nil {
8012 return ""
8013 }
8014 return *l.RefName
8015 }
8016
8017
8018 func (l *LargeFile) GetSize() int {
8019 if l == nil || l.Size == nil {
8020 return 0
8021 }
8022 return *l.Size
8023 }
8024
8025
8026 func (l *License) GetBody() string {
8027 if l == nil || l.Body == nil {
8028 return ""
8029 }
8030 return *l.Body
8031 }
8032
8033
8034 func (l *License) GetConditions() []string {
8035 if l == nil || l.Conditions == nil {
8036 return nil
8037 }
8038 return *l.Conditions
8039 }
8040
8041
8042 func (l *License) GetDescription() string {
8043 if l == nil || l.Description == nil {
8044 return ""
8045 }
8046 return *l.Description
8047 }
8048
8049
8050 func (l *License) GetFeatured() bool {
8051 if l == nil || l.Featured == nil {
8052 return false
8053 }
8054 return *l.Featured
8055 }
8056
8057
8058 func (l *License) GetHTMLURL() string {
8059 if l == nil || l.HTMLURL == nil {
8060 return ""
8061 }
8062 return *l.HTMLURL
8063 }
8064
8065
8066 func (l *License) GetImplementation() string {
8067 if l == nil || l.Implementation == nil {
8068 return ""
8069 }
8070 return *l.Implementation
8071 }
8072
8073
8074 func (l *License) GetKey() string {
8075 if l == nil || l.Key == nil {
8076 return ""
8077 }
8078 return *l.Key
8079 }
8080
8081
8082 func (l *License) GetLimitations() []string {
8083 if l == nil || l.Limitations == nil {
8084 return nil
8085 }
8086 return *l.Limitations
8087 }
8088
8089
8090 func (l *License) GetName() string {
8091 if l == nil || l.Name == nil {
8092 return ""
8093 }
8094 return *l.Name
8095 }
8096
8097
8098 func (l *License) GetPermissions() []string {
8099 if l == nil || l.Permissions == nil {
8100 return nil
8101 }
8102 return *l.Permissions
8103 }
8104
8105
8106 func (l *License) GetSPDXID() string {
8107 if l == nil || l.SPDXID == nil {
8108 return ""
8109 }
8110 return *l.SPDXID
8111 }
8112
8113
8114 func (l *License) GetURL() string {
8115 if l == nil || l.URL == nil {
8116 return ""
8117 }
8118 return *l.URL
8119 }
8120
8121
8122 func (l *ListCheckRunsOptions) GetAppID() int64 {
8123 if l == nil || l.AppID == nil {
8124 return 0
8125 }
8126 return *l.AppID
8127 }
8128
8129
8130 func (l *ListCheckRunsOptions) GetCheckName() string {
8131 if l == nil || l.CheckName == nil {
8132 return ""
8133 }
8134 return *l.CheckName
8135 }
8136
8137
8138 func (l *ListCheckRunsOptions) GetFilter() string {
8139 if l == nil || l.Filter == nil {
8140 return ""
8141 }
8142 return *l.Filter
8143 }
8144
8145
8146 func (l *ListCheckRunsOptions) GetStatus() string {
8147 if l == nil || l.Status == nil {
8148 return ""
8149 }
8150 return *l.Status
8151 }
8152
8153
8154 func (l *ListCheckRunsResults) GetTotal() int {
8155 if l == nil || l.Total == nil {
8156 return 0
8157 }
8158 return *l.Total
8159 }
8160
8161
8162 func (l *ListCheckSuiteOptions) GetAppID() int {
8163 if l == nil || l.AppID == nil {
8164 return 0
8165 }
8166 return *l.AppID
8167 }
8168
8169
8170 func (l *ListCheckSuiteOptions) GetCheckName() string {
8171 if l == nil || l.CheckName == nil {
8172 return ""
8173 }
8174 return *l.CheckName
8175 }
8176
8177
8178 func (l *ListCheckSuiteResults) GetTotal() int {
8179 if l == nil || l.Total == nil {
8180 return 0
8181 }
8182 return *l.Total
8183 }
8184
8185
8186 func (l *ListCollaboratorOptions) GetAffiliation() string {
8187 if l == nil || l.Affiliation == nil {
8188 return ""
8189 }
8190 return *l.Affiliation
8191 }
8192
8193
8194 func (l *ListExternalGroupsOptions) GetDisplayName() string {
8195 if l == nil || l.DisplayName == nil {
8196 return ""
8197 }
8198 return *l.DisplayName
8199 }
8200
8201
8202 func (l *ListRepositories) GetTotalCount() int {
8203 if l == nil || l.TotalCount == nil {
8204 return 0
8205 }
8206 return *l.TotalCount
8207 }
8208
8209
8210 func (l *ListSCIMProvisionedIdentitiesOptions) GetCount() int {
8211 if l == nil || l.Count == nil {
8212 return 0
8213 }
8214 return *l.Count
8215 }
8216
8217
8218 func (l *ListSCIMProvisionedIdentitiesOptions) GetFilter() string {
8219 if l == nil || l.Filter == nil {
8220 return ""
8221 }
8222 return *l.Filter
8223 }
8224
8225
8226 func (l *ListSCIMProvisionedIdentitiesOptions) GetStartIndex() int {
8227 if l == nil || l.StartIndex == nil {
8228 return 0
8229 }
8230 return *l.StartIndex
8231 }
8232
8233
8234 func (l *Location) GetEndColumn() int {
8235 if l == nil || l.EndColumn == nil {
8236 return 0
8237 }
8238 return *l.EndColumn
8239 }
8240
8241
8242 func (l *Location) GetEndLine() int {
8243 if l == nil || l.EndLine == nil {
8244 return 0
8245 }
8246 return *l.EndLine
8247 }
8248
8249
8250 func (l *Location) GetPath() string {
8251 if l == nil || l.Path == nil {
8252 return ""
8253 }
8254 return *l.Path
8255 }
8256
8257
8258 func (l *Location) GetStartColumn() int {
8259 if l == nil || l.StartColumn == nil {
8260 return 0
8261 }
8262 return *l.StartColumn
8263 }
8264
8265
8266 func (l *Location) GetStartLine() int {
8267 if l == nil || l.StartLine == nil {
8268 return 0
8269 }
8270 return *l.StartLine
8271 }
8272
8273
8274 func (m *MarketplacePendingChange) GetEffectiveDate() Timestamp {
8275 if m == nil || m.EffectiveDate == nil {
8276 return Timestamp{}
8277 }
8278 return *m.EffectiveDate
8279 }
8280
8281
8282 func (m *MarketplacePendingChange) GetID() int64 {
8283 if m == nil || m.ID == nil {
8284 return 0
8285 }
8286 return *m.ID
8287 }
8288
8289
8290 func (m *MarketplacePendingChange) GetPlan() *MarketplacePlan {
8291 if m == nil {
8292 return nil
8293 }
8294 return m.Plan
8295 }
8296
8297
8298 func (m *MarketplacePendingChange) GetUnitCount() int {
8299 if m == nil || m.UnitCount == nil {
8300 return 0
8301 }
8302 return *m.UnitCount
8303 }
8304
8305
8306 func (m *MarketplacePlan) GetAccountsURL() string {
8307 if m == nil || m.AccountsURL == nil {
8308 return ""
8309 }
8310 return *m.AccountsURL
8311 }
8312
8313
8314 func (m *MarketplacePlan) GetBullets() []string {
8315 if m == nil || m.Bullets == nil {
8316 return nil
8317 }
8318 return *m.Bullets
8319 }
8320
8321
8322 func (m *MarketplacePlan) GetDescription() string {
8323 if m == nil || m.Description == nil {
8324 return ""
8325 }
8326 return *m.Description
8327 }
8328
8329
8330 func (m *MarketplacePlan) GetHasFreeTrial() bool {
8331 if m == nil || m.HasFreeTrial == nil {
8332 return false
8333 }
8334 return *m.HasFreeTrial
8335 }
8336
8337
8338 func (m *MarketplacePlan) GetID() int64 {
8339 if m == nil || m.ID == nil {
8340 return 0
8341 }
8342 return *m.ID
8343 }
8344
8345
8346 func (m *MarketplacePlan) GetMonthlyPriceInCents() int {
8347 if m == nil || m.MonthlyPriceInCents == nil {
8348 return 0
8349 }
8350 return *m.MonthlyPriceInCents
8351 }
8352
8353
8354 func (m *MarketplacePlan) GetName() string {
8355 if m == nil || m.Name == nil {
8356 return ""
8357 }
8358 return *m.Name
8359 }
8360
8361
8362 func (m *MarketplacePlan) GetNumber() int {
8363 if m == nil || m.Number == nil {
8364 return 0
8365 }
8366 return *m.Number
8367 }
8368
8369
8370 func (m *MarketplacePlan) GetPriceModel() string {
8371 if m == nil || m.PriceModel == nil {
8372 return ""
8373 }
8374 return *m.PriceModel
8375 }
8376
8377
8378 func (m *MarketplacePlan) GetState() string {
8379 if m == nil || m.State == nil {
8380 return ""
8381 }
8382 return *m.State
8383 }
8384
8385
8386 func (m *MarketplacePlan) GetUnitName() string {
8387 if m == nil || m.UnitName == nil {
8388 return ""
8389 }
8390 return *m.UnitName
8391 }
8392
8393
8394 func (m *MarketplacePlan) GetURL() string {
8395 if m == nil || m.URL == nil {
8396 return ""
8397 }
8398 return *m.URL
8399 }
8400
8401
8402 func (m *MarketplacePlan) GetYearlyPriceInCents() int {
8403 if m == nil || m.YearlyPriceInCents == nil {
8404 return 0
8405 }
8406 return *m.YearlyPriceInCents
8407 }
8408
8409
8410 func (m *MarketplacePlanAccount) GetID() int64 {
8411 if m == nil || m.ID == nil {
8412 return 0
8413 }
8414 return *m.ID
8415 }
8416
8417
8418 func (m *MarketplacePlanAccount) GetLogin() string {
8419 if m == nil || m.Login == nil {
8420 return ""
8421 }
8422 return *m.Login
8423 }
8424
8425
8426 func (m *MarketplacePlanAccount) GetMarketplacePendingChange() *MarketplacePendingChange {
8427 if m == nil {
8428 return nil
8429 }
8430 return m.MarketplacePendingChange
8431 }
8432
8433
8434 func (m *MarketplacePlanAccount) GetMarketplacePurchase() *MarketplacePurchase {
8435 if m == nil {
8436 return nil
8437 }
8438 return m.MarketplacePurchase
8439 }
8440
8441
8442 func (m *MarketplacePlanAccount) GetOrganizationBillingEmail() string {
8443 if m == nil || m.OrganizationBillingEmail == nil {
8444 return ""
8445 }
8446 return *m.OrganizationBillingEmail
8447 }
8448
8449
8450 func (m *MarketplacePlanAccount) GetType() string {
8451 if m == nil || m.Type == nil {
8452 return ""
8453 }
8454 return *m.Type
8455 }
8456
8457
8458 func (m *MarketplacePlanAccount) GetURL() string {
8459 if m == nil || m.URL == nil {
8460 return ""
8461 }
8462 return *m.URL
8463 }
8464
8465
8466 func (m *MarketplacePurchase) GetBillingCycle() string {
8467 if m == nil || m.BillingCycle == nil {
8468 return ""
8469 }
8470 return *m.BillingCycle
8471 }
8472
8473
8474 func (m *MarketplacePurchase) GetFreeTrialEndsOn() Timestamp {
8475 if m == nil || m.FreeTrialEndsOn == nil {
8476 return Timestamp{}
8477 }
8478 return *m.FreeTrialEndsOn
8479 }
8480
8481
8482 func (m *MarketplacePurchase) GetNextBillingDate() Timestamp {
8483 if m == nil || m.NextBillingDate == nil {
8484 return Timestamp{}
8485 }
8486 return *m.NextBillingDate
8487 }
8488
8489
8490 func (m *MarketplacePurchase) GetOnFreeTrial() bool {
8491 if m == nil || m.OnFreeTrial == nil {
8492 return false
8493 }
8494 return *m.OnFreeTrial
8495 }
8496
8497
8498 func (m *MarketplacePurchase) GetPlan() *MarketplacePlan {
8499 if m == nil {
8500 return nil
8501 }
8502 return m.Plan
8503 }
8504
8505
8506 func (m *MarketplacePurchase) GetUnitCount() int {
8507 if m == nil || m.UnitCount == nil {
8508 return 0
8509 }
8510 return *m.UnitCount
8511 }
8512
8513
8514 func (m *MarketplacePurchase) GetUpdatedAt() Timestamp {
8515 if m == nil || m.UpdatedAt == nil {
8516 return Timestamp{}
8517 }
8518 return *m.UpdatedAt
8519 }
8520
8521
8522 func (m *MarketplacePurchaseEvent) GetAction() string {
8523 if m == nil || m.Action == nil {
8524 return ""
8525 }
8526 return *m.Action
8527 }
8528
8529
8530 func (m *MarketplacePurchaseEvent) GetEffectiveDate() Timestamp {
8531 if m == nil || m.EffectiveDate == nil {
8532 return Timestamp{}
8533 }
8534 return *m.EffectiveDate
8535 }
8536
8537
8538 func (m *MarketplacePurchaseEvent) GetInstallation() *Installation {
8539 if m == nil {
8540 return nil
8541 }
8542 return m.Installation
8543 }
8544
8545
8546 func (m *MarketplacePurchaseEvent) GetMarketplacePurchase() *MarketplacePurchase {
8547 if m == nil {
8548 return nil
8549 }
8550 return m.MarketplacePurchase
8551 }
8552
8553
8554 func (m *MarketplacePurchaseEvent) GetPreviousMarketplacePurchase() *MarketplacePurchase {
8555 if m == nil {
8556 return nil
8557 }
8558 return m.PreviousMarketplacePurchase
8559 }
8560
8561
8562 func (m *MarketplacePurchaseEvent) GetSender() *User {
8563 if m == nil {
8564 return nil
8565 }
8566 return m.Sender
8567 }
8568
8569
8570 func (m *Match) GetText() string {
8571 if m == nil || m.Text == nil {
8572 return ""
8573 }
8574 return *m.Text
8575 }
8576
8577
8578 func (m *MemberEvent) GetAction() string {
8579 if m == nil || m.Action == nil {
8580 return ""
8581 }
8582 return *m.Action
8583 }
8584
8585
8586 func (m *MemberEvent) GetInstallation() *Installation {
8587 if m == nil {
8588 return nil
8589 }
8590 return m.Installation
8591 }
8592
8593
8594 func (m *MemberEvent) GetMember() *User {
8595 if m == nil {
8596 return nil
8597 }
8598 return m.Member
8599 }
8600
8601
8602 func (m *MemberEvent) GetRepo() *Repository {
8603 if m == nil {
8604 return nil
8605 }
8606 return m.Repo
8607 }
8608
8609
8610 func (m *MemberEvent) GetSender() *User {
8611 if m == nil {
8612 return nil
8613 }
8614 return m.Sender
8615 }
8616
8617
8618 func (m *Membership) GetOrganization() *Organization {
8619 if m == nil {
8620 return nil
8621 }
8622 return m.Organization
8623 }
8624
8625
8626 func (m *Membership) GetOrganizationURL() string {
8627 if m == nil || m.OrganizationURL == nil {
8628 return ""
8629 }
8630 return *m.OrganizationURL
8631 }
8632
8633
8634 func (m *Membership) GetRole() string {
8635 if m == nil || m.Role == nil {
8636 return ""
8637 }
8638 return *m.Role
8639 }
8640
8641
8642 func (m *Membership) GetState() string {
8643 if m == nil || m.State == nil {
8644 return ""
8645 }
8646 return *m.State
8647 }
8648
8649
8650 func (m *Membership) GetURL() string {
8651 if m == nil || m.URL == nil {
8652 return ""
8653 }
8654 return *m.URL
8655 }
8656
8657
8658 func (m *Membership) GetUser() *User {
8659 if m == nil {
8660 return nil
8661 }
8662 return m.User
8663 }
8664
8665
8666 func (m *MembershipEvent) GetAction() string {
8667 if m == nil || m.Action == nil {
8668 return ""
8669 }
8670 return *m.Action
8671 }
8672
8673
8674 func (m *MembershipEvent) GetInstallation() *Installation {
8675 if m == nil {
8676 return nil
8677 }
8678 return m.Installation
8679 }
8680
8681
8682 func (m *MembershipEvent) GetMember() *User {
8683 if m == nil {
8684 return nil
8685 }
8686 return m.Member
8687 }
8688
8689
8690 func (m *MembershipEvent) GetOrg() *Organization {
8691 if m == nil {
8692 return nil
8693 }
8694 return m.Org
8695 }
8696
8697
8698 func (m *MembershipEvent) GetScope() string {
8699 if m == nil || m.Scope == nil {
8700 return ""
8701 }
8702 return *m.Scope
8703 }
8704
8705
8706 func (m *MembershipEvent) GetSender() *User {
8707 if m == nil {
8708 return nil
8709 }
8710 return m.Sender
8711 }
8712
8713
8714 func (m *MembershipEvent) GetTeam() *Team {
8715 if m == nil {
8716 return nil
8717 }
8718 return m.Team
8719 }
8720
8721
8722 func (m *Message) GetText() string {
8723 if m == nil || m.Text == nil {
8724 return ""
8725 }
8726 return *m.Text
8727 }
8728
8729
8730 func (m *MetaEvent) GetAction() string {
8731 if m == nil || m.Action == nil {
8732 return ""
8733 }
8734 return *m.Action
8735 }
8736
8737
8738 func (m *MetaEvent) GetHook() *Hook {
8739 if m == nil {
8740 return nil
8741 }
8742 return m.Hook
8743 }
8744
8745
8746 func (m *MetaEvent) GetHookID() int64 {
8747 if m == nil || m.HookID == nil {
8748 return 0
8749 }
8750 return *m.HookID
8751 }
8752
8753
8754 func (m *MetaEvent) GetInstallation() *Installation {
8755 if m == nil {
8756 return nil
8757 }
8758 return m.Installation
8759 }
8760
8761
8762 func (m *MetaEvent) GetOrg() *Organization {
8763 if m == nil {
8764 return nil
8765 }
8766 return m.Org
8767 }
8768
8769
8770 func (m *MetaEvent) GetRepo() *Repository {
8771 if m == nil {
8772 return nil
8773 }
8774 return m.Repo
8775 }
8776
8777
8778 func (m *MetaEvent) GetSender() *User {
8779 if m == nil {
8780 return nil
8781 }
8782 return m.Sender
8783 }
8784
8785
8786 func (m *Metric) GetHTMLURL() string {
8787 if m == nil || m.HTMLURL == nil {
8788 return ""
8789 }
8790 return *m.HTMLURL
8791 }
8792
8793
8794 func (m *Metric) GetKey() string {
8795 if m == nil || m.Key == nil {
8796 return ""
8797 }
8798 return *m.Key
8799 }
8800
8801
8802 func (m *Metric) GetName() string {
8803 if m == nil || m.Name == nil {
8804 return ""
8805 }
8806 return *m.Name
8807 }
8808
8809
8810 func (m *Metric) GetNodeID() string {
8811 if m == nil || m.NodeID == nil {
8812 return ""
8813 }
8814 return *m.NodeID
8815 }
8816
8817
8818 func (m *Metric) GetSPDXID() string {
8819 if m == nil || m.SPDXID == nil {
8820 return ""
8821 }
8822 return *m.SPDXID
8823 }
8824
8825
8826 func (m *Metric) GetURL() string {
8827 if m == nil || m.URL == nil {
8828 return ""
8829 }
8830 return *m.URL
8831 }
8832
8833
8834 func (m *Migration) GetCreatedAt() string {
8835 if m == nil || m.CreatedAt == nil {
8836 return ""
8837 }
8838 return *m.CreatedAt
8839 }
8840
8841
8842 func (m *Migration) GetExcludeAttachments() bool {
8843 if m == nil || m.ExcludeAttachments == nil {
8844 return false
8845 }
8846 return *m.ExcludeAttachments
8847 }
8848
8849
8850 func (m *Migration) GetGUID() string {
8851 if m == nil || m.GUID == nil {
8852 return ""
8853 }
8854 return *m.GUID
8855 }
8856
8857
8858 func (m *Migration) GetID() int64 {
8859 if m == nil || m.ID == nil {
8860 return 0
8861 }
8862 return *m.ID
8863 }
8864
8865
8866 func (m *Migration) GetLockRepositories() bool {
8867 if m == nil || m.LockRepositories == nil {
8868 return false
8869 }
8870 return *m.LockRepositories
8871 }
8872
8873
8874 func (m *Migration) GetState() string {
8875 if m == nil || m.State == nil {
8876 return ""
8877 }
8878 return *m.State
8879 }
8880
8881
8882 func (m *Migration) GetUpdatedAt() string {
8883 if m == nil || m.UpdatedAt == nil {
8884 return ""
8885 }
8886 return *m.UpdatedAt
8887 }
8888
8889
8890 func (m *Migration) GetURL() string {
8891 if m == nil || m.URL == nil {
8892 return ""
8893 }
8894 return *m.URL
8895 }
8896
8897
8898 func (m *Milestone) GetClosedAt() time.Time {
8899 if m == nil || m.ClosedAt == nil {
8900 return time.Time{}
8901 }
8902 return *m.ClosedAt
8903 }
8904
8905
8906 func (m *Milestone) GetClosedIssues() int {
8907 if m == nil || m.ClosedIssues == nil {
8908 return 0
8909 }
8910 return *m.ClosedIssues
8911 }
8912
8913
8914 func (m *Milestone) GetCreatedAt() time.Time {
8915 if m == nil || m.CreatedAt == nil {
8916 return time.Time{}
8917 }
8918 return *m.CreatedAt
8919 }
8920
8921
8922 func (m *Milestone) GetCreator() *User {
8923 if m == nil {
8924 return nil
8925 }
8926 return m.Creator
8927 }
8928
8929
8930 func (m *Milestone) GetDescription() string {
8931 if m == nil || m.Description == nil {
8932 return ""
8933 }
8934 return *m.Description
8935 }
8936
8937
8938 func (m *Milestone) GetDueOn() time.Time {
8939 if m == nil || m.DueOn == nil {
8940 return time.Time{}
8941 }
8942 return *m.DueOn
8943 }
8944
8945
8946 func (m *Milestone) GetHTMLURL() string {
8947 if m == nil || m.HTMLURL == nil {
8948 return ""
8949 }
8950 return *m.HTMLURL
8951 }
8952
8953
8954 func (m *Milestone) GetID() int64 {
8955 if m == nil || m.ID == nil {
8956 return 0
8957 }
8958 return *m.ID
8959 }
8960
8961
8962 func (m *Milestone) GetLabelsURL() string {
8963 if m == nil || m.LabelsURL == nil {
8964 return ""
8965 }
8966 return *m.LabelsURL
8967 }
8968
8969
8970 func (m *Milestone) GetNodeID() string {
8971 if m == nil || m.NodeID == nil {
8972 return ""
8973 }
8974 return *m.NodeID
8975 }
8976
8977
8978 func (m *Milestone) GetNumber() int {
8979 if m == nil || m.Number == nil {
8980 return 0
8981 }
8982 return *m.Number
8983 }
8984
8985
8986 func (m *Milestone) GetOpenIssues() int {
8987 if m == nil || m.OpenIssues == nil {
8988 return 0
8989 }
8990 return *m.OpenIssues
8991 }
8992
8993
8994 func (m *Milestone) GetState() string {
8995 if m == nil || m.State == nil {
8996 return ""
8997 }
8998 return *m.State
8999 }
9000
9001
9002 func (m *Milestone) GetTitle() string {
9003 if m == nil || m.Title == nil {
9004 return ""
9005 }
9006 return *m.Title
9007 }
9008
9009
9010 func (m *Milestone) GetUpdatedAt() time.Time {
9011 if m == nil || m.UpdatedAt == nil {
9012 return time.Time{}
9013 }
9014 return *m.UpdatedAt
9015 }
9016
9017
9018 func (m *Milestone) GetURL() string {
9019 if m == nil || m.URL == nil {
9020 return ""
9021 }
9022 return *m.URL
9023 }
9024
9025
9026 func (m *MilestoneEvent) GetAction() string {
9027 if m == nil || m.Action == nil {
9028 return ""
9029 }
9030 return *m.Action
9031 }
9032
9033
9034 func (m *MilestoneEvent) GetChanges() *EditChange {
9035 if m == nil {
9036 return nil
9037 }
9038 return m.Changes
9039 }
9040
9041
9042 func (m *MilestoneEvent) GetInstallation() *Installation {
9043 if m == nil {
9044 return nil
9045 }
9046 return m.Installation
9047 }
9048
9049
9050 func (m *MilestoneEvent) GetMilestone() *Milestone {
9051 if m == nil {
9052 return nil
9053 }
9054 return m.Milestone
9055 }
9056
9057
9058 func (m *MilestoneEvent) GetOrg() *Organization {
9059 if m == nil {
9060 return nil
9061 }
9062 return m.Org
9063 }
9064
9065
9066 func (m *MilestoneEvent) GetRepo() *Repository {
9067 if m == nil {
9068 return nil
9069 }
9070 return m.Repo
9071 }
9072
9073
9074 func (m *MilestoneEvent) GetSender() *User {
9075 if m == nil {
9076 return nil
9077 }
9078 return m.Sender
9079 }
9080
9081
9082 func (m *MilestoneStats) GetClosedMilestones() int {
9083 if m == nil || m.ClosedMilestones == nil {
9084 return 0
9085 }
9086 return *m.ClosedMilestones
9087 }
9088
9089
9090 func (m *MilestoneStats) GetOpenMilestones() int {
9091 if m == nil || m.OpenMilestones == nil {
9092 return 0
9093 }
9094 return *m.OpenMilestones
9095 }
9096
9097
9098 func (m *MilestoneStats) GetTotalMilestones() int {
9099 if m == nil || m.TotalMilestones == nil {
9100 return 0
9101 }
9102 return *m.TotalMilestones
9103 }
9104
9105
9106 func (m *MostRecentInstance) GetAnalysisKey() string {
9107 if m == nil || m.AnalysisKey == nil {
9108 return ""
9109 }
9110 return *m.AnalysisKey
9111 }
9112
9113
9114 func (m *MostRecentInstance) GetCommitSHA() string {
9115 if m == nil || m.CommitSHA == nil {
9116 return ""
9117 }
9118 return *m.CommitSHA
9119 }
9120
9121
9122 func (m *MostRecentInstance) GetEnvironment() string {
9123 if m == nil || m.Environment == nil {
9124 return ""
9125 }
9126 return *m.Environment
9127 }
9128
9129
9130 func (m *MostRecentInstance) GetLocation() *Location {
9131 if m == nil {
9132 return nil
9133 }
9134 return m.Location
9135 }
9136
9137
9138 func (m *MostRecentInstance) GetMessage() *Message {
9139 if m == nil {
9140 return nil
9141 }
9142 return m.Message
9143 }
9144
9145
9146 func (m *MostRecentInstance) GetRef() string {
9147 if m == nil || m.Ref == nil {
9148 return ""
9149 }
9150 return *m.Ref
9151 }
9152
9153
9154 func (m *MostRecentInstance) GetState() string {
9155 if m == nil || m.State == nil {
9156 return ""
9157 }
9158 return *m.State
9159 }
9160
9161
9162 func (n *NewPullRequest) GetBase() string {
9163 if n == nil || n.Base == nil {
9164 return ""
9165 }
9166 return *n.Base
9167 }
9168
9169
9170 func (n *NewPullRequest) GetBody() string {
9171 if n == nil || n.Body == nil {
9172 return ""
9173 }
9174 return *n.Body
9175 }
9176
9177
9178 func (n *NewPullRequest) GetDraft() bool {
9179 if n == nil || n.Draft == nil {
9180 return false
9181 }
9182 return *n.Draft
9183 }
9184
9185
9186 func (n *NewPullRequest) GetHead() string {
9187 if n == nil || n.Head == nil {
9188 return ""
9189 }
9190 return *n.Head
9191 }
9192
9193
9194 func (n *NewPullRequest) GetIssue() int {
9195 if n == nil || n.Issue == nil {
9196 return 0
9197 }
9198 return *n.Issue
9199 }
9200
9201
9202 func (n *NewPullRequest) GetMaintainerCanModify() bool {
9203 if n == nil || n.MaintainerCanModify == nil {
9204 return false
9205 }
9206 return *n.MaintainerCanModify
9207 }
9208
9209
9210 func (n *NewPullRequest) GetTitle() string {
9211 if n == nil || n.Title == nil {
9212 return ""
9213 }
9214 return *n.Title
9215 }
9216
9217
9218 func (n *NewTeam) GetDescription() string {
9219 if n == nil || n.Description == nil {
9220 return ""
9221 }
9222 return *n.Description
9223 }
9224
9225
9226 func (n *NewTeam) GetLDAPDN() string {
9227 if n == nil || n.LDAPDN == nil {
9228 return ""
9229 }
9230 return *n.LDAPDN
9231 }
9232
9233
9234 func (n *NewTeam) GetParentTeamID() int64 {
9235 if n == nil || n.ParentTeamID == nil {
9236 return 0
9237 }
9238 return *n.ParentTeamID
9239 }
9240
9241
9242 func (n *NewTeam) GetPermission() string {
9243 if n == nil || n.Permission == nil {
9244 return ""
9245 }
9246 return *n.Permission
9247 }
9248
9249
9250 func (n *NewTeam) GetPrivacy() string {
9251 if n == nil || n.Privacy == nil {
9252 return ""
9253 }
9254 return *n.Privacy
9255 }
9256
9257
9258 func (n *Notification) GetID() string {
9259 if n == nil || n.ID == nil {
9260 return ""
9261 }
9262 return *n.ID
9263 }
9264
9265
9266 func (n *Notification) GetLastReadAt() time.Time {
9267 if n == nil || n.LastReadAt == nil {
9268 return time.Time{}
9269 }
9270 return *n.LastReadAt
9271 }
9272
9273
9274 func (n *Notification) GetReason() string {
9275 if n == nil || n.Reason == nil {
9276 return ""
9277 }
9278 return *n.Reason
9279 }
9280
9281
9282 func (n *Notification) GetRepository() *Repository {
9283 if n == nil {
9284 return nil
9285 }
9286 return n.Repository
9287 }
9288
9289
9290 func (n *Notification) GetSubject() *NotificationSubject {
9291 if n == nil {
9292 return nil
9293 }
9294 return n.Subject
9295 }
9296
9297
9298 func (n *Notification) GetUnread() bool {
9299 if n == nil || n.Unread == nil {
9300 return false
9301 }
9302 return *n.Unread
9303 }
9304
9305
9306 func (n *Notification) GetUpdatedAt() time.Time {
9307 if n == nil || n.UpdatedAt == nil {
9308 return time.Time{}
9309 }
9310 return *n.UpdatedAt
9311 }
9312
9313
9314 func (n *Notification) GetURL() string {
9315 if n == nil || n.URL == nil {
9316 return ""
9317 }
9318 return *n.URL
9319 }
9320
9321
9322 func (n *NotificationSubject) GetLatestCommentURL() string {
9323 if n == nil || n.LatestCommentURL == nil {
9324 return ""
9325 }
9326 return *n.LatestCommentURL
9327 }
9328
9329
9330 func (n *NotificationSubject) GetTitle() string {
9331 if n == nil || n.Title == nil {
9332 return ""
9333 }
9334 return *n.Title
9335 }
9336
9337
9338 func (n *NotificationSubject) GetType() string {
9339 if n == nil || n.Type == nil {
9340 return ""
9341 }
9342 return *n.Type
9343 }
9344
9345
9346 func (n *NotificationSubject) GetURL() string {
9347 if n == nil || n.URL == nil {
9348 return ""
9349 }
9350 return *n.URL
9351 }
9352
9353
9354 func (o *OAuthAPP) GetClientID() string {
9355 if o == nil || o.ClientID == nil {
9356 return ""
9357 }
9358 return *o.ClientID
9359 }
9360
9361
9362 func (o *OAuthAPP) GetName() string {
9363 if o == nil || o.Name == nil {
9364 return ""
9365 }
9366 return *o.Name
9367 }
9368
9369
9370 func (o *OAuthAPP) GetURL() string {
9371 if o == nil || o.URL == nil {
9372 return ""
9373 }
9374 return *o.URL
9375 }
9376
9377
9378 func (o *Organization) GetAvatarURL() string {
9379 if o == nil || o.AvatarURL == nil {
9380 return ""
9381 }
9382 return *o.AvatarURL
9383 }
9384
9385
9386 func (o *Organization) GetBillingEmail() string {
9387 if o == nil || o.BillingEmail == nil {
9388 return ""
9389 }
9390 return *o.BillingEmail
9391 }
9392
9393
9394 func (o *Organization) GetBlog() string {
9395 if o == nil || o.Blog == nil {
9396 return ""
9397 }
9398 return *o.Blog
9399 }
9400
9401
9402 func (o *Organization) GetCollaborators() int {
9403 if o == nil || o.Collaborators == nil {
9404 return 0
9405 }
9406 return *o.Collaborators
9407 }
9408
9409
9410 func (o *Organization) GetCompany() string {
9411 if o == nil || o.Company == nil {
9412 return ""
9413 }
9414 return *o.Company
9415 }
9416
9417
9418 func (o *Organization) GetCreatedAt() time.Time {
9419 if o == nil || o.CreatedAt == nil {
9420 return time.Time{}
9421 }
9422 return *o.CreatedAt
9423 }
9424
9425
9426 func (o *Organization) GetDefaultRepoPermission() string {
9427 if o == nil || o.DefaultRepoPermission == nil {
9428 return ""
9429 }
9430 return *o.DefaultRepoPermission
9431 }
9432
9433
9434 func (o *Organization) GetDefaultRepoSettings() string {
9435 if o == nil || o.DefaultRepoSettings == nil {
9436 return ""
9437 }
9438 return *o.DefaultRepoSettings
9439 }
9440
9441
9442 func (o *Organization) GetDescription() string {
9443 if o == nil || o.Description == nil {
9444 return ""
9445 }
9446 return *o.Description
9447 }
9448
9449
9450 func (o *Organization) GetDiskUsage() int {
9451 if o == nil || o.DiskUsage == nil {
9452 return 0
9453 }
9454 return *o.DiskUsage
9455 }
9456
9457
9458 func (o *Organization) GetEmail() string {
9459 if o == nil || o.Email == nil {
9460 return ""
9461 }
9462 return *o.Email
9463 }
9464
9465
9466 func (o *Organization) GetEventsURL() string {
9467 if o == nil || o.EventsURL == nil {
9468 return ""
9469 }
9470 return *o.EventsURL
9471 }
9472
9473
9474 func (o *Organization) GetFollowers() int {
9475 if o == nil || o.Followers == nil {
9476 return 0
9477 }
9478 return *o.Followers
9479 }
9480
9481
9482 func (o *Organization) GetFollowing() int {
9483 if o == nil || o.Following == nil {
9484 return 0
9485 }
9486 return *o.Following
9487 }
9488
9489
9490 func (o *Organization) GetHasOrganizationProjects() bool {
9491 if o == nil || o.HasOrganizationProjects == nil {
9492 return false
9493 }
9494 return *o.HasOrganizationProjects
9495 }
9496
9497
9498 func (o *Organization) GetHasRepositoryProjects() bool {
9499 if o == nil || o.HasRepositoryProjects == nil {
9500 return false
9501 }
9502 return *o.HasRepositoryProjects
9503 }
9504
9505
9506 func (o *Organization) GetHooksURL() string {
9507 if o == nil || o.HooksURL == nil {
9508 return ""
9509 }
9510 return *o.HooksURL
9511 }
9512
9513
9514 func (o *Organization) GetHTMLURL() string {
9515 if o == nil || o.HTMLURL == nil {
9516 return ""
9517 }
9518 return *o.HTMLURL
9519 }
9520
9521
9522 func (o *Organization) GetID() int64 {
9523 if o == nil || o.ID == nil {
9524 return 0
9525 }
9526 return *o.ID
9527 }
9528
9529
9530 func (o *Organization) GetIssuesURL() string {
9531 if o == nil || o.IssuesURL == nil {
9532 return ""
9533 }
9534 return *o.IssuesURL
9535 }
9536
9537
9538 func (o *Organization) GetIsVerified() bool {
9539 if o == nil || o.IsVerified == nil {
9540 return false
9541 }
9542 return *o.IsVerified
9543 }
9544
9545
9546 func (o *Organization) GetLocation() string {
9547 if o == nil || o.Location == nil {
9548 return ""
9549 }
9550 return *o.Location
9551 }
9552
9553
9554 func (o *Organization) GetLogin() string {
9555 if o == nil || o.Login == nil {
9556 return ""
9557 }
9558 return *o.Login
9559 }
9560
9561
9562 func (o *Organization) GetMembersAllowedRepositoryCreationType() string {
9563 if o == nil || o.MembersAllowedRepositoryCreationType == nil {
9564 return ""
9565 }
9566 return *o.MembersAllowedRepositoryCreationType
9567 }
9568
9569
9570 func (o *Organization) GetMembersCanCreateInternalRepos() bool {
9571 if o == nil || o.MembersCanCreateInternalRepos == nil {
9572 return false
9573 }
9574 return *o.MembersCanCreateInternalRepos
9575 }
9576
9577
9578 func (o *Organization) GetMembersCanCreatePages() bool {
9579 if o == nil || o.MembersCanCreatePages == nil {
9580 return false
9581 }
9582 return *o.MembersCanCreatePages
9583 }
9584
9585
9586 func (o *Organization) GetMembersCanCreatePrivatePages() bool {
9587 if o == nil || o.MembersCanCreatePrivatePages == nil {
9588 return false
9589 }
9590 return *o.MembersCanCreatePrivatePages
9591 }
9592
9593
9594 func (o *Organization) GetMembersCanCreatePrivateRepos() bool {
9595 if o == nil || o.MembersCanCreatePrivateRepos == nil {
9596 return false
9597 }
9598 return *o.MembersCanCreatePrivateRepos
9599 }
9600
9601
9602 func (o *Organization) GetMembersCanCreatePublicPages() bool {
9603 if o == nil || o.MembersCanCreatePublicPages == nil {
9604 return false
9605 }
9606 return *o.MembersCanCreatePublicPages
9607 }
9608
9609
9610 func (o *Organization) GetMembersCanCreatePublicRepos() bool {
9611 if o == nil || o.MembersCanCreatePublicRepos == nil {
9612 return false
9613 }
9614 return *o.MembersCanCreatePublicRepos
9615 }
9616
9617
9618 func (o *Organization) GetMembersCanCreateRepos() bool {
9619 if o == nil || o.MembersCanCreateRepos == nil {
9620 return false
9621 }
9622 return *o.MembersCanCreateRepos
9623 }
9624
9625
9626 func (o *Organization) GetMembersCanForkPrivateRepos() bool {
9627 if o == nil || o.MembersCanForkPrivateRepos == nil {
9628 return false
9629 }
9630 return *o.MembersCanForkPrivateRepos
9631 }
9632
9633
9634 func (o *Organization) GetMembersURL() string {
9635 if o == nil || o.MembersURL == nil {
9636 return ""
9637 }
9638 return *o.MembersURL
9639 }
9640
9641
9642 func (o *Organization) GetName() string {
9643 if o == nil || o.Name == nil {
9644 return ""
9645 }
9646 return *o.Name
9647 }
9648
9649
9650 func (o *Organization) GetNodeID() string {
9651 if o == nil || o.NodeID == nil {
9652 return ""
9653 }
9654 return *o.NodeID
9655 }
9656
9657
9658 func (o *Organization) GetOwnedPrivateRepos() int {
9659 if o == nil || o.OwnedPrivateRepos == nil {
9660 return 0
9661 }
9662 return *o.OwnedPrivateRepos
9663 }
9664
9665
9666 func (o *Organization) GetPlan() *Plan {
9667 if o == nil {
9668 return nil
9669 }
9670 return o.Plan
9671 }
9672
9673
9674 func (o *Organization) GetPrivateGists() int {
9675 if o == nil || o.PrivateGists == nil {
9676 return 0
9677 }
9678 return *o.PrivateGists
9679 }
9680
9681
9682 func (o *Organization) GetPublicGists() int {
9683 if o == nil || o.PublicGists == nil {
9684 return 0
9685 }
9686 return *o.PublicGists
9687 }
9688
9689
9690 func (o *Organization) GetPublicMembersURL() string {
9691 if o == nil || o.PublicMembersURL == nil {
9692 return ""
9693 }
9694 return *o.PublicMembersURL
9695 }
9696
9697
9698 func (o *Organization) GetPublicRepos() int {
9699 if o == nil || o.PublicRepos == nil {
9700 return 0
9701 }
9702 return *o.PublicRepos
9703 }
9704
9705
9706 func (o *Organization) GetReposURL() string {
9707 if o == nil || o.ReposURL == nil {
9708 return ""
9709 }
9710 return *o.ReposURL
9711 }
9712
9713
9714 func (o *Organization) GetTotalPrivateRepos() int {
9715 if o == nil || o.TotalPrivateRepos == nil {
9716 return 0
9717 }
9718 return *o.TotalPrivateRepos
9719 }
9720
9721
9722 func (o *Organization) GetTwitterUsername() string {
9723 if o == nil || o.TwitterUsername == nil {
9724 return ""
9725 }
9726 return *o.TwitterUsername
9727 }
9728
9729
9730 func (o *Organization) GetTwoFactorRequirementEnabled() bool {
9731 if o == nil || o.TwoFactorRequirementEnabled == nil {
9732 return false
9733 }
9734 return *o.TwoFactorRequirementEnabled
9735 }
9736
9737
9738 func (o *Organization) GetType() string {
9739 if o == nil || o.Type == nil {
9740 return ""
9741 }
9742 return *o.Type
9743 }
9744
9745
9746 func (o *Organization) GetUpdatedAt() time.Time {
9747 if o == nil || o.UpdatedAt == nil {
9748 return time.Time{}
9749 }
9750 return *o.UpdatedAt
9751 }
9752
9753
9754 func (o *Organization) GetURL() string {
9755 if o == nil || o.URL == nil {
9756 return ""
9757 }
9758 return *o.URL
9759 }
9760
9761
9762 func (o *OrganizationCustomRepoRoles) GetTotalCount() int {
9763 if o == nil || o.TotalCount == nil {
9764 return 0
9765 }
9766 return *o.TotalCount
9767 }
9768
9769
9770 func (o *OrganizationEvent) GetAction() string {
9771 if o == nil || o.Action == nil {
9772 return ""
9773 }
9774 return *o.Action
9775 }
9776
9777
9778 func (o *OrganizationEvent) GetInstallation() *Installation {
9779 if o == nil {
9780 return nil
9781 }
9782 return o.Installation
9783 }
9784
9785
9786 func (o *OrganizationEvent) GetInvitation() *Invitation {
9787 if o == nil {
9788 return nil
9789 }
9790 return o.Invitation
9791 }
9792
9793
9794 func (o *OrganizationEvent) GetMembership() *Membership {
9795 if o == nil {
9796 return nil
9797 }
9798 return o.Membership
9799 }
9800
9801
9802 func (o *OrganizationEvent) GetOrganization() *Organization {
9803 if o == nil {
9804 return nil
9805 }
9806 return o.Organization
9807 }
9808
9809
9810 func (o *OrganizationEvent) GetSender() *User {
9811 if o == nil {
9812 return nil
9813 }
9814 return o.Sender
9815 }
9816
9817
9818 func (o *OrganizationInstallations) GetTotalCount() int {
9819 if o == nil || o.TotalCount == nil {
9820 return 0
9821 }
9822 return *o.TotalCount
9823 }
9824
9825
9826 func (o *OrgBlockEvent) GetAction() string {
9827 if o == nil || o.Action == nil {
9828 return ""
9829 }
9830 return *o.Action
9831 }
9832
9833
9834 func (o *OrgBlockEvent) GetBlockedUser() *User {
9835 if o == nil {
9836 return nil
9837 }
9838 return o.BlockedUser
9839 }
9840
9841
9842 func (o *OrgBlockEvent) GetInstallation() *Installation {
9843 if o == nil {
9844 return nil
9845 }
9846 return o.Installation
9847 }
9848
9849
9850 func (o *OrgBlockEvent) GetOrganization() *Organization {
9851 if o == nil {
9852 return nil
9853 }
9854 return o.Organization
9855 }
9856
9857
9858 func (o *OrgBlockEvent) GetSender() *User {
9859 if o == nil {
9860 return nil
9861 }
9862 return o.Sender
9863 }
9864
9865
9866 func (o *OrgStats) GetDisabledOrgs() int {
9867 if o == nil || o.DisabledOrgs == nil {
9868 return 0
9869 }
9870 return *o.DisabledOrgs
9871 }
9872
9873
9874 func (o *OrgStats) GetTotalOrgs() int {
9875 if o == nil || o.TotalOrgs == nil {
9876 return 0
9877 }
9878 return *o.TotalOrgs
9879 }
9880
9881
9882 func (o *OrgStats) GetTotalTeamMembers() int {
9883 if o == nil || o.TotalTeamMembers == nil {
9884 return 0
9885 }
9886 return *o.TotalTeamMembers
9887 }
9888
9889
9890 func (o *OrgStats) GetTotalTeams() int {
9891 if o == nil || o.TotalTeams == nil {
9892 return 0
9893 }
9894 return *o.TotalTeams
9895 }
9896
9897
9898 func (p *Package) GetCreatedAt() Timestamp {
9899 if p == nil || p.CreatedAt == nil {
9900 return Timestamp{}
9901 }
9902 return *p.CreatedAt
9903 }
9904
9905
9906 func (p *Package) GetHTMLURL() string {
9907 if p == nil || p.HTMLURL == nil {
9908 return ""
9909 }
9910 return *p.HTMLURL
9911 }
9912
9913
9914 func (p *Package) GetID() int64 {
9915 if p == nil || p.ID == nil {
9916 return 0
9917 }
9918 return *p.ID
9919 }
9920
9921
9922 func (p *Package) GetName() string {
9923 if p == nil || p.Name == nil {
9924 return ""
9925 }
9926 return *p.Name
9927 }
9928
9929
9930 func (p *Package) GetOwner() *User {
9931 if p == nil {
9932 return nil
9933 }
9934 return p.Owner
9935 }
9936
9937
9938 func (p *Package) GetPackageType() string {
9939 if p == nil || p.PackageType == nil {
9940 return ""
9941 }
9942 return *p.PackageType
9943 }
9944
9945
9946 func (p *Package) GetPackageVersion() *PackageVersion {
9947 if p == nil {
9948 return nil
9949 }
9950 return p.PackageVersion
9951 }
9952
9953
9954 func (p *Package) GetRegistry() *PackageRegistry {
9955 if p == nil {
9956 return nil
9957 }
9958 return p.Registry
9959 }
9960
9961
9962 func (p *Package) GetRepository() *Repository {
9963 if p == nil {
9964 return nil
9965 }
9966 return p.Repository
9967 }
9968
9969
9970 func (p *Package) GetUpdatedAt() Timestamp {
9971 if p == nil || p.UpdatedAt == nil {
9972 return Timestamp{}
9973 }
9974 return *p.UpdatedAt
9975 }
9976
9977
9978 func (p *Package) GetURL() string {
9979 if p == nil || p.URL == nil {
9980 return ""
9981 }
9982 return *p.URL
9983 }
9984
9985
9986 func (p *Package) GetVersionCount() int64 {
9987 if p == nil || p.VersionCount == nil {
9988 return 0
9989 }
9990 return *p.VersionCount
9991 }
9992
9993
9994 func (p *Package) GetVisibility() string {
9995 if p == nil || p.Visibility == nil {
9996 return ""
9997 }
9998 return *p.Visibility
9999 }
10000
10001
10002 func (p *PackageEvent) GetAction() string {
10003 if p == nil || p.Action == nil {
10004 return ""
10005 }
10006 return *p.Action
10007 }
10008
10009
10010 func (p *PackageEvent) GetInstallation() *Installation {
10011 if p == nil {
10012 return nil
10013 }
10014 return p.Installation
10015 }
10016
10017
10018 func (p *PackageEvent) GetOrg() *Organization {
10019 if p == nil {
10020 return nil
10021 }
10022 return p.Org
10023 }
10024
10025
10026 func (p *PackageEvent) GetPackage() *Package {
10027 if p == nil {
10028 return nil
10029 }
10030 return p.Package
10031 }
10032
10033
10034 func (p *PackageEvent) GetRepo() *Repository {
10035 if p == nil {
10036 return nil
10037 }
10038 return p.Repo
10039 }
10040
10041
10042 func (p *PackageEvent) GetSender() *User {
10043 if p == nil {
10044 return nil
10045 }
10046 return p.Sender
10047 }
10048
10049
10050 func (p *PackageFile) GetAuthor() *User {
10051 if p == nil {
10052 return nil
10053 }
10054 return p.Author
10055 }
10056
10057
10058 func (p *PackageFile) GetContentType() string {
10059 if p == nil || p.ContentType == nil {
10060 return ""
10061 }
10062 return *p.ContentType
10063 }
10064
10065
10066 func (p *PackageFile) GetCreatedAt() Timestamp {
10067 if p == nil || p.CreatedAt == nil {
10068 return Timestamp{}
10069 }
10070 return *p.CreatedAt
10071 }
10072
10073
10074 func (p *PackageFile) GetDownloadURL() string {
10075 if p == nil || p.DownloadURL == nil {
10076 return ""
10077 }
10078 return *p.DownloadURL
10079 }
10080
10081
10082 func (p *PackageFile) GetID() int64 {
10083 if p == nil || p.ID == nil {
10084 return 0
10085 }
10086 return *p.ID
10087 }
10088
10089
10090 func (p *PackageFile) GetMD5() string {
10091 if p == nil || p.MD5 == nil {
10092 return ""
10093 }
10094 return *p.MD5
10095 }
10096
10097
10098 func (p *PackageFile) GetName() string {
10099 if p == nil || p.Name == nil {
10100 return ""
10101 }
10102 return *p.Name
10103 }
10104
10105
10106 func (p *PackageFile) GetSHA1() string {
10107 if p == nil || p.SHA1 == nil {
10108 return ""
10109 }
10110 return *p.SHA1
10111 }
10112
10113
10114 func (p *PackageFile) GetSHA256() string {
10115 if p == nil || p.SHA256 == nil {
10116 return ""
10117 }
10118 return *p.SHA256
10119 }
10120
10121
10122 func (p *PackageFile) GetSize() int64 {
10123 if p == nil || p.Size == nil {
10124 return 0
10125 }
10126 return *p.Size
10127 }
10128
10129
10130 func (p *PackageFile) GetState() string {
10131 if p == nil || p.State == nil {
10132 return ""
10133 }
10134 return *p.State
10135 }
10136
10137
10138 func (p *PackageFile) GetUpdatedAt() Timestamp {
10139 if p == nil || p.UpdatedAt == nil {
10140 return Timestamp{}
10141 }
10142 return *p.UpdatedAt
10143 }
10144
10145
10146 func (p *PackageListOptions) GetPackageType() string {
10147 if p == nil || p.PackageType == nil {
10148 return ""
10149 }
10150 return *p.PackageType
10151 }
10152
10153
10154 func (p *PackageListOptions) GetState() string {
10155 if p == nil || p.State == nil {
10156 return ""
10157 }
10158 return *p.State
10159 }
10160
10161
10162 func (p *PackageListOptions) GetVisibility() string {
10163 if p == nil || p.Visibility == nil {
10164 return ""
10165 }
10166 return *p.Visibility
10167 }
10168
10169
10170 func (p *PackageMetadata) GetContainer() *PackageContainerMetadata {
10171 if p == nil {
10172 return nil
10173 }
10174 return p.Container
10175 }
10176
10177
10178 func (p *PackageMetadata) GetPackageType() string {
10179 if p == nil || p.PackageType == nil {
10180 return ""
10181 }
10182 return *p.PackageType
10183 }
10184
10185
10186 func (p *PackageRegistry) GetAboutURL() string {
10187 if p == nil || p.AboutURL == nil {
10188 return ""
10189 }
10190 return *p.AboutURL
10191 }
10192
10193
10194 func (p *PackageRegistry) GetName() string {
10195 if p == nil || p.Name == nil {
10196 return ""
10197 }
10198 return *p.Name
10199 }
10200
10201
10202 func (p *PackageRegistry) GetType() string {
10203 if p == nil || p.Type == nil {
10204 return ""
10205 }
10206 return *p.Type
10207 }
10208
10209
10210 func (p *PackageRegistry) GetURL() string {
10211 if p == nil || p.URL == nil {
10212 return ""
10213 }
10214 return *p.URL
10215 }
10216
10217
10218 func (p *PackageRegistry) GetVendor() string {
10219 if p == nil || p.Vendor == nil {
10220 return ""
10221 }
10222 return *p.Vendor
10223 }
10224
10225
10226 func (p *PackageRelease) GetAuthor() *User {
10227 if p == nil {
10228 return nil
10229 }
10230 return p.Author
10231 }
10232
10233
10234 func (p *PackageRelease) GetCreatedAt() Timestamp {
10235 if p == nil || p.CreatedAt == nil {
10236 return Timestamp{}
10237 }
10238 return *p.CreatedAt
10239 }
10240
10241
10242 func (p *PackageRelease) GetDraft() bool {
10243 if p == nil || p.Draft == nil {
10244 return false
10245 }
10246 return *p.Draft
10247 }
10248
10249
10250 func (p *PackageRelease) GetHTMLURL() string {
10251 if p == nil || p.HTMLURL == nil {
10252 return ""
10253 }
10254 return *p.HTMLURL
10255 }
10256
10257
10258 func (p *PackageRelease) GetID() int64 {
10259 if p == nil || p.ID == nil {
10260 return 0
10261 }
10262 return *p.ID
10263 }
10264
10265
10266 func (p *PackageRelease) GetName() string {
10267 if p == nil || p.Name == nil {
10268 return ""
10269 }
10270 return *p.Name
10271 }
10272
10273
10274 func (p *PackageRelease) GetPrerelease() bool {
10275 if p == nil || p.Prerelease == nil {
10276 return false
10277 }
10278 return *p.Prerelease
10279 }
10280
10281
10282 func (p *PackageRelease) GetPublishedAt() Timestamp {
10283 if p == nil || p.PublishedAt == nil {
10284 return Timestamp{}
10285 }
10286 return *p.PublishedAt
10287 }
10288
10289
10290 func (p *PackageRelease) GetTagName() string {
10291 if p == nil || p.TagName == nil {
10292 return ""
10293 }
10294 return *p.TagName
10295 }
10296
10297
10298 func (p *PackageRelease) GetTargetCommitish() string {
10299 if p == nil || p.TargetCommitish == nil {
10300 return ""
10301 }
10302 return *p.TargetCommitish
10303 }
10304
10305
10306 func (p *PackageRelease) GetURL() string {
10307 if p == nil || p.URL == nil {
10308 return ""
10309 }
10310 return *p.URL
10311 }
10312
10313
10314 func (p *PackageVersion) GetAuthor() *User {
10315 if p == nil {
10316 return nil
10317 }
10318 return p.Author
10319 }
10320
10321
10322 func (p *PackageVersion) GetBody() string {
10323 if p == nil || p.Body == nil {
10324 return ""
10325 }
10326 return *p.Body
10327 }
10328
10329
10330 func (p *PackageVersion) GetBodyHTML() string {
10331 if p == nil || p.BodyHTML == nil {
10332 return ""
10333 }
10334 return *p.BodyHTML
10335 }
10336
10337
10338 func (p *PackageVersion) GetCreatedAt() Timestamp {
10339 if p == nil || p.CreatedAt == nil {
10340 return Timestamp{}
10341 }
10342 return *p.CreatedAt
10343 }
10344
10345
10346 func (p *PackageVersion) GetDraft() bool {
10347 if p == nil || p.Draft == nil {
10348 return false
10349 }
10350 return *p.Draft
10351 }
10352
10353
10354 func (p *PackageVersion) GetHTMLURL() string {
10355 if p == nil || p.HTMLURL == nil {
10356 return ""
10357 }
10358 return *p.HTMLURL
10359 }
10360
10361
10362 func (p *PackageVersion) GetID() int64 {
10363 if p == nil || p.ID == nil {
10364 return 0
10365 }
10366 return *p.ID
10367 }
10368
10369
10370 func (p *PackageVersion) GetInstallationCommand() string {
10371 if p == nil || p.InstallationCommand == nil {
10372 return ""
10373 }
10374 return *p.InstallationCommand
10375 }
10376
10377
10378 func (p *PackageVersion) GetManifest() string {
10379 if p == nil || p.Manifest == nil {
10380 return ""
10381 }
10382 return *p.Manifest
10383 }
10384
10385
10386 func (p *PackageVersion) GetMetadata() *PackageMetadata {
10387 if p == nil {
10388 return nil
10389 }
10390 return p.Metadata
10391 }
10392
10393
10394 func (p *PackageVersion) GetName() string {
10395 if p == nil || p.Name == nil {
10396 return ""
10397 }
10398 return *p.Name
10399 }
10400
10401
10402 func (p *PackageVersion) GetPackageHTMLURL() string {
10403 if p == nil || p.PackageHTMLURL == nil {
10404 return ""
10405 }
10406 return *p.PackageHTMLURL
10407 }
10408
10409
10410 func (p *PackageVersion) GetPrerelease() bool {
10411 if p == nil || p.Prerelease == nil {
10412 return false
10413 }
10414 return *p.Prerelease
10415 }
10416
10417
10418 func (p *PackageVersion) GetRelease() *PackageRelease {
10419 if p == nil {
10420 return nil
10421 }
10422 return p.Release
10423 }
10424
10425
10426 func (p *PackageVersion) GetSummary() string {
10427 if p == nil || p.Summary == nil {
10428 return ""
10429 }
10430 return *p.Summary
10431 }
10432
10433
10434 func (p *PackageVersion) GetTagName() string {
10435 if p == nil || p.TagName == nil {
10436 return ""
10437 }
10438 return *p.TagName
10439 }
10440
10441
10442 func (p *PackageVersion) GetTargetCommitish() string {
10443 if p == nil || p.TargetCommitish == nil {
10444 return ""
10445 }
10446 return *p.TargetCommitish
10447 }
10448
10449
10450 func (p *PackageVersion) GetTargetOID() string {
10451 if p == nil || p.TargetOID == nil {
10452 return ""
10453 }
10454 return *p.TargetOID
10455 }
10456
10457
10458 func (p *PackageVersion) GetUpdatedAt() Timestamp {
10459 if p == nil || p.UpdatedAt == nil {
10460 return Timestamp{}
10461 }
10462 return *p.UpdatedAt
10463 }
10464
10465
10466 func (p *PackageVersion) GetURL() string {
10467 if p == nil || p.URL == nil {
10468 return ""
10469 }
10470 return *p.URL
10471 }
10472
10473
10474 func (p *PackageVersion) GetVersion() string {
10475 if p == nil || p.Version == nil {
10476 return ""
10477 }
10478 return *p.Version
10479 }
10480
10481
10482 func (p *Page) GetAction() string {
10483 if p == nil || p.Action == nil {
10484 return ""
10485 }
10486 return *p.Action
10487 }
10488
10489
10490 func (p *Page) GetHTMLURL() string {
10491 if p == nil || p.HTMLURL == nil {
10492 return ""
10493 }
10494 return *p.HTMLURL
10495 }
10496
10497
10498 func (p *Page) GetPageName() string {
10499 if p == nil || p.PageName == nil {
10500 return ""
10501 }
10502 return *p.PageName
10503 }
10504
10505
10506 func (p *Page) GetSHA() string {
10507 if p == nil || p.SHA == nil {
10508 return ""
10509 }
10510 return *p.SHA
10511 }
10512
10513
10514 func (p *Page) GetSummary() string {
10515 if p == nil || p.Summary == nil {
10516 return ""
10517 }
10518 return *p.Summary
10519 }
10520
10521
10522 func (p *Page) GetTitle() string {
10523 if p == nil || p.Title == nil {
10524 return ""
10525 }
10526 return *p.Title
10527 }
10528
10529
10530 func (p *PageBuildEvent) GetBuild() *PagesBuild {
10531 if p == nil {
10532 return nil
10533 }
10534 return p.Build
10535 }
10536
10537
10538 func (p *PageBuildEvent) GetID() int64 {
10539 if p == nil || p.ID == nil {
10540 return 0
10541 }
10542 return *p.ID
10543 }
10544
10545
10546 func (p *PageBuildEvent) GetInstallation() *Installation {
10547 if p == nil {
10548 return nil
10549 }
10550 return p.Installation
10551 }
10552
10553
10554 func (p *PageBuildEvent) GetRepo() *Repository {
10555 if p == nil {
10556 return nil
10557 }
10558 return p.Repo
10559 }
10560
10561
10562 func (p *PageBuildEvent) GetSender() *User {
10563 if p == nil {
10564 return nil
10565 }
10566 return p.Sender
10567 }
10568
10569
10570 func (p *Pages) GetCNAME() string {
10571 if p == nil || p.CNAME == nil {
10572 return ""
10573 }
10574 return *p.CNAME
10575 }
10576
10577
10578 func (p *Pages) GetCustom404() bool {
10579 if p == nil || p.Custom404 == nil {
10580 return false
10581 }
10582 return *p.Custom404
10583 }
10584
10585
10586 func (p *Pages) GetHTMLURL() string {
10587 if p == nil || p.HTMLURL == nil {
10588 return ""
10589 }
10590 return *p.HTMLURL
10591 }
10592
10593
10594 func (p *Pages) GetHTTPSCertificate() *PagesHTTPSCertificate {
10595 if p == nil {
10596 return nil
10597 }
10598 return p.HTTPSCertificate
10599 }
10600
10601
10602 func (p *Pages) GetHTTPSEnforced() bool {
10603 if p == nil || p.HTTPSEnforced == nil {
10604 return false
10605 }
10606 return *p.HTTPSEnforced
10607 }
10608
10609
10610 func (p *Pages) GetPublic() bool {
10611 if p == nil || p.Public == nil {
10612 return false
10613 }
10614 return *p.Public
10615 }
10616
10617
10618 func (p *Pages) GetSource() *PagesSource {
10619 if p == nil {
10620 return nil
10621 }
10622 return p.Source
10623 }
10624
10625
10626 func (p *Pages) GetStatus() string {
10627 if p == nil || p.Status == nil {
10628 return ""
10629 }
10630 return *p.Status
10631 }
10632
10633
10634 func (p *Pages) GetURL() string {
10635 if p == nil || p.URL == nil {
10636 return ""
10637 }
10638 return *p.URL
10639 }
10640
10641
10642 func (p *PagesBuild) GetCommit() string {
10643 if p == nil || p.Commit == nil {
10644 return ""
10645 }
10646 return *p.Commit
10647 }
10648
10649
10650 func (p *PagesBuild) GetCreatedAt() Timestamp {
10651 if p == nil || p.CreatedAt == nil {
10652 return Timestamp{}
10653 }
10654 return *p.CreatedAt
10655 }
10656
10657
10658 func (p *PagesBuild) GetDuration() int {
10659 if p == nil || p.Duration == nil {
10660 return 0
10661 }
10662 return *p.Duration
10663 }
10664
10665
10666 func (p *PagesBuild) GetError() *PagesError {
10667 if p == nil {
10668 return nil
10669 }
10670 return p.Error
10671 }
10672
10673
10674 func (p *PagesBuild) GetPusher() *User {
10675 if p == nil {
10676 return nil
10677 }
10678 return p.Pusher
10679 }
10680
10681
10682 func (p *PagesBuild) GetStatus() string {
10683 if p == nil || p.Status == nil {
10684 return ""
10685 }
10686 return *p.Status
10687 }
10688
10689
10690 func (p *PagesBuild) GetUpdatedAt() Timestamp {
10691 if p == nil || p.UpdatedAt == nil {
10692 return Timestamp{}
10693 }
10694 return *p.UpdatedAt
10695 }
10696
10697
10698 func (p *PagesBuild) GetURL() string {
10699 if p == nil || p.URL == nil {
10700 return ""
10701 }
10702 return *p.URL
10703 }
10704
10705
10706 func (p *PagesError) GetMessage() string {
10707 if p == nil || p.Message == nil {
10708 return ""
10709 }
10710 return *p.Message
10711 }
10712
10713
10714 func (p *PagesHTTPSCertificate) GetDescription() string {
10715 if p == nil || p.Description == nil {
10716 return ""
10717 }
10718 return *p.Description
10719 }
10720
10721
10722 func (p *PagesHTTPSCertificate) GetExpiresAt() string {
10723 if p == nil || p.ExpiresAt == nil {
10724 return ""
10725 }
10726 return *p.ExpiresAt
10727 }
10728
10729
10730 func (p *PagesHTTPSCertificate) GetState() string {
10731 if p == nil || p.State == nil {
10732 return ""
10733 }
10734 return *p.State
10735 }
10736
10737
10738 func (p *PagesSource) GetBranch() string {
10739 if p == nil || p.Branch == nil {
10740 return ""
10741 }
10742 return *p.Branch
10743 }
10744
10745
10746 func (p *PagesSource) GetPath() string {
10747 if p == nil || p.Path == nil {
10748 return ""
10749 }
10750 return *p.Path
10751 }
10752
10753
10754 func (p *PageStats) GetTotalPages() int {
10755 if p == nil || p.TotalPages == nil {
10756 return 0
10757 }
10758 return *p.TotalPages
10759 }
10760
10761
10762 func (p *PagesUpdate) GetCNAME() string {
10763 if p == nil || p.CNAME == nil {
10764 return ""
10765 }
10766 return *p.CNAME
10767 }
10768
10769
10770 func (p *PagesUpdate) GetHTTPSEnforced() bool {
10771 if p == nil || p.HTTPSEnforced == nil {
10772 return false
10773 }
10774 return *p.HTTPSEnforced
10775 }
10776
10777
10778 func (p *PagesUpdate) GetPublic() bool {
10779 if p == nil || p.Public == nil {
10780 return false
10781 }
10782 return *p.Public
10783 }
10784
10785
10786 func (p *PagesUpdate) GetSource() string {
10787 if p == nil || p.Source == nil {
10788 return ""
10789 }
10790 return *p.Source
10791 }
10792
10793
10794 func (p *PingEvent) GetHook() *Hook {
10795 if p == nil {
10796 return nil
10797 }
10798 return p.Hook
10799 }
10800
10801
10802 func (p *PingEvent) GetHookID() int64 {
10803 if p == nil || p.HookID == nil {
10804 return 0
10805 }
10806 return *p.HookID
10807 }
10808
10809
10810 func (p *PingEvent) GetInstallation() *Installation {
10811 if p == nil {
10812 return nil
10813 }
10814 return p.Installation
10815 }
10816
10817
10818 func (p *PingEvent) GetOrg() *Organization {
10819 if p == nil {
10820 return nil
10821 }
10822 return p.Org
10823 }
10824
10825
10826 func (p *PingEvent) GetRepo() *Repository {
10827 if p == nil {
10828 return nil
10829 }
10830 return p.Repo
10831 }
10832
10833
10834 func (p *PingEvent) GetSender() *User {
10835 if p == nil {
10836 return nil
10837 }
10838 return p.Sender
10839 }
10840
10841
10842 func (p *PingEvent) GetZen() string {
10843 if p == nil || p.Zen == nil {
10844 return ""
10845 }
10846 return *p.Zen
10847 }
10848
10849
10850 func (p *Plan) GetCollaborators() int {
10851 if p == nil || p.Collaborators == nil {
10852 return 0
10853 }
10854 return *p.Collaborators
10855 }
10856
10857
10858 func (p *Plan) GetFilledSeats() int {
10859 if p == nil || p.FilledSeats == nil {
10860 return 0
10861 }
10862 return *p.FilledSeats
10863 }
10864
10865
10866 func (p *Plan) GetName() string {
10867 if p == nil || p.Name == nil {
10868 return ""
10869 }
10870 return *p.Name
10871 }
10872
10873
10874 func (p *Plan) GetPrivateRepos() int {
10875 if p == nil || p.PrivateRepos == nil {
10876 return 0
10877 }
10878 return *p.PrivateRepos
10879 }
10880
10881
10882 func (p *Plan) GetSeats() int {
10883 if p == nil || p.Seats == nil {
10884 return 0
10885 }
10886 return *p.Seats
10887 }
10888
10889
10890 func (p *Plan) GetSpace() int {
10891 if p == nil || p.Space == nil {
10892 return 0
10893 }
10894 return *p.Space
10895 }
10896
10897
10898 func (p *PreReceiveHook) GetConfigURL() string {
10899 if p == nil || p.ConfigURL == nil {
10900 return ""
10901 }
10902 return *p.ConfigURL
10903 }
10904
10905
10906 func (p *PreReceiveHook) GetEnforcement() string {
10907 if p == nil || p.Enforcement == nil {
10908 return ""
10909 }
10910 return *p.Enforcement
10911 }
10912
10913
10914 func (p *PreReceiveHook) GetID() int64 {
10915 if p == nil || p.ID == nil {
10916 return 0
10917 }
10918 return *p.ID
10919 }
10920
10921
10922 func (p *PreReceiveHook) GetName() string {
10923 if p == nil || p.Name == nil {
10924 return ""
10925 }
10926 return *p.Name
10927 }
10928
10929
10930 func (p *PRLink) GetHRef() string {
10931 if p == nil || p.HRef == nil {
10932 return ""
10933 }
10934 return *p.HRef
10935 }
10936
10937
10938 func (p *PRLinks) GetComments() *PRLink {
10939 if p == nil {
10940 return nil
10941 }
10942 return p.Comments
10943 }
10944
10945
10946 func (p *PRLinks) GetCommits() *PRLink {
10947 if p == nil {
10948 return nil
10949 }
10950 return p.Commits
10951 }
10952
10953
10954 func (p *PRLinks) GetHTML() *PRLink {
10955 if p == nil {
10956 return nil
10957 }
10958 return p.HTML
10959 }
10960
10961
10962 func (p *PRLinks) GetIssue() *PRLink {
10963 if p == nil {
10964 return nil
10965 }
10966 return p.Issue
10967 }
10968
10969
10970 func (p *PRLinks) GetReviewComment() *PRLink {
10971 if p == nil {
10972 return nil
10973 }
10974 return p.ReviewComment
10975 }
10976
10977
10978 func (p *PRLinks) GetReviewComments() *PRLink {
10979 if p == nil {
10980 return nil
10981 }
10982 return p.ReviewComments
10983 }
10984
10985
10986 func (p *PRLinks) GetSelf() *PRLink {
10987 if p == nil {
10988 return nil
10989 }
10990 return p.Self
10991 }
10992
10993
10994 func (p *PRLinks) GetStatuses() *PRLink {
10995 if p == nil {
10996 return nil
10997 }
10998 return p.Statuses
10999 }
11000
11001
11002 func (p *Project) GetBody() string {
11003 if p == nil || p.Body == nil {
11004 return ""
11005 }
11006 return *p.Body
11007 }
11008
11009
11010 func (p *Project) GetColumnsURL() string {
11011 if p == nil || p.ColumnsURL == nil {
11012 return ""
11013 }
11014 return *p.ColumnsURL
11015 }
11016
11017
11018 func (p *Project) GetCreatedAt() Timestamp {
11019 if p == nil || p.CreatedAt == nil {
11020 return Timestamp{}
11021 }
11022 return *p.CreatedAt
11023 }
11024
11025
11026 func (p *Project) GetCreator() *User {
11027 if p == nil {
11028 return nil
11029 }
11030 return p.Creator
11031 }
11032
11033
11034 func (p *Project) GetHTMLURL() string {
11035 if p == nil || p.HTMLURL == nil {
11036 return ""
11037 }
11038 return *p.HTMLURL
11039 }
11040
11041
11042 func (p *Project) GetID() int64 {
11043 if p == nil || p.ID == nil {
11044 return 0
11045 }
11046 return *p.ID
11047 }
11048
11049
11050 func (p *Project) GetName() string {
11051 if p == nil || p.Name == nil {
11052 return ""
11053 }
11054 return *p.Name
11055 }
11056
11057
11058 func (p *Project) GetNodeID() string {
11059 if p == nil || p.NodeID == nil {
11060 return ""
11061 }
11062 return *p.NodeID
11063 }
11064
11065
11066 func (p *Project) GetNumber() int {
11067 if p == nil || p.Number == nil {
11068 return 0
11069 }
11070 return *p.Number
11071 }
11072
11073
11074 func (p *Project) GetOrganizationPermission() string {
11075 if p == nil || p.OrganizationPermission == nil {
11076 return ""
11077 }
11078 return *p.OrganizationPermission
11079 }
11080
11081
11082 func (p *Project) GetOwnerURL() string {
11083 if p == nil || p.OwnerURL == nil {
11084 return ""
11085 }
11086 return *p.OwnerURL
11087 }
11088
11089
11090 func (p *Project) GetPrivate() bool {
11091 if p == nil || p.Private == nil {
11092 return false
11093 }
11094 return *p.Private
11095 }
11096
11097
11098 func (p *Project) GetState() string {
11099 if p == nil || p.State == nil {
11100 return ""
11101 }
11102 return *p.State
11103 }
11104
11105
11106 func (p *Project) GetUpdatedAt() Timestamp {
11107 if p == nil || p.UpdatedAt == nil {
11108 return Timestamp{}
11109 }
11110 return *p.UpdatedAt
11111 }
11112
11113
11114 func (p *Project) GetURL() string {
11115 if p == nil || p.URL == nil {
11116 return ""
11117 }
11118 return *p.URL
11119 }
11120
11121
11122 func (p *ProjectBody) GetFrom() string {
11123 if p == nil || p.From == nil {
11124 return ""
11125 }
11126 return *p.From
11127 }
11128
11129
11130 func (p *ProjectCard) GetArchived() bool {
11131 if p == nil || p.Archived == nil {
11132 return false
11133 }
11134 return *p.Archived
11135 }
11136
11137
11138 func (p *ProjectCard) GetColumnID() int64 {
11139 if p == nil || p.ColumnID == nil {
11140 return 0
11141 }
11142 return *p.ColumnID
11143 }
11144
11145
11146 func (p *ProjectCard) GetColumnName() string {
11147 if p == nil || p.ColumnName == nil {
11148 return ""
11149 }
11150 return *p.ColumnName
11151 }
11152
11153
11154 func (p *ProjectCard) GetColumnURL() string {
11155 if p == nil || p.ColumnURL == nil {
11156 return ""
11157 }
11158 return *p.ColumnURL
11159 }
11160
11161
11162 func (p *ProjectCard) GetContentURL() string {
11163 if p == nil || p.ContentURL == nil {
11164 return ""
11165 }
11166 return *p.ContentURL
11167 }
11168
11169
11170 func (p *ProjectCard) GetCreatedAt() Timestamp {
11171 if p == nil || p.CreatedAt == nil {
11172 return Timestamp{}
11173 }
11174 return *p.CreatedAt
11175 }
11176
11177
11178 func (p *ProjectCard) GetCreator() *User {
11179 if p == nil {
11180 return nil
11181 }
11182 return p.Creator
11183 }
11184
11185
11186 func (p *ProjectCard) GetID() int64 {
11187 if p == nil || p.ID == nil {
11188 return 0
11189 }
11190 return *p.ID
11191 }
11192
11193
11194 func (p *ProjectCard) GetNodeID() string {
11195 if p == nil || p.NodeID == nil {
11196 return ""
11197 }
11198 return *p.NodeID
11199 }
11200
11201
11202 func (p *ProjectCard) GetNote() string {
11203 if p == nil || p.Note == nil {
11204 return ""
11205 }
11206 return *p.Note
11207 }
11208
11209
11210 func (p *ProjectCard) GetPreviousColumnName() string {
11211 if p == nil || p.PreviousColumnName == nil {
11212 return ""
11213 }
11214 return *p.PreviousColumnName
11215 }
11216
11217
11218 func (p *ProjectCard) GetProjectID() int64 {
11219 if p == nil || p.ProjectID == nil {
11220 return 0
11221 }
11222 return *p.ProjectID
11223 }
11224
11225
11226 func (p *ProjectCard) GetProjectURL() string {
11227 if p == nil || p.ProjectURL == nil {
11228 return ""
11229 }
11230 return *p.ProjectURL
11231 }
11232
11233
11234 func (p *ProjectCard) GetUpdatedAt() Timestamp {
11235 if p == nil || p.UpdatedAt == nil {
11236 return Timestamp{}
11237 }
11238 return *p.UpdatedAt
11239 }
11240
11241
11242 func (p *ProjectCard) GetURL() string {
11243 if p == nil || p.URL == nil {
11244 return ""
11245 }
11246 return *p.URL
11247 }
11248
11249
11250 func (p *ProjectCardChange) GetNote() *ProjectCardNote {
11251 if p == nil {
11252 return nil
11253 }
11254 return p.Note
11255 }
11256
11257
11258 func (p *ProjectCardEvent) GetAction() string {
11259 if p == nil || p.Action == nil {
11260 return ""
11261 }
11262 return *p.Action
11263 }
11264
11265
11266 func (p *ProjectCardEvent) GetAfterID() int64 {
11267 if p == nil || p.AfterID == nil {
11268 return 0
11269 }
11270 return *p.AfterID
11271 }
11272
11273
11274 func (p *ProjectCardEvent) GetChanges() *ProjectCardChange {
11275 if p == nil {
11276 return nil
11277 }
11278 return p.Changes
11279 }
11280
11281
11282 func (p *ProjectCardEvent) GetInstallation() *Installation {
11283 if p == nil {
11284 return nil
11285 }
11286 return p.Installation
11287 }
11288
11289
11290 func (p *ProjectCardEvent) GetOrg() *Organization {
11291 if p == nil {
11292 return nil
11293 }
11294 return p.Org
11295 }
11296
11297
11298 func (p *ProjectCardEvent) GetProjectCard() *ProjectCard {
11299 if p == nil {
11300 return nil
11301 }
11302 return p.ProjectCard
11303 }
11304
11305
11306 func (p *ProjectCardEvent) GetRepo() *Repository {
11307 if p == nil {
11308 return nil
11309 }
11310 return p.Repo
11311 }
11312
11313
11314 func (p *ProjectCardEvent) GetSender() *User {
11315 if p == nil {
11316 return nil
11317 }
11318 return p.Sender
11319 }
11320
11321
11322 func (p *ProjectCardListOptions) GetArchivedState() string {
11323 if p == nil || p.ArchivedState == nil {
11324 return ""
11325 }
11326 return *p.ArchivedState
11327 }
11328
11329
11330 func (p *ProjectCardNote) GetFrom() string {
11331 if p == nil || p.From == nil {
11332 return ""
11333 }
11334 return *p.From
11335 }
11336
11337
11338 func (p *ProjectCardOptions) GetArchived() bool {
11339 if p == nil || p.Archived == nil {
11340 return false
11341 }
11342 return *p.Archived
11343 }
11344
11345
11346 func (p *ProjectChange) GetBody() *ProjectBody {
11347 if p == nil {
11348 return nil
11349 }
11350 return p.Body
11351 }
11352
11353
11354 func (p *ProjectChange) GetName() *ProjectName {
11355 if p == nil {
11356 return nil
11357 }
11358 return p.Name
11359 }
11360
11361
11362 func (p *ProjectCollaboratorOptions) GetPermission() string {
11363 if p == nil || p.Permission == nil {
11364 return ""
11365 }
11366 return *p.Permission
11367 }
11368
11369
11370 func (p *ProjectColumn) GetCardsURL() string {
11371 if p == nil || p.CardsURL == nil {
11372 return ""
11373 }
11374 return *p.CardsURL
11375 }
11376
11377
11378 func (p *ProjectColumn) GetCreatedAt() Timestamp {
11379 if p == nil || p.CreatedAt == nil {
11380 return Timestamp{}
11381 }
11382 return *p.CreatedAt
11383 }
11384
11385
11386 func (p *ProjectColumn) GetID() int64 {
11387 if p == nil || p.ID == nil {
11388 return 0
11389 }
11390 return *p.ID
11391 }
11392
11393
11394 func (p *ProjectColumn) GetName() string {
11395 if p == nil || p.Name == nil {
11396 return ""
11397 }
11398 return *p.Name
11399 }
11400
11401
11402 func (p *ProjectColumn) GetNodeID() string {
11403 if p == nil || p.NodeID == nil {
11404 return ""
11405 }
11406 return *p.NodeID
11407 }
11408
11409
11410 func (p *ProjectColumn) GetProjectURL() string {
11411 if p == nil || p.ProjectURL == nil {
11412 return ""
11413 }
11414 return *p.ProjectURL
11415 }
11416
11417
11418 func (p *ProjectColumn) GetUpdatedAt() Timestamp {
11419 if p == nil || p.UpdatedAt == nil {
11420 return Timestamp{}
11421 }
11422 return *p.UpdatedAt
11423 }
11424
11425
11426 func (p *ProjectColumn) GetURL() string {
11427 if p == nil || p.URL == nil {
11428 return ""
11429 }
11430 return *p.URL
11431 }
11432
11433
11434 func (p *ProjectColumnChange) GetName() *ProjectColumnName {
11435 if p == nil {
11436 return nil
11437 }
11438 return p.Name
11439 }
11440
11441
11442 func (p *ProjectColumnEvent) GetAction() string {
11443 if p == nil || p.Action == nil {
11444 return ""
11445 }
11446 return *p.Action
11447 }
11448
11449
11450 func (p *ProjectColumnEvent) GetAfterID() int64 {
11451 if p == nil || p.AfterID == nil {
11452 return 0
11453 }
11454 return *p.AfterID
11455 }
11456
11457
11458 func (p *ProjectColumnEvent) GetChanges() *ProjectColumnChange {
11459 if p == nil {
11460 return nil
11461 }
11462 return p.Changes
11463 }
11464
11465
11466 func (p *ProjectColumnEvent) GetInstallation() *Installation {
11467 if p == nil {
11468 return nil
11469 }
11470 return p.Installation
11471 }
11472
11473
11474 func (p *ProjectColumnEvent) GetOrg() *Organization {
11475 if p == nil {
11476 return nil
11477 }
11478 return p.Org
11479 }
11480
11481
11482 func (p *ProjectColumnEvent) GetProjectColumn() *ProjectColumn {
11483 if p == nil {
11484 return nil
11485 }
11486 return p.ProjectColumn
11487 }
11488
11489
11490 func (p *ProjectColumnEvent) GetRepo() *Repository {
11491 if p == nil {
11492 return nil
11493 }
11494 return p.Repo
11495 }
11496
11497
11498 func (p *ProjectColumnEvent) GetSender() *User {
11499 if p == nil {
11500 return nil
11501 }
11502 return p.Sender
11503 }
11504
11505
11506 func (p *ProjectColumnName) GetFrom() string {
11507 if p == nil || p.From == nil {
11508 return ""
11509 }
11510 return *p.From
11511 }
11512
11513
11514 func (p *ProjectEvent) GetAction() string {
11515 if p == nil || p.Action == nil {
11516 return ""
11517 }
11518 return *p.Action
11519 }
11520
11521
11522 func (p *ProjectEvent) GetChanges() *ProjectChange {
11523 if p == nil {
11524 return nil
11525 }
11526 return p.Changes
11527 }
11528
11529
11530 func (p *ProjectEvent) GetInstallation() *Installation {
11531 if p == nil {
11532 return nil
11533 }
11534 return p.Installation
11535 }
11536
11537
11538 func (p *ProjectEvent) GetOrg() *Organization {
11539 if p == nil {
11540 return nil
11541 }
11542 return p.Org
11543 }
11544
11545
11546 func (p *ProjectEvent) GetProject() *Project {
11547 if p == nil {
11548 return nil
11549 }
11550 return p.Project
11551 }
11552
11553
11554 func (p *ProjectEvent) GetRepo() *Repository {
11555 if p == nil {
11556 return nil
11557 }
11558 return p.Repo
11559 }
11560
11561
11562 func (p *ProjectEvent) GetSender() *User {
11563 if p == nil {
11564 return nil
11565 }
11566 return p.Sender
11567 }
11568
11569
11570 func (p *ProjectName) GetFrom() string {
11571 if p == nil || p.From == nil {
11572 return ""
11573 }
11574 return *p.From
11575 }
11576
11577
11578 func (p *ProjectOptions) GetBody() string {
11579 if p == nil || p.Body == nil {
11580 return ""
11581 }
11582 return *p.Body
11583 }
11584
11585
11586 func (p *ProjectOptions) GetName() string {
11587 if p == nil || p.Name == nil {
11588 return ""
11589 }
11590 return *p.Name
11591 }
11592
11593
11594 func (p *ProjectOptions) GetOrganizationPermission() string {
11595 if p == nil || p.OrganizationPermission == nil {
11596 return ""
11597 }
11598 return *p.OrganizationPermission
11599 }
11600
11601
11602 func (p *ProjectOptions) GetPrivate() bool {
11603 if p == nil || p.Private == nil {
11604 return false
11605 }
11606 return *p.Private
11607 }
11608
11609
11610 func (p *ProjectOptions) GetState() string {
11611 if p == nil || p.State == nil {
11612 return ""
11613 }
11614 return *p.State
11615 }
11616
11617
11618 func (p *ProjectPermissionLevel) GetPermission() string {
11619 if p == nil || p.Permission == nil {
11620 return ""
11621 }
11622 return *p.Permission
11623 }
11624
11625
11626 func (p *ProjectPermissionLevel) GetUser() *User {
11627 if p == nil {
11628 return nil
11629 }
11630 return p.User
11631 }
11632
11633
11634 func (p *Protection) GetAllowDeletions() *AllowDeletions {
11635 if p == nil {
11636 return nil
11637 }
11638 return p.AllowDeletions
11639 }
11640
11641
11642 func (p *Protection) GetAllowForcePushes() *AllowForcePushes {
11643 if p == nil {
11644 return nil
11645 }
11646 return p.AllowForcePushes
11647 }
11648
11649
11650 func (p *Protection) GetEnforceAdmins() *AdminEnforcement {
11651 if p == nil {
11652 return nil
11653 }
11654 return p.EnforceAdmins
11655 }
11656
11657
11658 func (p *Protection) GetRequiredConversationResolution() *RequiredConversationResolution {
11659 if p == nil {
11660 return nil
11661 }
11662 return p.RequiredConversationResolution
11663 }
11664
11665
11666 func (p *Protection) GetRequiredPullRequestReviews() *PullRequestReviewsEnforcement {
11667 if p == nil {
11668 return nil
11669 }
11670 return p.RequiredPullRequestReviews
11671 }
11672
11673
11674 func (p *Protection) GetRequiredStatusChecks() *RequiredStatusChecks {
11675 if p == nil {
11676 return nil
11677 }
11678 return p.RequiredStatusChecks
11679 }
11680
11681
11682 func (p *Protection) GetRequireLinearHistory() *RequireLinearHistory {
11683 if p == nil {
11684 return nil
11685 }
11686 return p.RequireLinearHistory
11687 }
11688
11689
11690 func (p *Protection) GetRestrictions() *BranchRestrictions {
11691 if p == nil {
11692 return nil
11693 }
11694 return p.Restrictions
11695 }
11696
11697
11698 func (p *ProtectionChanges) GetAuthorizedActorNames() *AuthorizedActorNames {
11699 if p == nil {
11700 return nil
11701 }
11702 return p.AuthorizedActorNames
11703 }
11704
11705
11706 func (p *ProtectionChanges) GetAuthorizedActorsOnly() *AuthorizedActorsOnly {
11707 if p == nil {
11708 return nil
11709 }
11710 return p.AuthorizedActorsOnly
11711 }
11712
11713
11714 func (p *ProtectionRequest) GetAllowDeletions() bool {
11715 if p == nil || p.AllowDeletions == nil {
11716 return false
11717 }
11718 return *p.AllowDeletions
11719 }
11720
11721
11722 func (p *ProtectionRequest) GetAllowForcePushes() bool {
11723 if p == nil || p.AllowForcePushes == nil {
11724 return false
11725 }
11726 return *p.AllowForcePushes
11727 }
11728
11729
11730 func (p *ProtectionRequest) GetRequiredConversationResolution() bool {
11731 if p == nil || p.RequiredConversationResolution == nil {
11732 return false
11733 }
11734 return *p.RequiredConversationResolution
11735 }
11736
11737
11738 func (p *ProtectionRequest) GetRequiredPullRequestReviews() *PullRequestReviewsEnforcementRequest {
11739 if p == nil {
11740 return nil
11741 }
11742 return p.RequiredPullRequestReviews
11743 }
11744
11745
11746 func (p *ProtectionRequest) GetRequiredStatusChecks() *RequiredStatusChecks {
11747 if p == nil {
11748 return nil
11749 }
11750 return p.RequiredStatusChecks
11751 }
11752
11753
11754 func (p *ProtectionRequest) GetRequireLinearHistory() bool {
11755 if p == nil || p.RequireLinearHistory == nil {
11756 return false
11757 }
11758 return *p.RequireLinearHistory
11759 }
11760
11761
11762 func (p *ProtectionRequest) GetRestrictions() *BranchRestrictionsRequest {
11763 if p == nil {
11764 return nil
11765 }
11766 return p.Restrictions
11767 }
11768
11769
11770 func (p *ProtectionRule) GetID() int64 {
11771 if p == nil || p.ID == nil {
11772 return 0
11773 }
11774 return *p.ID
11775 }
11776
11777
11778 func (p *ProtectionRule) GetNodeID() string {
11779 if p == nil || p.NodeID == nil {
11780 return ""
11781 }
11782 return *p.NodeID
11783 }
11784
11785
11786 func (p *ProtectionRule) GetType() string {
11787 if p == nil || p.Type == nil {
11788 return ""
11789 }
11790 return *p.Type
11791 }
11792
11793
11794 func (p *ProtectionRule) GetWaitTimer() int {
11795 if p == nil || p.WaitTimer == nil {
11796 return 0
11797 }
11798 return *p.WaitTimer
11799 }
11800
11801
11802 func (p *PublicEvent) GetInstallation() *Installation {
11803 if p == nil {
11804 return nil
11805 }
11806 return p.Installation
11807 }
11808
11809
11810 func (p *PublicEvent) GetRepo() *Repository {
11811 if p == nil {
11812 return nil
11813 }
11814 return p.Repo
11815 }
11816
11817
11818 func (p *PublicEvent) GetSender() *User {
11819 if p == nil {
11820 return nil
11821 }
11822 return p.Sender
11823 }
11824
11825
11826 func (p *PublicKey) GetKey() string {
11827 if p == nil || p.Key == nil {
11828 return ""
11829 }
11830 return *p.Key
11831 }
11832
11833
11834 func (p *PublicKey) GetKeyID() string {
11835 if p == nil || p.KeyID == nil {
11836 return ""
11837 }
11838 return *p.KeyID
11839 }
11840
11841
11842 func (p *PullRequest) GetActiveLockReason() string {
11843 if p == nil || p.ActiveLockReason == nil {
11844 return ""
11845 }
11846 return *p.ActiveLockReason
11847 }
11848
11849
11850 func (p *PullRequest) GetAdditions() int {
11851 if p == nil || p.Additions == nil {
11852 return 0
11853 }
11854 return *p.Additions
11855 }
11856
11857
11858 func (p *PullRequest) GetAssignee() *User {
11859 if p == nil {
11860 return nil
11861 }
11862 return p.Assignee
11863 }
11864
11865
11866 func (p *PullRequest) GetAuthorAssociation() string {
11867 if p == nil || p.AuthorAssociation == nil {
11868 return ""
11869 }
11870 return *p.AuthorAssociation
11871 }
11872
11873
11874 func (p *PullRequest) GetAutoMerge() *PullRequestAutoMerge {
11875 if p == nil {
11876 return nil
11877 }
11878 return p.AutoMerge
11879 }
11880
11881
11882 func (p *PullRequest) GetBase() *PullRequestBranch {
11883 if p == nil {
11884 return nil
11885 }
11886 return p.Base
11887 }
11888
11889
11890 func (p *PullRequest) GetBody() string {
11891 if p == nil || p.Body == nil {
11892 return ""
11893 }
11894 return *p.Body
11895 }
11896
11897
11898 func (p *PullRequest) GetChangedFiles() int {
11899 if p == nil || p.ChangedFiles == nil {
11900 return 0
11901 }
11902 return *p.ChangedFiles
11903 }
11904
11905
11906 func (p *PullRequest) GetClosedAt() time.Time {
11907 if p == nil || p.ClosedAt == nil {
11908 return time.Time{}
11909 }
11910 return *p.ClosedAt
11911 }
11912
11913
11914 func (p *PullRequest) GetComments() int {
11915 if p == nil || p.Comments == nil {
11916 return 0
11917 }
11918 return *p.Comments
11919 }
11920
11921
11922 func (p *PullRequest) GetCommentsURL() string {
11923 if p == nil || p.CommentsURL == nil {
11924 return ""
11925 }
11926 return *p.CommentsURL
11927 }
11928
11929
11930 func (p *PullRequest) GetCommits() int {
11931 if p == nil || p.Commits == nil {
11932 return 0
11933 }
11934 return *p.Commits
11935 }
11936
11937
11938 func (p *PullRequest) GetCommitsURL() string {
11939 if p == nil || p.CommitsURL == nil {
11940 return ""
11941 }
11942 return *p.CommitsURL
11943 }
11944
11945
11946 func (p *PullRequest) GetCreatedAt() time.Time {
11947 if p == nil || p.CreatedAt == nil {
11948 return time.Time{}
11949 }
11950 return *p.CreatedAt
11951 }
11952
11953
11954 func (p *PullRequest) GetDeletions() int {
11955 if p == nil || p.Deletions == nil {
11956 return 0
11957 }
11958 return *p.Deletions
11959 }
11960
11961
11962 func (p *PullRequest) GetDiffURL() string {
11963 if p == nil || p.DiffURL == nil {
11964 return ""
11965 }
11966 return *p.DiffURL
11967 }
11968
11969
11970 func (p *PullRequest) GetDraft() bool {
11971 if p == nil || p.Draft == nil {
11972 return false
11973 }
11974 return *p.Draft
11975 }
11976
11977
11978 func (p *PullRequest) GetHead() *PullRequestBranch {
11979 if p == nil {
11980 return nil
11981 }
11982 return p.Head
11983 }
11984
11985
11986 func (p *PullRequest) GetHTMLURL() string {
11987 if p == nil || p.HTMLURL == nil {
11988 return ""
11989 }
11990 return *p.HTMLURL
11991 }
11992
11993
11994 func (p *PullRequest) GetID() int64 {
11995 if p == nil || p.ID == nil {
11996 return 0
11997 }
11998 return *p.ID
11999 }
12000
12001
12002 func (p *PullRequest) GetIssueURL() string {
12003 if p == nil || p.IssueURL == nil {
12004 return ""
12005 }
12006 return *p.IssueURL
12007 }
12008
12009
12010 func (p *PullRequest) GetLinks() *PRLinks {
12011 if p == nil {
12012 return nil
12013 }
12014 return p.Links
12015 }
12016
12017
12018 func (p *PullRequest) GetLocked() bool {
12019 if p == nil || p.Locked == nil {
12020 return false
12021 }
12022 return *p.Locked
12023 }
12024
12025
12026 func (p *PullRequest) GetMaintainerCanModify() bool {
12027 if p == nil || p.MaintainerCanModify == nil {
12028 return false
12029 }
12030 return *p.MaintainerCanModify
12031 }
12032
12033
12034 func (p *PullRequest) GetMergeable() bool {
12035 if p == nil || p.Mergeable == nil {
12036 return false
12037 }
12038 return *p.Mergeable
12039 }
12040
12041
12042 func (p *PullRequest) GetMergeableState() string {
12043 if p == nil || p.MergeableState == nil {
12044 return ""
12045 }
12046 return *p.MergeableState
12047 }
12048
12049
12050 func (p *PullRequest) GetMergeCommitSHA() string {
12051 if p == nil || p.MergeCommitSHA == nil {
12052 return ""
12053 }
12054 return *p.MergeCommitSHA
12055 }
12056
12057
12058 func (p *PullRequest) GetMerged() bool {
12059 if p == nil || p.Merged == nil {
12060 return false
12061 }
12062 return *p.Merged
12063 }
12064
12065
12066 func (p *PullRequest) GetMergedAt() time.Time {
12067 if p == nil || p.MergedAt == nil {
12068 return time.Time{}
12069 }
12070 return *p.MergedAt
12071 }
12072
12073
12074 func (p *PullRequest) GetMergedBy() *User {
12075 if p == nil {
12076 return nil
12077 }
12078 return p.MergedBy
12079 }
12080
12081
12082 func (p *PullRequest) GetMilestone() *Milestone {
12083 if p == nil {
12084 return nil
12085 }
12086 return p.Milestone
12087 }
12088
12089
12090 func (p *PullRequest) GetNodeID() string {
12091 if p == nil || p.NodeID == nil {
12092 return ""
12093 }
12094 return *p.NodeID
12095 }
12096
12097
12098 func (p *PullRequest) GetNumber() int {
12099 if p == nil || p.Number == nil {
12100 return 0
12101 }
12102 return *p.Number
12103 }
12104
12105
12106 func (p *PullRequest) GetPatchURL() string {
12107 if p == nil || p.PatchURL == nil {
12108 return ""
12109 }
12110 return *p.PatchURL
12111 }
12112
12113
12114 func (p *PullRequest) GetRebaseable() bool {
12115 if p == nil || p.Rebaseable == nil {
12116 return false
12117 }
12118 return *p.Rebaseable
12119 }
12120
12121
12122 func (p *PullRequest) GetReviewComments() int {
12123 if p == nil || p.ReviewComments == nil {
12124 return 0
12125 }
12126 return *p.ReviewComments
12127 }
12128
12129
12130 func (p *PullRequest) GetReviewCommentsURL() string {
12131 if p == nil || p.ReviewCommentsURL == nil {
12132 return ""
12133 }
12134 return *p.ReviewCommentsURL
12135 }
12136
12137
12138 func (p *PullRequest) GetReviewCommentURL() string {
12139 if p == nil || p.ReviewCommentURL == nil {
12140 return ""
12141 }
12142 return *p.ReviewCommentURL
12143 }
12144
12145
12146 func (p *PullRequest) GetState() string {
12147 if p == nil || p.State == nil {
12148 return ""
12149 }
12150 return *p.State
12151 }
12152
12153
12154 func (p *PullRequest) GetStatusesURL() string {
12155 if p == nil || p.StatusesURL == nil {
12156 return ""
12157 }
12158 return *p.StatusesURL
12159 }
12160
12161
12162 func (p *PullRequest) GetTitle() string {
12163 if p == nil || p.Title == nil {
12164 return ""
12165 }
12166 return *p.Title
12167 }
12168
12169
12170 func (p *PullRequest) GetUpdatedAt() time.Time {
12171 if p == nil || p.UpdatedAt == nil {
12172 return time.Time{}
12173 }
12174 return *p.UpdatedAt
12175 }
12176
12177
12178 func (p *PullRequest) GetURL() string {
12179 if p == nil || p.URL == nil {
12180 return ""
12181 }
12182 return *p.URL
12183 }
12184
12185
12186 func (p *PullRequest) GetUser() *User {
12187 if p == nil {
12188 return nil
12189 }
12190 return p.User
12191 }
12192
12193
12194 func (p *PullRequestAutoMerge) GetCommitMessage() string {
12195 if p == nil || p.CommitMessage == nil {
12196 return ""
12197 }
12198 return *p.CommitMessage
12199 }
12200
12201
12202 func (p *PullRequestAutoMerge) GetCommitTitle() string {
12203 if p == nil || p.CommitTitle == nil {
12204 return ""
12205 }
12206 return *p.CommitTitle
12207 }
12208
12209
12210 func (p *PullRequestAutoMerge) GetEnabledBy() *User {
12211 if p == nil {
12212 return nil
12213 }
12214 return p.EnabledBy
12215 }
12216
12217
12218 func (p *PullRequestAutoMerge) GetMergeMethod() string {
12219 if p == nil || p.MergeMethod == nil {
12220 return ""
12221 }
12222 return *p.MergeMethod
12223 }
12224
12225
12226 func (p *PullRequestBranch) GetLabel() string {
12227 if p == nil || p.Label == nil {
12228 return ""
12229 }
12230 return *p.Label
12231 }
12232
12233
12234 func (p *PullRequestBranch) GetRef() string {
12235 if p == nil || p.Ref == nil {
12236 return ""
12237 }
12238 return *p.Ref
12239 }
12240
12241
12242 func (p *PullRequestBranch) GetRepo() *Repository {
12243 if p == nil {
12244 return nil
12245 }
12246 return p.Repo
12247 }
12248
12249
12250 func (p *PullRequestBranch) GetSHA() string {
12251 if p == nil || p.SHA == nil {
12252 return ""
12253 }
12254 return *p.SHA
12255 }
12256
12257
12258 func (p *PullRequestBranch) GetUser() *User {
12259 if p == nil {
12260 return nil
12261 }
12262 return p.User
12263 }
12264
12265
12266 func (p *PullRequestBranchUpdateOptions) GetExpectedHeadSHA() string {
12267 if p == nil || p.ExpectedHeadSHA == nil {
12268 return ""
12269 }
12270 return *p.ExpectedHeadSHA
12271 }
12272
12273
12274 func (p *PullRequestBranchUpdateResponse) GetMessage() string {
12275 if p == nil || p.Message == nil {
12276 return ""
12277 }
12278 return *p.Message
12279 }
12280
12281
12282 func (p *PullRequestBranchUpdateResponse) GetURL() string {
12283 if p == nil || p.URL == nil {
12284 return ""
12285 }
12286 return *p.URL
12287 }
12288
12289
12290 func (p *PullRequestComment) GetAuthorAssociation() string {
12291 if p == nil || p.AuthorAssociation == nil {
12292 return ""
12293 }
12294 return *p.AuthorAssociation
12295 }
12296
12297
12298 func (p *PullRequestComment) GetBody() string {
12299 if p == nil || p.Body == nil {
12300 return ""
12301 }
12302 return *p.Body
12303 }
12304
12305
12306 func (p *PullRequestComment) GetCommitID() string {
12307 if p == nil || p.CommitID == nil {
12308 return ""
12309 }
12310 return *p.CommitID
12311 }
12312
12313
12314 func (p *PullRequestComment) GetCreatedAt() time.Time {
12315 if p == nil || p.CreatedAt == nil {
12316 return time.Time{}
12317 }
12318 return *p.CreatedAt
12319 }
12320
12321
12322 func (p *PullRequestComment) GetDiffHunk() string {
12323 if p == nil || p.DiffHunk == nil {
12324 return ""
12325 }
12326 return *p.DiffHunk
12327 }
12328
12329
12330 func (p *PullRequestComment) GetHTMLURL() string {
12331 if p == nil || p.HTMLURL == nil {
12332 return ""
12333 }
12334 return *p.HTMLURL
12335 }
12336
12337
12338 func (p *PullRequestComment) GetID() int64 {
12339 if p == nil || p.ID == nil {
12340 return 0
12341 }
12342 return *p.ID
12343 }
12344
12345
12346 func (p *PullRequestComment) GetInReplyTo() int64 {
12347 if p == nil || p.InReplyTo == nil {
12348 return 0
12349 }
12350 return *p.InReplyTo
12351 }
12352
12353
12354 func (p *PullRequestComment) GetLine() int {
12355 if p == nil || p.Line == nil {
12356 return 0
12357 }
12358 return *p.Line
12359 }
12360
12361
12362 func (p *PullRequestComment) GetNodeID() string {
12363 if p == nil || p.NodeID == nil {
12364 return ""
12365 }
12366 return *p.NodeID
12367 }
12368
12369
12370 func (p *PullRequestComment) GetOriginalCommitID() string {
12371 if p == nil || p.OriginalCommitID == nil {
12372 return ""
12373 }
12374 return *p.OriginalCommitID
12375 }
12376
12377
12378 func (p *PullRequestComment) GetOriginalLine() int {
12379 if p == nil || p.OriginalLine == nil {
12380 return 0
12381 }
12382 return *p.OriginalLine
12383 }
12384
12385
12386 func (p *PullRequestComment) GetOriginalPosition() int {
12387 if p == nil || p.OriginalPosition == nil {
12388 return 0
12389 }
12390 return *p.OriginalPosition
12391 }
12392
12393
12394 func (p *PullRequestComment) GetOriginalStartLine() int {
12395 if p == nil || p.OriginalStartLine == nil {
12396 return 0
12397 }
12398 return *p.OriginalStartLine
12399 }
12400
12401
12402 func (p *PullRequestComment) GetPath() string {
12403 if p == nil || p.Path == nil {
12404 return ""
12405 }
12406 return *p.Path
12407 }
12408
12409
12410 func (p *PullRequestComment) GetPosition() int {
12411 if p == nil || p.Position == nil {
12412 return 0
12413 }
12414 return *p.Position
12415 }
12416
12417
12418 func (p *PullRequestComment) GetPullRequestReviewID() int64 {
12419 if p == nil || p.PullRequestReviewID == nil {
12420 return 0
12421 }
12422 return *p.PullRequestReviewID
12423 }
12424
12425
12426 func (p *PullRequestComment) GetPullRequestURL() string {
12427 if p == nil || p.PullRequestURL == nil {
12428 return ""
12429 }
12430 return *p.PullRequestURL
12431 }
12432
12433
12434 func (p *PullRequestComment) GetReactions() *Reactions {
12435 if p == nil {
12436 return nil
12437 }
12438 return p.Reactions
12439 }
12440
12441
12442 func (p *PullRequestComment) GetSide() string {
12443 if p == nil || p.Side == nil {
12444 return ""
12445 }
12446 return *p.Side
12447 }
12448
12449
12450 func (p *PullRequestComment) GetStartLine() int {
12451 if p == nil || p.StartLine == nil {
12452 return 0
12453 }
12454 return *p.StartLine
12455 }
12456
12457
12458 func (p *PullRequestComment) GetStartSide() string {
12459 if p == nil || p.StartSide == nil {
12460 return ""
12461 }
12462 return *p.StartSide
12463 }
12464
12465
12466 func (p *PullRequestComment) GetUpdatedAt() time.Time {
12467 if p == nil || p.UpdatedAt == nil {
12468 return time.Time{}
12469 }
12470 return *p.UpdatedAt
12471 }
12472
12473
12474 func (p *PullRequestComment) GetURL() string {
12475 if p == nil || p.URL == nil {
12476 return ""
12477 }
12478 return *p.URL
12479 }
12480
12481
12482 func (p *PullRequestComment) GetUser() *User {
12483 if p == nil {
12484 return nil
12485 }
12486 return p.User
12487 }
12488
12489
12490 func (p *PullRequestEvent) GetAction() string {
12491 if p == nil || p.Action == nil {
12492 return ""
12493 }
12494 return *p.Action
12495 }
12496
12497
12498 func (p *PullRequestEvent) GetAfter() string {
12499 if p == nil || p.After == nil {
12500 return ""
12501 }
12502 return *p.After
12503 }
12504
12505
12506 func (p *PullRequestEvent) GetAssignee() *User {
12507 if p == nil {
12508 return nil
12509 }
12510 return p.Assignee
12511 }
12512
12513
12514 func (p *PullRequestEvent) GetBefore() string {
12515 if p == nil || p.Before == nil {
12516 return ""
12517 }
12518 return *p.Before
12519 }
12520
12521
12522 func (p *PullRequestEvent) GetChanges() *EditChange {
12523 if p == nil {
12524 return nil
12525 }
12526 return p.Changes
12527 }
12528
12529
12530 func (p *PullRequestEvent) GetInstallation() *Installation {
12531 if p == nil {
12532 return nil
12533 }
12534 return p.Installation
12535 }
12536
12537
12538 func (p *PullRequestEvent) GetLabel() *Label {
12539 if p == nil {
12540 return nil
12541 }
12542 return p.Label
12543 }
12544
12545
12546 func (p *PullRequestEvent) GetNumber() int {
12547 if p == nil || p.Number == nil {
12548 return 0
12549 }
12550 return *p.Number
12551 }
12552
12553
12554 func (p *PullRequestEvent) GetOrganization() *Organization {
12555 if p == nil {
12556 return nil
12557 }
12558 return p.Organization
12559 }
12560
12561
12562 func (p *PullRequestEvent) GetPullRequest() *PullRequest {
12563 if p == nil {
12564 return nil
12565 }
12566 return p.PullRequest
12567 }
12568
12569
12570 func (p *PullRequestEvent) GetRepo() *Repository {
12571 if p == nil {
12572 return nil
12573 }
12574 return p.Repo
12575 }
12576
12577
12578 func (p *PullRequestEvent) GetRequestedReviewer() *User {
12579 if p == nil {
12580 return nil
12581 }
12582 return p.RequestedReviewer
12583 }
12584
12585
12586 func (p *PullRequestEvent) GetRequestedTeam() *Team {
12587 if p == nil {
12588 return nil
12589 }
12590 return p.RequestedTeam
12591 }
12592
12593
12594 func (p *PullRequestEvent) GetSender() *User {
12595 if p == nil {
12596 return nil
12597 }
12598 return p.Sender
12599 }
12600
12601
12602 func (p *PullRequestLinks) GetDiffURL() string {
12603 if p == nil || p.DiffURL == nil {
12604 return ""
12605 }
12606 return *p.DiffURL
12607 }
12608
12609
12610 func (p *PullRequestLinks) GetHTMLURL() string {
12611 if p == nil || p.HTMLURL == nil {
12612 return ""
12613 }
12614 return *p.HTMLURL
12615 }
12616
12617
12618 func (p *PullRequestLinks) GetPatchURL() string {
12619 if p == nil || p.PatchURL == nil {
12620 return ""
12621 }
12622 return *p.PatchURL
12623 }
12624
12625
12626 func (p *PullRequestLinks) GetURL() string {
12627 if p == nil || p.URL == nil {
12628 return ""
12629 }
12630 return *p.URL
12631 }
12632
12633
12634 func (p *PullRequestMergeResult) GetMerged() bool {
12635 if p == nil || p.Merged == nil {
12636 return false
12637 }
12638 return *p.Merged
12639 }
12640
12641
12642 func (p *PullRequestMergeResult) GetMessage() string {
12643 if p == nil || p.Message == nil {
12644 return ""
12645 }
12646 return *p.Message
12647 }
12648
12649
12650 func (p *PullRequestMergeResult) GetSHA() string {
12651 if p == nil || p.SHA == nil {
12652 return ""
12653 }
12654 return *p.SHA
12655 }
12656
12657
12658 func (p *PullRequestReview) GetAuthorAssociation() string {
12659 if p == nil || p.AuthorAssociation == nil {
12660 return ""
12661 }
12662 return *p.AuthorAssociation
12663 }
12664
12665
12666 func (p *PullRequestReview) GetBody() string {
12667 if p == nil || p.Body == nil {
12668 return ""
12669 }
12670 return *p.Body
12671 }
12672
12673
12674 func (p *PullRequestReview) GetCommitID() string {
12675 if p == nil || p.CommitID == nil {
12676 return ""
12677 }
12678 return *p.CommitID
12679 }
12680
12681
12682 func (p *PullRequestReview) GetHTMLURL() string {
12683 if p == nil || p.HTMLURL == nil {
12684 return ""
12685 }
12686 return *p.HTMLURL
12687 }
12688
12689
12690 func (p *PullRequestReview) GetID() int64 {
12691 if p == nil || p.ID == nil {
12692 return 0
12693 }
12694 return *p.ID
12695 }
12696
12697
12698 func (p *PullRequestReview) GetNodeID() string {
12699 if p == nil || p.NodeID == nil {
12700 return ""
12701 }
12702 return *p.NodeID
12703 }
12704
12705
12706 func (p *PullRequestReview) GetPullRequestURL() string {
12707 if p == nil || p.PullRequestURL == nil {
12708 return ""
12709 }
12710 return *p.PullRequestURL
12711 }
12712
12713
12714 func (p *PullRequestReview) GetState() string {
12715 if p == nil || p.State == nil {
12716 return ""
12717 }
12718 return *p.State
12719 }
12720
12721
12722 func (p *PullRequestReview) GetSubmittedAt() time.Time {
12723 if p == nil || p.SubmittedAt == nil {
12724 return time.Time{}
12725 }
12726 return *p.SubmittedAt
12727 }
12728
12729
12730 func (p *PullRequestReview) GetUser() *User {
12731 if p == nil {
12732 return nil
12733 }
12734 return p.User
12735 }
12736
12737
12738 func (p *PullRequestReviewCommentEvent) GetAction() string {
12739 if p == nil || p.Action == nil {
12740 return ""
12741 }
12742 return *p.Action
12743 }
12744
12745
12746 func (p *PullRequestReviewCommentEvent) GetChanges() *EditChange {
12747 if p == nil {
12748 return nil
12749 }
12750 return p.Changes
12751 }
12752
12753
12754 func (p *PullRequestReviewCommentEvent) GetComment() *PullRequestComment {
12755 if p == nil {
12756 return nil
12757 }
12758 return p.Comment
12759 }
12760
12761
12762 func (p *PullRequestReviewCommentEvent) GetInstallation() *Installation {
12763 if p == nil {
12764 return nil
12765 }
12766 return p.Installation
12767 }
12768
12769
12770 func (p *PullRequestReviewCommentEvent) GetPullRequest() *PullRequest {
12771 if p == nil {
12772 return nil
12773 }
12774 return p.PullRequest
12775 }
12776
12777
12778 func (p *PullRequestReviewCommentEvent) GetRepo() *Repository {
12779 if p == nil {
12780 return nil
12781 }
12782 return p.Repo
12783 }
12784
12785
12786 func (p *PullRequestReviewCommentEvent) GetSender() *User {
12787 if p == nil {
12788 return nil
12789 }
12790 return p.Sender
12791 }
12792
12793
12794 func (p *PullRequestReviewDismissalRequest) GetMessage() string {
12795 if p == nil || p.Message == nil {
12796 return ""
12797 }
12798 return *p.Message
12799 }
12800
12801
12802 func (p *PullRequestReviewEvent) GetAction() string {
12803 if p == nil || p.Action == nil {
12804 return ""
12805 }
12806 return *p.Action
12807 }
12808
12809
12810 func (p *PullRequestReviewEvent) GetInstallation() *Installation {
12811 if p == nil {
12812 return nil
12813 }
12814 return p.Installation
12815 }
12816
12817
12818 func (p *PullRequestReviewEvent) GetOrganization() *Organization {
12819 if p == nil {
12820 return nil
12821 }
12822 return p.Organization
12823 }
12824
12825
12826 func (p *PullRequestReviewEvent) GetPullRequest() *PullRequest {
12827 if p == nil {
12828 return nil
12829 }
12830 return p.PullRequest
12831 }
12832
12833
12834 func (p *PullRequestReviewEvent) GetRepo() *Repository {
12835 if p == nil {
12836 return nil
12837 }
12838 return p.Repo
12839 }
12840
12841
12842 func (p *PullRequestReviewEvent) GetReview() *PullRequestReview {
12843 if p == nil {
12844 return nil
12845 }
12846 return p.Review
12847 }
12848
12849
12850 func (p *PullRequestReviewEvent) GetSender() *User {
12851 if p == nil {
12852 return nil
12853 }
12854 return p.Sender
12855 }
12856
12857
12858 func (p *PullRequestReviewRequest) GetBody() string {
12859 if p == nil || p.Body == nil {
12860 return ""
12861 }
12862 return *p.Body
12863 }
12864
12865
12866 func (p *PullRequestReviewRequest) GetCommitID() string {
12867 if p == nil || p.CommitID == nil {
12868 return ""
12869 }
12870 return *p.CommitID
12871 }
12872
12873
12874 func (p *PullRequestReviewRequest) GetEvent() string {
12875 if p == nil || p.Event == nil {
12876 return ""
12877 }
12878 return *p.Event
12879 }
12880
12881
12882 func (p *PullRequestReviewRequest) GetNodeID() string {
12883 if p == nil || p.NodeID == nil {
12884 return ""
12885 }
12886 return *p.NodeID
12887 }
12888
12889
12890 func (p *PullRequestReviewsEnforcement) GetDismissalRestrictions() *DismissalRestrictions {
12891 if p == nil {
12892 return nil
12893 }
12894 return p.DismissalRestrictions
12895 }
12896
12897
12898 func (p *PullRequestReviewsEnforcementRequest) GetDismissalRestrictionsRequest() *DismissalRestrictionsRequest {
12899 if p == nil {
12900 return nil
12901 }
12902 return p.DismissalRestrictionsRequest
12903 }
12904
12905
12906 func (p *PullRequestReviewsEnforcementUpdate) GetDismissalRestrictionsRequest() *DismissalRestrictionsRequest {
12907 if p == nil {
12908 return nil
12909 }
12910 return p.DismissalRestrictionsRequest
12911 }
12912
12913
12914 func (p *PullRequestReviewsEnforcementUpdate) GetDismissStaleReviews() bool {
12915 if p == nil || p.DismissStaleReviews == nil {
12916 return false
12917 }
12918 return *p.DismissStaleReviews
12919 }
12920
12921
12922 func (p *PullRequestReviewsEnforcementUpdate) GetRequireCodeOwnerReviews() bool {
12923 if p == nil || p.RequireCodeOwnerReviews == nil {
12924 return false
12925 }
12926 return *p.RequireCodeOwnerReviews
12927 }
12928
12929
12930 func (p *PullRequestReviewThreadEvent) GetAction() string {
12931 if p == nil || p.Action == nil {
12932 return ""
12933 }
12934 return *p.Action
12935 }
12936
12937
12938 func (p *PullRequestReviewThreadEvent) GetInstallation() *Installation {
12939 if p == nil {
12940 return nil
12941 }
12942 return p.Installation
12943 }
12944
12945
12946 func (p *PullRequestReviewThreadEvent) GetPullRequest() *PullRequest {
12947 if p == nil {
12948 return nil
12949 }
12950 return p.PullRequest
12951 }
12952
12953
12954 func (p *PullRequestReviewThreadEvent) GetRepo() *Repository {
12955 if p == nil {
12956 return nil
12957 }
12958 return p.Repo
12959 }
12960
12961
12962 func (p *PullRequestReviewThreadEvent) GetSender() *User {
12963 if p == nil {
12964 return nil
12965 }
12966 return p.Sender
12967 }
12968
12969
12970 func (p *PullRequestReviewThreadEvent) GetThread() *PullRequestThread {
12971 if p == nil {
12972 return nil
12973 }
12974 return p.Thread
12975 }
12976
12977
12978 func (p *PullRequestTargetEvent) GetAction() string {
12979 if p == nil || p.Action == nil {
12980 return ""
12981 }
12982 return *p.Action
12983 }
12984
12985
12986 func (p *PullRequestTargetEvent) GetAfter() string {
12987 if p == nil || p.After == nil {
12988 return ""
12989 }
12990 return *p.After
12991 }
12992
12993
12994 func (p *PullRequestTargetEvent) GetAssignee() *User {
12995 if p == nil {
12996 return nil
12997 }
12998 return p.Assignee
12999 }
13000
13001
13002 func (p *PullRequestTargetEvent) GetBefore() string {
13003 if p == nil || p.Before == nil {
13004 return ""
13005 }
13006 return *p.Before
13007 }
13008
13009
13010 func (p *PullRequestTargetEvent) GetChanges() *EditChange {
13011 if p == nil {
13012 return nil
13013 }
13014 return p.Changes
13015 }
13016
13017
13018 func (p *PullRequestTargetEvent) GetInstallation() *Installation {
13019 if p == nil {
13020 return nil
13021 }
13022 return p.Installation
13023 }
13024
13025
13026 func (p *PullRequestTargetEvent) GetLabel() *Label {
13027 if p == nil {
13028 return nil
13029 }
13030 return p.Label
13031 }
13032
13033
13034 func (p *PullRequestTargetEvent) GetNumber() int {
13035 if p == nil || p.Number == nil {
13036 return 0
13037 }
13038 return *p.Number
13039 }
13040
13041
13042 func (p *PullRequestTargetEvent) GetOrganization() *Organization {
13043 if p == nil {
13044 return nil
13045 }
13046 return p.Organization
13047 }
13048
13049
13050 func (p *PullRequestTargetEvent) GetPullRequest() *PullRequest {
13051 if p == nil {
13052 return nil
13053 }
13054 return p.PullRequest
13055 }
13056
13057
13058 func (p *PullRequestTargetEvent) GetRepo() *Repository {
13059 if p == nil {
13060 return nil
13061 }
13062 return p.Repo
13063 }
13064
13065
13066 func (p *PullRequestTargetEvent) GetRequestedReviewer() *User {
13067 if p == nil {
13068 return nil
13069 }
13070 return p.RequestedReviewer
13071 }
13072
13073
13074 func (p *PullRequestTargetEvent) GetRequestedTeam() *Team {
13075 if p == nil {
13076 return nil
13077 }
13078 return p.RequestedTeam
13079 }
13080
13081
13082 func (p *PullRequestTargetEvent) GetSender() *User {
13083 if p == nil {
13084 return nil
13085 }
13086 return p.Sender
13087 }
13088
13089
13090 func (p *PullRequestThread) GetID() int64 {
13091 if p == nil || p.ID == nil {
13092 return 0
13093 }
13094 return *p.ID
13095 }
13096
13097
13098 func (p *PullRequestThread) GetNodeID() string {
13099 if p == nil || p.NodeID == nil {
13100 return ""
13101 }
13102 return *p.NodeID
13103 }
13104
13105
13106 func (p *PullStats) GetMergablePulls() int {
13107 if p == nil || p.MergablePulls == nil {
13108 return 0
13109 }
13110 return *p.MergablePulls
13111 }
13112
13113
13114 func (p *PullStats) GetMergedPulls() int {
13115 if p == nil || p.MergedPulls == nil {
13116 return 0
13117 }
13118 return *p.MergedPulls
13119 }
13120
13121
13122 func (p *PullStats) GetTotalPulls() int {
13123 if p == nil || p.TotalPulls == nil {
13124 return 0
13125 }
13126 return *p.TotalPulls
13127 }
13128
13129
13130 func (p *PullStats) GetUnmergablePulls() int {
13131 if p == nil || p.UnmergablePulls == nil {
13132 return 0
13133 }
13134 return *p.UnmergablePulls
13135 }
13136
13137
13138 func (p *PunchCard) GetCommits() int {
13139 if p == nil || p.Commits == nil {
13140 return 0
13141 }
13142 return *p.Commits
13143 }
13144
13145
13146 func (p *PunchCard) GetDay() int {
13147 if p == nil || p.Day == nil {
13148 return 0
13149 }
13150 return *p.Day
13151 }
13152
13153
13154 func (p *PunchCard) GetHour() int {
13155 if p == nil || p.Hour == nil {
13156 return 0
13157 }
13158 return *p.Hour
13159 }
13160
13161
13162 func (p *PushEvent) GetAction() string {
13163 if p == nil || p.Action == nil {
13164 return ""
13165 }
13166 return *p.Action
13167 }
13168
13169
13170 func (p *PushEvent) GetAfter() string {
13171 if p == nil || p.After == nil {
13172 return ""
13173 }
13174 return *p.After
13175 }
13176
13177
13178 func (p *PushEvent) GetBaseRef() string {
13179 if p == nil || p.BaseRef == nil {
13180 return ""
13181 }
13182 return *p.BaseRef
13183 }
13184
13185
13186 func (p *PushEvent) GetBefore() string {
13187 if p == nil || p.Before == nil {
13188 return ""
13189 }
13190 return *p.Before
13191 }
13192
13193
13194 func (p *PushEvent) GetCompare() string {
13195 if p == nil || p.Compare == nil {
13196 return ""
13197 }
13198 return *p.Compare
13199 }
13200
13201
13202 func (p *PushEvent) GetCreated() bool {
13203 if p == nil || p.Created == nil {
13204 return false
13205 }
13206 return *p.Created
13207 }
13208
13209
13210 func (p *PushEvent) GetDeleted() bool {
13211 if p == nil || p.Deleted == nil {
13212 return false
13213 }
13214 return *p.Deleted
13215 }
13216
13217
13218 func (p *PushEvent) GetDistinctSize() int {
13219 if p == nil || p.DistinctSize == nil {
13220 return 0
13221 }
13222 return *p.DistinctSize
13223 }
13224
13225
13226 func (p *PushEvent) GetForced() bool {
13227 if p == nil || p.Forced == nil {
13228 return false
13229 }
13230 return *p.Forced
13231 }
13232
13233
13234 func (p *PushEvent) GetHead() string {
13235 if p == nil || p.Head == nil {
13236 return ""
13237 }
13238 return *p.Head
13239 }
13240
13241
13242 func (p *PushEvent) GetHeadCommit() *HeadCommit {
13243 if p == nil {
13244 return nil
13245 }
13246 return p.HeadCommit
13247 }
13248
13249
13250 func (p *PushEvent) GetInstallation() *Installation {
13251 if p == nil {
13252 return nil
13253 }
13254 return p.Installation
13255 }
13256
13257
13258 func (p *PushEvent) GetOrganization() *Organization {
13259 if p == nil {
13260 return nil
13261 }
13262 return p.Organization
13263 }
13264
13265
13266 func (p *PushEvent) GetPusher() *User {
13267 if p == nil {
13268 return nil
13269 }
13270 return p.Pusher
13271 }
13272
13273
13274 func (p *PushEvent) GetPushID() int64 {
13275 if p == nil || p.PushID == nil {
13276 return 0
13277 }
13278 return *p.PushID
13279 }
13280
13281
13282 func (p *PushEvent) GetRef() string {
13283 if p == nil || p.Ref == nil {
13284 return ""
13285 }
13286 return *p.Ref
13287 }
13288
13289
13290 func (p *PushEvent) GetRepo() *PushEventRepository {
13291 if p == nil {
13292 return nil
13293 }
13294 return p.Repo
13295 }
13296
13297
13298 func (p *PushEvent) GetSender() *User {
13299 if p == nil {
13300 return nil
13301 }
13302 return p.Sender
13303 }
13304
13305
13306 func (p *PushEvent) GetSize() int {
13307 if p == nil || p.Size == nil {
13308 return 0
13309 }
13310 return *p.Size
13311 }
13312
13313
13314 func (p *PushEventRepoOwner) GetEmail() string {
13315 if p == nil || p.Email == nil {
13316 return ""
13317 }
13318 return *p.Email
13319 }
13320
13321
13322 func (p *PushEventRepoOwner) GetName() string {
13323 if p == nil || p.Name == nil {
13324 return ""
13325 }
13326 return *p.Name
13327 }
13328
13329
13330 func (p *PushEventRepository) GetArchived() bool {
13331 if p == nil || p.Archived == nil {
13332 return false
13333 }
13334 return *p.Archived
13335 }
13336
13337
13338 func (p *PushEventRepository) GetArchiveURL() string {
13339 if p == nil || p.ArchiveURL == nil {
13340 return ""
13341 }
13342 return *p.ArchiveURL
13343 }
13344
13345
13346 func (p *PushEventRepository) GetCloneURL() string {
13347 if p == nil || p.CloneURL == nil {
13348 return ""
13349 }
13350 return *p.CloneURL
13351 }
13352
13353
13354 func (p *PushEventRepository) GetCreatedAt() Timestamp {
13355 if p == nil || p.CreatedAt == nil {
13356 return Timestamp{}
13357 }
13358 return *p.CreatedAt
13359 }
13360
13361
13362 func (p *PushEventRepository) GetDefaultBranch() string {
13363 if p == nil || p.DefaultBranch == nil {
13364 return ""
13365 }
13366 return *p.DefaultBranch
13367 }
13368
13369
13370 func (p *PushEventRepository) GetDescription() string {
13371 if p == nil || p.Description == nil {
13372 return ""
13373 }
13374 return *p.Description
13375 }
13376
13377
13378 func (p *PushEventRepository) GetDisabled() bool {
13379 if p == nil || p.Disabled == nil {
13380 return false
13381 }
13382 return *p.Disabled
13383 }
13384
13385
13386 func (p *PushEventRepository) GetFork() bool {
13387 if p == nil || p.Fork == nil {
13388 return false
13389 }
13390 return *p.Fork
13391 }
13392
13393
13394 func (p *PushEventRepository) GetForksCount() int {
13395 if p == nil || p.ForksCount == nil {
13396 return 0
13397 }
13398 return *p.ForksCount
13399 }
13400
13401
13402 func (p *PushEventRepository) GetFullName() string {
13403 if p == nil || p.FullName == nil {
13404 return ""
13405 }
13406 return *p.FullName
13407 }
13408
13409
13410 func (p *PushEventRepository) GetGitURL() string {
13411 if p == nil || p.GitURL == nil {
13412 return ""
13413 }
13414 return *p.GitURL
13415 }
13416
13417
13418 func (p *PushEventRepository) GetHasDownloads() bool {
13419 if p == nil || p.HasDownloads == nil {
13420 return false
13421 }
13422 return *p.HasDownloads
13423 }
13424
13425
13426 func (p *PushEventRepository) GetHasIssues() bool {
13427 if p == nil || p.HasIssues == nil {
13428 return false
13429 }
13430 return *p.HasIssues
13431 }
13432
13433
13434 func (p *PushEventRepository) GetHasPages() bool {
13435 if p == nil || p.HasPages == nil {
13436 return false
13437 }
13438 return *p.HasPages
13439 }
13440
13441
13442 func (p *PushEventRepository) GetHasWiki() bool {
13443 if p == nil || p.HasWiki == nil {
13444 return false
13445 }
13446 return *p.HasWiki
13447 }
13448
13449
13450 func (p *PushEventRepository) GetHomepage() string {
13451 if p == nil || p.Homepage == nil {
13452 return ""
13453 }
13454 return *p.Homepage
13455 }
13456
13457
13458 func (p *PushEventRepository) GetHTMLURL() string {
13459 if p == nil || p.HTMLURL == nil {
13460 return ""
13461 }
13462 return *p.HTMLURL
13463 }
13464
13465
13466 func (p *PushEventRepository) GetID() int64 {
13467 if p == nil || p.ID == nil {
13468 return 0
13469 }
13470 return *p.ID
13471 }
13472
13473
13474 func (p *PushEventRepository) GetLanguage() string {
13475 if p == nil || p.Language == nil {
13476 return ""
13477 }
13478 return *p.Language
13479 }
13480
13481
13482 func (p *PushEventRepository) GetMasterBranch() string {
13483 if p == nil || p.MasterBranch == nil {
13484 return ""
13485 }
13486 return *p.MasterBranch
13487 }
13488
13489
13490 func (p *PushEventRepository) GetName() string {
13491 if p == nil || p.Name == nil {
13492 return ""
13493 }
13494 return *p.Name
13495 }
13496
13497
13498 func (p *PushEventRepository) GetNodeID() string {
13499 if p == nil || p.NodeID == nil {
13500 return ""
13501 }
13502 return *p.NodeID
13503 }
13504
13505
13506 func (p *PushEventRepository) GetOpenIssuesCount() int {
13507 if p == nil || p.OpenIssuesCount == nil {
13508 return 0
13509 }
13510 return *p.OpenIssuesCount
13511 }
13512
13513
13514 func (p *PushEventRepository) GetOrganization() string {
13515 if p == nil || p.Organization == nil {
13516 return ""
13517 }
13518 return *p.Organization
13519 }
13520
13521
13522 func (p *PushEventRepository) GetOwner() *User {
13523 if p == nil {
13524 return nil
13525 }
13526 return p.Owner
13527 }
13528
13529
13530 func (p *PushEventRepository) GetPrivate() bool {
13531 if p == nil || p.Private == nil {
13532 return false
13533 }
13534 return *p.Private
13535 }
13536
13537
13538 func (p *PushEventRepository) GetPullsURL() string {
13539 if p == nil || p.PullsURL == nil {
13540 return ""
13541 }
13542 return *p.PullsURL
13543 }
13544
13545
13546 func (p *PushEventRepository) GetPushedAt() Timestamp {
13547 if p == nil || p.PushedAt == nil {
13548 return Timestamp{}
13549 }
13550 return *p.PushedAt
13551 }
13552
13553
13554 func (p *PushEventRepository) GetSize() int {
13555 if p == nil || p.Size == nil {
13556 return 0
13557 }
13558 return *p.Size
13559 }
13560
13561
13562 func (p *PushEventRepository) GetSSHURL() string {
13563 if p == nil || p.SSHURL == nil {
13564 return ""
13565 }
13566 return *p.SSHURL
13567 }
13568
13569
13570 func (p *PushEventRepository) GetStargazersCount() int {
13571 if p == nil || p.StargazersCount == nil {
13572 return 0
13573 }
13574 return *p.StargazersCount
13575 }
13576
13577
13578 func (p *PushEventRepository) GetStatusesURL() string {
13579 if p == nil || p.StatusesURL == nil {
13580 return ""
13581 }
13582 return *p.StatusesURL
13583 }
13584
13585
13586 func (p *PushEventRepository) GetSVNURL() string {
13587 if p == nil || p.SVNURL == nil {
13588 return ""
13589 }
13590 return *p.SVNURL
13591 }
13592
13593
13594 func (p *PushEventRepository) GetUpdatedAt() Timestamp {
13595 if p == nil || p.UpdatedAt == nil {
13596 return Timestamp{}
13597 }
13598 return *p.UpdatedAt
13599 }
13600
13601
13602 func (p *PushEventRepository) GetURL() string {
13603 if p == nil || p.URL == nil {
13604 return ""
13605 }
13606 return *p.URL
13607 }
13608
13609
13610 func (p *PushEventRepository) GetWatchersCount() int {
13611 if p == nil || p.WatchersCount == nil {
13612 return 0
13613 }
13614 return *p.WatchersCount
13615 }
13616
13617
13618 func (r *RateLimits) GetActionsRunnerRegistration() *Rate {
13619 if r == nil {
13620 return nil
13621 }
13622 return r.ActionsRunnerRegistration
13623 }
13624
13625
13626 func (r *RateLimits) GetCodeScanningUpload() *Rate {
13627 if r == nil {
13628 return nil
13629 }
13630 return r.CodeScanningUpload
13631 }
13632
13633
13634 func (r *RateLimits) GetCore() *Rate {
13635 if r == nil {
13636 return nil
13637 }
13638 return r.Core
13639 }
13640
13641
13642 func (r *RateLimits) GetGraphQL() *Rate {
13643 if r == nil {
13644 return nil
13645 }
13646 return r.GraphQL
13647 }
13648
13649
13650 func (r *RateLimits) GetIntegrationManifest() *Rate {
13651 if r == nil {
13652 return nil
13653 }
13654 return r.IntegrationManifest
13655 }
13656
13657
13658 func (r *RateLimits) GetSCIM() *Rate {
13659 if r == nil {
13660 return nil
13661 }
13662 return r.SCIM
13663 }
13664
13665
13666 func (r *RateLimits) GetSearch() *Rate {
13667 if r == nil {
13668 return nil
13669 }
13670 return r.Search
13671 }
13672
13673
13674 func (r *RateLimits) GetSourceImport() *Rate {
13675 if r == nil {
13676 return nil
13677 }
13678 return r.SourceImport
13679 }
13680
13681
13682 func (r *Reaction) GetContent() string {
13683 if r == nil || r.Content == nil {
13684 return ""
13685 }
13686 return *r.Content
13687 }
13688
13689
13690 func (r *Reaction) GetID() int64 {
13691 if r == nil || r.ID == nil {
13692 return 0
13693 }
13694 return *r.ID
13695 }
13696
13697
13698 func (r *Reaction) GetNodeID() string {
13699 if r == nil || r.NodeID == nil {
13700 return ""
13701 }
13702 return *r.NodeID
13703 }
13704
13705
13706 func (r *Reaction) GetUser() *User {
13707 if r == nil {
13708 return nil
13709 }
13710 return r.User
13711 }
13712
13713
13714 func (r *Reactions) GetConfused() int {
13715 if r == nil || r.Confused == nil {
13716 return 0
13717 }
13718 return *r.Confused
13719 }
13720
13721
13722 func (r *Reactions) GetEyes() int {
13723 if r == nil || r.Eyes == nil {
13724 return 0
13725 }
13726 return *r.Eyes
13727 }
13728
13729
13730 func (r *Reactions) GetHeart() int {
13731 if r == nil || r.Heart == nil {
13732 return 0
13733 }
13734 return *r.Heart
13735 }
13736
13737
13738 func (r *Reactions) GetHooray() int {
13739 if r == nil || r.Hooray == nil {
13740 return 0
13741 }
13742 return *r.Hooray
13743 }
13744
13745
13746 func (r *Reactions) GetLaugh() int {
13747 if r == nil || r.Laugh == nil {
13748 return 0
13749 }
13750 return *r.Laugh
13751 }
13752
13753
13754 func (r *Reactions) GetMinusOne() int {
13755 if r == nil || r.MinusOne == nil {
13756 return 0
13757 }
13758 return *r.MinusOne
13759 }
13760
13761
13762 func (r *Reactions) GetPlusOne() int {
13763 if r == nil || r.PlusOne == nil {
13764 return 0
13765 }
13766 return *r.PlusOne
13767 }
13768
13769
13770 func (r *Reactions) GetRocket() int {
13771 if r == nil || r.Rocket == nil {
13772 return 0
13773 }
13774 return *r.Rocket
13775 }
13776
13777
13778 func (r *Reactions) GetTotalCount() int {
13779 if r == nil || r.TotalCount == nil {
13780 return 0
13781 }
13782 return *r.TotalCount
13783 }
13784
13785
13786 func (r *Reactions) GetURL() string {
13787 if r == nil || r.URL == nil {
13788 return ""
13789 }
13790 return *r.URL
13791 }
13792
13793
13794 func (r *Reference) GetNodeID() string {
13795 if r == nil || r.NodeID == nil {
13796 return ""
13797 }
13798 return *r.NodeID
13799 }
13800
13801
13802 func (r *Reference) GetObject() *GitObject {
13803 if r == nil {
13804 return nil
13805 }
13806 return r.Object
13807 }
13808
13809
13810 func (r *Reference) GetRef() string {
13811 if r == nil || r.Ref == nil {
13812 return ""
13813 }
13814 return *r.Ref
13815 }
13816
13817
13818 func (r *Reference) GetURL() string {
13819 if r == nil || r.URL == nil {
13820 return ""
13821 }
13822 return *r.URL
13823 }
13824
13825
13826 func (r *RegistrationToken) GetExpiresAt() Timestamp {
13827 if r == nil || r.ExpiresAt == nil {
13828 return Timestamp{}
13829 }
13830 return *r.ExpiresAt
13831 }
13832
13833
13834 func (r *RegistrationToken) GetToken() string {
13835 if r == nil || r.Token == nil {
13836 return ""
13837 }
13838 return *r.Token
13839 }
13840
13841
13842 func (r *ReleaseAsset) GetBrowserDownloadURL() string {
13843 if r == nil || r.BrowserDownloadURL == nil {
13844 return ""
13845 }
13846 return *r.BrowserDownloadURL
13847 }
13848
13849
13850 func (r *ReleaseAsset) GetContentType() string {
13851 if r == nil || r.ContentType == nil {
13852 return ""
13853 }
13854 return *r.ContentType
13855 }
13856
13857
13858 func (r *ReleaseAsset) GetCreatedAt() Timestamp {
13859 if r == nil || r.CreatedAt == nil {
13860 return Timestamp{}
13861 }
13862 return *r.CreatedAt
13863 }
13864
13865
13866 func (r *ReleaseAsset) GetDownloadCount() int {
13867 if r == nil || r.DownloadCount == nil {
13868 return 0
13869 }
13870 return *r.DownloadCount
13871 }
13872
13873
13874 func (r *ReleaseAsset) GetID() int64 {
13875 if r == nil || r.ID == nil {
13876 return 0
13877 }
13878 return *r.ID
13879 }
13880
13881
13882 func (r *ReleaseAsset) GetLabel() string {
13883 if r == nil || r.Label == nil {
13884 return ""
13885 }
13886 return *r.Label
13887 }
13888
13889
13890 func (r *ReleaseAsset) GetName() string {
13891 if r == nil || r.Name == nil {
13892 return ""
13893 }
13894 return *r.Name
13895 }
13896
13897
13898 func (r *ReleaseAsset) GetNodeID() string {
13899 if r == nil || r.NodeID == nil {
13900 return ""
13901 }
13902 return *r.NodeID
13903 }
13904
13905
13906 func (r *ReleaseAsset) GetSize() int {
13907 if r == nil || r.Size == nil {
13908 return 0
13909 }
13910 return *r.Size
13911 }
13912
13913
13914 func (r *ReleaseAsset) GetState() string {
13915 if r == nil || r.State == nil {
13916 return ""
13917 }
13918 return *r.State
13919 }
13920
13921
13922 func (r *ReleaseAsset) GetUpdatedAt() Timestamp {
13923 if r == nil || r.UpdatedAt == nil {
13924 return Timestamp{}
13925 }
13926 return *r.UpdatedAt
13927 }
13928
13929
13930 func (r *ReleaseAsset) GetUploader() *User {
13931 if r == nil {
13932 return nil
13933 }
13934 return r.Uploader
13935 }
13936
13937
13938 func (r *ReleaseAsset) GetURL() string {
13939 if r == nil || r.URL == nil {
13940 return ""
13941 }
13942 return *r.URL
13943 }
13944
13945
13946 func (r *ReleaseEvent) GetAction() string {
13947 if r == nil || r.Action == nil {
13948 return ""
13949 }
13950 return *r.Action
13951 }
13952
13953
13954 func (r *ReleaseEvent) GetInstallation() *Installation {
13955 if r == nil {
13956 return nil
13957 }
13958 return r.Installation
13959 }
13960
13961
13962 func (r *ReleaseEvent) GetRelease() *RepositoryRelease {
13963 if r == nil {
13964 return nil
13965 }
13966 return r.Release
13967 }
13968
13969
13970 func (r *ReleaseEvent) GetRepo() *Repository {
13971 if r == nil {
13972 return nil
13973 }
13974 return r.Repo
13975 }
13976
13977
13978 func (r *ReleaseEvent) GetSender() *User {
13979 if r == nil {
13980 return nil
13981 }
13982 return r.Sender
13983 }
13984
13985
13986 func (r *RemoveToken) GetExpiresAt() Timestamp {
13987 if r == nil || r.ExpiresAt == nil {
13988 return Timestamp{}
13989 }
13990 return *r.ExpiresAt
13991 }
13992
13993
13994 func (r *RemoveToken) GetToken() string {
13995 if r == nil || r.Token == nil {
13996 return ""
13997 }
13998 return *r.Token
13999 }
14000
14001
14002 func (r *Rename) GetFrom() string {
14003 if r == nil || r.From == nil {
14004 return ""
14005 }
14006 return *r.From
14007 }
14008
14009
14010 func (r *Rename) GetTo() string {
14011 if r == nil || r.To == nil {
14012 return ""
14013 }
14014 return *r.To
14015 }
14016
14017
14018 func (r *RenameOrgResponse) GetMessage() string {
14019 if r == nil || r.Message == nil {
14020 return ""
14021 }
14022 return *r.Message
14023 }
14024
14025
14026 func (r *RenameOrgResponse) GetURL() string {
14027 if r == nil || r.URL == nil {
14028 return ""
14029 }
14030 return *r.URL
14031 }
14032
14033
14034 func (r *RepoMergeUpstreamRequest) GetBranch() string {
14035 if r == nil || r.Branch == nil {
14036 return ""
14037 }
14038 return *r.Branch
14039 }
14040
14041
14042 func (r *RepoMergeUpstreamResult) GetBaseBranch() string {
14043 if r == nil || r.BaseBranch == nil {
14044 return ""
14045 }
14046 return *r.BaseBranch
14047 }
14048
14049
14050 func (r *RepoMergeUpstreamResult) GetMergeType() string {
14051 if r == nil || r.MergeType == nil {
14052 return ""
14053 }
14054 return *r.MergeType
14055 }
14056
14057
14058 func (r *RepoMergeUpstreamResult) GetMessage() string {
14059 if r == nil || r.Message == nil {
14060 return ""
14061 }
14062 return *r.Message
14063 }
14064
14065
14066 func (r *RepoName) GetFrom() string {
14067 if r == nil || r.From == nil {
14068 return ""
14069 }
14070 return *r.From
14071 }
14072
14073
14074 func (r *RepositoriesSearchResult) GetIncompleteResults() bool {
14075 if r == nil || r.IncompleteResults == nil {
14076 return false
14077 }
14078 return *r.IncompleteResults
14079 }
14080
14081
14082 func (r *RepositoriesSearchResult) GetTotal() int {
14083 if r == nil || r.Total == nil {
14084 return 0
14085 }
14086 return *r.Total
14087 }
14088
14089
14090 func (r *Repository) GetAllowAutoMerge() bool {
14091 if r == nil || r.AllowAutoMerge == nil {
14092 return false
14093 }
14094 return *r.AllowAutoMerge
14095 }
14096
14097
14098 func (r *Repository) GetAllowForking() bool {
14099 if r == nil || r.AllowForking == nil {
14100 return false
14101 }
14102 return *r.AllowForking
14103 }
14104
14105
14106 func (r *Repository) GetAllowMergeCommit() bool {
14107 if r == nil || r.AllowMergeCommit == nil {
14108 return false
14109 }
14110 return *r.AllowMergeCommit
14111 }
14112
14113
14114 func (r *Repository) GetAllowRebaseMerge() bool {
14115 if r == nil || r.AllowRebaseMerge == nil {
14116 return false
14117 }
14118 return *r.AllowRebaseMerge
14119 }
14120
14121
14122 func (r *Repository) GetAllowSquashMerge() bool {
14123 if r == nil || r.AllowSquashMerge == nil {
14124 return false
14125 }
14126 return *r.AllowSquashMerge
14127 }
14128
14129
14130 func (r *Repository) GetAllowUpdateBranch() bool {
14131 if r == nil || r.AllowUpdateBranch == nil {
14132 return false
14133 }
14134 return *r.AllowUpdateBranch
14135 }
14136
14137
14138 func (r *Repository) GetArchived() bool {
14139 if r == nil || r.Archived == nil {
14140 return false
14141 }
14142 return *r.Archived
14143 }
14144
14145
14146 func (r *Repository) GetArchiveURL() string {
14147 if r == nil || r.ArchiveURL == nil {
14148 return ""
14149 }
14150 return *r.ArchiveURL
14151 }
14152
14153
14154 func (r *Repository) GetAssigneesURL() string {
14155 if r == nil || r.AssigneesURL == nil {
14156 return ""
14157 }
14158 return *r.AssigneesURL
14159 }
14160
14161
14162 func (r *Repository) GetAutoInit() bool {
14163 if r == nil || r.AutoInit == nil {
14164 return false
14165 }
14166 return *r.AutoInit
14167 }
14168
14169
14170 func (r *Repository) GetBlobsURL() string {
14171 if r == nil || r.BlobsURL == nil {
14172 return ""
14173 }
14174 return *r.BlobsURL
14175 }
14176
14177
14178 func (r *Repository) GetBranchesURL() string {
14179 if r == nil || r.BranchesURL == nil {
14180 return ""
14181 }
14182 return *r.BranchesURL
14183 }
14184
14185
14186 func (r *Repository) GetCloneURL() string {
14187 if r == nil || r.CloneURL == nil {
14188 return ""
14189 }
14190 return *r.CloneURL
14191 }
14192
14193
14194 func (r *Repository) GetCodeOfConduct() *CodeOfConduct {
14195 if r == nil {
14196 return nil
14197 }
14198 return r.CodeOfConduct
14199 }
14200
14201
14202 func (r *Repository) GetCollaboratorsURL() string {
14203 if r == nil || r.CollaboratorsURL == nil {
14204 return ""
14205 }
14206 return *r.CollaboratorsURL
14207 }
14208
14209
14210 func (r *Repository) GetCommentsURL() string {
14211 if r == nil || r.CommentsURL == nil {
14212 return ""
14213 }
14214 return *r.CommentsURL
14215 }
14216
14217
14218 func (r *Repository) GetCommitsURL() string {
14219 if r == nil || r.CommitsURL == nil {
14220 return ""
14221 }
14222 return *r.CommitsURL
14223 }
14224
14225
14226 func (r *Repository) GetCompareURL() string {
14227 if r == nil || r.CompareURL == nil {
14228 return ""
14229 }
14230 return *r.CompareURL
14231 }
14232
14233
14234 func (r *Repository) GetContentsURL() string {
14235 if r == nil || r.ContentsURL == nil {
14236 return ""
14237 }
14238 return *r.ContentsURL
14239 }
14240
14241
14242 func (r *Repository) GetContributorsURL() string {
14243 if r == nil || r.ContributorsURL == nil {
14244 return ""
14245 }
14246 return *r.ContributorsURL
14247 }
14248
14249
14250 func (r *Repository) GetCreatedAt() Timestamp {
14251 if r == nil || r.CreatedAt == nil {
14252 return Timestamp{}
14253 }
14254 return *r.CreatedAt
14255 }
14256
14257
14258 func (r *Repository) GetDefaultBranch() string {
14259 if r == nil || r.DefaultBranch == nil {
14260 return ""
14261 }
14262 return *r.DefaultBranch
14263 }
14264
14265
14266 func (r *Repository) GetDeleteBranchOnMerge() bool {
14267 if r == nil || r.DeleteBranchOnMerge == nil {
14268 return false
14269 }
14270 return *r.DeleteBranchOnMerge
14271 }
14272
14273
14274 func (r *Repository) GetDeploymentsURL() string {
14275 if r == nil || r.DeploymentsURL == nil {
14276 return ""
14277 }
14278 return *r.DeploymentsURL
14279 }
14280
14281
14282 func (r *Repository) GetDescription() string {
14283 if r == nil || r.Description == nil {
14284 return ""
14285 }
14286 return *r.Description
14287 }
14288
14289
14290 func (r *Repository) GetDisabled() bool {
14291 if r == nil || r.Disabled == nil {
14292 return false
14293 }
14294 return *r.Disabled
14295 }
14296
14297
14298 func (r *Repository) GetDownloadsURL() string {
14299 if r == nil || r.DownloadsURL == nil {
14300 return ""
14301 }
14302 return *r.DownloadsURL
14303 }
14304
14305
14306 func (r *Repository) GetEventsURL() string {
14307 if r == nil || r.EventsURL == nil {
14308 return ""
14309 }
14310 return *r.EventsURL
14311 }
14312
14313
14314 func (r *Repository) GetFork() bool {
14315 if r == nil || r.Fork == nil {
14316 return false
14317 }
14318 return *r.Fork
14319 }
14320
14321
14322 func (r *Repository) GetForksCount() int {
14323 if r == nil || r.ForksCount == nil {
14324 return 0
14325 }
14326 return *r.ForksCount
14327 }
14328
14329
14330 func (r *Repository) GetForksURL() string {
14331 if r == nil || r.ForksURL == nil {
14332 return ""
14333 }
14334 return *r.ForksURL
14335 }
14336
14337
14338 func (r *Repository) GetFullName() string {
14339 if r == nil || r.FullName == nil {
14340 return ""
14341 }
14342 return *r.FullName
14343 }
14344
14345
14346 func (r *Repository) GetGitCommitsURL() string {
14347 if r == nil || r.GitCommitsURL == nil {
14348 return ""
14349 }
14350 return *r.GitCommitsURL
14351 }
14352
14353
14354 func (r *Repository) GetGitignoreTemplate() string {
14355 if r == nil || r.GitignoreTemplate == nil {
14356 return ""
14357 }
14358 return *r.GitignoreTemplate
14359 }
14360
14361
14362 func (r *Repository) GetGitRefsURL() string {
14363 if r == nil || r.GitRefsURL == nil {
14364 return ""
14365 }
14366 return *r.GitRefsURL
14367 }
14368
14369
14370 func (r *Repository) GetGitTagsURL() string {
14371 if r == nil || r.GitTagsURL == nil {
14372 return ""
14373 }
14374 return *r.GitTagsURL
14375 }
14376
14377
14378 func (r *Repository) GetGitURL() string {
14379 if r == nil || r.GitURL == nil {
14380 return ""
14381 }
14382 return *r.GitURL
14383 }
14384
14385
14386 func (r *Repository) GetHasDownloads() bool {
14387 if r == nil || r.HasDownloads == nil {
14388 return false
14389 }
14390 return *r.HasDownloads
14391 }
14392
14393
14394 func (r *Repository) GetHasIssues() bool {
14395 if r == nil || r.HasIssues == nil {
14396 return false
14397 }
14398 return *r.HasIssues
14399 }
14400
14401
14402 func (r *Repository) GetHasPages() bool {
14403 if r == nil || r.HasPages == nil {
14404 return false
14405 }
14406 return *r.HasPages
14407 }
14408
14409
14410 func (r *Repository) GetHasProjects() bool {
14411 if r == nil || r.HasProjects == nil {
14412 return false
14413 }
14414 return *r.HasProjects
14415 }
14416
14417
14418 func (r *Repository) GetHasWiki() bool {
14419 if r == nil || r.HasWiki == nil {
14420 return false
14421 }
14422 return *r.HasWiki
14423 }
14424
14425
14426 func (r *Repository) GetHomepage() string {
14427 if r == nil || r.Homepage == nil {
14428 return ""
14429 }
14430 return *r.Homepage
14431 }
14432
14433
14434 func (r *Repository) GetHooksURL() string {
14435 if r == nil || r.HooksURL == nil {
14436 return ""
14437 }
14438 return *r.HooksURL
14439 }
14440
14441
14442 func (r *Repository) GetHTMLURL() string {
14443 if r == nil || r.HTMLURL == nil {
14444 return ""
14445 }
14446 return *r.HTMLURL
14447 }
14448
14449
14450 func (r *Repository) GetID() int64 {
14451 if r == nil || r.ID == nil {
14452 return 0
14453 }
14454 return *r.ID
14455 }
14456
14457
14458 func (r *Repository) GetIssueCommentURL() string {
14459 if r == nil || r.IssueCommentURL == nil {
14460 return ""
14461 }
14462 return *r.IssueCommentURL
14463 }
14464
14465
14466 func (r *Repository) GetIssueEventsURL() string {
14467 if r == nil || r.IssueEventsURL == nil {
14468 return ""
14469 }
14470 return *r.IssueEventsURL
14471 }
14472
14473
14474 func (r *Repository) GetIssuesURL() string {
14475 if r == nil || r.IssuesURL == nil {
14476 return ""
14477 }
14478 return *r.IssuesURL
14479 }
14480
14481
14482 func (r *Repository) GetIsTemplate() bool {
14483 if r == nil || r.IsTemplate == nil {
14484 return false
14485 }
14486 return *r.IsTemplate
14487 }
14488
14489
14490 func (r *Repository) GetKeysURL() string {
14491 if r == nil || r.KeysURL == nil {
14492 return ""
14493 }
14494 return *r.KeysURL
14495 }
14496
14497
14498 func (r *Repository) GetLabelsURL() string {
14499 if r == nil || r.LabelsURL == nil {
14500 return ""
14501 }
14502 return *r.LabelsURL
14503 }
14504
14505
14506 func (r *Repository) GetLanguage() string {
14507 if r == nil || r.Language == nil {
14508 return ""
14509 }
14510 return *r.Language
14511 }
14512
14513
14514 func (r *Repository) GetLanguagesURL() string {
14515 if r == nil || r.LanguagesURL == nil {
14516 return ""
14517 }
14518 return *r.LanguagesURL
14519 }
14520
14521
14522 func (r *Repository) GetLicense() *License {
14523 if r == nil {
14524 return nil
14525 }
14526 return r.License
14527 }
14528
14529
14530 func (r *Repository) GetLicenseTemplate() string {
14531 if r == nil || r.LicenseTemplate == nil {
14532 return ""
14533 }
14534 return *r.LicenseTemplate
14535 }
14536
14537
14538 func (r *Repository) GetMasterBranch() string {
14539 if r == nil || r.MasterBranch == nil {
14540 return ""
14541 }
14542 return *r.MasterBranch
14543 }
14544
14545
14546 func (r *Repository) GetMergesURL() string {
14547 if r == nil || r.MergesURL == nil {
14548 return ""
14549 }
14550 return *r.MergesURL
14551 }
14552
14553
14554 func (r *Repository) GetMilestonesURL() string {
14555 if r == nil || r.MilestonesURL == nil {
14556 return ""
14557 }
14558 return *r.MilestonesURL
14559 }
14560
14561
14562 func (r *Repository) GetMirrorURL() string {
14563 if r == nil || r.MirrorURL == nil {
14564 return ""
14565 }
14566 return *r.MirrorURL
14567 }
14568
14569
14570 func (r *Repository) GetName() string {
14571 if r == nil || r.Name == nil {
14572 return ""
14573 }
14574 return *r.Name
14575 }
14576
14577
14578 func (r *Repository) GetNetworkCount() int {
14579 if r == nil || r.NetworkCount == nil {
14580 return 0
14581 }
14582 return *r.NetworkCount
14583 }
14584
14585
14586 func (r *Repository) GetNodeID() string {
14587 if r == nil || r.NodeID == nil {
14588 return ""
14589 }
14590 return *r.NodeID
14591 }
14592
14593
14594 func (r *Repository) GetNotificationsURL() string {
14595 if r == nil || r.NotificationsURL == nil {
14596 return ""
14597 }
14598 return *r.NotificationsURL
14599 }
14600
14601
14602 func (r *Repository) GetOpenIssues() int {
14603 if r == nil || r.OpenIssues == nil {
14604 return 0
14605 }
14606 return *r.OpenIssues
14607 }
14608
14609
14610 func (r *Repository) GetOpenIssuesCount() int {
14611 if r == nil || r.OpenIssuesCount == nil {
14612 return 0
14613 }
14614 return *r.OpenIssuesCount
14615 }
14616
14617
14618 func (r *Repository) GetOrganization() *Organization {
14619 if r == nil {
14620 return nil
14621 }
14622 return r.Organization
14623 }
14624
14625
14626 func (r *Repository) GetOwner() *User {
14627 if r == nil {
14628 return nil
14629 }
14630 return r.Owner
14631 }
14632
14633
14634 func (r *Repository) GetParent() *Repository {
14635 if r == nil {
14636 return nil
14637 }
14638 return r.Parent
14639 }
14640
14641
14642 func (r *Repository) GetPermissions() map[string]bool {
14643 if r == nil || r.Permissions == nil {
14644 return map[string]bool{}
14645 }
14646 return r.Permissions
14647 }
14648
14649
14650 func (r *Repository) GetPrivate() bool {
14651 if r == nil || r.Private == nil {
14652 return false
14653 }
14654 return *r.Private
14655 }
14656
14657
14658 func (r *Repository) GetPullsURL() string {
14659 if r == nil || r.PullsURL == nil {
14660 return ""
14661 }
14662 return *r.PullsURL
14663 }
14664
14665
14666 func (r *Repository) GetPushedAt() Timestamp {
14667 if r == nil || r.PushedAt == nil {
14668 return Timestamp{}
14669 }
14670 return *r.PushedAt
14671 }
14672
14673
14674 func (r *Repository) GetReleasesURL() string {
14675 if r == nil || r.ReleasesURL == nil {
14676 return ""
14677 }
14678 return *r.ReleasesURL
14679 }
14680
14681
14682 func (r *Repository) GetRoleName() string {
14683 if r == nil || r.RoleName == nil {
14684 return ""
14685 }
14686 return *r.RoleName
14687 }
14688
14689
14690 func (r *Repository) GetSecurityAndAnalysis() *SecurityAndAnalysis {
14691 if r == nil {
14692 return nil
14693 }
14694 return r.SecurityAndAnalysis
14695 }
14696
14697
14698 func (r *Repository) GetSize() int {
14699 if r == nil || r.Size == nil {
14700 return 0
14701 }
14702 return *r.Size
14703 }
14704
14705
14706 func (r *Repository) GetSource() *Repository {
14707 if r == nil {
14708 return nil
14709 }
14710 return r.Source
14711 }
14712
14713
14714 func (r *Repository) GetSSHURL() string {
14715 if r == nil || r.SSHURL == nil {
14716 return ""
14717 }
14718 return *r.SSHURL
14719 }
14720
14721
14722 func (r *Repository) GetStargazersCount() int {
14723 if r == nil || r.StargazersCount == nil {
14724 return 0
14725 }
14726 return *r.StargazersCount
14727 }
14728
14729
14730 func (r *Repository) GetStargazersURL() string {
14731 if r == nil || r.StargazersURL == nil {
14732 return ""
14733 }
14734 return *r.StargazersURL
14735 }
14736
14737
14738 func (r *Repository) GetStatusesURL() string {
14739 if r == nil || r.StatusesURL == nil {
14740 return ""
14741 }
14742 return *r.StatusesURL
14743 }
14744
14745
14746 func (r *Repository) GetSubscribersCount() int {
14747 if r == nil || r.SubscribersCount == nil {
14748 return 0
14749 }
14750 return *r.SubscribersCount
14751 }
14752
14753
14754 func (r *Repository) GetSubscribersURL() string {
14755 if r == nil || r.SubscribersURL == nil {
14756 return ""
14757 }
14758 return *r.SubscribersURL
14759 }
14760
14761
14762 func (r *Repository) GetSubscriptionURL() string {
14763 if r == nil || r.SubscriptionURL == nil {
14764 return ""
14765 }
14766 return *r.SubscriptionURL
14767 }
14768
14769
14770 func (r *Repository) GetSVNURL() string {
14771 if r == nil || r.SVNURL == nil {
14772 return ""
14773 }
14774 return *r.SVNURL
14775 }
14776
14777
14778 func (r *Repository) GetTagsURL() string {
14779 if r == nil || r.TagsURL == nil {
14780 return ""
14781 }
14782 return *r.TagsURL
14783 }
14784
14785
14786 func (r *Repository) GetTeamID() int64 {
14787 if r == nil || r.TeamID == nil {
14788 return 0
14789 }
14790 return *r.TeamID
14791 }
14792
14793
14794 func (r *Repository) GetTeamsURL() string {
14795 if r == nil || r.TeamsURL == nil {
14796 return ""
14797 }
14798 return *r.TeamsURL
14799 }
14800
14801
14802 func (r *Repository) GetTemplateRepository() *Repository {
14803 if r == nil {
14804 return nil
14805 }
14806 return r.TemplateRepository
14807 }
14808
14809
14810 func (r *Repository) GetTreesURL() string {
14811 if r == nil || r.TreesURL == nil {
14812 return ""
14813 }
14814 return *r.TreesURL
14815 }
14816
14817
14818 func (r *Repository) GetUpdatedAt() Timestamp {
14819 if r == nil || r.UpdatedAt == nil {
14820 return Timestamp{}
14821 }
14822 return *r.UpdatedAt
14823 }
14824
14825
14826 func (r *Repository) GetURL() string {
14827 if r == nil || r.URL == nil {
14828 return ""
14829 }
14830 return *r.URL
14831 }
14832
14833
14834 func (r *Repository) GetUseSquashPRTitleAsDefault() bool {
14835 if r == nil || r.UseSquashPRTitleAsDefault == nil {
14836 return false
14837 }
14838 return *r.UseSquashPRTitleAsDefault
14839 }
14840
14841
14842 func (r *Repository) GetVisibility() string {
14843 if r == nil || r.Visibility == nil {
14844 return ""
14845 }
14846 return *r.Visibility
14847 }
14848
14849
14850 func (r *Repository) GetWatchers() int {
14851 if r == nil || r.Watchers == nil {
14852 return 0
14853 }
14854 return *r.Watchers
14855 }
14856
14857
14858 func (r *Repository) GetWatchersCount() int {
14859 if r == nil || r.WatchersCount == nil {
14860 return 0
14861 }
14862 return *r.WatchersCount
14863 }
14864
14865
14866 func (r *RepositoryActiveCommitters) GetAdvancedSecurityCommitters() int {
14867 if r == nil || r.AdvancedSecurityCommitters == nil {
14868 return 0
14869 }
14870 return *r.AdvancedSecurityCommitters
14871 }
14872
14873
14874 func (r *RepositoryActiveCommitters) GetName() string {
14875 if r == nil || r.Name == nil {
14876 return ""
14877 }
14878 return *r.Name
14879 }
14880
14881
14882 func (r *RepositoryComment) GetBody() string {
14883 if r == nil || r.Body == nil {
14884 return ""
14885 }
14886 return *r.Body
14887 }
14888
14889
14890 func (r *RepositoryComment) GetCommitID() string {
14891 if r == nil || r.CommitID == nil {
14892 return ""
14893 }
14894 return *r.CommitID
14895 }
14896
14897
14898 func (r *RepositoryComment) GetCreatedAt() time.Time {
14899 if r == nil || r.CreatedAt == nil {
14900 return time.Time{}
14901 }
14902 return *r.CreatedAt
14903 }
14904
14905
14906 func (r *RepositoryComment) GetHTMLURL() string {
14907 if r == nil || r.HTMLURL == nil {
14908 return ""
14909 }
14910 return *r.HTMLURL
14911 }
14912
14913
14914 func (r *RepositoryComment) GetID() int64 {
14915 if r == nil || r.ID == nil {
14916 return 0
14917 }
14918 return *r.ID
14919 }
14920
14921
14922 func (r *RepositoryComment) GetNodeID() string {
14923 if r == nil || r.NodeID == nil {
14924 return ""
14925 }
14926 return *r.NodeID
14927 }
14928
14929
14930 func (r *RepositoryComment) GetPath() string {
14931 if r == nil || r.Path == nil {
14932 return ""
14933 }
14934 return *r.Path
14935 }
14936
14937
14938 func (r *RepositoryComment) GetPosition() int {
14939 if r == nil || r.Position == nil {
14940 return 0
14941 }
14942 return *r.Position
14943 }
14944
14945
14946 func (r *RepositoryComment) GetReactions() *Reactions {
14947 if r == nil {
14948 return nil
14949 }
14950 return r.Reactions
14951 }
14952
14953
14954 func (r *RepositoryComment) GetUpdatedAt() time.Time {
14955 if r == nil || r.UpdatedAt == nil {
14956 return time.Time{}
14957 }
14958 return *r.UpdatedAt
14959 }
14960
14961
14962 func (r *RepositoryComment) GetURL() string {
14963 if r == nil || r.URL == nil {
14964 return ""
14965 }
14966 return *r.URL
14967 }
14968
14969
14970 func (r *RepositoryComment) GetUser() *User {
14971 if r == nil {
14972 return nil
14973 }
14974 return r.User
14975 }
14976
14977
14978 func (r *RepositoryCommit) GetAuthor() *User {
14979 if r == nil {
14980 return nil
14981 }
14982 return r.Author
14983 }
14984
14985
14986 func (r *RepositoryCommit) GetCommentsURL() string {
14987 if r == nil || r.CommentsURL == nil {
14988 return ""
14989 }
14990 return *r.CommentsURL
14991 }
14992
14993
14994 func (r *RepositoryCommit) GetCommit() *Commit {
14995 if r == nil {
14996 return nil
14997 }
14998 return r.Commit
14999 }
15000
15001
15002 func (r *RepositoryCommit) GetCommitter() *User {
15003 if r == nil {
15004 return nil
15005 }
15006 return r.Committer
15007 }
15008
15009
15010 func (r *RepositoryCommit) GetHTMLURL() string {
15011 if r == nil || r.HTMLURL == nil {
15012 return ""
15013 }
15014 return *r.HTMLURL
15015 }
15016
15017
15018 func (r *RepositoryCommit) GetNodeID() string {
15019 if r == nil || r.NodeID == nil {
15020 return ""
15021 }
15022 return *r.NodeID
15023 }
15024
15025
15026 func (r *RepositoryCommit) GetSHA() string {
15027 if r == nil || r.SHA == nil {
15028 return ""
15029 }
15030 return *r.SHA
15031 }
15032
15033
15034 func (r *RepositoryCommit) GetStats() *CommitStats {
15035 if r == nil {
15036 return nil
15037 }
15038 return r.Stats
15039 }
15040
15041
15042 func (r *RepositoryCommit) GetURL() string {
15043 if r == nil || r.URL == nil {
15044 return ""
15045 }
15046 return *r.URL
15047 }
15048
15049
15050 func (r *RepositoryContent) GetDownloadURL() string {
15051 if r == nil || r.DownloadURL == nil {
15052 return ""
15053 }
15054 return *r.DownloadURL
15055 }
15056
15057
15058 func (r *RepositoryContent) GetEncoding() string {
15059 if r == nil || r.Encoding == nil {
15060 return ""
15061 }
15062 return *r.Encoding
15063 }
15064
15065
15066 func (r *RepositoryContent) GetGitURL() string {
15067 if r == nil || r.GitURL == nil {
15068 return ""
15069 }
15070 return *r.GitURL
15071 }
15072
15073
15074 func (r *RepositoryContent) GetHTMLURL() string {
15075 if r == nil || r.HTMLURL == nil {
15076 return ""
15077 }
15078 return *r.HTMLURL
15079 }
15080
15081
15082 func (r *RepositoryContent) GetName() string {
15083 if r == nil || r.Name == nil {
15084 return ""
15085 }
15086 return *r.Name
15087 }
15088
15089
15090 func (r *RepositoryContent) GetPath() string {
15091 if r == nil || r.Path == nil {
15092 return ""
15093 }
15094 return *r.Path
15095 }
15096
15097
15098 func (r *RepositoryContent) GetSHA() string {
15099 if r == nil || r.SHA == nil {
15100 return ""
15101 }
15102 return *r.SHA
15103 }
15104
15105
15106 func (r *RepositoryContent) GetSize() int {
15107 if r == nil || r.Size == nil {
15108 return 0
15109 }
15110 return *r.Size
15111 }
15112
15113
15114 func (r *RepositoryContent) GetTarget() string {
15115 if r == nil || r.Target == nil {
15116 return ""
15117 }
15118 return *r.Target
15119 }
15120
15121
15122 func (r *RepositoryContent) GetType() string {
15123 if r == nil || r.Type == nil {
15124 return ""
15125 }
15126 return *r.Type
15127 }
15128
15129
15130 func (r *RepositoryContent) GetURL() string {
15131 if r == nil || r.URL == nil {
15132 return ""
15133 }
15134 return *r.URL
15135 }
15136
15137
15138 func (r *RepositoryContentFileOptions) GetAuthor() *CommitAuthor {
15139 if r == nil {
15140 return nil
15141 }
15142 return r.Author
15143 }
15144
15145
15146 func (r *RepositoryContentFileOptions) GetBranch() string {
15147 if r == nil || r.Branch == nil {
15148 return ""
15149 }
15150 return *r.Branch
15151 }
15152
15153
15154 func (r *RepositoryContentFileOptions) GetCommitter() *CommitAuthor {
15155 if r == nil {
15156 return nil
15157 }
15158 return r.Committer
15159 }
15160
15161
15162 func (r *RepositoryContentFileOptions) GetMessage() string {
15163 if r == nil || r.Message == nil {
15164 return ""
15165 }
15166 return *r.Message
15167 }
15168
15169
15170 func (r *RepositoryContentFileOptions) GetSHA() string {
15171 if r == nil || r.SHA == nil {
15172 return ""
15173 }
15174 return *r.SHA
15175 }
15176
15177
15178 func (r *RepositoryContentResponse) GetContent() *RepositoryContent {
15179 if r == nil {
15180 return nil
15181 }
15182 return r.Content
15183 }
15184
15185
15186 func (r *RepositoryDispatchEvent) GetAction() string {
15187 if r == nil || r.Action == nil {
15188 return ""
15189 }
15190 return *r.Action
15191 }
15192
15193
15194 func (r *RepositoryDispatchEvent) GetBranch() string {
15195 if r == nil || r.Branch == nil {
15196 return ""
15197 }
15198 return *r.Branch
15199 }
15200
15201
15202 func (r *RepositoryDispatchEvent) GetInstallation() *Installation {
15203 if r == nil {
15204 return nil
15205 }
15206 return r.Installation
15207 }
15208
15209
15210 func (r *RepositoryDispatchEvent) GetOrg() *Organization {
15211 if r == nil {
15212 return nil
15213 }
15214 return r.Org
15215 }
15216
15217
15218 func (r *RepositoryDispatchEvent) GetRepo() *Repository {
15219 if r == nil {
15220 return nil
15221 }
15222 return r.Repo
15223 }
15224
15225
15226 func (r *RepositoryDispatchEvent) GetSender() *User {
15227 if r == nil {
15228 return nil
15229 }
15230 return r.Sender
15231 }
15232
15233
15234 func (r *RepositoryEvent) GetAction() string {
15235 if r == nil || r.Action == nil {
15236 return ""
15237 }
15238 return *r.Action
15239 }
15240
15241
15242 func (r *RepositoryEvent) GetChanges() *EditChange {
15243 if r == nil {
15244 return nil
15245 }
15246 return r.Changes
15247 }
15248
15249
15250 func (r *RepositoryEvent) GetInstallation() *Installation {
15251 if r == nil {
15252 return nil
15253 }
15254 return r.Installation
15255 }
15256
15257
15258 func (r *RepositoryEvent) GetOrg() *Organization {
15259 if r == nil {
15260 return nil
15261 }
15262 return r.Org
15263 }
15264
15265
15266 func (r *RepositoryEvent) GetRepo() *Repository {
15267 if r == nil {
15268 return nil
15269 }
15270 return r.Repo
15271 }
15272
15273
15274 func (r *RepositoryEvent) GetSender() *User {
15275 if r == nil {
15276 return nil
15277 }
15278 return r.Sender
15279 }
15280
15281
15282 func (r *RepositoryImportEvent) GetOrg() *Organization {
15283 if r == nil {
15284 return nil
15285 }
15286 return r.Org
15287 }
15288
15289
15290 func (r *RepositoryImportEvent) GetRepo() *Repository {
15291 if r == nil {
15292 return nil
15293 }
15294 return r.Repo
15295 }
15296
15297
15298 func (r *RepositoryImportEvent) GetSender() *User {
15299 if r == nil {
15300 return nil
15301 }
15302 return r.Sender
15303 }
15304
15305
15306 func (r *RepositoryImportEvent) GetStatus() string {
15307 if r == nil || r.Status == nil {
15308 return ""
15309 }
15310 return *r.Status
15311 }
15312
15313
15314 func (r *RepositoryInvitation) GetCreatedAt() Timestamp {
15315 if r == nil || r.CreatedAt == nil {
15316 return Timestamp{}
15317 }
15318 return *r.CreatedAt
15319 }
15320
15321
15322 func (r *RepositoryInvitation) GetHTMLURL() string {
15323 if r == nil || r.HTMLURL == nil {
15324 return ""
15325 }
15326 return *r.HTMLURL
15327 }
15328
15329
15330 func (r *RepositoryInvitation) GetID() int64 {
15331 if r == nil || r.ID == nil {
15332 return 0
15333 }
15334 return *r.ID
15335 }
15336
15337
15338 func (r *RepositoryInvitation) GetInvitee() *User {
15339 if r == nil {
15340 return nil
15341 }
15342 return r.Invitee
15343 }
15344
15345
15346 func (r *RepositoryInvitation) GetInviter() *User {
15347 if r == nil {
15348 return nil
15349 }
15350 return r.Inviter
15351 }
15352
15353
15354 func (r *RepositoryInvitation) GetPermissions() string {
15355 if r == nil || r.Permissions == nil {
15356 return ""
15357 }
15358 return *r.Permissions
15359 }
15360
15361
15362 func (r *RepositoryInvitation) GetRepo() *Repository {
15363 if r == nil {
15364 return nil
15365 }
15366 return r.Repo
15367 }
15368
15369
15370 func (r *RepositoryInvitation) GetURL() string {
15371 if r == nil || r.URL == nil {
15372 return ""
15373 }
15374 return *r.URL
15375 }
15376
15377
15378 func (r *RepositoryLicense) GetContent() string {
15379 if r == nil || r.Content == nil {
15380 return ""
15381 }
15382 return *r.Content
15383 }
15384
15385
15386 func (r *RepositoryLicense) GetDownloadURL() string {
15387 if r == nil || r.DownloadURL == nil {
15388 return ""
15389 }
15390 return *r.DownloadURL
15391 }
15392
15393
15394 func (r *RepositoryLicense) GetEncoding() string {
15395 if r == nil || r.Encoding == nil {
15396 return ""
15397 }
15398 return *r.Encoding
15399 }
15400
15401
15402 func (r *RepositoryLicense) GetGitURL() string {
15403 if r == nil || r.GitURL == nil {
15404 return ""
15405 }
15406 return *r.GitURL
15407 }
15408
15409
15410 func (r *RepositoryLicense) GetHTMLURL() string {
15411 if r == nil || r.HTMLURL == nil {
15412 return ""
15413 }
15414 return *r.HTMLURL
15415 }
15416
15417
15418 func (r *RepositoryLicense) GetLicense() *License {
15419 if r == nil {
15420 return nil
15421 }
15422 return r.License
15423 }
15424
15425
15426 func (r *RepositoryLicense) GetName() string {
15427 if r == nil || r.Name == nil {
15428 return ""
15429 }
15430 return *r.Name
15431 }
15432
15433
15434 func (r *RepositoryLicense) GetPath() string {
15435 if r == nil || r.Path == nil {
15436 return ""
15437 }
15438 return *r.Path
15439 }
15440
15441
15442 func (r *RepositoryLicense) GetSHA() string {
15443 if r == nil || r.SHA == nil {
15444 return ""
15445 }
15446 return *r.SHA
15447 }
15448
15449
15450 func (r *RepositoryLicense) GetSize() int {
15451 if r == nil || r.Size == nil {
15452 return 0
15453 }
15454 return *r.Size
15455 }
15456
15457
15458 func (r *RepositoryLicense) GetType() string {
15459 if r == nil || r.Type == nil {
15460 return ""
15461 }
15462 return *r.Type
15463 }
15464
15465
15466 func (r *RepositoryLicense) GetURL() string {
15467 if r == nil || r.URL == nil {
15468 return ""
15469 }
15470 return *r.URL
15471 }
15472
15473
15474 func (r *RepositoryMergeRequest) GetBase() string {
15475 if r == nil || r.Base == nil {
15476 return ""
15477 }
15478 return *r.Base
15479 }
15480
15481
15482 func (r *RepositoryMergeRequest) GetCommitMessage() string {
15483 if r == nil || r.CommitMessage == nil {
15484 return ""
15485 }
15486 return *r.CommitMessage
15487 }
15488
15489
15490 func (r *RepositoryMergeRequest) GetHead() string {
15491 if r == nil || r.Head == nil {
15492 return ""
15493 }
15494 return *r.Head
15495 }
15496
15497
15498 func (r *RepositoryPermissionLevel) GetPermission() string {
15499 if r == nil || r.Permission == nil {
15500 return ""
15501 }
15502 return *r.Permission
15503 }
15504
15505
15506 func (r *RepositoryPermissionLevel) GetUser() *User {
15507 if r == nil {
15508 return nil
15509 }
15510 return r.User
15511 }
15512
15513
15514 func (r *RepositoryRelease) GetAssetsURL() string {
15515 if r == nil || r.AssetsURL == nil {
15516 return ""
15517 }
15518 return *r.AssetsURL
15519 }
15520
15521
15522 func (r *RepositoryRelease) GetAuthor() *User {
15523 if r == nil {
15524 return nil
15525 }
15526 return r.Author
15527 }
15528
15529
15530 func (r *RepositoryRelease) GetBody() string {
15531 if r == nil || r.Body == nil {
15532 return ""
15533 }
15534 return *r.Body
15535 }
15536
15537
15538 func (r *RepositoryRelease) GetCreatedAt() Timestamp {
15539 if r == nil || r.CreatedAt == nil {
15540 return Timestamp{}
15541 }
15542 return *r.CreatedAt
15543 }
15544
15545
15546 func (r *RepositoryRelease) GetDiscussionCategoryName() string {
15547 if r == nil || r.DiscussionCategoryName == nil {
15548 return ""
15549 }
15550 return *r.DiscussionCategoryName
15551 }
15552
15553
15554 func (r *RepositoryRelease) GetDraft() bool {
15555 if r == nil || r.Draft == nil {
15556 return false
15557 }
15558 return *r.Draft
15559 }
15560
15561
15562 func (r *RepositoryRelease) GetGenerateReleaseNotes() bool {
15563 if r == nil || r.GenerateReleaseNotes == nil {
15564 return false
15565 }
15566 return *r.GenerateReleaseNotes
15567 }
15568
15569
15570 func (r *RepositoryRelease) GetHTMLURL() string {
15571 if r == nil || r.HTMLURL == nil {
15572 return ""
15573 }
15574 return *r.HTMLURL
15575 }
15576
15577
15578 func (r *RepositoryRelease) GetID() int64 {
15579 if r == nil || r.ID == nil {
15580 return 0
15581 }
15582 return *r.ID
15583 }
15584
15585
15586 func (r *RepositoryRelease) GetName() string {
15587 if r == nil || r.Name == nil {
15588 return ""
15589 }
15590 return *r.Name
15591 }
15592
15593
15594 func (r *RepositoryRelease) GetNodeID() string {
15595 if r == nil || r.NodeID == nil {
15596 return ""
15597 }
15598 return *r.NodeID
15599 }
15600
15601
15602 func (r *RepositoryRelease) GetPrerelease() bool {
15603 if r == nil || r.Prerelease == nil {
15604 return false
15605 }
15606 return *r.Prerelease
15607 }
15608
15609
15610 func (r *RepositoryRelease) GetPublishedAt() Timestamp {
15611 if r == nil || r.PublishedAt == nil {
15612 return Timestamp{}
15613 }
15614 return *r.PublishedAt
15615 }
15616
15617
15618 func (r *RepositoryRelease) GetTagName() string {
15619 if r == nil || r.TagName == nil {
15620 return ""
15621 }
15622 return *r.TagName
15623 }
15624
15625
15626 func (r *RepositoryRelease) GetTarballURL() string {
15627 if r == nil || r.TarballURL == nil {
15628 return ""
15629 }
15630 return *r.TarballURL
15631 }
15632
15633
15634 func (r *RepositoryRelease) GetTargetCommitish() string {
15635 if r == nil || r.TargetCommitish == nil {
15636 return ""
15637 }
15638 return *r.TargetCommitish
15639 }
15640
15641
15642 func (r *RepositoryRelease) GetUploadURL() string {
15643 if r == nil || r.UploadURL == nil {
15644 return ""
15645 }
15646 return *r.UploadURL
15647 }
15648
15649
15650 func (r *RepositoryRelease) GetURL() string {
15651 if r == nil || r.URL == nil {
15652 return ""
15653 }
15654 return *r.URL
15655 }
15656
15657
15658 func (r *RepositoryRelease) GetZipballURL() string {
15659 if r == nil || r.ZipballURL == nil {
15660 return ""
15661 }
15662 return *r.ZipballURL
15663 }
15664
15665
15666 func (r *RepositoryTag) GetCommit() *Commit {
15667 if r == nil {
15668 return nil
15669 }
15670 return r.Commit
15671 }
15672
15673
15674 func (r *RepositoryTag) GetName() string {
15675 if r == nil || r.Name == nil {
15676 return ""
15677 }
15678 return *r.Name
15679 }
15680
15681
15682 func (r *RepositoryTag) GetTarballURL() string {
15683 if r == nil || r.TarballURL == nil {
15684 return ""
15685 }
15686 return *r.TarballURL
15687 }
15688
15689
15690 func (r *RepositoryTag) GetZipballURL() string {
15691 if r == nil || r.ZipballURL == nil {
15692 return ""
15693 }
15694 return *r.ZipballURL
15695 }
15696
15697
15698 func (r *RepositoryVulnerabilityAlert) GetAffectedPackageName() string {
15699 if r == nil || r.AffectedPackageName == nil {
15700 return ""
15701 }
15702 return *r.AffectedPackageName
15703 }
15704
15705
15706 func (r *RepositoryVulnerabilityAlert) GetAffectedRange() string {
15707 if r == nil || r.AffectedRange == nil {
15708 return ""
15709 }
15710 return *r.AffectedRange
15711 }
15712
15713
15714 func (r *RepositoryVulnerabilityAlert) GetCreatedAt() Timestamp {
15715 if r == nil || r.CreatedAt == nil {
15716 return Timestamp{}
15717 }
15718 return *r.CreatedAt
15719 }
15720
15721
15722 func (r *RepositoryVulnerabilityAlert) GetDismissedAt() Timestamp {
15723 if r == nil || r.DismissedAt == nil {
15724 return Timestamp{}
15725 }
15726 return *r.DismissedAt
15727 }
15728
15729
15730 func (r *RepositoryVulnerabilityAlert) GetDismisser() *User {
15731 if r == nil {
15732 return nil
15733 }
15734 return r.Dismisser
15735 }
15736
15737
15738 func (r *RepositoryVulnerabilityAlert) GetDismissReason() string {
15739 if r == nil || r.DismissReason == nil {
15740 return ""
15741 }
15742 return *r.DismissReason
15743 }
15744
15745
15746 func (r *RepositoryVulnerabilityAlert) GetExternalIdentifier() string {
15747 if r == nil || r.ExternalIdentifier == nil {
15748 return ""
15749 }
15750 return *r.ExternalIdentifier
15751 }
15752
15753
15754 func (r *RepositoryVulnerabilityAlert) GetExternalReference() string {
15755 if r == nil || r.ExternalReference == nil {
15756 return ""
15757 }
15758 return *r.ExternalReference
15759 }
15760
15761
15762 func (r *RepositoryVulnerabilityAlert) GetFixedIn() string {
15763 if r == nil || r.FixedIn == nil {
15764 return ""
15765 }
15766 return *r.FixedIn
15767 }
15768
15769
15770 func (r *RepositoryVulnerabilityAlert) GetGitHubSecurityAdvisoryID() string {
15771 if r == nil || r.GitHubSecurityAdvisoryID == nil {
15772 return ""
15773 }
15774 return *r.GitHubSecurityAdvisoryID
15775 }
15776
15777
15778 func (r *RepositoryVulnerabilityAlert) GetID() int64 {
15779 if r == nil || r.ID == nil {
15780 return 0
15781 }
15782 return *r.ID
15783 }
15784
15785
15786 func (r *RepositoryVulnerabilityAlert) GetSeverity() string {
15787 if r == nil || r.Severity == nil {
15788 return ""
15789 }
15790 return *r.Severity
15791 }
15792
15793
15794 func (r *RepositoryVulnerabilityAlertEvent) GetAction() string {
15795 if r == nil || r.Action == nil {
15796 return ""
15797 }
15798 return *r.Action
15799 }
15800
15801
15802 func (r *RepositoryVulnerabilityAlertEvent) GetAlert() *RepositoryVulnerabilityAlert {
15803 if r == nil {
15804 return nil
15805 }
15806 return r.Alert
15807 }
15808
15809
15810 func (r *RepositoryVulnerabilityAlertEvent) GetInstallation() *Installation {
15811 if r == nil {
15812 return nil
15813 }
15814 return r.Installation
15815 }
15816
15817
15818 func (r *RepositoryVulnerabilityAlertEvent) GetRepository() *Repository {
15819 if r == nil {
15820 return nil
15821 }
15822 return r.Repository
15823 }
15824
15825
15826 func (r *RepositoryVulnerabilityAlertEvent) GetSender() *User {
15827 if r == nil {
15828 return nil
15829 }
15830 return r.Sender
15831 }
15832
15833
15834 func (r *RepoStats) GetForkRepos() int {
15835 if r == nil || r.ForkRepos == nil {
15836 return 0
15837 }
15838 return *r.ForkRepos
15839 }
15840
15841
15842 func (r *RepoStats) GetOrgRepos() int {
15843 if r == nil || r.OrgRepos == nil {
15844 return 0
15845 }
15846 return *r.OrgRepos
15847 }
15848
15849
15850 func (r *RepoStats) GetRootRepos() int {
15851 if r == nil || r.RootRepos == nil {
15852 return 0
15853 }
15854 return *r.RootRepos
15855 }
15856
15857
15858 func (r *RepoStats) GetTotalPushes() int {
15859 if r == nil || r.TotalPushes == nil {
15860 return 0
15861 }
15862 return *r.TotalPushes
15863 }
15864
15865
15866 func (r *RepoStats) GetTotalRepos() int {
15867 if r == nil || r.TotalRepos == nil {
15868 return 0
15869 }
15870 return *r.TotalRepos
15871 }
15872
15873
15874 func (r *RepoStats) GetTotalWikis() int {
15875 if r == nil || r.TotalWikis == nil {
15876 return 0
15877 }
15878 return *r.TotalWikis
15879 }
15880
15881
15882 func (r *RepoStatus) GetAvatarURL() string {
15883 if r == nil || r.AvatarURL == nil {
15884 return ""
15885 }
15886 return *r.AvatarURL
15887 }
15888
15889
15890 func (r *RepoStatus) GetContext() string {
15891 if r == nil || r.Context == nil {
15892 return ""
15893 }
15894 return *r.Context
15895 }
15896
15897
15898 func (r *RepoStatus) GetCreatedAt() time.Time {
15899 if r == nil || r.CreatedAt == nil {
15900 return time.Time{}
15901 }
15902 return *r.CreatedAt
15903 }
15904
15905
15906 func (r *RepoStatus) GetCreator() *User {
15907 if r == nil {
15908 return nil
15909 }
15910 return r.Creator
15911 }
15912
15913
15914 func (r *RepoStatus) GetDescription() string {
15915 if r == nil || r.Description == nil {
15916 return ""
15917 }
15918 return *r.Description
15919 }
15920
15921
15922 func (r *RepoStatus) GetID() int64 {
15923 if r == nil || r.ID == nil {
15924 return 0
15925 }
15926 return *r.ID
15927 }
15928
15929
15930 func (r *RepoStatus) GetNodeID() string {
15931 if r == nil || r.NodeID == nil {
15932 return ""
15933 }
15934 return *r.NodeID
15935 }
15936
15937
15938 func (r *RepoStatus) GetState() string {
15939 if r == nil || r.State == nil {
15940 return ""
15941 }
15942 return *r.State
15943 }
15944
15945
15946 func (r *RepoStatus) GetTargetURL() string {
15947 if r == nil || r.TargetURL == nil {
15948 return ""
15949 }
15950 return *r.TargetURL
15951 }
15952
15953
15954 func (r *RepoStatus) GetUpdatedAt() time.Time {
15955 if r == nil || r.UpdatedAt == nil {
15956 return time.Time{}
15957 }
15958 return *r.UpdatedAt
15959 }
15960
15961
15962 func (r *RepoStatus) GetURL() string {
15963 if r == nil || r.URL == nil {
15964 return ""
15965 }
15966 return *r.URL
15967 }
15968
15969
15970 func (r *RequiredReviewer) GetType() string {
15971 if r == nil || r.Type == nil {
15972 return ""
15973 }
15974 return *r.Type
15975 }
15976
15977
15978 func (r *RequiredStatusCheck) GetAppID() int64 {
15979 if r == nil || r.AppID == nil {
15980 return 0
15981 }
15982 return *r.AppID
15983 }
15984
15985
15986 func (r *RequiredStatusChecksRequest) GetStrict() bool {
15987 if r == nil || r.Strict == nil {
15988 return false
15989 }
15990 return *r.Strict
15991 }
15992
15993
15994 func (r *ReviewersRequest) GetNodeID() string {
15995 if r == nil || r.NodeID == nil {
15996 return ""
15997 }
15998 return *r.NodeID
15999 }
16000
16001
16002 func (r *Rule) GetDescription() string {
16003 if r == nil || r.Description == nil {
16004 return ""
16005 }
16006 return *r.Description
16007 }
16008
16009
16010 func (r *Rule) GetFullDescription() string {
16011 if r == nil || r.FullDescription == nil {
16012 return ""
16013 }
16014 return *r.FullDescription
16015 }
16016
16017
16018 func (r *Rule) GetHelp() string {
16019 if r == nil || r.Help == nil {
16020 return ""
16021 }
16022 return *r.Help
16023 }
16024
16025
16026 func (r *Rule) GetID() string {
16027 if r == nil || r.ID == nil {
16028 return ""
16029 }
16030 return *r.ID
16031 }
16032
16033
16034 func (r *Rule) GetName() string {
16035 if r == nil || r.Name == nil {
16036 return ""
16037 }
16038 return *r.Name
16039 }
16040
16041
16042 func (r *Rule) GetSecuritySeverityLevel() string {
16043 if r == nil || r.SecuritySeverityLevel == nil {
16044 return ""
16045 }
16046 return *r.SecuritySeverityLevel
16047 }
16048
16049
16050 func (r *Rule) GetSeverity() string {
16051 if r == nil || r.Severity == nil {
16052 return ""
16053 }
16054 return *r.Severity
16055 }
16056
16057
16058 func (r *Runner) GetBusy() bool {
16059 if r == nil || r.Busy == nil {
16060 return false
16061 }
16062 return *r.Busy
16063 }
16064
16065
16066 func (r *Runner) GetID() int64 {
16067 if r == nil || r.ID == nil {
16068 return 0
16069 }
16070 return *r.ID
16071 }
16072
16073
16074 func (r *Runner) GetName() string {
16075 if r == nil || r.Name == nil {
16076 return ""
16077 }
16078 return *r.Name
16079 }
16080
16081
16082 func (r *Runner) GetOS() string {
16083 if r == nil || r.OS == nil {
16084 return ""
16085 }
16086 return *r.OS
16087 }
16088
16089
16090 func (r *Runner) GetStatus() string {
16091 if r == nil || r.Status == nil {
16092 return ""
16093 }
16094 return *r.Status
16095 }
16096
16097
16098 func (r *RunnerApplicationDownload) GetArchitecture() string {
16099 if r == nil || r.Architecture == nil {
16100 return ""
16101 }
16102 return *r.Architecture
16103 }
16104
16105
16106 func (r *RunnerApplicationDownload) GetDownloadURL() string {
16107 if r == nil || r.DownloadURL == nil {
16108 return ""
16109 }
16110 return *r.DownloadURL
16111 }
16112
16113
16114 func (r *RunnerApplicationDownload) GetFilename() string {
16115 if r == nil || r.Filename == nil {
16116 return ""
16117 }
16118 return *r.Filename
16119 }
16120
16121
16122 func (r *RunnerApplicationDownload) GetOS() string {
16123 if r == nil || r.OS == nil {
16124 return ""
16125 }
16126 return *r.OS
16127 }
16128
16129
16130 func (r *RunnerApplicationDownload) GetSHA256Checksum() string {
16131 if r == nil || r.SHA256Checksum == nil {
16132 return ""
16133 }
16134 return *r.SHA256Checksum
16135 }
16136
16137
16138 func (r *RunnerApplicationDownload) GetTempDownloadToken() string {
16139 if r == nil || r.TempDownloadToken == nil {
16140 return ""
16141 }
16142 return *r.TempDownloadToken
16143 }
16144
16145
16146 func (r *RunnerGroup) GetAllowsPublicRepositories() bool {
16147 if r == nil || r.AllowsPublicRepositories == nil {
16148 return false
16149 }
16150 return *r.AllowsPublicRepositories
16151 }
16152
16153
16154 func (r *RunnerGroup) GetDefault() bool {
16155 if r == nil || r.Default == nil {
16156 return false
16157 }
16158 return *r.Default
16159 }
16160
16161
16162 func (r *RunnerGroup) GetID() int64 {
16163 if r == nil || r.ID == nil {
16164 return 0
16165 }
16166 return *r.ID
16167 }
16168
16169
16170 func (r *RunnerGroup) GetInherited() bool {
16171 if r == nil || r.Inherited == nil {
16172 return false
16173 }
16174 return *r.Inherited
16175 }
16176
16177
16178 func (r *RunnerGroup) GetName() string {
16179 if r == nil || r.Name == nil {
16180 return ""
16181 }
16182 return *r.Name
16183 }
16184
16185
16186 func (r *RunnerGroup) GetRunnersURL() string {
16187 if r == nil || r.RunnersURL == nil {
16188 return ""
16189 }
16190 return *r.RunnersURL
16191 }
16192
16193
16194 func (r *RunnerGroup) GetSelectedRepositoriesURL() string {
16195 if r == nil || r.SelectedRepositoriesURL == nil {
16196 return ""
16197 }
16198 return *r.SelectedRepositoriesURL
16199 }
16200
16201
16202 func (r *RunnerGroup) GetVisibility() string {
16203 if r == nil || r.Visibility == nil {
16204 return ""
16205 }
16206 return *r.Visibility
16207 }
16208
16209
16210 func (r *RunnerLabels) GetID() int64 {
16211 if r == nil || r.ID == nil {
16212 return 0
16213 }
16214 return *r.ID
16215 }
16216
16217
16218 func (r *RunnerLabels) GetName() string {
16219 if r == nil || r.Name == nil {
16220 return ""
16221 }
16222 return *r.Name
16223 }
16224
16225
16226 func (r *RunnerLabels) GetType() string {
16227 if r == nil || r.Type == nil {
16228 return ""
16229 }
16230 return *r.Type
16231 }
16232
16233
16234 func (s *SarifAnalysis) GetCheckoutURI() string {
16235 if s == nil || s.CheckoutURI == nil {
16236 return ""
16237 }
16238 return *s.CheckoutURI
16239 }
16240
16241
16242 func (s *SarifAnalysis) GetCommitSHA() string {
16243 if s == nil || s.CommitSHA == nil {
16244 return ""
16245 }
16246 return *s.CommitSHA
16247 }
16248
16249
16250 func (s *SarifAnalysis) GetRef() string {
16251 if s == nil || s.Ref == nil {
16252 return ""
16253 }
16254 return *s.Ref
16255 }
16256
16257
16258 func (s *SarifAnalysis) GetSarif() string {
16259 if s == nil || s.Sarif == nil {
16260 return ""
16261 }
16262 return *s.Sarif
16263 }
16264
16265
16266 func (s *SarifAnalysis) GetStartedAt() Timestamp {
16267 if s == nil || s.StartedAt == nil {
16268 return Timestamp{}
16269 }
16270 return *s.StartedAt
16271 }
16272
16273
16274 func (s *SarifAnalysis) GetToolName() string {
16275 if s == nil || s.ToolName == nil {
16276 return ""
16277 }
16278 return *s.ToolName
16279 }
16280
16281
16282 func (s *SarifID) GetID() string {
16283 if s == nil || s.ID == nil {
16284 return ""
16285 }
16286 return *s.ID
16287 }
16288
16289
16290 func (s *SarifID) GetURL() string {
16291 if s == nil || s.URL == nil {
16292 return ""
16293 }
16294 return *s.URL
16295 }
16296
16297
16298 func (s *ScanningAnalysis) GetAnalysisKey() string {
16299 if s == nil || s.AnalysisKey == nil {
16300 return ""
16301 }
16302 return *s.AnalysisKey
16303 }
16304
16305
16306 func (s *ScanningAnalysis) GetCategory() string {
16307 if s == nil || s.Category == nil {
16308 return ""
16309 }
16310 return *s.Category
16311 }
16312
16313
16314 func (s *ScanningAnalysis) GetCommitSHA() string {
16315 if s == nil || s.CommitSHA == nil {
16316 return ""
16317 }
16318 return *s.CommitSHA
16319 }
16320
16321
16322 func (s *ScanningAnalysis) GetCreatedAt() Timestamp {
16323 if s == nil || s.CreatedAt == nil {
16324 return Timestamp{}
16325 }
16326 return *s.CreatedAt
16327 }
16328
16329
16330 func (s *ScanningAnalysis) GetDeletable() bool {
16331 if s == nil || s.Deletable == nil {
16332 return false
16333 }
16334 return *s.Deletable
16335 }
16336
16337
16338 func (s *ScanningAnalysis) GetEnvironment() string {
16339 if s == nil || s.Environment == nil {
16340 return ""
16341 }
16342 return *s.Environment
16343 }
16344
16345
16346 func (s *ScanningAnalysis) GetError() string {
16347 if s == nil || s.Error == nil {
16348 return ""
16349 }
16350 return *s.Error
16351 }
16352
16353
16354 func (s *ScanningAnalysis) GetID() int64 {
16355 if s == nil || s.ID == nil {
16356 return 0
16357 }
16358 return *s.ID
16359 }
16360
16361
16362 func (s *ScanningAnalysis) GetRef() string {
16363 if s == nil || s.Ref == nil {
16364 return ""
16365 }
16366 return *s.Ref
16367 }
16368
16369
16370 func (s *ScanningAnalysis) GetResultsCount() int {
16371 if s == nil || s.ResultsCount == nil {
16372 return 0
16373 }
16374 return *s.ResultsCount
16375 }
16376
16377
16378 func (s *ScanningAnalysis) GetRulesCount() int {
16379 if s == nil || s.RulesCount == nil {
16380 return 0
16381 }
16382 return *s.RulesCount
16383 }
16384
16385
16386 func (s *ScanningAnalysis) GetSarifID() string {
16387 if s == nil || s.SarifID == nil {
16388 return ""
16389 }
16390 return *s.SarifID
16391 }
16392
16393
16394 func (s *ScanningAnalysis) GetTool() *Tool {
16395 if s == nil {
16396 return nil
16397 }
16398 return s.Tool
16399 }
16400
16401
16402 func (s *ScanningAnalysis) GetURL() string {
16403 if s == nil || s.URL == nil {
16404 return ""
16405 }
16406 return *s.URL
16407 }
16408
16409
16410 func (s *ScanningAnalysis) GetWarning() string {
16411 if s == nil || s.Warning == nil {
16412 return ""
16413 }
16414 return *s.Warning
16415 }
16416
16417
16418 func (s *SCIMUserAttributes) GetActive() bool {
16419 if s == nil || s.Active == nil {
16420 return false
16421 }
16422 return *s.Active
16423 }
16424
16425
16426 func (s *SCIMUserAttributes) GetDisplayName() string {
16427 if s == nil || s.DisplayName == nil {
16428 return ""
16429 }
16430 return *s.DisplayName
16431 }
16432
16433
16434 func (s *SCIMUserAttributes) GetExternalID() string {
16435 if s == nil || s.ExternalID == nil {
16436 return ""
16437 }
16438 return *s.ExternalID
16439 }
16440
16441
16442 func (s *SCIMUserEmail) GetPrimary() bool {
16443 if s == nil || s.Primary == nil {
16444 return false
16445 }
16446 return *s.Primary
16447 }
16448
16449
16450 func (s *SCIMUserEmail) GetType() string {
16451 if s == nil || s.Type == nil {
16452 return ""
16453 }
16454 return *s.Type
16455 }
16456
16457
16458 func (s *SCIMUserName) GetFormatted() string {
16459 if s == nil || s.Formatted == nil {
16460 return ""
16461 }
16462 return *s.Formatted
16463 }
16464
16465
16466 func (s *SecretScanning) GetStatus() string {
16467 if s == nil || s.Status == nil {
16468 return ""
16469 }
16470 return *s.Status
16471 }
16472
16473
16474 func (s *SecretScanningAlert) GetCreatedAt() Timestamp {
16475 if s == nil || s.CreatedAt == nil {
16476 return Timestamp{}
16477 }
16478 return *s.CreatedAt
16479 }
16480
16481
16482 func (s *SecretScanningAlert) GetHTMLURL() string {
16483 if s == nil || s.HTMLURL == nil {
16484 return ""
16485 }
16486 return *s.HTMLURL
16487 }
16488
16489
16490 func (s *SecretScanningAlert) GetLocationsURL() string {
16491 if s == nil || s.LocationsURL == nil {
16492 return ""
16493 }
16494 return *s.LocationsURL
16495 }
16496
16497
16498 func (s *SecretScanningAlert) GetNumber() int {
16499 if s == nil || s.Number == nil {
16500 return 0
16501 }
16502 return *s.Number
16503 }
16504
16505
16506 func (s *SecretScanningAlert) GetResolution() string {
16507 if s == nil || s.Resolution == nil {
16508 return ""
16509 }
16510 return *s.Resolution
16511 }
16512
16513
16514 func (s *SecretScanningAlert) GetResolvedAt() Timestamp {
16515 if s == nil || s.ResolvedAt == nil {
16516 return Timestamp{}
16517 }
16518 return *s.ResolvedAt
16519 }
16520
16521
16522 func (s *SecretScanningAlert) GetResolvedBy() *User {
16523 if s == nil {
16524 return nil
16525 }
16526 return s.ResolvedBy
16527 }
16528
16529
16530 func (s *SecretScanningAlert) GetSecret() string {
16531 if s == nil || s.Secret == nil {
16532 return ""
16533 }
16534 return *s.Secret
16535 }
16536
16537
16538 func (s *SecretScanningAlert) GetSecretType() string {
16539 if s == nil || s.SecretType == nil {
16540 return ""
16541 }
16542 return *s.SecretType
16543 }
16544
16545
16546 func (s *SecretScanningAlert) GetState() string {
16547 if s == nil || s.State == nil {
16548 return ""
16549 }
16550 return *s.State
16551 }
16552
16553
16554 func (s *SecretScanningAlert) GetURL() string {
16555 if s == nil || s.URL == nil {
16556 return ""
16557 }
16558 return *s.URL
16559 }
16560
16561
16562 func (s *SecretScanningAlertEvent) GetAction() string {
16563 if s == nil || s.Action == nil {
16564 return ""
16565 }
16566 return *s.Action
16567 }
16568
16569
16570 func (s *SecretScanningAlertEvent) GetAlert() *SecretScanningAlert {
16571 if s == nil {
16572 return nil
16573 }
16574 return s.Alert
16575 }
16576
16577
16578 func (s *SecretScanningAlertEvent) GetEnterprise() *Enterprise {
16579 if s == nil {
16580 return nil
16581 }
16582 return s.Enterprise
16583 }
16584
16585
16586 func (s *SecretScanningAlertEvent) GetInstallation() *Installation {
16587 if s == nil {
16588 return nil
16589 }
16590 return s.Installation
16591 }
16592
16593
16594 func (s *SecretScanningAlertEvent) GetOrganization() *Organization {
16595 if s == nil {
16596 return nil
16597 }
16598 return s.Organization
16599 }
16600
16601
16602 func (s *SecretScanningAlertEvent) GetRepo() *Repository {
16603 if s == nil {
16604 return nil
16605 }
16606 return s.Repo
16607 }
16608
16609
16610 func (s *SecretScanningAlertEvent) GetSender() *User {
16611 if s == nil {
16612 return nil
16613 }
16614 return s.Sender
16615 }
16616
16617
16618 func (s *SecretScanningAlertLocation) GetDetails() *SecretScanningAlertLocationDetails {
16619 if s == nil {
16620 return nil
16621 }
16622 return s.Details
16623 }
16624
16625
16626 func (s *SecretScanningAlertLocation) GetType() string {
16627 if s == nil || s.Type == nil {
16628 return ""
16629 }
16630 return *s.Type
16631 }
16632
16633
16634 func (s *SecretScanningAlertLocationDetails) GetBlobSHA() string {
16635 if s == nil || s.BlobSHA == nil {
16636 return ""
16637 }
16638 return *s.BlobSHA
16639 }
16640
16641
16642 func (s *SecretScanningAlertLocationDetails) GetBlobURL() string {
16643 if s == nil || s.BlobURL == nil {
16644 return ""
16645 }
16646 return *s.BlobURL
16647 }
16648
16649
16650 func (s *SecretScanningAlertLocationDetails) GetCommitSHA() string {
16651 if s == nil || s.CommitSHA == nil {
16652 return ""
16653 }
16654 return *s.CommitSHA
16655 }
16656
16657
16658 func (s *SecretScanningAlertLocationDetails) GetCommitURL() string {
16659 if s == nil || s.CommitURL == nil {
16660 return ""
16661 }
16662 return *s.CommitURL
16663 }
16664
16665
16666 func (s *SecretScanningAlertLocationDetails) GetEndColumn() int {
16667 if s == nil || s.EndColumn == nil {
16668 return 0
16669 }
16670 return *s.EndColumn
16671 }
16672
16673
16674 func (s *SecretScanningAlertLocationDetails) GetEndLine() int {
16675 if s == nil || s.EndLine == nil {
16676 return 0
16677 }
16678 return *s.EndLine
16679 }
16680
16681
16682 func (s *SecretScanningAlertLocationDetails) GetPath() string {
16683 if s == nil || s.Path == nil {
16684 return ""
16685 }
16686 return *s.Path
16687 }
16688
16689
16690 func (s *SecretScanningAlertLocationDetails) GetStartColumn() int {
16691 if s == nil || s.StartColumn == nil {
16692 return 0
16693 }
16694 return *s.StartColumn
16695 }
16696
16697
16698 func (s *SecretScanningAlertLocationDetails) GetStartline() int {
16699 if s == nil || s.Startline == nil {
16700 return 0
16701 }
16702 return *s.Startline
16703 }
16704
16705
16706 func (s *SecretScanningAlertUpdateOptions) GetResolution() string {
16707 if s == nil || s.Resolution == nil {
16708 return ""
16709 }
16710 return *s.Resolution
16711 }
16712
16713
16714 func (s *SecretScanningAlertUpdateOptions) GetSecretType() string {
16715 if s == nil || s.SecretType == nil {
16716 return ""
16717 }
16718 return *s.SecretType
16719 }
16720
16721
16722 func (s *SecretScanningAlertUpdateOptions) GetState() string {
16723 if s == nil || s.State == nil {
16724 return ""
16725 }
16726 return *s.State
16727 }
16728
16729
16730 func (s *SecurityAdvisory) GetDescription() string {
16731 if s == nil || s.Description == nil {
16732 return ""
16733 }
16734 return *s.Description
16735 }
16736
16737
16738 func (s *SecurityAdvisory) GetGHSAID() string {
16739 if s == nil || s.GHSAID == nil {
16740 return ""
16741 }
16742 return *s.GHSAID
16743 }
16744
16745
16746 func (s *SecurityAdvisory) GetPublishedAt() Timestamp {
16747 if s == nil || s.PublishedAt == nil {
16748 return Timestamp{}
16749 }
16750 return *s.PublishedAt
16751 }
16752
16753
16754 func (s *SecurityAdvisory) GetSeverity() string {
16755 if s == nil || s.Severity == nil {
16756 return ""
16757 }
16758 return *s.Severity
16759 }
16760
16761
16762 func (s *SecurityAdvisory) GetSummary() string {
16763 if s == nil || s.Summary == nil {
16764 return ""
16765 }
16766 return *s.Summary
16767 }
16768
16769
16770 func (s *SecurityAdvisory) GetUpdatedAt() Timestamp {
16771 if s == nil || s.UpdatedAt == nil {
16772 return Timestamp{}
16773 }
16774 return *s.UpdatedAt
16775 }
16776
16777
16778 func (s *SecurityAdvisory) GetWithdrawnAt() Timestamp {
16779 if s == nil || s.WithdrawnAt == nil {
16780 return Timestamp{}
16781 }
16782 return *s.WithdrawnAt
16783 }
16784
16785
16786 func (s *SecurityAdvisoryEvent) GetAction() string {
16787 if s == nil || s.Action == nil {
16788 return ""
16789 }
16790 return *s.Action
16791 }
16792
16793
16794 func (s *SecurityAdvisoryEvent) GetSecurityAdvisory() *SecurityAdvisory {
16795 if s == nil {
16796 return nil
16797 }
16798 return s.SecurityAdvisory
16799 }
16800
16801
16802 func (s *SecurityAndAnalysis) GetAdvancedSecurity() *AdvancedSecurity {
16803 if s == nil {
16804 return nil
16805 }
16806 return s.AdvancedSecurity
16807 }
16808
16809
16810 func (s *SecurityAndAnalysis) GetSecretScanning() *SecretScanning {
16811 if s == nil {
16812 return nil
16813 }
16814 return s.SecretScanning
16815 }
16816
16817
16818 func (s *SelectedReposList) GetTotalCount() int {
16819 if s == nil || s.TotalCount == nil {
16820 return 0
16821 }
16822 return *s.TotalCount
16823 }
16824
16825
16826 func (s *ServiceHook) GetName() string {
16827 if s == nil || s.Name == nil {
16828 return ""
16829 }
16830 return *s.Name
16831 }
16832
16833
16834 func (s *SignaturesProtectedBranch) GetEnabled() bool {
16835 if s == nil || s.Enabled == nil {
16836 return false
16837 }
16838 return *s.Enabled
16839 }
16840
16841
16842 func (s *SignaturesProtectedBranch) GetURL() string {
16843 if s == nil || s.URL == nil {
16844 return ""
16845 }
16846 return *s.URL
16847 }
16848
16849
16850 func (s *SignatureVerification) GetPayload() string {
16851 if s == nil || s.Payload == nil {
16852 return ""
16853 }
16854 return *s.Payload
16855 }
16856
16857
16858 func (s *SignatureVerification) GetReason() string {
16859 if s == nil || s.Reason == nil {
16860 return ""
16861 }
16862 return *s.Reason
16863 }
16864
16865
16866 func (s *SignatureVerification) GetSignature() string {
16867 if s == nil || s.Signature == nil {
16868 return ""
16869 }
16870 return *s.Signature
16871 }
16872
16873
16874 func (s *SignatureVerification) GetVerified() bool {
16875 if s == nil || s.Verified == nil {
16876 return false
16877 }
16878 return *s.Verified
16879 }
16880
16881
16882 func (s *Source) GetActor() *User {
16883 if s == nil {
16884 return nil
16885 }
16886 return s.Actor
16887 }
16888
16889
16890 func (s *Source) GetID() int64 {
16891 if s == nil || s.ID == nil {
16892 return 0
16893 }
16894 return *s.ID
16895 }
16896
16897
16898 func (s *Source) GetIssue() *Issue {
16899 if s == nil {
16900 return nil
16901 }
16902 return s.Issue
16903 }
16904
16905
16906 func (s *Source) GetType() string {
16907 if s == nil || s.Type == nil {
16908 return ""
16909 }
16910 return *s.Type
16911 }
16912
16913
16914 func (s *Source) GetURL() string {
16915 if s == nil || s.URL == nil {
16916 return ""
16917 }
16918 return *s.URL
16919 }
16920
16921
16922 func (s *SourceImportAuthor) GetEmail() string {
16923 if s == nil || s.Email == nil {
16924 return ""
16925 }
16926 return *s.Email
16927 }
16928
16929
16930 func (s *SourceImportAuthor) GetID() int64 {
16931 if s == nil || s.ID == nil {
16932 return 0
16933 }
16934 return *s.ID
16935 }
16936
16937
16938 func (s *SourceImportAuthor) GetImportURL() string {
16939 if s == nil || s.ImportURL == nil {
16940 return ""
16941 }
16942 return *s.ImportURL
16943 }
16944
16945
16946 func (s *SourceImportAuthor) GetName() string {
16947 if s == nil || s.Name == nil {
16948 return ""
16949 }
16950 return *s.Name
16951 }
16952
16953
16954 func (s *SourceImportAuthor) GetRemoteID() string {
16955 if s == nil || s.RemoteID == nil {
16956 return ""
16957 }
16958 return *s.RemoteID
16959 }
16960
16961
16962 func (s *SourceImportAuthor) GetRemoteName() string {
16963 if s == nil || s.RemoteName == nil {
16964 return ""
16965 }
16966 return *s.RemoteName
16967 }
16968
16969
16970 func (s *SourceImportAuthor) GetURL() string {
16971 if s == nil || s.URL == nil {
16972 return ""
16973 }
16974 return *s.URL
16975 }
16976
16977
16978 func (s *StarEvent) GetAction() string {
16979 if s == nil || s.Action == nil {
16980 return ""
16981 }
16982 return *s.Action
16983 }
16984
16985
16986 func (s *StarEvent) GetInstallation() *Installation {
16987 if s == nil {
16988 return nil
16989 }
16990 return s.Installation
16991 }
16992
16993
16994 func (s *StarEvent) GetOrg() *Organization {
16995 if s == nil {
16996 return nil
16997 }
16998 return s.Org
16999 }
17000
17001
17002 func (s *StarEvent) GetRepo() *Repository {
17003 if s == nil {
17004 return nil
17005 }
17006 return s.Repo
17007 }
17008
17009
17010 func (s *StarEvent) GetSender() *User {
17011 if s == nil {
17012 return nil
17013 }
17014 return s.Sender
17015 }
17016
17017
17018 func (s *StarEvent) GetStarredAt() Timestamp {
17019 if s == nil || s.StarredAt == nil {
17020 return Timestamp{}
17021 }
17022 return *s.StarredAt
17023 }
17024
17025
17026 func (s *Stargazer) GetStarredAt() Timestamp {
17027 if s == nil || s.StarredAt == nil {
17028 return Timestamp{}
17029 }
17030 return *s.StarredAt
17031 }
17032
17033
17034 func (s *Stargazer) GetUser() *User {
17035 if s == nil {
17036 return nil
17037 }
17038 return s.User
17039 }
17040
17041
17042 func (s *StarredRepository) GetRepository() *Repository {
17043 if s == nil {
17044 return nil
17045 }
17046 return s.Repository
17047 }
17048
17049
17050 func (s *StarredRepository) GetStarredAt() Timestamp {
17051 if s == nil || s.StarredAt == nil {
17052 return Timestamp{}
17053 }
17054 return *s.StarredAt
17055 }
17056
17057
17058 func (s *StatusEvent) GetCommit() *RepositoryCommit {
17059 if s == nil {
17060 return nil
17061 }
17062 return s.Commit
17063 }
17064
17065
17066 func (s *StatusEvent) GetContext() string {
17067 if s == nil || s.Context == nil {
17068 return ""
17069 }
17070 return *s.Context
17071 }
17072
17073
17074 func (s *StatusEvent) GetCreatedAt() Timestamp {
17075 if s == nil || s.CreatedAt == nil {
17076 return Timestamp{}
17077 }
17078 return *s.CreatedAt
17079 }
17080
17081
17082 func (s *StatusEvent) GetDescription() string {
17083 if s == nil || s.Description == nil {
17084 return ""
17085 }
17086 return *s.Description
17087 }
17088
17089
17090 func (s *StatusEvent) GetID() int64 {
17091 if s == nil || s.ID == nil {
17092 return 0
17093 }
17094 return *s.ID
17095 }
17096
17097
17098 func (s *StatusEvent) GetInstallation() *Installation {
17099 if s == nil {
17100 return nil
17101 }
17102 return s.Installation
17103 }
17104
17105
17106 func (s *StatusEvent) GetName() string {
17107 if s == nil || s.Name == nil {
17108 return ""
17109 }
17110 return *s.Name
17111 }
17112
17113
17114 func (s *StatusEvent) GetRepo() *Repository {
17115 if s == nil {
17116 return nil
17117 }
17118 return s.Repo
17119 }
17120
17121
17122 func (s *StatusEvent) GetSender() *User {
17123 if s == nil {
17124 return nil
17125 }
17126 return s.Sender
17127 }
17128
17129
17130 func (s *StatusEvent) GetSHA() string {
17131 if s == nil || s.SHA == nil {
17132 return ""
17133 }
17134 return *s.SHA
17135 }
17136
17137
17138 func (s *StatusEvent) GetState() string {
17139 if s == nil || s.State == nil {
17140 return ""
17141 }
17142 return *s.State
17143 }
17144
17145
17146 func (s *StatusEvent) GetTargetURL() string {
17147 if s == nil || s.TargetURL == nil {
17148 return ""
17149 }
17150 return *s.TargetURL
17151 }
17152
17153
17154 func (s *StatusEvent) GetUpdatedAt() Timestamp {
17155 if s == nil || s.UpdatedAt == nil {
17156 return Timestamp{}
17157 }
17158 return *s.UpdatedAt
17159 }
17160
17161
17162 func (s *Subscription) GetCreatedAt() Timestamp {
17163 if s == nil || s.CreatedAt == nil {
17164 return Timestamp{}
17165 }
17166 return *s.CreatedAt
17167 }
17168
17169
17170 func (s *Subscription) GetIgnored() bool {
17171 if s == nil || s.Ignored == nil {
17172 return false
17173 }
17174 return *s.Ignored
17175 }
17176
17177
17178 func (s *Subscription) GetReason() string {
17179 if s == nil || s.Reason == nil {
17180 return ""
17181 }
17182 return *s.Reason
17183 }
17184
17185
17186 func (s *Subscription) GetRepositoryURL() string {
17187 if s == nil || s.RepositoryURL == nil {
17188 return ""
17189 }
17190 return *s.RepositoryURL
17191 }
17192
17193
17194 func (s *Subscription) GetSubscribed() bool {
17195 if s == nil || s.Subscribed == nil {
17196 return false
17197 }
17198 return *s.Subscribed
17199 }
17200
17201
17202 func (s *Subscription) GetThreadURL() string {
17203 if s == nil || s.ThreadURL == nil {
17204 return ""
17205 }
17206 return *s.ThreadURL
17207 }
17208
17209
17210 func (s *Subscription) GetURL() string {
17211 if s == nil || s.URL == nil {
17212 return ""
17213 }
17214 return *s.URL
17215 }
17216
17217
17218 func (t *Tag) GetMessage() string {
17219 if t == nil || t.Message == nil {
17220 return ""
17221 }
17222 return *t.Message
17223 }
17224
17225
17226 func (t *Tag) GetNodeID() string {
17227 if t == nil || t.NodeID == nil {
17228 return ""
17229 }
17230 return *t.NodeID
17231 }
17232
17233
17234 func (t *Tag) GetObject() *GitObject {
17235 if t == nil {
17236 return nil
17237 }
17238 return t.Object
17239 }
17240
17241
17242 func (t *Tag) GetSHA() string {
17243 if t == nil || t.SHA == nil {
17244 return ""
17245 }
17246 return *t.SHA
17247 }
17248
17249
17250 func (t *Tag) GetTag() string {
17251 if t == nil || t.Tag == nil {
17252 return ""
17253 }
17254 return *t.Tag
17255 }
17256
17257
17258 func (t *Tag) GetTagger() *CommitAuthor {
17259 if t == nil {
17260 return nil
17261 }
17262 return t.Tagger
17263 }
17264
17265
17266 func (t *Tag) GetURL() string {
17267 if t == nil || t.URL == nil {
17268 return ""
17269 }
17270 return *t.URL
17271 }
17272
17273
17274 func (t *Tag) GetVerification() *SignatureVerification {
17275 if t == nil {
17276 return nil
17277 }
17278 return t.Verification
17279 }
17280
17281
17282 func (t *TaskStep) GetCompletedAt() Timestamp {
17283 if t == nil || t.CompletedAt == nil {
17284 return Timestamp{}
17285 }
17286 return *t.CompletedAt
17287 }
17288
17289
17290 func (t *TaskStep) GetConclusion() string {
17291 if t == nil || t.Conclusion == nil {
17292 return ""
17293 }
17294 return *t.Conclusion
17295 }
17296
17297
17298 func (t *TaskStep) GetName() string {
17299 if t == nil || t.Name == nil {
17300 return ""
17301 }
17302 return *t.Name
17303 }
17304
17305
17306 func (t *TaskStep) GetNumber() int64 {
17307 if t == nil || t.Number == nil {
17308 return 0
17309 }
17310 return *t.Number
17311 }
17312
17313
17314 func (t *TaskStep) GetStartedAt() Timestamp {
17315 if t == nil || t.StartedAt == nil {
17316 return Timestamp{}
17317 }
17318 return *t.StartedAt
17319 }
17320
17321
17322 func (t *TaskStep) GetStatus() string {
17323 if t == nil || t.Status == nil {
17324 return ""
17325 }
17326 return *t.Status
17327 }
17328
17329
17330 func (t *Team) GetDescription() string {
17331 if t == nil || t.Description == nil {
17332 return ""
17333 }
17334 return *t.Description
17335 }
17336
17337
17338 func (t *Team) GetHTMLURL() string {
17339 if t == nil || t.HTMLURL == nil {
17340 return ""
17341 }
17342 return *t.HTMLURL
17343 }
17344
17345
17346 func (t *Team) GetID() int64 {
17347 if t == nil || t.ID == nil {
17348 return 0
17349 }
17350 return *t.ID
17351 }
17352
17353
17354 func (t *Team) GetLDAPDN() string {
17355 if t == nil || t.LDAPDN == nil {
17356 return ""
17357 }
17358 return *t.LDAPDN
17359 }
17360
17361
17362 func (t *Team) GetMembersCount() int {
17363 if t == nil || t.MembersCount == nil {
17364 return 0
17365 }
17366 return *t.MembersCount
17367 }
17368
17369
17370 func (t *Team) GetMembersURL() string {
17371 if t == nil || t.MembersURL == nil {
17372 return ""
17373 }
17374 return *t.MembersURL
17375 }
17376
17377
17378 func (t *Team) GetName() string {
17379 if t == nil || t.Name == nil {
17380 return ""
17381 }
17382 return *t.Name
17383 }
17384
17385
17386 func (t *Team) GetNodeID() string {
17387 if t == nil || t.NodeID == nil {
17388 return ""
17389 }
17390 return *t.NodeID
17391 }
17392
17393
17394 func (t *Team) GetOrganization() *Organization {
17395 if t == nil {
17396 return nil
17397 }
17398 return t.Organization
17399 }
17400
17401
17402 func (t *Team) GetParent() *Team {
17403 if t == nil {
17404 return nil
17405 }
17406 return t.Parent
17407 }
17408
17409
17410 func (t *Team) GetPermission() string {
17411 if t == nil || t.Permission == nil {
17412 return ""
17413 }
17414 return *t.Permission
17415 }
17416
17417
17418 func (t *Team) GetPermissions() map[string]bool {
17419 if t == nil || t.Permissions == nil {
17420 return map[string]bool{}
17421 }
17422 return t.Permissions
17423 }
17424
17425
17426 func (t *Team) GetPrivacy() string {
17427 if t == nil || t.Privacy == nil {
17428 return ""
17429 }
17430 return *t.Privacy
17431 }
17432
17433
17434 func (t *Team) GetReposCount() int {
17435 if t == nil || t.ReposCount == nil {
17436 return 0
17437 }
17438 return *t.ReposCount
17439 }
17440
17441
17442 func (t *Team) GetRepositoriesURL() string {
17443 if t == nil || t.RepositoriesURL == nil {
17444 return ""
17445 }
17446 return *t.RepositoriesURL
17447 }
17448
17449
17450 func (t *Team) GetSlug() string {
17451 if t == nil || t.Slug == nil {
17452 return ""
17453 }
17454 return *t.Slug
17455 }
17456
17457
17458 func (t *Team) GetURL() string {
17459 if t == nil || t.URL == nil {
17460 return ""
17461 }
17462 return *t.URL
17463 }
17464
17465
17466 func (t *TeamAddEvent) GetInstallation() *Installation {
17467 if t == nil {
17468 return nil
17469 }
17470 return t.Installation
17471 }
17472
17473
17474 func (t *TeamAddEvent) GetOrg() *Organization {
17475 if t == nil {
17476 return nil
17477 }
17478 return t.Org
17479 }
17480
17481
17482 func (t *TeamAddEvent) GetRepo() *Repository {
17483 if t == nil {
17484 return nil
17485 }
17486 return t.Repo
17487 }
17488
17489
17490 func (t *TeamAddEvent) GetSender() *User {
17491 if t == nil {
17492 return nil
17493 }
17494 return t.Sender
17495 }
17496
17497
17498 func (t *TeamAddEvent) GetTeam() *Team {
17499 if t == nil {
17500 return nil
17501 }
17502 return t.Team
17503 }
17504
17505
17506 func (t *TeamChange) GetDescription() *TeamDescription {
17507 if t == nil {
17508 return nil
17509 }
17510 return t.Description
17511 }
17512
17513
17514 func (t *TeamChange) GetName() *TeamName {
17515 if t == nil {
17516 return nil
17517 }
17518 return t.Name
17519 }
17520
17521
17522 func (t *TeamChange) GetPrivacy() *TeamPrivacy {
17523 if t == nil {
17524 return nil
17525 }
17526 return t.Privacy
17527 }
17528
17529
17530 func (t *TeamChange) GetRepository() *TeamRepository {
17531 if t == nil {
17532 return nil
17533 }
17534 return t.Repository
17535 }
17536
17537
17538 func (t *TeamDescription) GetFrom() string {
17539 if t == nil || t.From == nil {
17540 return ""
17541 }
17542 return *t.From
17543 }
17544
17545
17546 func (t *TeamDiscussion) GetAuthor() *User {
17547 if t == nil {
17548 return nil
17549 }
17550 return t.Author
17551 }
17552
17553
17554 func (t *TeamDiscussion) GetBody() string {
17555 if t == nil || t.Body == nil {
17556 return ""
17557 }
17558 return *t.Body
17559 }
17560
17561
17562 func (t *TeamDiscussion) GetBodyHTML() string {
17563 if t == nil || t.BodyHTML == nil {
17564 return ""
17565 }
17566 return *t.BodyHTML
17567 }
17568
17569
17570 func (t *TeamDiscussion) GetBodyVersion() string {
17571 if t == nil || t.BodyVersion == nil {
17572 return ""
17573 }
17574 return *t.BodyVersion
17575 }
17576
17577
17578 func (t *TeamDiscussion) GetCommentsCount() int {
17579 if t == nil || t.CommentsCount == nil {
17580 return 0
17581 }
17582 return *t.CommentsCount
17583 }
17584
17585
17586 func (t *TeamDiscussion) GetCommentsURL() string {
17587 if t == nil || t.CommentsURL == nil {
17588 return ""
17589 }
17590 return *t.CommentsURL
17591 }
17592
17593
17594 func (t *TeamDiscussion) GetCreatedAt() Timestamp {
17595 if t == nil || t.CreatedAt == nil {
17596 return Timestamp{}
17597 }
17598 return *t.CreatedAt
17599 }
17600
17601
17602 func (t *TeamDiscussion) GetHTMLURL() string {
17603 if t == nil || t.HTMLURL == nil {
17604 return ""
17605 }
17606 return *t.HTMLURL
17607 }
17608
17609
17610 func (t *TeamDiscussion) GetLastEditedAt() Timestamp {
17611 if t == nil || t.LastEditedAt == nil {
17612 return Timestamp{}
17613 }
17614 return *t.LastEditedAt
17615 }
17616
17617
17618 func (t *TeamDiscussion) GetNodeID() string {
17619 if t == nil || t.NodeID == nil {
17620 return ""
17621 }
17622 return *t.NodeID
17623 }
17624
17625
17626 func (t *TeamDiscussion) GetNumber() int {
17627 if t == nil || t.Number == nil {
17628 return 0
17629 }
17630 return *t.Number
17631 }
17632
17633
17634 func (t *TeamDiscussion) GetPinned() bool {
17635 if t == nil || t.Pinned == nil {
17636 return false
17637 }
17638 return *t.Pinned
17639 }
17640
17641
17642 func (t *TeamDiscussion) GetPrivate() bool {
17643 if t == nil || t.Private == nil {
17644 return false
17645 }
17646 return *t.Private
17647 }
17648
17649
17650 func (t *TeamDiscussion) GetReactions() *Reactions {
17651 if t == nil {
17652 return nil
17653 }
17654 return t.Reactions
17655 }
17656
17657
17658 func (t *TeamDiscussion) GetTeamURL() string {
17659 if t == nil || t.TeamURL == nil {
17660 return ""
17661 }
17662 return *t.TeamURL
17663 }
17664
17665
17666 func (t *TeamDiscussion) GetTitle() string {
17667 if t == nil || t.Title == nil {
17668 return ""
17669 }
17670 return *t.Title
17671 }
17672
17673
17674 func (t *TeamDiscussion) GetUpdatedAt() Timestamp {
17675 if t == nil || t.UpdatedAt == nil {
17676 return Timestamp{}
17677 }
17678 return *t.UpdatedAt
17679 }
17680
17681
17682 func (t *TeamDiscussion) GetURL() string {
17683 if t == nil || t.URL == nil {
17684 return ""
17685 }
17686 return *t.URL
17687 }
17688
17689
17690 func (t *TeamEvent) GetAction() string {
17691 if t == nil || t.Action == nil {
17692 return ""
17693 }
17694 return *t.Action
17695 }
17696
17697
17698 func (t *TeamEvent) GetChanges() *TeamChange {
17699 if t == nil {
17700 return nil
17701 }
17702 return t.Changes
17703 }
17704
17705
17706 func (t *TeamEvent) GetInstallation() *Installation {
17707 if t == nil {
17708 return nil
17709 }
17710 return t.Installation
17711 }
17712
17713
17714 func (t *TeamEvent) GetOrg() *Organization {
17715 if t == nil {
17716 return nil
17717 }
17718 return t.Org
17719 }
17720
17721
17722 func (t *TeamEvent) GetRepo() *Repository {
17723 if t == nil {
17724 return nil
17725 }
17726 return t.Repo
17727 }
17728
17729
17730 func (t *TeamEvent) GetSender() *User {
17731 if t == nil {
17732 return nil
17733 }
17734 return t.Sender
17735 }
17736
17737
17738 func (t *TeamEvent) GetTeam() *Team {
17739 if t == nil {
17740 return nil
17741 }
17742 return t.Team
17743 }
17744
17745
17746 func (t *TeamLDAPMapping) GetDescription() string {
17747 if t == nil || t.Description == nil {
17748 return ""
17749 }
17750 return *t.Description
17751 }
17752
17753
17754 func (t *TeamLDAPMapping) GetID() int64 {
17755 if t == nil || t.ID == nil {
17756 return 0
17757 }
17758 return *t.ID
17759 }
17760
17761
17762 func (t *TeamLDAPMapping) GetLDAPDN() string {
17763 if t == nil || t.LDAPDN == nil {
17764 return ""
17765 }
17766 return *t.LDAPDN
17767 }
17768
17769
17770 func (t *TeamLDAPMapping) GetMembersURL() string {
17771 if t == nil || t.MembersURL == nil {
17772 return ""
17773 }
17774 return *t.MembersURL
17775 }
17776
17777
17778 func (t *TeamLDAPMapping) GetName() string {
17779 if t == nil || t.Name == nil {
17780 return ""
17781 }
17782 return *t.Name
17783 }
17784
17785
17786 func (t *TeamLDAPMapping) GetPermission() string {
17787 if t == nil || t.Permission == nil {
17788 return ""
17789 }
17790 return *t.Permission
17791 }
17792
17793
17794 func (t *TeamLDAPMapping) GetPrivacy() string {
17795 if t == nil || t.Privacy == nil {
17796 return ""
17797 }
17798 return *t.Privacy
17799 }
17800
17801
17802 func (t *TeamLDAPMapping) GetRepositoriesURL() string {
17803 if t == nil || t.RepositoriesURL == nil {
17804 return ""
17805 }
17806 return *t.RepositoriesURL
17807 }
17808
17809
17810 func (t *TeamLDAPMapping) GetSlug() string {
17811 if t == nil || t.Slug == nil {
17812 return ""
17813 }
17814 return *t.Slug
17815 }
17816
17817
17818 func (t *TeamLDAPMapping) GetURL() string {
17819 if t == nil || t.URL == nil {
17820 return ""
17821 }
17822 return *t.URL
17823 }
17824
17825
17826 func (t *TeamName) GetFrom() string {
17827 if t == nil || t.From == nil {
17828 return ""
17829 }
17830 return *t.From
17831 }
17832
17833
17834 func (t *TeamPermissions) GetFrom() *TeamPermissionsFrom {
17835 if t == nil {
17836 return nil
17837 }
17838 return t.From
17839 }
17840
17841
17842 func (t *TeamPermissionsFrom) GetAdmin() bool {
17843 if t == nil || t.Admin == nil {
17844 return false
17845 }
17846 return *t.Admin
17847 }
17848
17849
17850 func (t *TeamPermissionsFrom) GetPull() bool {
17851 if t == nil || t.Pull == nil {
17852 return false
17853 }
17854 return *t.Pull
17855 }
17856
17857
17858 func (t *TeamPermissionsFrom) GetPush() bool {
17859 if t == nil || t.Push == nil {
17860 return false
17861 }
17862 return *t.Push
17863 }
17864
17865
17866 func (t *TeamPrivacy) GetFrom() string {
17867 if t == nil || t.From == nil {
17868 return ""
17869 }
17870 return *t.From
17871 }
17872
17873
17874 func (t *TeamProjectOptions) GetPermission() string {
17875 if t == nil || t.Permission == nil {
17876 return ""
17877 }
17878 return *t.Permission
17879 }
17880
17881
17882 func (t *TeamRepository) GetPermissions() *TeamPermissions {
17883 if t == nil {
17884 return nil
17885 }
17886 return t.Permissions
17887 }
17888
17889
17890 func (t *TemplateRepoRequest) GetDescription() string {
17891 if t == nil || t.Description == nil {
17892 return ""
17893 }
17894 return *t.Description
17895 }
17896
17897
17898 func (t *TemplateRepoRequest) GetIncludeAllBranches() bool {
17899 if t == nil || t.IncludeAllBranches == nil {
17900 return false
17901 }
17902 return *t.IncludeAllBranches
17903 }
17904
17905
17906 func (t *TemplateRepoRequest) GetName() string {
17907 if t == nil || t.Name == nil {
17908 return ""
17909 }
17910 return *t.Name
17911 }
17912
17913
17914 func (t *TemplateRepoRequest) GetOwner() string {
17915 if t == nil || t.Owner == nil {
17916 return ""
17917 }
17918 return *t.Owner
17919 }
17920
17921
17922 func (t *TemplateRepoRequest) GetPrivate() bool {
17923 if t == nil || t.Private == nil {
17924 return false
17925 }
17926 return *t.Private
17927 }
17928
17929
17930 func (t *TextMatch) GetFragment() string {
17931 if t == nil || t.Fragment == nil {
17932 return ""
17933 }
17934 return *t.Fragment
17935 }
17936
17937
17938 func (t *TextMatch) GetObjectType() string {
17939 if t == nil || t.ObjectType == nil {
17940 return ""
17941 }
17942 return *t.ObjectType
17943 }
17944
17945
17946 func (t *TextMatch) GetObjectURL() string {
17947 if t == nil || t.ObjectURL == nil {
17948 return ""
17949 }
17950 return *t.ObjectURL
17951 }
17952
17953
17954 func (t *TextMatch) GetProperty() string {
17955 if t == nil || t.Property == nil {
17956 return ""
17957 }
17958 return *t.Property
17959 }
17960
17961
17962 func (t *Timeline) GetActor() *User {
17963 if t == nil {
17964 return nil
17965 }
17966 return t.Actor
17967 }
17968
17969
17970 func (t *Timeline) GetAssignee() *User {
17971 if t == nil {
17972 return nil
17973 }
17974 return t.Assignee
17975 }
17976
17977
17978 func (t *Timeline) GetAssigner() *User {
17979 if t == nil {
17980 return nil
17981 }
17982 return t.Assigner
17983 }
17984
17985
17986 func (t *Timeline) GetAuthor() *CommitAuthor {
17987 if t == nil {
17988 return nil
17989 }
17990 return t.Author
17991 }
17992
17993
17994 func (t *Timeline) GetBody() string {
17995 if t == nil || t.Body == nil {
17996 return ""
17997 }
17998 return *t.Body
17999 }
18000
18001
18002 func (t *Timeline) GetCommitID() string {
18003 if t == nil || t.CommitID == nil {
18004 return ""
18005 }
18006 return *t.CommitID
18007 }
18008
18009
18010 func (t *Timeline) GetCommitter() *CommitAuthor {
18011 if t == nil {
18012 return nil
18013 }
18014 return t.Committer
18015 }
18016
18017
18018 func (t *Timeline) GetCommitURL() string {
18019 if t == nil || t.CommitURL == nil {
18020 return ""
18021 }
18022 return *t.CommitURL
18023 }
18024
18025
18026 func (t *Timeline) GetCreatedAt() time.Time {
18027 if t == nil || t.CreatedAt == nil {
18028 return time.Time{}
18029 }
18030 return *t.CreatedAt
18031 }
18032
18033
18034 func (t *Timeline) GetEvent() string {
18035 if t == nil || t.Event == nil {
18036 return ""
18037 }
18038 return *t.Event
18039 }
18040
18041
18042 func (t *Timeline) GetID() int64 {
18043 if t == nil || t.ID == nil {
18044 return 0
18045 }
18046 return *t.ID
18047 }
18048
18049
18050 func (t *Timeline) GetLabel() *Label {
18051 if t == nil {
18052 return nil
18053 }
18054 return t.Label
18055 }
18056
18057
18058 func (t *Timeline) GetMessage() string {
18059 if t == nil || t.Message == nil {
18060 return ""
18061 }
18062 return *t.Message
18063 }
18064
18065
18066 func (t *Timeline) GetMilestone() *Milestone {
18067 if t == nil {
18068 return nil
18069 }
18070 return t.Milestone
18071 }
18072
18073
18074 func (t *Timeline) GetProjectCard() *ProjectCard {
18075 if t == nil {
18076 return nil
18077 }
18078 return t.ProjectCard
18079 }
18080
18081
18082 func (t *Timeline) GetRename() *Rename {
18083 if t == nil {
18084 return nil
18085 }
18086 return t.Rename
18087 }
18088
18089
18090 func (t *Timeline) GetRequester() *User {
18091 if t == nil {
18092 return nil
18093 }
18094 return t.Requester
18095 }
18096
18097
18098 func (t *Timeline) GetReviewer() *User {
18099 if t == nil {
18100 return nil
18101 }
18102 return t.Reviewer
18103 }
18104
18105
18106 func (t *Timeline) GetSHA() string {
18107 if t == nil || t.SHA == nil {
18108 return ""
18109 }
18110 return *t.SHA
18111 }
18112
18113
18114 func (t *Timeline) GetSource() *Source {
18115 if t == nil {
18116 return nil
18117 }
18118 return t.Source
18119 }
18120
18121
18122 func (t *Timeline) GetState() string {
18123 if t == nil || t.State == nil {
18124 return ""
18125 }
18126 return *t.State
18127 }
18128
18129
18130 func (t *Timeline) GetSubmittedAt() time.Time {
18131 if t == nil || t.SubmittedAt == nil {
18132 return time.Time{}
18133 }
18134 return *t.SubmittedAt
18135 }
18136
18137
18138 func (t *Timeline) GetURL() string {
18139 if t == nil || t.URL == nil {
18140 return ""
18141 }
18142 return *t.URL
18143 }
18144
18145
18146 func (t *Timeline) GetUser() *User {
18147 if t == nil {
18148 return nil
18149 }
18150 return t.User
18151 }
18152
18153
18154 func (t *Tool) GetGUID() string {
18155 if t == nil || t.GUID == nil {
18156 return ""
18157 }
18158 return *t.GUID
18159 }
18160
18161
18162 func (t *Tool) GetName() string {
18163 if t == nil || t.Name == nil {
18164 return ""
18165 }
18166 return *t.Name
18167 }
18168
18169
18170 func (t *Tool) GetVersion() string {
18171 if t == nil || t.Version == nil {
18172 return ""
18173 }
18174 return *t.Version
18175 }
18176
18177
18178 func (t *TopicResult) GetCreatedAt() Timestamp {
18179 if t == nil || t.CreatedAt == nil {
18180 return Timestamp{}
18181 }
18182 return *t.CreatedAt
18183 }
18184
18185
18186 func (t *TopicResult) GetCreatedBy() string {
18187 if t == nil || t.CreatedBy == nil {
18188 return ""
18189 }
18190 return *t.CreatedBy
18191 }
18192
18193
18194 func (t *TopicResult) GetCurated() bool {
18195 if t == nil || t.Curated == nil {
18196 return false
18197 }
18198 return *t.Curated
18199 }
18200
18201
18202 func (t *TopicResult) GetDescription() string {
18203 if t == nil || t.Description == nil {
18204 return ""
18205 }
18206 return *t.Description
18207 }
18208
18209
18210 func (t *TopicResult) GetDisplayName() string {
18211 if t == nil || t.DisplayName == nil {
18212 return ""
18213 }
18214 return *t.DisplayName
18215 }
18216
18217
18218 func (t *TopicResult) GetFeatured() bool {
18219 if t == nil || t.Featured == nil {
18220 return false
18221 }
18222 return *t.Featured
18223 }
18224
18225
18226 func (t *TopicResult) GetName() string {
18227 if t == nil || t.Name == nil {
18228 return ""
18229 }
18230 return *t.Name
18231 }
18232
18233
18234 func (t *TopicResult) GetScore() *float64 {
18235 if t == nil {
18236 return nil
18237 }
18238 return t.Score
18239 }
18240
18241
18242 func (t *TopicResult) GetShortDescription() string {
18243 if t == nil || t.ShortDescription == nil {
18244 return ""
18245 }
18246 return *t.ShortDescription
18247 }
18248
18249
18250 func (t *TopicResult) GetUpdatedAt() string {
18251 if t == nil || t.UpdatedAt == nil {
18252 return ""
18253 }
18254 return *t.UpdatedAt
18255 }
18256
18257
18258 func (t *TopicsSearchResult) GetIncompleteResults() bool {
18259 if t == nil || t.IncompleteResults == nil {
18260 return false
18261 }
18262 return *t.IncompleteResults
18263 }
18264
18265
18266 func (t *TopicsSearchResult) GetTotal() int {
18267 if t == nil || t.Total == nil {
18268 return 0
18269 }
18270 return *t.Total
18271 }
18272
18273
18274 func (t *TrafficClones) GetCount() int {
18275 if t == nil || t.Count == nil {
18276 return 0
18277 }
18278 return *t.Count
18279 }
18280
18281
18282 func (t *TrafficClones) GetUniques() int {
18283 if t == nil || t.Uniques == nil {
18284 return 0
18285 }
18286 return *t.Uniques
18287 }
18288
18289
18290 func (t *TrafficData) GetCount() int {
18291 if t == nil || t.Count == nil {
18292 return 0
18293 }
18294 return *t.Count
18295 }
18296
18297
18298 func (t *TrafficData) GetTimestamp() Timestamp {
18299 if t == nil || t.Timestamp == nil {
18300 return Timestamp{}
18301 }
18302 return *t.Timestamp
18303 }
18304
18305
18306 func (t *TrafficData) GetUniques() int {
18307 if t == nil || t.Uniques == nil {
18308 return 0
18309 }
18310 return *t.Uniques
18311 }
18312
18313
18314 func (t *TrafficPath) GetCount() int {
18315 if t == nil || t.Count == nil {
18316 return 0
18317 }
18318 return *t.Count
18319 }
18320
18321
18322 func (t *TrafficPath) GetPath() string {
18323 if t == nil || t.Path == nil {
18324 return ""
18325 }
18326 return *t.Path
18327 }
18328
18329
18330 func (t *TrafficPath) GetTitle() string {
18331 if t == nil || t.Title == nil {
18332 return ""
18333 }
18334 return *t.Title
18335 }
18336
18337
18338 func (t *TrafficPath) GetUniques() int {
18339 if t == nil || t.Uniques == nil {
18340 return 0
18341 }
18342 return *t.Uniques
18343 }
18344
18345
18346 func (t *TrafficReferrer) GetCount() int {
18347 if t == nil || t.Count == nil {
18348 return 0
18349 }
18350 return *t.Count
18351 }
18352
18353
18354 func (t *TrafficReferrer) GetReferrer() string {
18355 if t == nil || t.Referrer == nil {
18356 return ""
18357 }
18358 return *t.Referrer
18359 }
18360
18361
18362 func (t *TrafficReferrer) GetUniques() int {
18363 if t == nil || t.Uniques == nil {
18364 return 0
18365 }
18366 return *t.Uniques
18367 }
18368
18369
18370 func (t *TrafficViews) GetCount() int {
18371 if t == nil || t.Count == nil {
18372 return 0
18373 }
18374 return *t.Count
18375 }
18376
18377
18378 func (t *TrafficViews) GetUniques() int {
18379 if t == nil || t.Uniques == nil {
18380 return 0
18381 }
18382 return *t.Uniques
18383 }
18384
18385
18386 func (t *Tree) GetSHA() string {
18387 if t == nil || t.SHA == nil {
18388 return ""
18389 }
18390 return *t.SHA
18391 }
18392
18393
18394 func (t *Tree) GetTruncated() bool {
18395 if t == nil || t.Truncated == nil {
18396 return false
18397 }
18398 return *t.Truncated
18399 }
18400
18401
18402 func (t *TreeEntry) GetContent() string {
18403 if t == nil || t.Content == nil {
18404 return ""
18405 }
18406 return *t.Content
18407 }
18408
18409
18410 func (t *TreeEntry) GetMode() string {
18411 if t == nil || t.Mode == nil {
18412 return ""
18413 }
18414 return *t.Mode
18415 }
18416
18417
18418 func (t *TreeEntry) GetPath() string {
18419 if t == nil || t.Path == nil {
18420 return ""
18421 }
18422 return *t.Path
18423 }
18424
18425
18426 func (t *TreeEntry) GetSHA() string {
18427 if t == nil || t.SHA == nil {
18428 return ""
18429 }
18430 return *t.SHA
18431 }
18432
18433
18434 func (t *TreeEntry) GetSize() int {
18435 if t == nil || t.Size == nil {
18436 return 0
18437 }
18438 return *t.Size
18439 }
18440
18441
18442 func (t *TreeEntry) GetType() string {
18443 if t == nil || t.Type == nil {
18444 return ""
18445 }
18446 return *t.Type
18447 }
18448
18449
18450 func (t *TreeEntry) GetURL() string {
18451 if t == nil || t.URL == nil {
18452 return ""
18453 }
18454 return *t.URL
18455 }
18456
18457
18458 func (u *UpdateAttributeForSCIMUserOperations) GetPath() string {
18459 if u == nil || u.Path == nil {
18460 return ""
18461 }
18462 return *u.Path
18463 }
18464
18465
18466 func (u *UpdateCheckRunOptions) GetCompletedAt() Timestamp {
18467 if u == nil || u.CompletedAt == nil {
18468 return Timestamp{}
18469 }
18470 return *u.CompletedAt
18471 }
18472
18473
18474 func (u *UpdateCheckRunOptions) GetConclusion() string {
18475 if u == nil || u.Conclusion == nil {
18476 return ""
18477 }
18478 return *u.Conclusion
18479 }
18480
18481
18482 func (u *UpdateCheckRunOptions) GetDetailsURL() string {
18483 if u == nil || u.DetailsURL == nil {
18484 return ""
18485 }
18486 return *u.DetailsURL
18487 }
18488
18489
18490 func (u *UpdateCheckRunOptions) GetExternalID() string {
18491 if u == nil || u.ExternalID == nil {
18492 return ""
18493 }
18494 return *u.ExternalID
18495 }
18496
18497
18498 func (u *UpdateCheckRunOptions) GetOutput() *CheckRunOutput {
18499 if u == nil {
18500 return nil
18501 }
18502 return u.Output
18503 }
18504
18505
18506 func (u *UpdateCheckRunOptions) GetStatus() string {
18507 if u == nil || u.Status == nil {
18508 return ""
18509 }
18510 return *u.Status
18511 }
18512
18513
18514 func (u *UpdateRunnerGroupRequest) GetAllowsPublicRepositories() bool {
18515 if u == nil || u.AllowsPublicRepositories == nil {
18516 return false
18517 }
18518 return *u.AllowsPublicRepositories
18519 }
18520
18521
18522 func (u *UpdateRunnerGroupRequest) GetName() string {
18523 if u == nil || u.Name == nil {
18524 return ""
18525 }
18526 return *u.Name
18527 }
18528
18529
18530 func (u *UpdateRunnerGroupRequest) GetVisibility() string {
18531 if u == nil || u.Visibility == nil {
18532 return ""
18533 }
18534 return *u.Visibility
18535 }
18536
18537
18538 func (u *User) GetAvatarURL() string {
18539 if u == nil || u.AvatarURL == nil {
18540 return ""
18541 }
18542 return *u.AvatarURL
18543 }
18544
18545
18546 func (u *User) GetBio() string {
18547 if u == nil || u.Bio == nil {
18548 return ""
18549 }
18550 return *u.Bio
18551 }
18552
18553
18554 func (u *User) GetBlog() string {
18555 if u == nil || u.Blog == nil {
18556 return ""
18557 }
18558 return *u.Blog
18559 }
18560
18561
18562 func (u *User) GetCollaborators() int {
18563 if u == nil || u.Collaborators == nil {
18564 return 0
18565 }
18566 return *u.Collaborators
18567 }
18568
18569
18570 func (u *User) GetCompany() string {
18571 if u == nil || u.Company == nil {
18572 return ""
18573 }
18574 return *u.Company
18575 }
18576
18577
18578 func (u *User) GetCreatedAt() Timestamp {
18579 if u == nil || u.CreatedAt == nil {
18580 return Timestamp{}
18581 }
18582 return *u.CreatedAt
18583 }
18584
18585
18586 func (u *User) GetDiskUsage() int {
18587 if u == nil || u.DiskUsage == nil {
18588 return 0
18589 }
18590 return *u.DiskUsage
18591 }
18592
18593
18594 func (u *User) GetEmail() string {
18595 if u == nil || u.Email == nil {
18596 return ""
18597 }
18598 return *u.Email
18599 }
18600
18601
18602 func (u *User) GetEventsURL() string {
18603 if u == nil || u.EventsURL == nil {
18604 return ""
18605 }
18606 return *u.EventsURL
18607 }
18608
18609
18610 func (u *User) GetFollowers() int {
18611 if u == nil || u.Followers == nil {
18612 return 0
18613 }
18614 return *u.Followers
18615 }
18616
18617
18618 func (u *User) GetFollowersURL() string {
18619 if u == nil || u.FollowersURL == nil {
18620 return ""
18621 }
18622 return *u.FollowersURL
18623 }
18624
18625
18626 func (u *User) GetFollowing() int {
18627 if u == nil || u.Following == nil {
18628 return 0
18629 }
18630 return *u.Following
18631 }
18632
18633
18634 func (u *User) GetFollowingURL() string {
18635 if u == nil || u.FollowingURL == nil {
18636 return ""
18637 }
18638 return *u.FollowingURL
18639 }
18640
18641
18642 func (u *User) GetGistsURL() string {
18643 if u == nil || u.GistsURL == nil {
18644 return ""
18645 }
18646 return *u.GistsURL
18647 }
18648
18649
18650 func (u *User) GetGravatarID() string {
18651 if u == nil || u.GravatarID == nil {
18652 return ""
18653 }
18654 return *u.GravatarID
18655 }
18656
18657
18658 func (u *User) GetHireable() bool {
18659 if u == nil || u.Hireable == nil {
18660 return false
18661 }
18662 return *u.Hireable
18663 }
18664
18665
18666 func (u *User) GetHTMLURL() string {
18667 if u == nil || u.HTMLURL == nil {
18668 return ""
18669 }
18670 return *u.HTMLURL
18671 }
18672
18673
18674 func (u *User) GetID() int64 {
18675 if u == nil || u.ID == nil {
18676 return 0
18677 }
18678 return *u.ID
18679 }
18680
18681
18682 func (u *User) GetLdapDn() string {
18683 if u == nil || u.LdapDn == nil {
18684 return ""
18685 }
18686 return *u.LdapDn
18687 }
18688
18689
18690 func (u *User) GetLocation() string {
18691 if u == nil || u.Location == nil {
18692 return ""
18693 }
18694 return *u.Location
18695 }
18696
18697
18698 func (u *User) GetLogin() string {
18699 if u == nil || u.Login == nil {
18700 return ""
18701 }
18702 return *u.Login
18703 }
18704
18705
18706 func (u *User) GetName() string {
18707 if u == nil || u.Name == nil {
18708 return ""
18709 }
18710 return *u.Name
18711 }
18712
18713
18714 func (u *User) GetNodeID() string {
18715 if u == nil || u.NodeID == nil {
18716 return ""
18717 }
18718 return *u.NodeID
18719 }
18720
18721
18722 func (u *User) GetOrganizationsURL() string {
18723 if u == nil || u.OrganizationsURL == nil {
18724 return ""
18725 }
18726 return *u.OrganizationsURL
18727 }
18728
18729
18730 func (u *User) GetOwnedPrivateRepos() int {
18731 if u == nil || u.OwnedPrivateRepos == nil {
18732 return 0
18733 }
18734 return *u.OwnedPrivateRepos
18735 }
18736
18737
18738 func (u *User) GetPermissions() map[string]bool {
18739 if u == nil || u.Permissions == nil {
18740 return map[string]bool{}
18741 }
18742 return u.Permissions
18743 }
18744
18745
18746 func (u *User) GetPlan() *Plan {
18747 if u == nil {
18748 return nil
18749 }
18750 return u.Plan
18751 }
18752
18753
18754 func (u *User) GetPrivateGists() int {
18755 if u == nil || u.PrivateGists == nil {
18756 return 0
18757 }
18758 return *u.PrivateGists
18759 }
18760
18761
18762 func (u *User) GetPublicGists() int {
18763 if u == nil || u.PublicGists == nil {
18764 return 0
18765 }
18766 return *u.PublicGists
18767 }
18768
18769
18770 func (u *User) GetPublicRepos() int {
18771 if u == nil || u.PublicRepos == nil {
18772 return 0
18773 }
18774 return *u.PublicRepos
18775 }
18776
18777
18778 func (u *User) GetReceivedEventsURL() string {
18779 if u == nil || u.ReceivedEventsURL == nil {
18780 return ""
18781 }
18782 return *u.ReceivedEventsURL
18783 }
18784
18785
18786 func (u *User) GetReposURL() string {
18787 if u == nil || u.ReposURL == nil {
18788 return ""
18789 }
18790 return *u.ReposURL
18791 }
18792
18793
18794 func (u *User) GetRoleName() string {
18795 if u == nil || u.RoleName == nil {
18796 return ""
18797 }
18798 return *u.RoleName
18799 }
18800
18801
18802 func (u *User) GetSiteAdmin() bool {
18803 if u == nil || u.SiteAdmin == nil {
18804 return false
18805 }
18806 return *u.SiteAdmin
18807 }
18808
18809
18810 func (u *User) GetStarredURL() string {
18811 if u == nil || u.StarredURL == nil {
18812 return ""
18813 }
18814 return *u.StarredURL
18815 }
18816
18817
18818 func (u *User) GetSubscriptionsURL() string {
18819 if u == nil || u.SubscriptionsURL == nil {
18820 return ""
18821 }
18822 return *u.SubscriptionsURL
18823 }
18824
18825
18826 func (u *User) GetSuspendedAt() Timestamp {
18827 if u == nil || u.SuspendedAt == nil {
18828 return Timestamp{}
18829 }
18830 return *u.SuspendedAt
18831 }
18832
18833
18834 func (u *User) GetTotalPrivateRepos() int {
18835 if u == nil || u.TotalPrivateRepos == nil {
18836 return 0
18837 }
18838 return *u.TotalPrivateRepos
18839 }
18840
18841
18842 func (u *User) GetTwitterUsername() string {
18843 if u == nil || u.TwitterUsername == nil {
18844 return ""
18845 }
18846 return *u.TwitterUsername
18847 }
18848
18849
18850 func (u *User) GetTwoFactorAuthentication() bool {
18851 if u == nil || u.TwoFactorAuthentication == nil {
18852 return false
18853 }
18854 return *u.TwoFactorAuthentication
18855 }
18856
18857
18858 func (u *User) GetType() string {
18859 if u == nil || u.Type == nil {
18860 return ""
18861 }
18862 return *u.Type
18863 }
18864
18865
18866 func (u *User) GetUpdatedAt() Timestamp {
18867 if u == nil || u.UpdatedAt == nil {
18868 return Timestamp{}
18869 }
18870 return *u.UpdatedAt
18871 }
18872
18873
18874 func (u *User) GetURL() string {
18875 if u == nil || u.URL == nil {
18876 return ""
18877 }
18878 return *u.URL
18879 }
18880
18881
18882 func (u *UserAuthorization) GetApp() *OAuthAPP {
18883 if u == nil {
18884 return nil
18885 }
18886 return u.App
18887 }
18888
18889
18890 func (u *UserAuthorization) GetCreatedAt() Timestamp {
18891 if u == nil || u.CreatedAt == nil {
18892 return Timestamp{}
18893 }
18894 return *u.CreatedAt
18895 }
18896
18897
18898 func (u *UserAuthorization) GetFingerprint() string {
18899 if u == nil || u.Fingerprint == nil {
18900 return ""
18901 }
18902 return *u.Fingerprint
18903 }
18904
18905
18906 func (u *UserAuthorization) GetHashedToken() string {
18907 if u == nil || u.HashedToken == nil {
18908 return ""
18909 }
18910 return *u.HashedToken
18911 }
18912
18913
18914 func (u *UserAuthorization) GetID() int64 {
18915 if u == nil || u.ID == nil {
18916 return 0
18917 }
18918 return *u.ID
18919 }
18920
18921
18922 func (u *UserAuthorization) GetNote() string {
18923 if u == nil || u.Note == nil {
18924 return ""
18925 }
18926 return *u.Note
18927 }
18928
18929
18930 func (u *UserAuthorization) GetNoteURL() string {
18931 if u == nil || u.NoteURL == nil {
18932 return ""
18933 }
18934 return *u.NoteURL
18935 }
18936
18937
18938 func (u *UserAuthorization) GetToken() string {
18939 if u == nil || u.Token == nil {
18940 return ""
18941 }
18942 return *u.Token
18943 }
18944
18945
18946 func (u *UserAuthorization) GetTokenLastEight() string {
18947 if u == nil || u.TokenLastEight == nil {
18948 return ""
18949 }
18950 return *u.TokenLastEight
18951 }
18952
18953
18954 func (u *UserAuthorization) GetUpdatedAt() Timestamp {
18955 if u == nil || u.UpdatedAt == nil {
18956 return Timestamp{}
18957 }
18958 return *u.UpdatedAt
18959 }
18960
18961
18962 func (u *UserAuthorization) GetURL() string {
18963 if u == nil || u.URL == nil {
18964 return ""
18965 }
18966 return *u.URL
18967 }
18968
18969
18970 func (u *UserContext) GetMessage() string {
18971 if u == nil || u.Message == nil {
18972 return ""
18973 }
18974 return *u.Message
18975 }
18976
18977
18978 func (u *UserContext) GetOcticon() string {
18979 if u == nil || u.Octicon == nil {
18980 return ""
18981 }
18982 return *u.Octicon
18983 }
18984
18985
18986 func (u *UserEmail) GetEmail() string {
18987 if u == nil || u.Email == nil {
18988 return ""
18989 }
18990 return *u.Email
18991 }
18992
18993
18994 func (u *UserEmail) GetPrimary() bool {
18995 if u == nil || u.Primary == nil {
18996 return false
18997 }
18998 return *u.Primary
18999 }
19000
19001
19002 func (u *UserEmail) GetVerified() bool {
19003 if u == nil || u.Verified == nil {
19004 return false
19005 }
19006 return *u.Verified
19007 }
19008
19009
19010 func (u *UserEmail) GetVisibility() string {
19011 if u == nil || u.Visibility == nil {
19012 return ""
19013 }
19014 return *u.Visibility
19015 }
19016
19017
19018 func (u *UserEvent) GetAction() string {
19019 if u == nil || u.Action == nil {
19020 return ""
19021 }
19022 return *u.Action
19023 }
19024
19025
19026 func (u *UserEvent) GetEnterprise() *Enterprise {
19027 if u == nil {
19028 return nil
19029 }
19030 return u.Enterprise
19031 }
19032
19033
19034 func (u *UserEvent) GetInstallation() *Installation {
19035 if u == nil {
19036 return nil
19037 }
19038 return u.Installation
19039 }
19040
19041
19042 func (u *UserEvent) GetSender() *User {
19043 if u == nil {
19044 return nil
19045 }
19046 return u.Sender
19047 }
19048
19049
19050 func (u *UserEvent) GetUser() *User {
19051 if u == nil {
19052 return nil
19053 }
19054 return u.User
19055 }
19056
19057
19058 func (u *UserLDAPMapping) GetAvatarURL() string {
19059 if u == nil || u.AvatarURL == nil {
19060 return ""
19061 }
19062 return *u.AvatarURL
19063 }
19064
19065
19066 func (u *UserLDAPMapping) GetEventsURL() string {
19067 if u == nil || u.EventsURL == nil {
19068 return ""
19069 }
19070 return *u.EventsURL
19071 }
19072
19073
19074 func (u *UserLDAPMapping) GetFollowersURL() string {
19075 if u == nil || u.FollowersURL == nil {
19076 return ""
19077 }
19078 return *u.FollowersURL
19079 }
19080
19081
19082 func (u *UserLDAPMapping) GetFollowingURL() string {
19083 if u == nil || u.FollowingURL == nil {
19084 return ""
19085 }
19086 return *u.FollowingURL
19087 }
19088
19089
19090 func (u *UserLDAPMapping) GetGistsURL() string {
19091 if u == nil || u.GistsURL == nil {
19092 return ""
19093 }
19094 return *u.GistsURL
19095 }
19096
19097
19098 func (u *UserLDAPMapping) GetGravatarID() string {
19099 if u == nil || u.GravatarID == nil {
19100 return ""
19101 }
19102 return *u.GravatarID
19103 }
19104
19105
19106 func (u *UserLDAPMapping) GetID() int64 {
19107 if u == nil || u.ID == nil {
19108 return 0
19109 }
19110 return *u.ID
19111 }
19112
19113
19114 func (u *UserLDAPMapping) GetLDAPDN() string {
19115 if u == nil || u.LDAPDN == nil {
19116 return ""
19117 }
19118 return *u.LDAPDN
19119 }
19120
19121
19122 func (u *UserLDAPMapping) GetLogin() string {
19123 if u == nil || u.Login == nil {
19124 return ""
19125 }
19126 return *u.Login
19127 }
19128
19129
19130 func (u *UserLDAPMapping) GetOrganizationsURL() string {
19131 if u == nil || u.OrganizationsURL == nil {
19132 return ""
19133 }
19134 return *u.OrganizationsURL
19135 }
19136
19137
19138 func (u *UserLDAPMapping) GetReceivedEventsURL() string {
19139 if u == nil || u.ReceivedEventsURL == nil {
19140 return ""
19141 }
19142 return *u.ReceivedEventsURL
19143 }
19144
19145
19146 func (u *UserLDAPMapping) GetReposURL() string {
19147 if u == nil || u.ReposURL == nil {
19148 return ""
19149 }
19150 return *u.ReposURL
19151 }
19152
19153
19154 func (u *UserLDAPMapping) GetSiteAdmin() bool {
19155 if u == nil || u.SiteAdmin == nil {
19156 return false
19157 }
19158 return *u.SiteAdmin
19159 }
19160
19161
19162 func (u *UserLDAPMapping) GetStarredURL() string {
19163 if u == nil || u.StarredURL == nil {
19164 return ""
19165 }
19166 return *u.StarredURL
19167 }
19168
19169
19170 func (u *UserLDAPMapping) GetSubscriptionsURL() string {
19171 if u == nil || u.SubscriptionsURL == nil {
19172 return ""
19173 }
19174 return *u.SubscriptionsURL
19175 }
19176
19177
19178 func (u *UserLDAPMapping) GetType() string {
19179 if u == nil || u.Type == nil {
19180 return ""
19181 }
19182 return *u.Type
19183 }
19184
19185
19186 func (u *UserLDAPMapping) GetURL() string {
19187 if u == nil || u.URL == nil {
19188 return ""
19189 }
19190 return *u.URL
19191 }
19192
19193
19194 func (u *UserMigration) GetCreatedAt() string {
19195 if u == nil || u.CreatedAt == nil {
19196 return ""
19197 }
19198 return *u.CreatedAt
19199 }
19200
19201
19202 func (u *UserMigration) GetExcludeAttachments() bool {
19203 if u == nil || u.ExcludeAttachments == nil {
19204 return false
19205 }
19206 return *u.ExcludeAttachments
19207 }
19208
19209
19210 func (u *UserMigration) GetGUID() string {
19211 if u == nil || u.GUID == nil {
19212 return ""
19213 }
19214 return *u.GUID
19215 }
19216
19217
19218 func (u *UserMigration) GetID() int64 {
19219 if u == nil || u.ID == nil {
19220 return 0
19221 }
19222 return *u.ID
19223 }
19224
19225
19226 func (u *UserMigration) GetLockRepositories() bool {
19227 if u == nil || u.LockRepositories == nil {
19228 return false
19229 }
19230 return *u.LockRepositories
19231 }
19232
19233
19234 func (u *UserMigration) GetState() string {
19235 if u == nil || u.State == nil {
19236 return ""
19237 }
19238 return *u.State
19239 }
19240
19241
19242 func (u *UserMigration) GetUpdatedAt() string {
19243 if u == nil || u.UpdatedAt == nil {
19244 return ""
19245 }
19246 return *u.UpdatedAt
19247 }
19248
19249
19250 func (u *UserMigration) GetURL() string {
19251 if u == nil || u.URL == nil {
19252 return ""
19253 }
19254 return *u.URL
19255 }
19256
19257
19258 func (u *UsersSearchResult) GetIncompleteResults() bool {
19259 if u == nil || u.IncompleteResults == nil {
19260 return false
19261 }
19262 return *u.IncompleteResults
19263 }
19264
19265
19266 func (u *UsersSearchResult) GetTotal() int {
19267 if u == nil || u.Total == nil {
19268 return 0
19269 }
19270 return *u.Total
19271 }
19272
19273
19274 func (u *UserStats) GetAdminUsers() int {
19275 if u == nil || u.AdminUsers == nil {
19276 return 0
19277 }
19278 return *u.AdminUsers
19279 }
19280
19281
19282 func (u *UserStats) GetSuspendedUsers() int {
19283 if u == nil || u.SuspendedUsers == nil {
19284 return 0
19285 }
19286 return *u.SuspendedUsers
19287 }
19288
19289
19290 func (u *UserStats) GetTotalUsers() int {
19291 if u == nil || u.TotalUsers == nil {
19292 return 0
19293 }
19294 return *u.TotalUsers
19295 }
19296
19297
19298 func (u *UserSuspendOptions) GetReason() string {
19299 if u == nil || u.Reason == nil {
19300 return ""
19301 }
19302 return *u.Reason
19303 }
19304
19305
19306 func (v *VulnerabilityPackage) GetEcosystem() string {
19307 if v == nil || v.Ecosystem == nil {
19308 return ""
19309 }
19310 return *v.Ecosystem
19311 }
19312
19313
19314 func (v *VulnerabilityPackage) GetName() string {
19315 if v == nil || v.Name == nil {
19316 return ""
19317 }
19318 return *v.Name
19319 }
19320
19321
19322 func (w *WatchEvent) GetAction() string {
19323 if w == nil || w.Action == nil {
19324 return ""
19325 }
19326 return *w.Action
19327 }
19328
19329
19330 func (w *WatchEvent) GetInstallation() *Installation {
19331 if w == nil {
19332 return nil
19333 }
19334 return w.Installation
19335 }
19336
19337
19338 func (w *WatchEvent) GetRepo() *Repository {
19339 if w == nil {
19340 return nil
19341 }
19342 return w.Repo
19343 }
19344
19345
19346 func (w *WatchEvent) GetSender() *User {
19347 if w == nil {
19348 return nil
19349 }
19350 return w.Sender
19351 }
19352
19353
19354 func (w *WeeklyCommitActivity) GetTotal() int {
19355 if w == nil || w.Total == nil {
19356 return 0
19357 }
19358 return *w.Total
19359 }
19360
19361
19362 func (w *WeeklyCommitActivity) GetWeek() Timestamp {
19363 if w == nil || w.Week == nil {
19364 return Timestamp{}
19365 }
19366 return *w.Week
19367 }
19368
19369
19370 func (w *WeeklyStats) GetAdditions() int {
19371 if w == nil || w.Additions == nil {
19372 return 0
19373 }
19374 return *w.Additions
19375 }
19376
19377
19378 func (w *WeeklyStats) GetCommits() int {
19379 if w == nil || w.Commits == nil {
19380 return 0
19381 }
19382 return *w.Commits
19383 }
19384
19385
19386 func (w *WeeklyStats) GetDeletions() int {
19387 if w == nil || w.Deletions == nil {
19388 return 0
19389 }
19390 return *w.Deletions
19391 }
19392
19393
19394 func (w *WeeklyStats) GetWeek() Timestamp {
19395 if w == nil || w.Week == nil {
19396 return Timestamp{}
19397 }
19398 return *w.Week
19399 }
19400
19401
19402 func (w *Workflow) GetBadgeURL() string {
19403 if w == nil || w.BadgeURL == nil {
19404 return ""
19405 }
19406 return *w.BadgeURL
19407 }
19408
19409
19410 func (w *Workflow) GetCreatedAt() Timestamp {
19411 if w == nil || w.CreatedAt == nil {
19412 return Timestamp{}
19413 }
19414 return *w.CreatedAt
19415 }
19416
19417
19418 func (w *Workflow) GetHTMLURL() string {
19419 if w == nil || w.HTMLURL == nil {
19420 return ""
19421 }
19422 return *w.HTMLURL
19423 }
19424
19425
19426 func (w *Workflow) GetID() int64 {
19427 if w == nil || w.ID == nil {
19428 return 0
19429 }
19430 return *w.ID
19431 }
19432
19433
19434 func (w *Workflow) GetName() string {
19435 if w == nil || w.Name == nil {
19436 return ""
19437 }
19438 return *w.Name
19439 }
19440
19441
19442 func (w *Workflow) GetNodeID() string {
19443 if w == nil || w.NodeID == nil {
19444 return ""
19445 }
19446 return *w.NodeID
19447 }
19448
19449
19450 func (w *Workflow) GetPath() string {
19451 if w == nil || w.Path == nil {
19452 return ""
19453 }
19454 return *w.Path
19455 }
19456
19457
19458 func (w *Workflow) GetState() string {
19459 if w == nil || w.State == nil {
19460 return ""
19461 }
19462 return *w.State
19463 }
19464
19465
19466 func (w *Workflow) GetUpdatedAt() Timestamp {
19467 if w == nil || w.UpdatedAt == nil {
19468 return Timestamp{}
19469 }
19470 return *w.UpdatedAt
19471 }
19472
19473
19474 func (w *Workflow) GetURL() string {
19475 if w == nil || w.URL == nil {
19476 return ""
19477 }
19478 return *w.URL
19479 }
19480
19481
19482 func (w *WorkflowBill) GetTotalMS() int64 {
19483 if w == nil || w.TotalMS == nil {
19484 return 0
19485 }
19486 return *w.TotalMS
19487 }
19488
19489
19490 func (w *WorkflowDispatchEvent) GetInstallation() *Installation {
19491 if w == nil {
19492 return nil
19493 }
19494 return w.Installation
19495 }
19496
19497
19498 func (w *WorkflowDispatchEvent) GetOrg() *Organization {
19499 if w == nil {
19500 return nil
19501 }
19502 return w.Org
19503 }
19504
19505
19506 func (w *WorkflowDispatchEvent) GetRef() string {
19507 if w == nil || w.Ref == nil {
19508 return ""
19509 }
19510 return *w.Ref
19511 }
19512
19513
19514 func (w *WorkflowDispatchEvent) GetRepo() *Repository {
19515 if w == nil {
19516 return nil
19517 }
19518 return w.Repo
19519 }
19520
19521
19522 func (w *WorkflowDispatchEvent) GetSender() *User {
19523 if w == nil {
19524 return nil
19525 }
19526 return w.Sender
19527 }
19528
19529
19530 func (w *WorkflowDispatchEvent) GetWorkflow() string {
19531 if w == nil || w.Workflow == nil {
19532 return ""
19533 }
19534 return *w.Workflow
19535 }
19536
19537
19538 func (w *WorkflowEnvironment) GetMacOS() *WorkflowBill {
19539 if w == nil {
19540 return nil
19541 }
19542 return w.MacOS
19543 }
19544
19545
19546 func (w *WorkflowEnvironment) GetUbuntu() *WorkflowBill {
19547 if w == nil {
19548 return nil
19549 }
19550 return w.Ubuntu
19551 }
19552
19553
19554 func (w *WorkflowEnvironment) GetWindows() *WorkflowBill {
19555 if w == nil {
19556 return nil
19557 }
19558 return w.Windows
19559 }
19560
19561
19562 func (w *WorkflowJob) GetCheckRunURL() string {
19563 if w == nil || w.CheckRunURL == nil {
19564 return ""
19565 }
19566 return *w.CheckRunURL
19567 }
19568
19569
19570 func (w *WorkflowJob) GetCompletedAt() Timestamp {
19571 if w == nil || w.CompletedAt == nil {
19572 return Timestamp{}
19573 }
19574 return *w.CompletedAt
19575 }
19576
19577
19578 func (w *WorkflowJob) GetConclusion() string {
19579 if w == nil || w.Conclusion == nil {
19580 return ""
19581 }
19582 return *w.Conclusion
19583 }
19584
19585
19586 func (w *WorkflowJob) GetHeadSHA() string {
19587 if w == nil || w.HeadSHA == nil {
19588 return ""
19589 }
19590 return *w.HeadSHA
19591 }
19592
19593
19594 func (w *WorkflowJob) GetHTMLURL() string {
19595 if w == nil || w.HTMLURL == nil {
19596 return ""
19597 }
19598 return *w.HTMLURL
19599 }
19600
19601
19602 func (w *WorkflowJob) GetID() int64 {
19603 if w == nil || w.ID == nil {
19604 return 0
19605 }
19606 return *w.ID
19607 }
19608
19609
19610 func (w *WorkflowJob) GetName() string {
19611 if w == nil || w.Name == nil {
19612 return ""
19613 }
19614 return *w.Name
19615 }
19616
19617
19618 func (w *WorkflowJob) GetNodeID() string {
19619 if w == nil || w.NodeID == nil {
19620 return ""
19621 }
19622 return *w.NodeID
19623 }
19624
19625
19626 func (w *WorkflowJob) GetRunID() int64 {
19627 if w == nil || w.RunID == nil {
19628 return 0
19629 }
19630 return *w.RunID
19631 }
19632
19633
19634 func (w *WorkflowJob) GetRunnerGroupID() int64 {
19635 if w == nil || w.RunnerGroupID == nil {
19636 return 0
19637 }
19638 return *w.RunnerGroupID
19639 }
19640
19641
19642 func (w *WorkflowJob) GetRunnerGroupName() string {
19643 if w == nil || w.RunnerGroupName == nil {
19644 return ""
19645 }
19646 return *w.RunnerGroupName
19647 }
19648
19649
19650 func (w *WorkflowJob) GetRunnerID() int64 {
19651 if w == nil || w.RunnerID == nil {
19652 return 0
19653 }
19654 return *w.RunnerID
19655 }
19656
19657
19658 func (w *WorkflowJob) GetRunnerName() string {
19659 if w == nil || w.RunnerName == nil {
19660 return ""
19661 }
19662 return *w.RunnerName
19663 }
19664
19665
19666 func (w *WorkflowJob) GetRunURL() string {
19667 if w == nil || w.RunURL == nil {
19668 return ""
19669 }
19670 return *w.RunURL
19671 }
19672
19673
19674 func (w *WorkflowJob) GetStartedAt() Timestamp {
19675 if w == nil || w.StartedAt == nil {
19676 return Timestamp{}
19677 }
19678 return *w.StartedAt
19679 }
19680
19681
19682 func (w *WorkflowJob) GetStatus() string {
19683 if w == nil || w.Status == nil {
19684 return ""
19685 }
19686 return *w.Status
19687 }
19688
19689
19690 func (w *WorkflowJob) GetURL() string {
19691 if w == nil || w.URL == nil {
19692 return ""
19693 }
19694 return *w.URL
19695 }
19696
19697
19698 func (w *WorkflowJobEvent) GetAction() string {
19699 if w == nil || w.Action == nil {
19700 return ""
19701 }
19702 return *w.Action
19703 }
19704
19705
19706 func (w *WorkflowJobEvent) GetInstallation() *Installation {
19707 if w == nil {
19708 return nil
19709 }
19710 return w.Installation
19711 }
19712
19713
19714 func (w *WorkflowJobEvent) GetOrg() *Organization {
19715 if w == nil {
19716 return nil
19717 }
19718 return w.Org
19719 }
19720
19721
19722 func (w *WorkflowJobEvent) GetRepo() *Repository {
19723 if w == nil {
19724 return nil
19725 }
19726 return w.Repo
19727 }
19728
19729
19730 func (w *WorkflowJobEvent) GetSender() *User {
19731 if w == nil {
19732 return nil
19733 }
19734 return w.Sender
19735 }
19736
19737
19738 func (w *WorkflowJobEvent) GetWorkflowJob() *WorkflowJob {
19739 if w == nil {
19740 return nil
19741 }
19742 return w.WorkflowJob
19743 }
19744
19745
19746 func (w *WorkflowRun) GetActor() *User {
19747 if w == nil {
19748 return nil
19749 }
19750 return w.Actor
19751 }
19752
19753
19754 func (w *WorkflowRun) GetArtifactsURL() string {
19755 if w == nil || w.ArtifactsURL == nil {
19756 return ""
19757 }
19758 return *w.ArtifactsURL
19759 }
19760
19761
19762 func (w *WorkflowRun) GetCancelURL() string {
19763 if w == nil || w.CancelURL == nil {
19764 return ""
19765 }
19766 return *w.CancelURL
19767 }
19768
19769
19770 func (w *WorkflowRun) GetCheckSuiteID() int64 {
19771 if w == nil || w.CheckSuiteID == nil {
19772 return 0
19773 }
19774 return *w.CheckSuiteID
19775 }
19776
19777
19778 func (w *WorkflowRun) GetCheckSuiteNodeID() string {
19779 if w == nil || w.CheckSuiteNodeID == nil {
19780 return ""
19781 }
19782 return *w.CheckSuiteNodeID
19783 }
19784
19785
19786 func (w *WorkflowRun) GetCheckSuiteURL() string {
19787 if w == nil || w.CheckSuiteURL == nil {
19788 return ""
19789 }
19790 return *w.CheckSuiteURL
19791 }
19792
19793
19794 func (w *WorkflowRun) GetConclusion() string {
19795 if w == nil || w.Conclusion == nil {
19796 return ""
19797 }
19798 return *w.Conclusion
19799 }
19800
19801
19802 func (w *WorkflowRun) GetCreatedAt() Timestamp {
19803 if w == nil || w.CreatedAt == nil {
19804 return Timestamp{}
19805 }
19806 return *w.CreatedAt
19807 }
19808
19809
19810 func (w *WorkflowRun) GetEvent() string {
19811 if w == nil || w.Event == nil {
19812 return ""
19813 }
19814 return *w.Event
19815 }
19816
19817
19818 func (w *WorkflowRun) GetHeadBranch() string {
19819 if w == nil || w.HeadBranch == nil {
19820 return ""
19821 }
19822 return *w.HeadBranch
19823 }
19824
19825
19826 func (w *WorkflowRun) GetHeadCommit() *HeadCommit {
19827 if w == nil {
19828 return nil
19829 }
19830 return w.HeadCommit
19831 }
19832
19833
19834 func (w *WorkflowRun) GetHeadRepository() *Repository {
19835 if w == nil {
19836 return nil
19837 }
19838 return w.HeadRepository
19839 }
19840
19841
19842 func (w *WorkflowRun) GetHeadSHA() string {
19843 if w == nil || w.HeadSHA == nil {
19844 return ""
19845 }
19846 return *w.HeadSHA
19847 }
19848
19849
19850 func (w *WorkflowRun) GetHTMLURL() string {
19851 if w == nil || w.HTMLURL == nil {
19852 return ""
19853 }
19854 return *w.HTMLURL
19855 }
19856
19857
19858 func (w *WorkflowRun) GetID() int64 {
19859 if w == nil || w.ID == nil {
19860 return 0
19861 }
19862 return *w.ID
19863 }
19864
19865
19866 func (w *WorkflowRun) GetJobsURL() string {
19867 if w == nil || w.JobsURL == nil {
19868 return ""
19869 }
19870 return *w.JobsURL
19871 }
19872
19873
19874 func (w *WorkflowRun) GetLogsURL() string {
19875 if w == nil || w.LogsURL == nil {
19876 return ""
19877 }
19878 return *w.LogsURL
19879 }
19880
19881
19882 func (w *WorkflowRun) GetName() string {
19883 if w == nil || w.Name == nil {
19884 return ""
19885 }
19886 return *w.Name
19887 }
19888
19889
19890 func (w *WorkflowRun) GetNodeID() string {
19891 if w == nil || w.NodeID == nil {
19892 return ""
19893 }
19894 return *w.NodeID
19895 }
19896
19897
19898 func (w *WorkflowRun) GetPreviousAttemptURL() string {
19899 if w == nil || w.PreviousAttemptURL == nil {
19900 return ""
19901 }
19902 return *w.PreviousAttemptURL
19903 }
19904
19905
19906 func (w *WorkflowRun) GetRepository() *Repository {
19907 if w == nil {
19908 return nil
19909 }
19910 return w.Repository
19911 }
19912
19913
19914 func (w *WorkflowRun) GetRerunURL() string {
19915 if w == nil || w.RerunURL == nil {
19916 return ""
19917 }
19918 return *w.RerunURL
19919 }
19920
19921
19922 func (w *WorkflowRun) GetRunAttempt() int {
19923 if w == nil || w.RunAttempt == nil {
19924 return 0
19925 }
19926 return *w.RunAttempt
19927 }
19928
19929
19930 func (w *WorkflowRun) GetRunNumber() int {
19931 if w == nil || w.RunNumber == nil {
19932 return 0
19933 }
19934 return *w.RunNumber
19935 }
19936
19937
19938 func (w *WorkflowRun) GetRunStartedAt() Timestamp {
19939 if w == nil || w.RunStartedAt == nil {
19940 return Timestamp{}
19941 }
19942 return *w.RunStartedAt
19943 }
19944
19945
19946 func (w *WorkflowRun) GetStatus() string {
19947 if w == nil || w.Status == nil {
19948 return ""
19949 }
19950 return *w.Status
19951 }
19952
19953
19954 func (w *WorkflowRun) GetUpdatedAt() Timestamp {
19955 if w == nil || w.UpdatedAt == nil {
19956 return Timestamp{}
19957 }
19958 return *w.UpdatedAt
19959 }
19960
19961
19962 func (w *WorkflowRun) GetURL() string {
19963 if w == nil || w.URL == nil {
19964 return ""
19965 }
19966 return *w.URL
19967 }
19968
19969
19970 func (w *WorkflowRun) GetWorkflowID() int64 {
19971 if w == nil || w.WorkflowID == nil {
19972 return 0
19973 }
19974 return *w.WorkflowID
19975 }
19976
19977
19978 func (w *WorkflowRun) GetWorkflowURL() string {
19979 if w == nil || w.WorkflowURL == nil {
19980 return ""
19981 }
19982 return *w.WorkflowURL
19983 }
19984
19985
19986 func (w *WorkflowRunAttemptOptions) GetExcludePullRequests() bool {
19987 if w == nil || w.ExcludePullRequests == nil {
19988 return false
19989 }
19990 return *w.ExcludePullRequests
19991 }
19992
19993
19994 func (w *WorkflowRunBill) GetJobs() int {
19995 if w == nil || w.Jobs == nil {
19996 return 0
19997 }
19998 return *w.Jobs
19999 }
20000
20001
20002 func (w *WorkflowRunBill) GetTotalMS() int64 {
20003 if w == nil || w.TotalMS == nil {
20004 return 0
20005 }
20006 return *w.TotalMS
20007 }
20008
20009
20010 func (w *WorkflowRunEnvironment) GetMacOS() *WorkflowRunBill {
20011 if w == nil {
20012 return nil
20013 }
20014 return w.MacOS
20015 }
20016
20017
20018 func (w *WorkflowRunEnvironment) GetUbuntu() *WorkflowRunBill {
20019 if w == nil {
20020 return nil
20021 }
20022 return w.Ubuntu
20023 }
20024
20025
20026 func (w *WorkflowRunEnvironment) GetWindows() *WorkflowRunBill {
20027 if w == nil {
20028 return nil
20029 }
20030 return w.Windows
20031 }
20032
20033
20034 func (w *WorkflowRunEvent) GetAction() string {
20035 if w == nil || w.Action == nil {
20036 return ""
20037 }
20038 return *w.Action
20039 }
20040
20041
20042 func (w *WorkflowRunEvent) GetInstallation() *Installation {
20043 if w == nil {
20044 return nil
20045 }
20046 return w.Installation
20047 }
20048
20049
20050 func (w *WorkflowRunEvent) GetOrg() *Organization {
20051 if w == nil {
20052 return nil
20053 }
20054 return w.Org
20055 }
20056
20057
20058 func (w *WorkflowRunEvent) GetRepo() *Repository {
20059 if w == nil {
20060 return nil
20061 }
20062 return w.Repo
20063 }
20064
20065
20066 func (w *WorkflowRunEvent) GetSender() *User {
20067 if w == nil {
20068 return nil
20069 }
20070 return w.Sender
20071 }
20072
20073
20074 func (w *WorkflowRunEvent) GetWorkflow() *Workflow {
20075 if w == nil {
20076 return nil
20077 }
20078 return w.Workflow
20079 }
20080
20081
20082 func (w *WorkflowRunEvent) GetWorkflowRun() *WorkflowRun {
20083 if w == nil {
20084 return nil
20085 }
20086 return w.WorkflowRun
20087 }
20088
20089
20090 func (w *WorkflowRunJobRun) GetDurationMS() int64 {
20091 if w == nil || w.DurationMS == nil {
20092 return 0
20093 }
20094 return *w.DurationMS
20095 }
20096
20097
20098 func (w *WorkflowRunJobRun) GetJobID() int {
20099 if w == nil || w.JobID == nil {
20100 return 0
20101 }
20102 return *w.JobID
20103 }
20104
20105
20106 func (w *WorkflowRuns) GetTotalCount() int {
20107 if w == nil || w.TotalCount == nil {
20108 return 0
20109 }
20110 return *w.TotalCount
20111 }
20112
20113
20114 func (w *WorkflowRunUsage) GetBillable() *WorkflowRunEnvironment {
20115 if w == nil {
20116 return nil
20117 }
20118 return w.Billable
20119 }
20120
20121
20122 func (w *WorkflowRunUsage) GetRunDurationMS() int64 {
20123 if w == nil || w.RunDurationMS == nil {
20124 return 0
20125 }
20126 return *w.RunDurationMS
20127 }
20128
20129
20130 func (w *Workflows) GetTotalCount() int {
20131 if w == nil || w.TotalCount == nil {
20132 return 0
20133 }
20134 return *w.TotalCount
20135 }
20136
20137
20138 func (w *WorkflowUsage) GetBillable() *WorkflowEnvironment {
20139 if w == nil {
20140 return nil
20141 }
20142 return w.Billable
20143 }
20144
View as plain text