1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51 package clouddeploy
52
53 import (
54 "bytes"
55 "context"
56 "encoding/json"
57 "errors"
58 "fmt"
59 "io"
60 "net/http"
61 "net/url"
62 "strconv"
63 "strings"
64
65 googleapi "google.golang.org/api/googleapi"
66 internal "google.golang.org/api/internal"
67 gensupport "google.golang.org/api/internal/gensupport"
68 option "google.golang.org/api/option"
69 internaloption "google.golang.org/api/option/internaloption"
70 htransport "google.golang.org/api/transport/http"
71 )
72
73
74
75 var _ = bytes.NewBuffer
76 var _ = strconv.Itoa
77 var _ = fmt.Sprintf
78 var _ = json.NewDecoder
79 var _ = io.Copy
80 var _ = url.Parse
81 var _ = gensupport.MarshalJSON
82 var _ = googleapi.Version
83 var _ = errors.New
84 var _ = strings.Replace
85 var _ = context.Canceled
86 var _ = internaloption.WithDefaultEndpoint
87 var _ = internal.Version
88
89 const apiId = "clouddeploy:v1"
90 const apiName = "clouddeploy"
91 const apiVersion = "v1"
92 const basePath = "https://clouddeploy.googleapis.com/"
93 const basePathTemplate = "https://clouddeploy.UNIVERSE_DOMAIN/"
94 const mtlsBasePath = "https://clouddeploy.mtls.googleapis.com/"
95
96
97 const (
98
99
100 CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
101 )
102
103
104 func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
105 scopesOption := internaloption.WithDefaultScopes(
106 "https://www.googleapis.com/auth/cloud-platform",
107 )
108
109 opts = append([]option.ClientOption{scopesOption}, opts...)
110 opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
111 opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate))
112 opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
113 opts = append(opts, internaloption.EnableNewAuthLibrary())
114 client, endpoint, err := htransport.NewClient(ctx, opts...)
115 if err != nil {
116 return nil, err
117 }
118 s, err := New(client)
119 if err != nil {
120 return nil, err
121 }
122 if endpoint != "" {
123 s.BasePath = endpoint
124 }
125 return s, nil
126 }
127
128
129
130
131
132
133 func New(client *http.Client) (*Service, error) {
134 if client == nil {
135 return nil, errors.New("client is nil")
136 }
137 s := &Service{client: client, BasePath: basePath}
138 s.Projects = NewProjectsService(s)
139 return s, nil
140 }
141
142 type Service struct {
143 client *http.Client
144 BasePath string
145 UserAgent string
146
147 Projects *ProjectsService
148 }
149
150 func (s *Service) userAgent() string {
151 if s.UserAgent == "" {
152 return googleapi.UserAgent
153 }
154 return googleapi.UserAgent + " " + s.UserAgent
155 }
156
157 func NewProjectsService(s *Service) *ProjectsService {
158 rs := &ProjectsService{s: s}
159 rs.Locations = NewProjectsLocationsService(s)
160 return rs
161 }
162
163 type ProjectsService struct {
164 s *Service
165
166 Locations *ProjectsLocationsService
167 }
168
169 func NewProjectsLocationsService(s *Service) *ProjectsLocationsService {
170 rs := &ProjectsLocationsService{s: s}
171 rs.CustomTargetTypes = NewProjectsLocationsCustomTargetTypesService(s)
172 rs.DeliveryPipelines = NewProjectsLocationsDeliveryPipelinesService(s)
173 rs.Operations = NewProjectsLocationsOperationsService(s)
174 rs.Targets = NewProjectsLocationsTargetsService(s)
175 return rs
176 }
177
178 type ProjectsLocationsService struct {
179 s *Service
180
181 CustomTargetTypes *ProjectsLocationsCustomTargetTypesService
182
183 DeliveryPipelines *ProjectsLocationsDeliveryPipelinesService
184
185 Operations *ProjectsLocationsOperationsService
186
187 Targets *ProjectsLocationsTargetsService
188 }
189
190 func NewProjectsLocationsCustomTargetTypesService(s *Service) *ProjectsLocationsCustomTargetTypesService {
191 rs := &ProjectsLocationsCustomTargetTypesService{s: s}
192 return rs
193 }
194
195 type ProjectsLocationsCustomTargetTypesService struct {
196 s *Service
197 }
198
199 func NewProjectsLocationsDeliveryPipelinesService(s *Service) *ProjectsLocationsDeliveryPipelinesService {
200 rs := &ProjectsLocationsDeliveryPipelinesService{s: s}
201 rs.AutomationRuns = NewProjectsLocationsDeliveryPipelinesAutomationRunsService(s)
202 rs.Automations = NewProjectsLocationsDeliveryPipelinesAutomationsService(s)
203 rs.Releases = NewProjectsLocationsDeliveryPipelinesReleasesService(s)
204 return rs
205 }
206
207 type ProjectsLocationsDeliveryPipelinesService struct {
208 s *Service
209
210 AutomationRuns *ProjectsLocationsDeliveryPipelinesAutomationRunsService
211
212 Automations *ProjectsLocationsDeliveryPipelinesAutomationsService
213
214 Releases *ProjectsLocationsDeliveryPipelinesReleasesService
215 }
216
217 func NewProjectsLocationsDeliveryPipelinesAutomationRunsService(s *Service) *ProjectsLocationsDeliveryPipelinesAutomationRunsService {
218 rs := &ProjectsLocationsDeliveryPipelinesAutomationRunsService{s: s}
219 return rs
220 }
221
222 type ProjectsLocationsDeliveryPipelinesAutomationRunsService struct {
223 s *Service
224 }
225
226 func NewProjectsLocationsDeliveryPipelinesAutomationsService(s *Service) *ProjectsLocationsDeliveryPipelinesAutomationsService {
227 rs := &ProjectsLocationsDeliveryPipelinesAutomationsService{s: s}
228 return rs
229 }
230
231 type ProjectsLocationsDeliveryPipelinesAutomationsService struct {
232 s *Service
233 }
234
235 func NewProjectsLocationsDeliveryPipelinesReleasesService(s *Service) *ProjectsLocationsDeliveryPipelinesReleasesService {
236 rs := &ProjectsLocationsDeliveryPipelinesReleasesService{s: s}
237 rs.Rollouts = NewProjectsLocationsDeliveryPipelinesReleasesRolloutsService(s)
238 return rs
239 }
240
241 type ProjectsLocationsDeliveryPipelinesReleasesService struct {
242 s *Service
243
244 Rollouts *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService
245 }
246
247 func NewProjectsLocationsDeliveryPipelinesReleasesRolloutsService(s *Service) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService {
248 rs := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsService{s: s}
249 rs.JobRuns = NewProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService(s)
250 return rs
251 }
252
253 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsService struct {
254 s *Service
255
256 JobRuns *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService
257 }
258
259 func NewProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService(s *Service) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService {
260 rs := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService{s: s}
261 return rs
262 }
263
264 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService struct {
265 s *Service
266 }
267
268 func NewProjectsLocationsOperationsService(s *Service) *ProjectsLocationsOperationsService {
269 rs := &ProjectsLocationsOperationsService{s: s}
270 return rs
271 }
272
273 type ProjectsLocationsOperationsService struct {
274 s *Service
275 }
276
277 func NewProjectsLocationsTargetsService(s *Service) *ProjectsLocationsTargetsService {
278 rs := &ProjectsLocationsTargetsService{s: s}
279 return rs
280 }
281
282 type ProjectsLocationsTargetsService struct {
283 s *Service
284 }
285
286
287 type AbandonReleaseRequest struct {
288 }
289
290
291 type AbandonReleaseResponse struct {
292
293 googleapi.ServerResponse `json:"-"`
294 }
295
296
297 type AdvanceChildRolloutJob struct {
298 }
299
300
301
302 type AdvanceChildRolloutJobRun struct {
303
304
305
306 Rollout string `json:"rollout,omitempty"`
307
308 RolloutPhaseId string `json:"rolloutPhaseId,omitempty"`
309
310
311
312
313
314 ForceSendFields []string `json:"-"`
315
316
317
318
319 NullFields []string `json:"-"`
320 }
321
322 func (s *AdvanceChildRolloutJobRun) MarshalJSON() ([]byte, error) {
323 type NoMethod AdvanceChildRolloutJobRun
324 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
325 }
326
327
328
329 type AdvanceRolloutOperation struct {
330
331 DestinationPhase string `json:"destinationPhase,omitempty"`
332
333
334 Rollout string `json:"rollout,omitempty"`
335
336
337 SourcePhase string `json:"sourcePhase,omitempty"`
338
339 Wait string `json:"wait,omitempty"`
340
341
342
343
344
345 ForceSendFields []string `json:"-"`
346
347
348
349
350 NullFields []string `json:"-"`
351 }
352
353 func (s *AdvanceRolloutOperation) MarshalJSON() ([]byte, error) {
354 type NoMethod AdvanceRolloutOperation
355 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
356 }
357
358
359 type AdvanceRolloutRequest struct {
360
361 PhaseId string `json:"phaseId,omitempty"`
362
363
364
365
366
367 ForceSendFields []string `json:"-"`
368
369
370
371
372 NullFields []string `json:"-"`
373 }
374
375 func (s *AdvanceRolloutRequest) MarshalJSON() ([]byte, error) {
376 type NoMethod AdvanceRolloutRequest
377 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
378 }
379
380
381 type AdvanceRolloutResponse struct {
382
383 googleapi.ServerResponse `json:"-"`
384 }
385
386
387
388 type AdvanceRolloutRule struct {
389
390 Condition *AutomationRuleCondition `json:"condition,omitempty"`
391
392
393
394 Id string `json:"id,omitempty"`
395
396
397
398
399
400 SourcePhases []string `json:"sourcePhases,omitempty"`
401
402 Wait string `json:"wait,omitempty"`
403
404
405
406
407
408 ForceSendFields []string `json:"-"`
409
410
411
412
413 NullFields []string `json:"-"`
414 }
415
416 func (s *AdvanceRolloutRule) MarshalJSON() ([]byte, error) {
417 type NoMethod AdvanceRolloutRule
418 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
419 }
420
421
422 type AnthosCluster struct {
423
424
425
426 Membership string `json:"membership,omitempty"`
427
428
429
430
431
432 ForceSendFields []string `json:"-"`
433
434
435
436
437 NullFields []string `json:"-"`
438 }
439
440 func (s *AnthosCluster) MarshalJSON() ([]byte, error) {
441 type NoMethod AnthosCluster
442 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
443 }
444
445
446 type ApproveRolloutRequest struct {
447
448 Approved bool `json:"approved,omitempty"`
449
450
451
452
453
454 ForceSendFields []string `json:"-"`
455
456
457
458
459 NullFields []string `json:"-"`
460 }
461
462 func (s *ApproveRolloutRequest) MarshalJSON() ([]byte, error) {
463 type NoMethod ApproveRolloutRequest
464 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
465 }
466
467
468 type ApproveRolloutResponse struct {
469
470 googleapi.ServerResponse `json:"-"`
471 }
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489 type AuditConfig struct {
490
491 AuditLogConfigs []*AuditLogConfig `json:"auditLogConfigs,omitempty"`
492
493
494
495 Service string `json:"service,omitempty"`
496
497
498
499
500
501 ForceSendFields []string `json:"-"`
502
503
504
505
506 NullFields []string `json:"-"`
507 }
508
509 func (s *AuditConfig) MarshalJSON() ([]byte, error) {
510 type NoMethod AuditConfig
511 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
512 }
513
514
515
516
517
518
519 type AuditLogConfig struct {
520
521
522 ExemptedMembers []string `json:"exemptedMembers,omitempty"`
523
524
525
526
527
528
529
530 LogType string `json:"logType,omitempty"`
531
532
533
534
535
536 ForceSendFields []string `json:"-"`
537
538
539
540
541 NullFields []string `json:"-"`
542 }
543
544 func (s *AuditLogConfig) MarshalJSON() ([]byte, error) {
545 type NoMethod AuditLogConfig
546 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
547 }
548
549
550
551
552
553
554
555 type Automation struct {
556
557
558
559
560
561
562
563
564
565
566
567
568 Annotations map[string]string `json:"annotations,omitempty"`
569
570 CreateTime string `json:"createTime,omitempty"`
571
572
573 Description string `json:"description,omitempty"`
574
575
576
577
578 Etag string `json:"etag,omitempty"`
579
580
581
582
583
584
585
586
587 Labels map[string]string `json:"labels,omitempty"`
588
589
590
591 Name string `json:"name,omitempty"`
592
593
594
595
596 Rules []*AutomationRule `json:"rules,omitempty"`
597
598
599 Selector *AutomationResourceSelector `json:"selector,omitempty"`
600
601
602 ServiceAccount string `json:"serviceAccount,omitempty"`
603
604
605 Suspended bool `json:"suspended,omitempty"`
606
607 Uid string `json:"uid,omitempty"`
608
609 UpdateTime string `json:"updateTime,omitempty"`
610
611
612 googleapi.ServerResponse `json:"-"`
613
614
615
616
617
618 ForceSendFields []string `json:"-"`
619
620
621
622
623 NullFields []string `json:"-"`
624 }
625
626 func (s *Automation) MarshalJSON() ([]byte, error) {
627 type NoMethod Automation
628 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
629 }
630
631
632
633 type AutomationEvent struct {
634
635 Automation string `json:"automation,omitempty"`
636
637
638 Message string `json:"message,omitempty"`
639
640 PipelineUid string `json:"pipelineUid,omitempty"`
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655 Type string `json:"type,omitempty"`
656
657
658
659
660
661 ForceSendFields []string `json:"-"`
662
663
664
665
666 NullFields []string `json:"-"`
667 }
668
669 func (s *AutomationEvent) MarshalJSON() ([]byte, error) {
670 type NoMethod AutomationEvent
671 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
672 }
673
674
675
676
677 type AutomationResourceSelector struct {
678
679 Targets []*TargetAttribute `json:"targets,omitempty"`
680
681
682
683
684
685 ForceSendFields []string `json:"-"`
686
687
688
689
690 NullFields []string `json:"-"`
691 }
692
693 func (s *AutomationResourceSelector) MarshalJSON() ([]byte, error) {
694 type NoMethod AutomationResourceSelector
695 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
696 }
697
698
699
700 type AutomationRolloutMetadata struct {
701
702
703 AdvanceAutomationRuns []string `json:"advanceAutomationRuns,omitempty"`
704
705
706 CurrentRepairAutomationRun string `json:"currentRepairAutomationRun,omitempty"`
707
708
709 PromoteAutomationRun string `json:"promoteAutomationRun,omitempty"`
710
711
712 RepairAutomationRuns []string `json:"repairAutomationRuns,omitempty"`
713
714
715
716
717
718 ForceSendFields []string `json:"-"`
719
720
721
722
723 NullFields []string `json:"-"`
724 }
725
726 func (s *AutomationRolloutMetadata) MarshalJSON() ([]byte, error) {
727 type NoMethod AutomationRolloutMetadata
728 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
729 }
730
731
732 type AutomationRule struct {
733
734
735 AdvanceRolloutRule *AdvanceRolloutRule `json:"advanceRolloutRule,omitempty"`
736
737
738 PromoteReleaseRule *PromoteReleaseRule `json:"promoteReleaseRule,omitempty"`
739
740
741 RepairRolloutRule *RepairRolloutRule `json:"repairRolloutRule,omitempty"`
742
743
744
745
746
747 ForceSendFields []string `json:"-"`
748
749
750
751
752 NullFields []string `json:"-"`
753 }
754
755 func (s *AutomationRule) MarshalJSON() ([]byte, error) {
756 type NoMethod AutomationRule
757 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
758 }
759
760
761
762 type AutomationRuleCondition struct {
763
764
765 TargetsPresentCondition *TargetsPresentCondition `json:"targetsPresentCondition,omitempty"`
766
767
768
769
770
771 ForceSendFields []string `json:"-"`
772
773
774
775
776 NullFields []string `json:"-"`
777 }
778
779 func (s *AutomationRuleCondition) MarshalJSON() ([]byte, error) {
780 type NoMethod AutomationRuleCondition
781 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
782 }
783
784
785
786 type AutomationRun struct {
787
788 AdvanceRolloutOperation *AdvanceRolloutOperation `json:"advanceRolloutOperation,omitempty"`
789
790
791 AutomationId string `json:"automationId,omitempty"`
792
793
794 AutomationSnapshot *Automation `json:"automationSnapshot,omitempty"`
795
796 CreateTime string `json:"createTime,omitempty"`
797
798
799
800
801 Etag string `json:"etag,omitempty"`
802
803
804 ExpireTime string `json:"expireTime,omitempty"`
805
806
807
808 Name string `json:"name,omitempty"`
809
810
811 PromoteReleaseOperation *PromoteReleaseOperation `json:"promoteReleaseOperation,omitempty"`
812
813 RepairRolloutOperation *RepairRolloutOperation `json:"repairRolloutOperation,omitempty"`
814
815
816 RuleId string `json:"ruleId,omitempty"`
817
818
819 ServiceAccount string `json:"serviceAccount,omitempty"`
820
821
822
823
824
825
826
827
828
829
830 State string `json:"state,omitempty"`
831
832
833 StateDescription string `json:"stateDescription,omitempty"`
834
835
836
837 TargetId string `json:"targetId,omitempty"`
838
839 UpdateTime string `json:"updateTime,omitempty"`
840
841
842 WaitUntilTime string `json:"waitUntilTime,omitempty"`
843
844
845 googleapi.ServerResponse `json:"-"`
846
847
848
849
850
851 ForceSendFields []string `json:"-"`
852
853
854
855
856 NullFields []string `json:"-"`
857 }
858
859 func (s *AutomationRun) MarshalJSON() ([]byte, error) {
860 type NoMethod AutomationRun
861 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
862 }
863
864
865
866
867 type AutomationRunEvent struct {
868
869 AutomationId string `json:"automationId,omitempty"`
870
871 AutomationRun string `json:"automationRun,omitempty"`
872
873
874 DestinationTargetId string `json:"destinationTargetId,omitempty"`
875
876
877 Message string `json:"message,omitempty"`
878
879 PipelineUid string `json:"pipelineUid,omitempty"`
880
881 RuleId string `json:"ruleId,omitempty"`
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896 Type string `json:"type,omitempty"`
897
898
899
900
901
902 ForceSendFields []string `json:"-"`
903
904
905
906
907 NullFields []string `json:"-"`
908 }
909
910 func (s *AutomationRunEvent) MarshalJSON() ([]byte, error) {
911 type NoMethod AutomationRunEvent
912 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
913 }
914
915
916 type Binding struct {
917
918
919
920
921
922
923
924
925 Condition *Expr `json:"condition,omitempty"`
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988 Members []string `json:"members,omitempty"`
989
990
991
992
993
994
995 Role string `json:"role,omitempty"`
996
997
998
999
1000
1001 ForceSendFields []string `json:"-"`
1002
1003
1004
1005
1006 NullFields []string `json:"-"`
1007 }
1008
1009 func (s *Binding) MarshalJSON() ([]byte, error) {
1010 type NoMethod Binding
1011 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1012 }
1013
1014
1015 type BuildArtifact struct {
1016
1017 Image string `json:"image,omitempty"`
1018
1019
1020
1021 Tag string `json:"tag,omitempty"`
1022
1023
1024
1025
1026
1027 ForceSendFields []string `json:"-"`
1028
1029
1030
1031
1032 NullFields []string `json:"-"`
1033 }
1034
1035 func (s *BuildArtifact) MarshalJSON() ([]byte, error) {
1036 type NoMethod BuildArtifact
1037 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1038 }
1039
1040
1041 type Canary struct {
1042
1043 CanaryDeployment *CanaryDeployment `json:"canaryDeployment,omitempty"`
1044
1045
1046
1047 CustomCanaryDeployment *CustomCanaryDeployment `json:"customCanaryDeployment,omitempty"`
1048
1049
1050
1051 RuntimeConfig *RuntimeConfig `json:"runtimeConfig,omitempty"`
1052
1053
1054
1055
1056
1057 ForceSendFields []string `json:"-"`
1058
1059
1060
1061
1062 NullFields []string `json:"-"`
1063 }
1064
1065 func (s *Canary) MarshalJSON() ([]byte, error) {
1066 type NoMethod Canary
1067 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1068 }
1069
1070
1071
1072 type CanaryDeployment struct {
1073
1074
1075
1076 Percentages []int64 `json:"percentages,omitempty"`
1077
1078
1079
1080 Postdeploy *Postdeploy `json:"postdeploy,omitempty"`
1081
1082
1083 Predeploy *Predeploy `json:"predeploy,omitempty"`
1084
1085 Verify bool `json:"verify,omitempty"`
1086
1087
1088
1089
1090
1091 ForceSendFields []string `json:"-"`
1092
1093
1094
1095
1096 NullFields []string `json:"-"`
1097 }
1098
1099 func (s *CanaryDeployment) MarshalJSON() ([]byte, error) {
1100 type NoMethod CanaryDeployment
1101 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1102 }
1103
1104
1105
1106 type CancelAutomationRunRequest struct {
1107 }
1108
1109
1110 type CancelAutomationRunResponse struct {
1111
1112 googleapi.ServerResponse `json:"-"`
1113 }
1114
1115
1116 type CancelOperationRequest struct {
1117 }
1118
1119
1120 type CancelRolloutRequest struct {
1121 }
1122
1123
1124 type CancelRolloutResponse struct {
1125
1126 googleapi.ServerResponse `json:"-"`
1127 }
1128
1129
1130 type ChildRolloutJobs struct {
1131
1132 AdvanceRolloutJobs []*Job `json:"advanceRolloutJobs,omitempty"`
1133
1134 CreateRolloutJobs []*Job `json:"createRolloutJobs,omitempty"`
1135
1136
1137
1138
1139
1140 ForceSendFields []string `json:"-"`
1141
1142
1143
1144
1145 NullFields []string `json:"-"`
1146 }
1147
1148 func (s *ChildRolloutJobs) MarshalJSON() ([]byte, error) {
1149 type NoMethod ChildRolloutJobs
1150 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1151 }
1152
1153
1154 type CloudRunConfig struct {
1155
1156
1157
1158
1159 AutomaticTrafficControl bool `json:"automaticTrafficControl,omitempty"`
1160
1161
1162 CanaryRevisionTags []string `json:"canaryRevisionTags,omitempty"`
1163
1164
1165 PriorRevisionTags []string `json:"priorRevisionTags,omitempty"`
1166
1167
1168 StableRevisionTags []string `json:"stableRevisionTags,omitempty"`
1169
1170
1171
1172
1173
1174 ForceSendFields []string `json:"-"`
1175
1176
1177
1178
1179 NullFields []string `json:"-"`
1180 }
1181
1182 func (s *CloudRunConfig) MarshalJSON() ([]byte, error) {
1183 type NoMethod CloudRunConfig
1184 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1185 }
1186
1187
1188
1189 type CloudRunLocation struct {
1190
1191
1192 Location string `json:"location,omitempty"`
1193
1194
1195
1196
1197
1198 ForceSendFields []string `json:"-"`
1199
1200
1201
1202
1203 NullFields []string `json:"-"`
1204 }
1205
1206 func (s *CloudRunLocation) MarshalJSON() ([]byte, error) {
1207 type NoMethod CloudRunLocation
1208 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1209 }
1210
1211
1212
1213 type CloudRunMetadata struct {
1214
1215
1216
1217 Job string `json:"job,omitempty"`
1218
1219
1220 Revision string `json:"revision,omitempty"`
1221
1222
1223
1224 Service string `json:"service,omitempty"`
1225
1226
1227 ServiceUrls []string `json:"serviceUrls,omitempty"`
1228
1229
1230
1231
1232
1233 ForceSendFields []string `json:"-"`
1234
1235
1236
1237
1238 NullFields []string `json:"-"`
1239 }
1240
1241 func (s *CloudRunMetadata) MarshalJSON() ([]byte, error) {
1242 type NoMethod CloudRunMetadata
1243 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1244 }
1245
1246
1247
1248 type CloudRunRenderMetadata struct {
1249
1250
1251
1252 Service string `json:"service,omitempty"`
1253
1254
1255
1256
1257
1258 ForceSendFields []string `json:"-"`
1259
1260
1261
1262
1263 NullFields []string `json:"-"`
1264 }
1265
1266 func (s *CloudRunRenderMetadata) MarshalJSON() ([]byte, error) {
1267 type NoMethod CloudRunRenderMetadata
1268 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1269 }
1270
1271
1272 type Config struct {
1273
1274
1275 DefaultSkaffoldVersion string `json:"defaultSkaffoldVersion,omitempty"`
1276
1277 Name string `json:"name,omitempty"`
1278
1279 SupportedVersions []*SkaffoldVersion `json:"supportedVersions,omitempty"`
1280
1281
1282 googleapi.ServerResponse `json:"-"`
1283
1284
1285
1286
1287
1288 ForceSendFields []string `json:"-"`
1289
1290
1291
1292
1293 NullFields []string `json:"-"`
1294 }
1295
1296 func (s *Config) MarshalJSON() ([]byte, error) {
1297 type NoMethod Config
1298 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1299 }
1300
1301
1302 type CreateChildRolloutJob struct {
1303 }
1304
1305
1306
1307 type CreateChildRolloutJobRun struct {
1308
1309
1310
1311 Rollout string `json:"rollout,omitempty"`
1312
1313
1314 RolloutPhaseId string `json:"rolloutPhaseId,omitempty"`
1315
1316
1317
1318
1319
1320 ForceSendFields []string `json:"-"`
1321
1322
1323
1324
1325 NullFields []string `json:"-"`
1326 }
1327
1328 func (s *CreateChildRolloutJobRun) MarshalJSON() ([]byte, error) {
1329 type NoMethod CreateChildRolloutJobRun
1330 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1331 }
1332
1333
1334
1335 type CustomCanaryDeployment struct {
1336
1337
1338 PhaseConfigs []*PhaseConfig `json:"phaseConfigs,omitempty"`
1339
1340
1341
1342
1343
1344 ForceSendFields []string `json:"-"`
1345
1346
1347
1348
1349 NullFields []string `json:"-"`
1350 }
1351
1352 func (s *CustomCanaryDeployment) MarshalJSON() ([]byte, error) {
1353 type NoMethod CustomCanaryDeployment
1354 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1355 }
1356
1357
1358
1359 type CustomMetadata struct {
1360
1361 Values map[string]string `json:"values,omitempty"`
1362
1363
1364
1365
1366
1367 ForceSendFields []string `json:"-"`
1368
1369
1370
1371
1372 NullFields []string `json:"-"`
1373 }
1374
1375 func (s *CustomMetadata) MarshalJSON() ([]byte, error) {
1376 type NoMethod CustomMetadata
1377 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1378 }
1379
1380
1381 type CustomTarget struct {
1382
1383
1384
1385 CustomTargetType string `json:"customTargetType,omitempty"`
1386
1387
1388
1389
1390
1391 ForceSendFields []string `json:"-"`
1392
1393
1394
1395
1396 NullFields []string `json:"-"`
1397 }
1398
1399 func (s *CustomTarget) MarshalJSON() ([]byte, error) {
1400 type NoMethod CustomTarget
1401 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1402 }
1403
1404
1405
1406 type CustomTargetDeployMetadata struct {
1407
1408
1409 SkipMessage string `json:"skipMessage,omitempty"`
1410
1411
1412
1413
1414
1415 ForceSendFields []string `json:"-"`
1416
1417
1418
1419
1420 NullFields []string `json:"-"`
1421 }
1422
1423 func (s *CustomTargetDeployMetadata) MarshalJSON() ([]byte, error) {
1424 type NoMethod CustomTargetDeployMetadata
1425 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1426 }
1427
1428
1429
1430 type CustomTargetSkaffoldActions struct {
1431
1432
1433 DeployAction string `json:"deployAction,omitempty"`
1434
1435
1436 IncludeSkaffoldModules []*SkaffoldModules `json:"includeSkaffoldModules,omitempty"`
1437
1438
1439
1440 RenderAction string `json:"renderAction,omitempty"`
1441
1442
1443
1444
1445
1446 ForceSendFields []string `json:"-"`
1447
1448
1449
1450
1451 NullFields []string `json:"-"`
1452 }
1453
1454 func (s *CustomTargetSkaffoldActions) MarshalJSON() ([]byte, error) {
1455 type NoMethod CustomTargetSkaffoldActions
1456 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1457 }
1458
1459
1460
1461
1462
1463 type CustomTargetType struct {
1464
1465
1466
1467
1468 Annotations map[string]string `json:"annotations,omitempty"`
1469
1470 CreateTime string `json:"createTime,omitempty"`
1471
1472
1473 CustomActions *CustomTargetSkaffoldActions `json:"customActions,omitempty"`
1474
1475 CustomTargetTypeId string `json:"customTargetTypeId,omitempty"`
1476
1477
1478 Description string `json:"description,omitempty"`
1479
1480
1481
1482 Etag string `json:"etag,omitempty"`
1483
1484
1485
1486
1487
1488
1489
1490
1491 Labels map[string]string `json:"labels,omitempty"`
1492
1493
1494
1495
1496 Name string `json:"name,omitempty"`
1497
1498 Uid string `json:"uid,omitempty"`
1499
1500
1501 UpdateTime string `json:"updateTime,omitempty"`
1502
1503
1504 googleapi.ServerResponse `json:"-"`
1505
1506
1507
1508
1509
1510 ForceSendFields []string `json:"-"`
1511
1512
1513
1514
1515 NullFields []string `json:"-"`
1516 }
1517
1518 func (s *CustomTargetType) MarshalJSON() ([]byte, error) {
1519 type NoMethod CustomTargetType
1520 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1521 }
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532 type Date struct {
1533
1534
1535
1536 Day int64 `json:"day,omitempty"`
1537
1538
1539 Month int64 `json:"month,omitempty"`
1540
1541
1542 Year int64 `json:"year,omitempty"`
1543
1544
1545
1546
1547
1548 ForceSendFields []string `json:"-"`
1549
1550
1551
1552
1553 NullFields []string `json:"-"`
1554 }
1555
1556 func (s *Date) MarshalJSON() ([]byte, error) {
1557 type NoMethod Date
1558 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1559 }
1560
1561
1562 type DefaultPool struct {
1563
1564
1565
1566
1567 ArtifactStorage string `json:"artifactStorage,omitempty"`
1568
1569
1570
1571 ServiceAccount string `json:"serviceAccount,omitempty"`
1572
1573
1574
1575
1576
1577 ForceSendFields []string `json:"-"`
1578
1579
1580
1581
1582 NullFields []string `json:"-"`
1583 }
1584
1585 func (s *DefaultPool) MarshalJSON() ([]byte, error) {
1586 type NoMethod DefaultPool
1587 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1588 }
1589
1590
1591
1592
1593 type DeliveryPipeline struct {
1594
1595
1596 Annotations map[string]string `json:"annotations,omitempty"`
1597
1598
1599 Condition *PipelineCondition `json:"condition,omitempty"`
1600
1601 CreateTime string `json:"createTime,omitempty"`
1602
1603
1604 Description string `json:"description,omitempty"`
1605
1606
1607
1608 Etag string `json:"etag,omitempty"`
1609
1610
1611
1612
1613
1614
1615
1616
1617 Labels map[string]string `json:"labels,omitempty"`
1618
1619
1620
1621
1622 Name string `json:"name,omitempty"`
1623
1624
1625 SerialPipeline *SerialPipeline `json:"serialPipeline,omitempty"`
1626
1627
1628 Suspended bool `json:"suspended,omitempty"`
1629
1630 Uid string `json:"uid,omitempty"`
1631
1632 UpdateTime string `json:"updateTime,omitempty"`
1633
1634
1635 googleapi.ServerResponse `json:"-"`
1636
1637
1638
1639
1640
1641 ForceSendFields []string `json:"-"`
1642
1643
1644
1645
1646 NullFields []string `json:"-"`
1647 }
1648
1649 func (s *DeliveryPipeline) MarshalJSON() ([]byte, error) {
1650 type NoMethod DeliveryPipeline
1651 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1652 }
1653
1654
1655
1656
1657
1658 type DeliveryPipelineNotificationEvent struct {
1659
1660 DeliveryPipeline string `json:"deliveryPipeline,omitempty"`
1661
1662 Message string `json:"message,omitempty"`
1663
1664 PipelineUid string `json:"pipelineUid,omitempty"`
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679 Type string `json:"type,omitempty"`
1680
1681
1682
1683
1684
1685 ForceSendFields []string `json:"-"`
1686
1687
1688
1689
1690 NullFields []string `json:"-"`
1691 }
1692
1693 func (s *DeliveryPipelineNotificationEvent) MarshalJSON() ([]byte, error) {
1694 type NoMethod DeliveryPipelineNotificationEvent
1695 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1696 }
1697
1698
1699 type DeployArtifact struct {
1700
1701
1702 ArtifactUri string `json:"artifactUri,omitempty"`
1703
1704
1705 ManifestPaths []string `json:"manifestPaths,omitempty"`
1706
1707
1708
1709
1710
1711 ForceSendFields []string `json:"-"`
1712
1713
1714
1715
1716 NullFields []string `json:"-"`
1717 }
1718
1719 func (s *DeployArtifact) MarshalJSON() ([]byte, error) {
1720 type NoMethod DeployArtifact
1721 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1722 }
1723
1724
1725 type DeployJob struct {
1726 }
1727
1728
1729
1730 type DeployJobRun struct {
1731
1732 Artifact *DeployArtifact `json:"artifact,omitempty"`
1733
1734
1735
1736 Build string `json:"build,omitempty"`
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758 FailureCause string `json:"failureCause,omitempty"`
1759
1760
1761 FailureMessage string `json:"failureMessage,omitempty"`
1762
1763
1764 Metadata *DeployJobRunMetadata `json:"metadata,omitempty"`
1765
1766
1767
1768
1769
1770 ForceSendFields []string `json:"-"`
1771
1772
1773
1774
1775 NullFields []string `json:"-"`
1776 }
1777
1778 func (s *DeployJobRun) MarshalJSON() ([]byte, error) {
1779 type NoMethod DeployJobRun
1780 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1781 }
1782
1783
1784
1785 type DeployJobRunMetadata struct {
1786
1787
1788 CloudRun *CloudRunMetadata `json:"cloudRun,omitempty"`
1789
1790
1791 Custom *CustomMetadata `json:"custom,omitempty"`
1792
1793
1794 CustomTarget *CustomTargetDeployMetadata `json:"customTarget,omitempty"`
1795
1796
1797
1798
1799
1800 ForceSendFields []string `json:"-"`
1801
1802
1803
1804
1805 NullFields []string `json:"-"`
1806 }
1807
1808 func (s *DeployJobRunMetadata) MarshalJSON() ([]byte, error) {
1809 type NoMethod DeployJobRunMetadata
1810 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1811 }
1812
1813
1814 type DeployParameters struct {
1815
1816
1817
1818 MatchTargetLabels map[string]string `json:"matchTargetLabels,omitempty"`
1819
1820 Values map[string]string `json:"values,omitempty"`
1821
1822
1823
1824
1825
1826 ForceSendFields []string `json:"-"`
1827
1828
1829
1830
1831 NullFields []string `json:"-"`
1832 }
1833
1834 func (s *DeployParameters) MarshalJSON() ([]byte, error) {
1835 type NoMethod DeployParameters
1836 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1837 }
1838
1839
1840 type DeploymentJobs struct {
1841
1842 DeployJob *Job `json:"deployJob,omitempty"`
1843
1844
1845 PostdeployJob *Job `json:"postdeployJob,omitempty"`
1846
1847
1848 PredeployJob *Job `json:"predeployJob,omitempty"`
1849
1850
1851 VerifyJob *Job `json:"verifyJob,omitempty"`
1852
1853
1854
1855
1856
1857 ForceSendFields []string `json:"-"`
1858
1859
1860
1861
1862 NullFields []string `json:"-"`
1863 }
1864
1865 func (s *DeploymentJobs) MarshalJSON() ([]byte, error) {
1866 type NoMethod DeploymentJobs
1867 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1868 }
1869
1870
1871
1872
1873
1874 type Empty struct {
1875
1876 googleapi.ServerResponse `json:"-"`
1877 }
1878
1879
1880
1881 type ExecutionConfig struct {
1882
1883
1884
1885
1886 ArtifactStorage string `json:"artifactStorage,omitempty"`
1887
1888 DefaultPool *DefaultPool `json:"defaultPool,omitempty"`
1889
1890
1891
1892 ExecutionTimeout string `json:"executionTimeout,omitempty"`
1893
1894 PrivatePool *PrivatePool `json:"privatePool,omitempty"`
1895
1896
1897
1898 ServiceAccount string `json:"serviceAccount,omitempty"`
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909 Usages []string `json:"usages,omitempty"`
1910
1911
1912
1913 WorkerPool string `json:"workerPool,omitempty"`
1914
1915
1916
1917
1918
1919 ForceSendFields []string `json:"-"`
1920
1921
1922
1923
1924 NullFields []string `json:"-"`
1925 }
1926
1927 func (s *ExecutionConfig) MarshalJSON() ([]byte, error) {
1928 type NoMethod ExecutionConfig
1929 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1930 }
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948 type Expr struct {
1949
1950
1951 Description string `json:"description,omitempty"`
1952
1953
1954 Expression string `json:"expression,omitempty"`
1955
1956
1957 Location string `json:"location,omitempty"`
1958
1959
1960
1961 Title string `json:"title,omitempty"`
1962
1963
1964
1965
1966
1967 ForceSendFields []string `json:"-"`
1968
1969
1970
1971
1972 NullFields []string `json:"-"`
1973 }
1974
1975 func (s *Expr) MarshalJSON() ([]byte, error) {
1976 type NoMethod Expr
1977 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1978 }
1979
1980
1981
1982 type GatewayServiceMesh struct {
1983
1984
1985 Deployment string `json:"deployment,omitempty"`
1986
1987 HttpRoute string `json:"httpRoute,omitempty"`
1988
1989
1990
1991 RouteUpdateWaitTime string `json:"routeUpdateWaitTime,omitempty"`
1992
1993 Service string `json:"service,omitempty"`
1994
1995
1996
1997
1998 StableCutbackDuration string `json:"stableCutbackDuration,omitempty"`
1999
2000
2001
2002
2003
2004 ForceSendFields []string `json:"-"`
2005
2006
2007
2008
2009 NullFields []string `json:"-"`
2010 }
2011
2012 func (s *GatewayServiceMesh) MarshalJSON() ([]byte, error) {
2013 type NoMethod GatewayServiceMesh
2014 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2015 }
2016
2017
2018 type GkeCluster struct {
2019
2020
2021 Cluster string `json:"cluster,omitempty"`
2022
2023
2024
2025
2026
2027
2028
2029 InternalIp bool `json:"internalIp,omitempty"`
2030
2031
2032
2033
2034
2035 ForceSendFields []string `json:"-"`
2036
2037
2038
2039
2040 NullFields []string `json:"-"`
2041 }
2042
2043 func (s *GkeCluster) MarshalJSON() ([]byte, error) {
2044 type NoMethod GkeCluster
2045 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2046 }
2047
2048
2049 type IgnoreJobRequest struct {
2050
2051 JobId string `json:"jobId,omitempty"`
2052
2053 PhaseId string `json:"phaseId,omitempty"`
2054
2055
2056
2057
2058
2059 ForceSendFields []string `json:"-"`
2060
2061
2062
2063
2064 NullFields []string `json:"-"`
2065 }
2066
2067 func (s *IgnoreJobRequest) MarshalJSON() ([]byte, error) {
2068 type NoMethod IgnoreJobRequest
2069 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2070 }
2071
2072
2073 type IgnoreJobResponse struct {
2074
2075 googleapi.ServerResponse `json:"-"`
2076 }
2077
2078
2079 type Job struct {
2080
2081 AdvanceChildRolloutJob *AdvanceChildRolloutJob `json:"advanceChildRolloutJob,omitempty"`
2082
2083 CreateChildRolloutJob *CreateChildRolloutJob `json:"createChildRolloutJob,omitempty"`
2084
2085 DeployJob *DeployJob `json:"deployJob,omitempty"`
2086
2087 Id string `json:"id,omitempty"`
2088
2089
2090 JobRun string `json:"jobRun,omitempty"`
2091
2092 PostdeployJob *PostdeployJob `json:"postdeployJob,omitempty"`
2093
2094 PredeployJob *PredeployJob `json:"predeployJob,omitempty"`
2095
2096
2097 SkipMessage string `json:"skipMessage,omitempty"`
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111 State string `json:"state,omitempty"`
2112
2113 VerifyJob *VerifyJob `json:"verifyJob,omitempty"`
2114
2115
2116
2117
2118
2119 ForceSendFields []string `json:"-"`
2120
2121
2122
2123
2124 NullFields []string `json:"-"`
2125 }
2126
2127 func (s *Job) MarshalJSON() ([]byte, error) {
2128 type NoMethod Job
2129 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2130 }
2131
2132
2133
2134 type JobRun struct {
2135
2136
2137 AdvanceChildRolloutJobRun *AdvanceChildRolloutJobRun `json:"advanceChildRolloutJobRun,omitempty"`
2138
2139
2140 CreateChildRolloutJobRun *CreateChildRolloutJobRun `json:"createChildRolloutJobRun,omitempty"`
2141
2142 CreateTime string `json:"createTime,omitempty"`
2143
2144 DeployJobRun *DeployJobRun `json:"deployJobRun,omitempty"`
2145
2146 EndTime string `json:"endTime,omitempty"`
2147
2148
2149
2150 Etag string `json:"etag,omitempty"`
2151
2152 JobId string `json:"jobId,omitempty"`
2153
2154
2155
2156 Name string `json:"name,omitempty"`
2157
2158 PhaseId string `json:"phaseId,omitempty"`
2159
2160
2161 PostdeployJobRun *PostdeployJobRun `json:"postdeployJobRun,omitempty"`
2162
2163 PredeployJobRun *PredeployJobRun `json:"predeployJobRun,omitempty"`
2164
2165 StartTime string `json:"startTime,omitempty"`
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175 State string `json:"state,omitempty"`
2176
2177 Uid string `json:"uid,omitempty"`
2178
2179 VerifyJobRun *VerifyJobRun `json:"verifyJobRun,omitempty"`
2180
2181
2182 googleapi.ServerResponse `json:"-"`
2183
2184
2185
2186
2187
2188 ForceSendFields []string `json:"-"`
2189
2190
2191
2192
2193 NullFields []string `json:"-"`
2194 }
2195
2196 func (s *JobRun) MarshalJSON() ([]byte, error) {
2197 type NoMethod JobRun
2198 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2199 }
2200
2201
2202
2203
2204 type JobRunNotificationEvent struct {
2205
2206 JobRun string `json:"jobRun,omitempty"`
2207
2208 Message string `json:"message,omitempty"`
2209
2210 PipelineUid string `json:"pipelineUid,omitempty"`
2211
2212 Release string `json:"release,omitempty"`
2213
2214 ReleaseUid string `json:"releaseUid,omitempty"`
2215
2216 Rollout string `json:"rollout,omitempty"`
2217
2218 RolloutUid string `json:"rolloutUid,omitempty"`
2219
2220 TargetId string `json:"targetId,omitempty"`
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235 Type string `json:"type,omitempty"`
2236
2237
2238
2239
2240
2241 ForceSendFields []string `json:"-"`
2242
2243
2244
2245
2246 NullFields []string `json:"-"`
2247 }
2248
2249 func (s *JobRunNotificationEvent) MarshalJSON() ([]byte, error) {
2250 type NoMethod JobRunNotificationEvent
2251 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2252 }
2253
2254
2255
2256 type KubernetesConfig struct {
2257
2258 GatewayServiceMesh *GatewayServiceMesh `json:"gatewayServiceMesh,omitempty"`
2259
2260 ServiceNetworking *ServiceNetworking `json:"serviceNetworking,omitempty"`
2261
2262
2263
2264
2265
2266 ForceSendFields []string `json:"-"`
2267
2268
2269
2270
2271 NullFields []string `json:"-"`
2272 }
2273
2274 func (s *KubernetesConfig) MarshalJSON() ([]byte, error) {
2275 type NoMethod KubernetesConfig
2276 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2277 }
2278
2279
2280 type ListAutomationRunsResponse struct {
2281
2282 AutomationRuns []*AutomationRun `json:"automationRuns,omitempty"`
2283
2284
2285 NextPageToken string `json:"nextPageToken,omitempty"`
2286
2287 Unreachable []string `json:"unreachable,omitempty"`
2288
2289
2290 googleapi.ServerResponse `json:"-"`
2291
2292
2293
2294
2295
2296 ForceSendFields []string `json:"-"`
2297
2298
2299
2300
2301 NullFields []string `json:"-"`
2302 }
2303
2304 func (s *ListAutomationRunsResponse) MarshalJSON() ([]byte, error) {
2305 type NoMethod ListAutomationRunsResponse
2306 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2307 }
2308
2309
2310 type ListAutomationsResponse struct {
2311
2312 Automations []*Automation `json:"automations,omitempty"`
2313
2314
2315 NextPageToken string `json:"nextPageToken,omitempty"`
2316
2317 Unreachable []string `json:"unreachable,omitempty"`
2318
2319
2320 googleapi.ServerResponse `json:"-"`
2321
2322
2323
2324
2325
2326 ForceSendFields []string `json:"-"`
2327
2328
2329
2330
2331 NullFields []string `json:"-"`
2332 }
2333
2334 func (s *ListAutomationsResponse) MarshalJSON() ([]byte, error) {
2335 type NoMethod ListAutomationsResponse
2336 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2337 }
2338
2339
2340
2341 type ListCustomTargetTypesResponse struct {
2342
2343 CustomTargetTypes []*CustomTargetType `json:"customTargetTypes,omitempty"`
2344
2345
2346 NextPageToken string `json:"nextPageToken,omitempty"`
2347
2348 Unreachable []string `json:"unreachable,omitempty"`
2349
2350
2351 googleapi.ServerResponse `json:"-"`
2352
2353
2354
2355
2356
2357 ForceSendFields []string `json:"-"`
2358
2359
2360
2361
2362 NullFields []string `json:"-"`
2363 }
2364
2365 func (s *ListCustomTargetTypesResponse) MarshalJSON() ([]byte, error) {
2366 type NoMethod ListCustomTargetTypesResponse
2367 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2368 }
2369
2370
2371
2372 type ListDeliveryPipelinesResponse struct {
2373
2374 DeliveryPipelines []*DeliveryPipeline `json:"deliveryPipelines,omitempty"`
2375
2376
2377 NextPageToken string `json:"nextPageToken,omitempty"`
2378
2379 Unreachable []string `json:"unreachable,omitempty"`
2380
2381
2382 googleapi.ServerResponse `json:"-"`
2383
2384
2385
2386
2387
2388 ForceSendFields []string `json:"-"`
2389
2390
2391
2392
2393 NullFields []string `json:"-"`
2394 }
2395
2396 func (s *ListDeliveryPipelinesResponse) MarshalJSON() ([]byte, error) {
2397 type NoMethod ListDeliveryPipelinesResponse
2398 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2399 }
2400
2401
2402
2403 type ListJobRunsResponse struct {
2404
2405 JobRuns []*JobRun `json:"jobRuns,omitempty"`
2406
2407
2408 NextPageToken string `json:"nextPageToken,omitempty"`
2409
2410 Unreachable []string `json:"unreachable,omitempty"`
2411
2412
2413 googleapi.ServerResponse `json:"-"`
2414
2415
2416
2417
2418
2419 ForceSendFields []string `json:"-"`
2420
2421
2422
2423
2424 NullFields []string `json:"-"`
2425 }
2426
2427 func (s *ListJobRunsResponse) MarshalJSON() ([]byte, error) {
2428 type NoMethod ListJobRunsResponse
2429 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2430 }
2431
2432
2433 type ListLocationsResponse struct {
2434
2435
2436 Locations []*Location `json:"locations,omitempty"`
2437
2438 NextPageToken string `json:"nextPageToken,omitempty"`
2439
2440
2441 googleapi.ServerResponse `json:"-"`
2442
2443
2444
2445
2446
2447 ForceSendFields []string `json:"-"`
2448
2449
2450
2451
2452 NullFields []string `json:"-"`
2453 }
2454
2455 func (s *ListLocationsResponse) MarshalJSON() ([]byte, error) {
2456 type NoMethod ListLocationsResponse
2457 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2458 }
2459
2460
2461 type ListOperationsResponse struct {
2462
2463 NextPageToken string `json:"nextPageToken,omitempty"`
2464
2465
2466 Operations []*Operation `json:"operations,omitempty"`
2467
2468
2469 googleapi.ServerResponse `json:"-"`
2470
2471
2472
2473
2474
2475 ForceSendFields []string `json:"-"`
2476
2477
2478
2479
2480 NullFields []string `json:"-"`
2481 }
2482
2483 func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) {
2484 type NoMethod ListOperationsResponse
2485 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2486 }
2487
2488
2489 type ListReleasesResponse struct {
2490
2491
2492 NextPageToken string `json:"nextPageToken,omitempty"`
2493
2494 Releases []*Release `json:"releases,omitempty"`
2495
2496 Unreachable []string `json:"unreachable,omitempty"`
2497
2498
2499 googleapi.ServerResponse `json:"-"`
2500
2501
2502
2503
2504
2505 ForceSendFields []string `json:"-"`
2506
2507
2508
2509
2510 NullFields []string `json:"-"`
2511 }
2512
2513 func (s *ListReleasesResponse) MarshalJSON() ([]byte, error) {
2514 type NoMethod ListReleasesResponse
2515 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2516 }
2517
2518
2519
2520 type ListRolloutsResponse struct {
2521
2522
2523 NextPageToken string `json:"nextPageToken,omitempty"`
2524
2525 Rollouts []*Rollout `json:"rollouts,omitempty"`
2526
2527 Unreachable []string `json:"unreachable,omitempty"`
2528
2529
2530 googleapi.ServerResponse `json:"-"`
2531
2532
2533
2534
2535
2536 ForceSendFields []string `json:"-"`
2537
2538
2539
2540
2541 NullFields []string `json:"-"`
2542 }
2543
2544 func (s *ListRolloutsResponse) MarshalJSON() ([]byte, error) {
2545 type NoMethod ListRolloutsResponse
2546 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2547 }
2548
2549
2550 type ListTargetsResponse struct {
2551
2552
2553 NextPageToken string `json:"nextPageToken,omitempty"`
2554
2555 Targets []*Target `json:"targets,omitempty"`
2556
2557 Unreachable []string `json:"unreachable,omitempty"`
2558
2559
2560 googleapi.ServerResponse `json:"-"`
2561
2562
2563
2564
2565
2566 ForceSendFields []string `json:"-"`
2567
2568
2569
2570
2571 NullFields []string `json:"-"`
2572 }
2573
2574 func (s *ListTargetsResponse) MarshalJSON() ([]byte, error) {
2575 type NoMethod ListTargetsResponse
2576 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2577 }
2578
2579
2580 type Location struct {
2581
2582
2583 DisplayName string `json:"displayName,omitempty"`
2584
2585
2586 Labels map[string]string `json:"labels,omitempty"`
2587
2588 LocationId string `json:"locationId,omitempty"`
2589
2590
2591 Metadata googleapi.RawMessage `json:"metadata,omitempty"`
2592
2593
2594
2595 Name string `json:"name,omitempty"`
2596
2597
2598 googleapi.ServerResponse `json:"-"`
2599
2600
2601
2602
2603
2604 ForceSendFields []string `json:"-"`
2605
2606
2607
2608
2609 NullFields []string `json:"-"`
2610 }
2611
2612 func (s *Location) MarshalJSON() ([]byte, error) {
2613 type NoMethod Location
2614 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2615 }
2616
2617
2618 type Metadata struct {
2619
2620
2621 Automation *AutomationRolloutMetadata `json:"automation,omitempty"`
2622
2623
2624 CloudRun *CloudRunMetadata `json:"cloudRun,omitempty"`
2625
2626
2627 Custom *CustomMetadata `json:"custom,omitempty"`
2628
2629
2630
2631
2632
2633 ForceSendFields []string `json:"-"`
2634
2635
2636
2637
2638 NullFields []string `json:"-"`
2639 }
2640
2641 func (s *Metadata) MarshalJSON() ([]byte, error) {
2642 type NoMethod Metadata
2643 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2644 }
2645
2646
2647 type MultiTarget struct {
2648
2649 TargetIds []string `json:"targetIds,omitempty"`
2650
2651
2652
2653
2654
2655 ForceSendFields []string `json:"-"`
2656
2657
2658
2659
2660 NullFields []string `json:"-"`
2661 }
2662
2663 func (s *MultiTarget) MarshalJSON() ([]byte, error) {
2664 type NoMethod MultiTarget
2665 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2666 }
2667
2668
2669
2670 type Operation struct {
2671
2672
2673
2674 Done bool `json:"done,omitempty"`
2675
2676 Error *Status `json:"error,omitempty"`
2677
2678
2679
2680
2681 Metadata googleapi.RawMessage `json:"metadata,omitempty"`
2682
2683
2684
2685 Name string `json:"name,omitempty"`
2686
2687
2688
2689
2690
2691
2692
2693 Response googleapi.RawMessage `json:"response,omitempty"`
2694
2695
2696 googleapi.ServerResponse `json:"-"`
2697
2698
2699
2700
2701
2702 ForceSendFields []string `json:"-"`
2703
2704
2705
2706
2707 NullFields []string `json:"-"`
2708 }
2709
2710 func (s *Operation) MarshalJSON() ([]byte, error) {
2711 type NoMethod Operation
2712 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2713 }
2714
2715
2716 type OperationMetadata struct {
2717
2718 ApiVersion string `json:"apiVersion,omitempty"`
2719
2720 CreateTime string `json:"createTime,omitempty"`
2721
2722 EndTime string `json:"endTime,omitempty"`
2723
2724
2725
2726
2727 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
2728
2729 StatusMessage string `json:"statusMessage,omitempty"`
2730
2731
2732 Target string `json:"target,omitempty"`
2733
2734 Verb string `json:"verb,omitempty"`
2735
2736
2737
2738
2739
2740 ForceSendFields []string `json:"-"`
2741
2742
2743
2744
2745 NullFields []string `json:"-"`
2746 }
2747
2748 func (s *OperationMetadata) MarshalJSON() ([]byte, error) {
2749 type NoMethod OperationMetadata
2750 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2751 }
2752
2753
2754
2755 type Phase struct {
2756
2757 ChildRolloutJobs *ChildRolloutJobs `json:"childRolloutJobs,omitempty"`
2758
2759 DeploymentJobs *DeploymentJobs `json:"deploymentJobs,omitempty"`
2760
2761 Id string `json:"id,omitempty"`
2762
2763
2764 SkipMessage string `json:"skipMessage,omitempty"`
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775 State string `json:"state,omitempty"`
2776
2777
2778
2779
2780
2781 ForceSendFields []string `json:"-"`
2782
2783
2784
2785
2786 NullFields []string `json:"-"`
2787 }
2788
2789 func (s *Phase) MarshalJSON() ([]byte, error) {
2790 type NoMethod Phase
2791 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2792 }
2793
2794
2795
2796 type PhaseArtifact struct {
2797
2798
2799 JobManifestsPath string `json:"jobManifestsPath,omitempty"`
2800
2801
2802 ManifestPath string `json:"manifestPath,omitempty"`
2803
2804
2805 SkaffoldConfigPath string `json:"skaffoldConfigPath,omitempty"`
2806
2807
2808
2809
2810
2811 ForceSendFields []string `json:"-"`
2812
2813
2814
2815
2816 NullFields []string `json:"-"`
2817 }
2818
2819 func (s *PhaseArtifact) MarshalJSON() ([]byte, error) {
2820 type NoMethod PhaseArtifact
2821 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2822 }
2823
2824
2825
2826 type PhaseConfig struct {
2827
2828 Percentage int64 `json:"percentage,omitempty"`
2829
2830
2831
2832
2833
2834 PhaseId string `json:"phaseId,omitempty"`
2835
2836
2837 Postdeploy *Postdeploy `json:"postdeploy,omitempty"`
2838
2839
2840 Predeploy *Predeploy `json:"predeploy,omitempty"`
2841
2842
2843
2844 Profiles []string `json:"profiles,omitempty"`
2845
2846 Verify bool `json:"verify,omitempty"`
2847
2848
2849
2850
2851
2852 ForceSendFields []string `json:"-"`
2853
2854
2855
2856
2857 NullFields []string `json:"-"`
2858 }
2859
2860 func (s *PhaseConfig) MarshalJSON() ([]byte, error) {
2861 type NoMethod PhaseConfig
2862 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2863 }
2864
2865
2866
2867 type PipelineCondition struct {
2868
2869 PipelineReadyCondition *PipelineReadyCondition `json:"pipelineReadyCondition,omitempty"`
2870
2871 TargetsPresentCondition *TargetsPresentCondition `json:"targetsPresentCondition,omitempty"`
2872
2873
2874 TargetsTypeCondition *TargetsTypeCondition `json:"targetsTypeCondition,omitempty"`
2875
2876
2877
2878
2879
2880 ForceSendFields []string `json:"-"`
2881
2882
2883
2884
2885 NullFields []string `json:"-"`
2886 }
2887
2888 func (s *PipelineCondition) MarshalJSON() ([]byte, error) {
2889 type NoMethod PipelineCondition
2890 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2891 }
2892
2893
2894
2895 type PipelineReadyCondition struct {
2896
2897
2898
2899
2900 Status bool `json:"status,omitempty"`
2901
2902 UpdateTime string `json:"updateTime,omitempty"`
2903
2904
2905
2906
2907
2908 ForceSendFields []string `json:"-"`
2909
2910
2911
2912
2913 NullFields []string `json:"-"`
2914 }
2915
2916 func (s *PipelineReadyCondition) MarshalJSON() ([]byte, error) {
2917 type NoMethod PipelineReadyCondition
2918 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2919 }
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951 type Policy struct {
2952
2953 AuditConfigs []*AuditConfig `json:"auditConfigs,omitempty"`
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963 Bindings []*Binding `json:"bindings,omitempty"`
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975 Etag string `json:"etag,omitempty"`
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991 Version int64 `json:"version,omitempty"`
2992
2993
2994 googleapi.ServerResponse `json:"-"`
2995
2996
2997
2998
2999
3000 ForceSendFields []string `json:"-"`
3001
3002
3003
3004
3005 NullFields []string `json:"-"`
3006 }
3007
3008 func (s *Policy) MarshalJSON() ([]byte, error) {
3009 type NoMethod Policy
3010 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3011 }
3012
3013
3014
3015 type Postdeploy struct {
3016
3017
3018 Actions []string `json:"actions,omitempty"`
3019
3020
3021
3022
3023
3024 ForceSendFields []string `json:"-"`
3025
3026
3027
3028
3029 NullFields []string `json:"-"`
3030 }
3031
3032 func (s *Postdeploy) MarshalJSON() ([]byte, error) {
3033 type NoMethod Postdeploy
3034 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3035 }
3036
3037
3038 type PostdeployJob struct {
3039
3040 Actions []string `json:"actions,omitempty"`
3041
3042
3043
3044
3045
3046 ForceSendFields []string `json:"-"`
3047
3048
3049
3050
3051 NullFields []string `json:"-"`
3052 }
3053
3054 func (s *PostdeployJob) MarshalJSON() ([]byte, error) {
3055 type NoMethod PostdeployJob
3056 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3057 }
3058
3059
3060
3061 type PostdeployJobRun struct {
3062
3063
3064
3065 Build string `json:"build,omitempty"`
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083 FailureCause string `json:"failureCause,omitempty"`
3084
3085
3086 FailureMessage string `json:"failureMessage,omitempty"`
3087
3088
3089
3090
3091
3092 ForceSendFields []string `json:"-"`
3093
3094
3095
3096
3097 NullFields []string `json:"-"`
3098 }
3099
3100 func (s *PostdeployJobRun) MarshalJSON() ([]byte, error) {
3101 type NoMethod PostdeployJobRun
3102 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3103 }
3104
3105
3106 type Predeploy struct {
3107
3108
3109 Actions []string `json:"actions,omitempty"`
3110
3111
3112
3113
3114
3115 ForceSendFields []string `json:"-"`
3116
3117
3118
3119
3120 NullFields []string `json:"-"`
3121 }
3122
3123 func (s *Predeploy) MarshalJSON() ([]byte, error) {
3124 type NoMethod Predeploy
3125 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3126 }
3127
3128
3129 type PredeployJob struct {
3130
3131 Actions []string `json:"actions,omitempty"`
3132
3133
3134
3135
3136
3137 ForceSendFields []string `json:"-"`
3138
3139
3140
3141
3142 NullFields []string `json:"-"`
3143 }
3144
3145 func (s *PredeployJob) MarshalJSON() ([]byte, error) {
3146 type NoMethod PredeployJob
3147 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3148 }
3149
3150
3151
3152 type PredeployJobRun struct {
3153
3154
3155
3156 Build string `json:"build,omitempty"`
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173 FailureCause string `json:"failureCause,omitempty"`
3174
3175
3176 FailureMessage string `json:"failureMessage,omitempty"`
3177
3178
3179
3180
3181
3182 ForceSendFields []string `json:"-"`
3183
3184
3185
3186
3187 NullFields []string `json:"-"`
3188 }
3189
3190 func (s *PredeployJobRun) MarshalJSON() ([]byte, error) {
3191 type NoMethod PredeployJobRun
3192 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3193 }
3194
3195
3196 type PrivatePool struct {
3197
3198
3199
3200
3201 ArtifactStorage string `json:"artifactStorage,omitempty"`
3202
3203
3204
3205 ServiceAccount string `json:"serviceAccount,omitempty"`
3206
3207
3208 WorkerPool string `json:"workerPool,omitempty"`
3209
3210
3211
3212
3213
3214 ForceSendFields []string `json:"-"`
3215
3216
3217
3218
3219 NullFields []string `json:"-"`
3220 }
3221
3222 func (s *PrivatePool) MarshalJSON() ([]byte, error) {
3223 type NoMethod PrivatePool
3224 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3225 }
3226
3227
3228
3229 type PromoteReleaseOperation struct {
3230
3231
3232 Phase string `json:"phase,omitempty"`
3233
3234
3235 Rollout string `json:"rollout,omitempty"`
3236
3237
3238
3239 TargetId string `json:"targetId,omitempty"`
3240
3241 Wait string `json:"wait,omitempty"`
3242
3243
3244
3245
3246
3247 ForceSendFields []string `json:"-"`
3248
3249
3250
3251
3252 NullFields []string `json:"-"`
3253 }
3254
3255 func (s *PromoteReleaseOperation) MarshalJSON() ([]byte, error) {
3256 type NoMethod PromoteReleaseOperation
3257 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3258 }
3259
3260
3261
3262 type PromoteReleaseRule struct {
3263
3264 Condition *AutomationRuleCondition `json:"condition,omitempty"`
3265
3266
3267 DestinationPhase string `json:"destinationPhase,omitempty"`
3268
3269
3270
3271
3272
3273
3274 DestinationTargetId string `json:"destinationTargetId,omitempty"`
3275
3276
3277
3278 Id string `json:"id,omitempty"`
3279
3280
3281 Wait string `json:"wait,omitempty"`
3282
3283
3284
3285
3286
3287 ForceSendFields []string `json:"-"`
3288
3289
3290
3291
3292 NullFields []string `json:"-"`
3293 }
3294
3295 func (s *PromoteReleaseRule) MarshalJSON() ([]byte, error) {
3296 type NoMethod PromoteReleaseRule
3297 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3298 }
3299
3300
3301
3302 type Release struct {
3303
3304 Abandoned bool `json:"abandoned,omitempty"`
3305
3306
3307
3308
3309 Annotations map[string]string `json:"annotations,omitempty"`
3310
3311 BuildArtifacts []*BuildArtifact `json:"buildArtifacts,omitempty"`
3312
3313 Condition *ReleaseCondition `json:"condition,omitempty"`
3314
3315 CreateTime string `json:"createTime,omitempty"`
3316
3317
3318 CustomTargetTypeSnapshots []*CustomTargetType `json:"customTargetTypeSnapshots,omitempty"`
3319
3320
3321 DeliveryPipelineSnapshot *DeliveryPipeline `json:"deliveryPipelineSnapshot,omitempty"`
3322
3323
3324 DeployParameters map[string]string `json:"deployParameters,omitempty"`
3325
3326 Description string `json:"description,omitempty"`
3327
3328
3329
3330 Etag string `json:"etag,omitempty"`
3331
3332
3333
3334
3335
3336
3337
3338
3339 Labels map[string]string `json:"labels,omitempty"`
3340
3341
3342
3343
3344 Name string `json:"name,omitempty"`
3345
3346 RenderEndTime string `json:"renderEndTime,omitempty"`
3347
3348 RenderStartTime string `json:"renderStartTime,omitempty"`
3349
3350
3351
3352
3353
3354
3355
3356
3357 RenderState string `json:"renderState,omitempty"`
3358
3359
3360 SkaffoldConfigPath string `json:"skaffoldConfigPath,omitempty"`
3361
3362
3363 SkaffoldConfigUri string `json:"skaffoldConfigUri,omitempty"`
3364
3365
3366
3367
3368 SkaffoldVersion string `json:"skaffoldVersion,omitempty"`
3369
3370
3371 TargetArtifacts map[string]TargetArtifact `json:"targetArtifacts,omitempty"`
3372
3373
3374 TargetRenders map[string]TargetRender `json:"targetRenders,omitempty"`
3375
3376
3377 TargetSnapshots []*Target `json:"targetSnapshots,omitempty"`
3378
3379 Uid string `json:"uid,omitempty"`
3380
3381
3382 googleapi.ServerResponse `json:"-"`
3383
3384
3385
3386
3387
3388 ForceSendFields []string `json:"-"`
3389
3390
3391
3392
3393 NullFields []string `json:"-"`
3394 }
3395
3396 func (s *Release) MarshalJSON() ([]byte, error) {
3397 type NoMethod Release
3398 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3399 }
3400
3401
3402
3403 type ReleaseCondition struct {
3404
3405 ReleaseReadyCondition *ReleaseReadyCondition `json:"releaseReadyCondition,omitempty"`
3406
3407
3408 SkaffoldSupportedCondition *SkaffoldSupportedCondition `json:"skaffoldSupportedCondition,omitempty"`
3409
3410
3411
3412
3413
3414 ForceSendFields []string `json:"-"`
3415
3416
3417
3418
3419 NullFields []string `json:"-"`
3420 }
3421
3422 func (s *ReleaseCondition) MarshalJSON() ([]byte, error) {
3423 type NoMethod ReleaseCondition
3424 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3425 }
3426
3427
3428
3429
3430 type ReleaseNotificationEvent struct {
3431
3432 Message string `json:"message,omitempty"`
3433
3434 PipelineUid string `json:"pipelineUid,omitempty"`
3435
3436 Release string `json:"release,omitempty"`
3437
3438 ReleaseUid string `json:"releaseUid,omitempty"`
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453 Type string `json:"type,omitempty"`
3454
3455
3456
3457
3458
3459 ForceSendFields []string `json:"-"`
3460
3461
3462
3463
3464 NullFields []string `json:"-"`
3465 }
3466
3467 func (s *ReleaseNotificationEvent) MarshalJSON() ([]byte, error) {
3468 type NoMethod ReleaseNotificationEvent
3469 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3470 }
3471
3472
3473
3474
3475 type ReleaseReadyCondition struct {
3476
3477
3478
3479
3480 Status bool `json:"status,omitempty"`
3481
3482
3483
3484
3485
3486 ForceSendFields []string `json:"-"`
3487
3488
3489
3490
3491 NullFields []string `json:"-"`
3492 }
3493
3494 func (s *ReleaseReadyCondition) MarshalJSON() ([]byte, error) {
3495 type NoMethod ReleaseReadyCondition
3496 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3497 }
3498
3499
3500
3501
3502 type ReleaseRenderEvent struct {
3503
3504
3505 Message string `json:"message,omitempty"`
3506
3507 PipelineUid string `json:"pipelineUid,omitempty"`
3508
3509
3510
3511 Release string `json:"release,omitempty"`
3512
3513
3514
3515
3516
3517
3518
3519
3520 ReleaseRenderState string `json:"releaseRenderState,omitempty"`
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535
3536 Type string `json:"type,omitempty"`
3537
3538
3539
3540
3541
3542 ForceSendFields []string `json:"-"`
3543
3544
3545
3546
3547 NullFields []string `json:"-"`
3548 }
3549
3550 func (s *ReleaseRenderEvent) MarshalJSON() ([]byte, error) {
3551 type NoMethod ReleaseRenderEvent
3552 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3553 }
3554
3555
3556
3557 type RenderMetadata struct {
3558
3559 CloudRun *CloudRunRenderMetadata `json:"cloudRun,omitempty"`
3560
3561
3562 Custom *CustomMetadata `json:"custom,omitempty"`
3563
3564
3565
3566
3567
3568 ForceSendFields []string `json:"-"`
3569
3570
3571
3572
3573 NullFields []string `json:"-"`
3574 }
3575
3576 func (s *RenderMetadata) MarshalJSON() ([]byte, error) {
3577 type NoMethod RenderMetadata
3578 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3579 }
3580
3581
3582 type RepairMode struct {
3583
3584 Retry *Retry `json:"retry,omitempty"`
3585
3586 Rollback *Rollback `json:"rollback,omitempty"`
3587
3588
3589
3590
3591
3592 ForceSendFields []string `json:"-"`
3593
3594
3595
3596
3597 NullFields []string `json:"-"`
3598 }
3599
3600 func (s *RepairMode) MarshalJSON() ([]byte, error) {
3601 type NoMethod RepairMode
3602 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3603 }
3604
3605
3606
3607 type RepairPhase struct {
3608
3609 Retry *RetryPhase `json:"retry,omitempty"`
3610
3611 Rollback *RollbackAttempt `json:"rollback,omitempty"`
3612
3613
3614
3615
3616
3617 ForceSendFields []string `json:"-"`
3618
3619
3620
3621
3622 NullFields []string `json:"-"`
3623 }
3624
3625 func (s *RepairPhase) MarshalJSON() ([]byte, error) {
3626 type NoMethod RepairPhase
3627 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3628 }
3629
3630
3631
3632 type RepairRolloutOperation struct {
3633
3634
3635 CurrentRepairModeIndex int64 `json:"currentRepairModeIndex,omitempty,string"`
3636
3637 JobId string `json:"jobId,omitempty"`
3638
3639
3640 PhaseId string `json:"phaseId,omitempty"`
3641
3642
3643 RepairPhases []*RepairPhase `json:"repairPhases,omitempty"`
3644
3645
3646 Rollout string `json:"rollout,omitempty"`
3647
3648
3649
3650
3651
3652 ForceSendFields []string `json:"-"`
3653
3654
3655
3656
3657 NullFields []string `json:"-"`
3658 }
3659
3660 func (s *RepairRolloutOperation) MarshalJSON() ([]byte, error) {
3661 type NoMethod RepairRolloutOperation
3662 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3663 }
3664
3665
3666
3667 type RepairRolloutRule struct {
3668
3669
3670 Condition *AutomationRuleCondition `json:"condition,omitempty"`
3671
3672
3673
3674 Id string `json:"id,omitempty"`
3675
3676
3677
3678
3679
3680
3681
3682 Jobs []string `json:"jobs,omitempty"`
3683
3684
3685 RepairModes []*RepairMode `json:"repairModes,omitempty"`
3686
3687
3688
3689
3690
3691
3692 SourcePhases []string `json:"sourcePhases,omitempty"`
3693
3694
3695
3696
3697
3698 ForceSendFields []string `json:"-"`
3699
3700
3701
3702
3703 NullFields []string `json:"-"`
3704 }
3705
3706 func (s *RepairRolloutRule) MarshalJSON() ([]byte, error) {
3707 type NoMethod RepairRolloutRule
3708 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3709 }
3710
3711
3712 type Retry struct {
3713
3714
3715 Attempts int64 `json:"attempts,omitempty,string"`
3716
3717
3718
3719
3720
3721
3722
3723 BackoffMode string `json:"backoffMode,omitempty"`
3724
3725
3726 Wait string `json:"wait,omitempty"`
3727
3728
3729
3730
3731
3732 ForceSendFields []string `json:"-"`
3733
3734
3735
3736
3737 NullFields []string `json:"-"`
3738 }
3739
3740 func (s *Retry) MarshalJSON() ([]byte, error) {
3741 type NoMethod Retry
3742 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3743 }
3744
3745
3746
3747 type RetryAttempt struct {
3748
3749 Attempt int64 `json:"attempt,omitempty,string"`
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761 State string `json:"state,omitempty"`
3762
3763 StateDesc string `json:"stateDesc,omitempty"`
3764
3765 Wait string `json:"wait,omitempty"`
3766
3767
3768
3769
3770
3771 ForceSendFields []string `json:"-"`
3772
3773
3774
3775
3776 NullFields []string `json:"-"`
3777 }
3778
3779 func (s *RetryAttempt) MarshalJSON() ([]byte, error) {
3780 type NoMethod RetryAttempt
3781 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3782 }
3783
3784
3785 type RetryJobRequest struct {
3786
3787 JobId string `json:"jobId,omitempty"`
3788
3789 PhaseId string `json:"phaseId,omitempty"`
3790
3791
3792
3793
3794
3795 ForceSendFields []string `json:"-"`
3796
3797
3798
3799
3800 NullFields []string `json:"-"`
3801 }
3802
3803 func (s *RetryJobRequest) MarshalJSON() ([]byte, error) {
3804 type NoMethod RetryJobRequest
3805 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3806 }
3807
3808
3809 type RetryJobResponse struct {
3810
3811 googleapi.ServerResponse `json:"-"`
3812 }
3813
3814
3815
3816 type RetryPhase struct {
3817
3818 Attempts []*RetryAttempt `json:"attempts,omitempty"`
3819
3820
3821
3822
3823
3824
3825
3826 BackoffMode string `json:"backoffMode,omitempty"`
3827
3828 JobId string `json:"jobId,omitempty"`
3829
3830
3831 PhaseId string `json:"phaseId,omitempty"`
3832
3833 TotalAttempts int64 `json:"totalAttempts,omitempty,string"`
3834
3835
3836
3837
3838
3839 ForceSendFields []string `json:"-"`
3840
3841
3842
3843
3844 NullFields []string `json:"-"`
3845 }
3846
3847 func (s *RetryPhase) MarshalJSON() ([]byte, error) {
3848 type NoMethod RetryPhase
3849 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3850 }
3851
3852
3853 type Rollback struct {
3854
3855
3856 DestinationPhase string `json:"destinationPhase,omitempty"`
3857
3858
3859
3860
3861
3862 ForceSendFields []string `json:"-"`
3863
3864
3865
3866
3867 NullFields []string `json:"-"`
3868 }
3869
3870 func (s *Rollback) MarshalJSON() ([]byte, error) {
3871 type NoMethod Rollback
3872 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3873 }
3874
3875
3876
3877 type RollbackAttempt struct {
3878
3879
3880 DestinationPhase string `json:"destinationPhase,omitempty"`
3881
3882 RolloutId string `json:"rolloutId,omitempty"`
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894 State string `json:"state,omitempty"`
3895
3896 StateDesc string `json:"stateDesc,omitempty"`
3897
3898
3899
3900
3901
3902 ForceSendFields []string `json:"-"`
3903
3904
3905
3906
3907 NullFields []string `json:"-"`
3908 }
3909
3910 func (s *RollbackAttempt) MarshalJSON() ([]byte, error) {
3911 type NoMethod RollbackAttempt
3912 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3913 }
3914
3915
3916 type RollbackTargetConfig struct {
3917
3918 Rollout *Rollout `json:"rollout,omitempty"`
3919
3920
3921 StartingPhaseId string `json:"startingPhaseId,omitempty"`
3922
3923
3924
3925
3926
3927 ForceSendFields []string `json:"-"`
3928
3929
3930
3931
3932 NullFields []string `json:"-"`
3933 }
3934
3935 func (s *RollbackTargetConfig) MarshalJSON() ([]byte, error) {
3936 type NoMethod RollbackTargetConfig
3937 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3938 }
3939
3940
3941 type RollbackTargetRequest struct {
3942
3943
3944
3945 ReleaseId string `json:"releaseId,omitempty"`
3946
3947 RollbackConfig *RollbackTargetConfig `json:"rollbackConfig,omitempty"`
3948
3949 RolloutId string `json:"rolloutId,omitempty"`
3950
3951
3952 RolloutToRollBack string `json:"rolloutToRollBack,omitempty"`
3953
3954 TargetId string `json:"targetId,omitempty"`
3955
3956
3957 ValidateOnly bool `json:"validateOnly,omitempty"`
3958
3959
3960
3961
3962
3963 ForceSendFields []string `json:"-"`
3964
3965
3966
3967
3968 NullFields []string `json:"-"`
3969 }
3970
3971 func (s *RollbackTargetRequest) MarshalJSON() ([]byte, error) {
3972 type NoMethod RollbackTargetRequest
3973 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3974 }
3975
3976
3977 type RollbackTargetResponse struct {
3978
3979
3980 RollbackConfig *RollbackTargetConfig `json:"rollbackConfig,omitempty"`
3981
3982
3983 googleapi.ServerResponse `json:"-"`
3984
3985
3986
3987
3988
3989 ForceSendFields []string `json:"-"`
3990
3991
3992
3993
3994 NullFields []string `json:"-"`
3995 }
3996
3997 func (s *RollbackTargetResponse) MarshalJSON() ([]byte, error) {
3998 type NoMethod RollbackTargetResponse
3999 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4000 }
4001
4002
4003
4004 type Rollout struct {
4005
4006
4007
4008
4009 Annotations map[string]string `json:"annotations,omitempty"`
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019 ApprovalState string `json:"approvalState,omitempty"`
4020
4021 ApproveTime string `json:"approveTime,omitempty"`
4022
4023
4024
4025 ControllerRollout string `json:"controllerRollout,omitempty"`
4026
4027 CreateTime string `json:"createTime,omitempty"`
4028
4029 DeployEndTime string `json:"deployEndTime,omitempty"`
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051 DeployFailureCause string `json:"deployFailureCause,omitempty"`
4052
4053 DeployStartTime string `json:"deployStartTime,omitempty"`
4054
4055
4056
4057 DeployingBuild string `json:"deployingBuild,omitempty"`
4058
4059
4060 Description string `json:"description,omitempty"`
4061
4062 EnqueueTime string `json:"enqueueTime,omitempty"`
4063
4064
4065
4066 Etag string `json:"etag,omitempty"`
4067
4068
4069 FailureReason string `json:"failureReason,omitempty"`
4070
4071
4072
4073
4074
4075
4076
4077
4078 Labels map[string]string `json:"labels,omitempty"`
4079
4080 Metadata *Metadata `json:"metadata,omitempty"`
4081
4082
4083
4084
4085 Name string `json:"name,omitempty"`
4086
4087
4088 Phases []*Phase `json:"phases,omitempty"`
4089
4090
4091 RollbackOfRollout string `json:"rollbackOfRollout,omitempty"`
4092
4093
4094 RolledBackByRollouts []string `json:"rolledBackByRollouts,omitempty"`
4095
4096
4097
4098
4099
4100
4101
4102
4103
4104
4105
4106
4107
4108
4109
4110
4111 State string `json:"state,omitempty"`
4112
4113 TargetId string `json:"targetId,omitempty"`
4114
4115 Uid string `json:"uid,omitempty"`
4116
4117
4118 googleapi.ServerResponse `json:"-"`
4119
4120
4121
4122
4123
4124 ForceSendFields []string `json:"-"`
4125
4126
4127
4128
4129 NullFields []string `json:"-"`
4130 }
4131
4132 func (s *Rollout) MarshalJSON() ([]byte, error) {
4133 type NoMethod Rollout
4134 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4135 }
4136
4137
4138
4139
4140 type RolloutNotificationEvent struct {
4141
4142 Message string `json:"message,omitempty"`
4143
4144 PipelineUid string `json:"pipelineUid,omitempty"`
4145
4146 Release string `json:"release,omitempty"`
4147
4148 ReleaseUid string `json:"releaseUid,omitempty"`
4149
4150 Rollout string `json:"rollout,omitempty"`
4151
4152 RolloutUid string `json:"rolloutUid,omitempty"`
4153
4154 TargetId string `json:"targetId,omitempty"`
4155
4156
4157
4158
4159
4160
4161
4162
4163
4164
4165
4166
4167
4168
4169 Type string `json:"type,omitempty"`
4170
4171
4172
4173
4174
4175 ForceSendFields []string `json:"-"`
4176
4177
4178
4179
4180 NullFields []string `json:"-"`
4181 }
4182
4183 func (s *RolloutNotificationEvent) MarshalJSON() ([]byte, error) {
4184 type NoMethod RolloutNotificationEvent
4185 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4186 }
4187
4188
4189
4190
4191 type RolloutUpdateEvent struct {
4192
4193 Message string `json:"message,omitempty"`
4194
4195 PipelineUid string `json:"pipelineUid,omitempty"`
4196
4197 Release string `json:"release,omitempty"`
4198
4199 ReleaseUid string `json:"releaseUid,omitempty"`
4200
4201
4202
4203 Rollout string `json:"rollout,omitempty"`
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221 RolloutUpdateType string `json:"rolloutUpdateType,omitempty"`
4222
4223 TargetId string `json:"targetId,omitempty"`
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238 Type string `json:"type,omitempty"`
4239
4240
4241
4242
4243
4244 ForceSendFields []string `json:"-"`
4245
4246
4247
4248
4249 NullFields []string `json:"-"`
4250 }
4251
4252 func (s *RolloutUpdateEvent) MarshalJSON() ([]byte, error) {
4253 type NoMethod RolloutUpdateEvent
4254 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4255 }
4256
4257
4258
4259 type RuntimeConfig struct {
4260
4261 CloudRun *CloudRunConfig `json:"cloudRun,omitempty"`
4262
4263 Kubernetes *KubernetesConfig `json:"kubernetes,omitempty"`
4264
4265
4266
4267
4268
4269 ForceSendFields []string `json:"-"`
4270
4271
4272
4273
4274 NullFields []string `json:"-"`
4275 }
4276
4277 func (s *RuntimeConfig) MarshalJSON() ([]byte, error) {
4278 type NoMethod RuntimeConfig
4279 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4280 }
4281
4282
4283
4284 type SerialPipeline struct {
4285
4286
4287 Stages []*Stage `json:"stages,omitempty"`
4288
4289
4290
4291
4292
4293 ForceSendFields []string `json:"-"`
4294
4295
4296
4297
4298 NullFields []string `json:"-"`
4299 }
4300
4301 func (s *SerialPipeline) MarshalJSON() ([]byte, error) {
4302 type NoMethod SerialPipeline
4303 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4304 }
4305
4306
4307
4308 type ServiceNetworking struct {
4309
4310
4311 Deployment string `json:"deployment,omitempty"`
4312
4313
4314
4315
4316 DisablePodOverprovisioning bool `json:"disablePodOverprovisioning,omitempty"`
4317
4318 Service string `json:"service,omitempty"`
4319
4320
4321
4322
4323
4324 ForceSendFields []string `json:"-"`
4325
4326
4327
4328
4329 NullFields []string `json:"-"`
4330 }
4331
4332 func (s *ServiceNetworking) MarshalJSON() ([]byte, error) {
4333 type NoMethod ServiceNetworking
4334 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4335 }
4336
4337
4338 type SetIamPolicyRequest struct {
4339
4340
4341
4342
4343 Policy *Policy `json:"policy,omitempty"`
4344
4345
4346
4347 UpdateMask string `json:"updateMask,omitempty"`
4348
4349
4350
4351
4352
4353 ForceSendFields []string `json:"-"`
4354
4355
4356
4357
4358 NullFields []string `json:"-"`
4359 }
4360
4361 func (s *SetIamPolicyRequest) MarshalJSON() ([]byte, error) {
4362 type NoMethod SetIamPolicyRequest
4363 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4364 }
4365
4366
4367
4368 type SkaffoldGCBRepoSource struct {
4369
4370
4371 Path string `json:"path,omitempty"`
4372
4373 Ref string `json:"ref,omitempty"`
4374
4375
4376
4377 Repository string `json:"repository,omitempty"`
4378
4379
4380
4381
4382
4383 ForceSendFields []string `json:"-"`
4384
4385
4386
4387
4388 NullFields []string `json:"-"`
4389 }
4390
4391 func (s *SkaffoldGCBRepoSource) MarshalJSON() ([]byte, error) {
4392 type NoMethod SkaffoldGCBRepoSource
4393 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4394 }
4395
4396
4397 type SkaffoldGCSSource struct {
4398
4399 Path string `json:"path,omitempty"`
4400
4401
4402
4403
4404 Source string `json:"source,omitempty"`
4405
4406
4407
4408
4409
4410 ForceSendFields []string `json:"-"`
4411
4412
4413
4414
4415 NullFields []string `json:"-"`
4416 }
4417
4418 func (s *SkaffoldGCSSource) MarshalJSON() ([]byte, error) {
4419 type NoMethod SkaffoldGCSSource
4420 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4421 }
4422
4423
4424 type SkaffoldGitSource struct {
4425
4426 Path string `json:"path,omitempty"`
4427
4428 Ref string `json:"ref,omitempty"`
4429
4430 Repo string `json:"repo,omitempty"`
4431
4432
4433
4434
4435
4436 ForceSendFields []string `json:"-"`
4437
4438
4439
4440
4441 NullFields []string `json:"-"`
4442 }
4443
4444 func (s *SkaffoldGitSource) MarshalJSON() ([]byte, error) {
4445 type NoMethod SkaffoldGitSource
4446 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4447 }
4448
4449
4450 type SkaffoldModules struct {
4451
4452
4453 Configs []string `json:"configs,omitempty"`
4454
4455 Git *SkaffoldGitSource `json:"git,omitempty"`
4456
4457
4458 GoogleCloudBuildRepo *SkaffoldGCBRepoSource `json:"googleCloudBuildRepo,omitempty"`
4459
4460
4461 GoogleCloudStorage *SkaffoldGCSSource `json:"googleCloudStorage,omitempty"`
4462
4463
4464
4465
4466
4467 ForceSendFields []string `json:"-"`
4468
4469
4470
4471
4472 NullFields []string `json:"-"`
4473 }
4474
4475 func (s *SkaffoldModules) MarshalJSON() ([]byte, error) {
4476 type NoMethod SkaffoldModules
4477 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4478 }
4479
4480
4481
4482 type SkaffoldSupportedCondition struct {
4483
4484
4485 MaintenanceModeTime string `json:"maintenanceModeTime,omitempty"`
4486
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496
4497
4498 SkaffoldSupportState string `json:"skaffoldSupportState,omitempty"`
4499
4500 Status bool `json:"status,omitempty"`
4501
4502
4503 SupportExpirationTime string `json:"supportExpirationTime,omitempty"`
4504
4505
4506
4507
4508
4509 ForceSendFields []string `json:"-"`
4510
4511
4512
4513
4514 NullFields []string `json:"-"`
4515 }
4516
4517 func (s *SkaffoldSupportedCondition) MarshalJSON() ([]byte, error) {
4518 type NoMethod SkaffoldSupportedCondition
4519 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4520 }
4521
4522
4523 type SkaffoldVersion struct {
4524
4525
4526 MaintenanceModeTime string `json:"maintenanceModeTime,omitempty"`
4527
4528
4529 SupportEndDate *Date `json:"supportEndDate,omitempty"`
4530
4531
4532 SupportExpirationTime string `json:"supportExpirationTime,omitempty"`
4533
4534 Version string `json:"version,omitempty"`
4535
4536
4537
4538
4539
4540 ForceSendFields []string `json:"-"`
4541
4542
4543
4544
4545 NullFields []string `json:"-"`
4546 }
4547
4548 func (s *SkaffoldVersion) MarshalJSON() ([]byte, error) {
4549 type NoMethod SkaffoldVersion
4550 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4551 }
4552
4553
4554 type Stage struct {
4555
4556
4557 DeployParameters []*DeployParameters `json:"deployParameters,omitempty"`
4558
4559
4560 Profiles []string `json:"profiles,omitempty"`
4561
4562 Strategy *Strategy `json:"strategy,omitempty"`
4563
4564
4565
4566
4567
4568
4569 TargetId string `json:"targetId,omitempty"`
4570
4571
4572
4573
4574
4575 ForceSendFields []string `json:"-"`
4576
4577
4578
4579
4580 NullFields []string `json:"-"`
4581 }
4582
4583 func (s *Stage) MarshalJSON() ([]byte, error) {
4584 type NoMethod Stage
4585 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4586 }
4587
4588
4589 type Standard struct {
4590
4591
4592 Postdeploy *Postdeploy `json:"postdeploy,omitempty"`
4593
4594
4595 Predeploy *Predeploy `json:"predeploy,omitempty"`
4596
4597 Verify bool `json:"verify,omitempty"`
4598
4599
4600
4601
4602
4603 ForceSendFields []string `json:"-"`
4604
4605
4606
4607
4608 NullFields []string `json:"-"`
4609 }
4610
4611 func (s *Standard) MarshalJSON() ([]byte, error) {
4612 type NoMethod Standard
4613 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4614 }
4615
4616
4617
4618
4619
4620
4621
4622 type Status struct {
4623
4624 Code int64 `json:"code,omitempty"`
4625
4626
4627 Details []googleapi.RawMessage `json:"details,omitempty"`
4628
4629
4630
4631 Message string `json:"message,omitempty"`
4632
4633
4634
4635
4636
4637 ForceSendFields []string `json:"-"`
4638
4639
4640
4641
4642 NullFields []string `json:"-"`
4643 }
4644
4645 func (s *Status) MarshalJSON() ([]byte, error) {
4646 type NoMethod Status
4647 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4648 }
4649
4650
4651 type Strategy struct {
4652
4653
4654 Canary *Canary `json:"canary,omitempty"`
4655
4656
4657 Standard *Standard `json:"standard,omitempty"`
4658
4659
4660
4661
4662
4663 ForceSendFields []string `json:"-"`
4664
4665
4666
4667
4668 NullFields []string `json:"-"`
4669 }
4670
4671 func (s *Strategy) MarshalJSON() ([]byte, error) {
4672 type NoMethod Strategy
4673 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4674 }
4675
4676
4677
4678 type Target struct {
4679
4680
4681
4682
4683 Annotations map[string]string `json:"annotations,omitempty"`
4684
4685 AnthosCluster *AnthosCluster `json:"anthosCluster,omitempty"`
4686
4687 CreateTime string `json:"createTime,omitempty"`
4688
4689 CustomTarget *CustomTarget `json:"customTarget,omitempty"`
4690
4691 DeployParameters map[string]string `json:"deployParameters,omitempty"`
4692
4693
4694 Description string `json:"description,omitempty"`
4695
4696
4697
4698 Etag string `json:"etag,omitempty"`
4699
4700
4701
4702
4703
4704
4705 ExecutionConfigs []*ExecutionConfig `json:"executionConfigs,omitempty"`
4706
4707 Gke *GkeCluster `json:"gke,omitempty"`
4708
4709
4710
4711
4712
4713
4714
4715
4716 Labels map[string]string `json:"labels,omitempty"`
4717
4718 MultiTarget *MultiTarget `json:"multiTarget,omitempty"`
4719
4720
4721
4722 Name string `json:"name,omitempty"`
4723
4724 RequireApproval bool `json:"requireApproval,omitempty"`
4725
4726 Run *CloudRunLocation `json:"run,omitempty"`
4727
4728 TargetId string `json:"targetId,omitempty"`
4729
4730 Uid string `json:"uid,omitempty"`
4731
4732 UpdateTime string `json:"updateTime,omitempty"`
4733
4734
4735 googleapi.ServerResponse `json:"-"`
4736
4737
4738
4739
4740
4741 ForceSendFields []string `json:"-"`
4742
4743
4744
4745
4746 NullFields []string `json:"-"`
4747 }
4748
4749 func (s *Target) MarshalJSON() ([]byte, error) {
4750 type NoMethod Target
4751 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4752 }
4753
4754
4755 type TargetArtifact struct {
4756
4757
4758
4759 ArtifactUri string `json:"artifactUri,omitempty"`
4760
4761
4762 ManifestPath string `json:"manifestPath,omitempty"`
4763
4764
4765 PhaseArtifacts map[string]PhaseArtifact `json:"phaseArtifacts,omitempty"`
4766
4767
4768 SkaffoldConfigPath string `json:"skaffoldConfigPath,omitempty"`
4769
4770
4771
4772
4773
4774 ForceSendFields []string `json:"-"`
4775
4776
4777
4778
4779 NullFields []string `json:"-"`
4780 }
4781
4782 func (s *TargetArtifact) MarshalJSON() ([]byte, error) {
4783 type NoMethod TargetArtifact
4784 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4785 }
4786
4787
4788 type TargetAttribute struct {
4789
4790
4791
4792
4793 Id string `json:"id,omitempty"`
4794
4795 Labels map[string]string `json:"labels,omitempty"`
4796
4797
4798
4799
4800
4801 ForceSendFields []string `json:"-"`
4802
4803
4804
4805
4806 NullFields []string `json:"-"`
4807 }
4808
4809 func (s *TargetAttribute) MarshalJSON() ([]byte, error) {
4810 type NoMethod TargetAttribute
4811 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4812 }
4813
4814
4815
4816
4817 type TargetNotificationEvent struct {
4818
4819 Message string `json:"message,omitempty"`
4820
4821 Target string `json:"target,omitempty"`
4822
4823
4824
4825
4826
4827
4828
4829
4830
4831
4832
4833
4834
4835
4836 Type string `json:"type,omitempty"`
4837
4838
4839
4840
4841
4842 ForceSendFields []string `json:"-"`
4843
4844
4845
4846
4847 NullFields []string `json:"-"`
4848 }
4849
4850 func (s *TargetNotificationEvent) MarshalJSON() ([]byte, error) {
4851 type NoMethod TargetNotificationEvent
4852 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4853 }
4854
4855
4856 type TargetRender struct {
4857
4858
4859
4860
4861
4862
4863
4864
4865
4866
4867
4868
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883 FailureCause string `json:"failureCause,omitempty"`
4884
4885
4886 FailureMessage string `json:"failureMessage,omitempty"`
4887
4888
4889 Metadata *RenderMetadata `json:"metadata,omitempty"`
4890
4891
4892
4893 RenderingBuild string `json:"renderingBuild,omitempty"`
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903 RenderingState string `json:"renderingState,omitempty"`
4904
4905
4906
4907
4908
4909 ForceSendFields []string `json:"-"`
4910
4911
4912
4913
4914 NullFields []string `json:"-"`
4915 }
4916
4917 func (s *TargetRender) MarshalJSON() ([]byte, error) {
4918 type NoMethod TargetRender
4919 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4920 }
4921
4922
4923
4924 type TargetsPresentCondition struct {
4925
4926
4927 MissingTargets []string `json:"missingTargets,omitempty"`
4928
4929 Status bool `json:"status,omitempty"`
4930
4931 UpdateTime string `json:"updateTime,omitempty"`
4932
4933
4934
4935
4936
4937 ForceSendFields []string `json:"-"`
4938
4939
4940
4941
4942 NullFields []string `json:"-"`
4943 }
4944
4945 func (s *TargetsPresentCondition) MarshalJSON() ([]byte, error) {
4946 type NoMethod TargetsPresentCondition
4947 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4948 }
4949
4950
4951
4952 type TargetsTypeCondition struct {
4953
4954 ErrorDetails string `json:"errorDetails,omitempty"`
4955
4956
4957
4958 Status bool `json:"status,omitempty"`
4959
4960
4961
4962
4963
4964 ForceSendFields []string `json:"-"`
4965
4966
4967
4968
4969 NullFields []string `json:"-"`
4970 }
4971
4972 func (s *TargetsTypeCondition) MarshalJSON() ([]byte, error) {
4973 type NoMethod TargetsTypeCondition
4974 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4975 }
4976
4977
4978 type TerminateJobRunRequest struct {
4979 }
4980
4981
4982 type TerminateJobRunResponse struct {
4983
4984 googleapi.ServerResponse `json:"-"`
4985 }
4986
4987
4988 type TestIamPermissionsRequest struct {
4989
4990
4991
4992
4993 Permissions []string `json:"permissions,omitempty"`
4994
4995
4996
4997
4998
4999 ForceSendFields []string `json:"-"`
5000
5001
5002
5003
5004 NullFields []string `json:"-"`
5005 }
5006
5007 func (s *TestIamPermissionsRequest) MarshalJSON() ([]byte, error) {
5008 type NoMethod TestIamPermissionsRequest
5009 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5010 }
5011
5012
5013
5014 type TestIamPermissionsResponse struct {
5015
5016
5017 Permissions []string `json:"permissions,omitempty"`
5018
5019
5020 googleapi.ServerResponse `json:"-"`
5021
5022
5023
5024
5025
5026 ForceSendFields []string `json:"-"`
5027
5028
5029
5030
5031 NullFields []string `json:"-"`
5032 }
5033
5034 func (s *TestIamPermissionsResponse) MarshalJSON() ([]byte, error) {
5035 type NoMethod TestIamPermissionsResponse
5036 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5037 }
5038
5039
5040 type VerifyJob struct {
5041 }
5042
5043
5044
5045 type VerifyJobRun struct {
5046
5047
5048 ArtifactUri string `json:"artifactUri,omitempty"`
5049
5050
5051
5052 Build string `json:"build,omitempty"`
5053
5054
5055 EventLogPath string `json:"eventLogPath,omitempty"`
5056
5057
5058
5059
5060
5061
5062
5063
5064
5065
5066
5067
5068
5069
5070
5071
5072
5073
5074 FailureCause string `json:"failureCause,omitempty"`
5075
5076
5077 FailureMessage string `json:"failureMessage,omitempty"`
5078
5079
5080
5081
5082
5083 ForceSendFields []string `json:"-"`
5084
5085
5086
5087
5088 NullFields []string `json:"-"`
5089 }
5090
5091 func (s *VerifyJobRun) MarshalJSON() ([]byte, error) {
5092 type NoMethod VerifyJobRun
5093 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5094 }
5095
5096 type ProjectsLocationsGetCall struct {
5097 s *Service
5098 name string
5099 urlParams_ gensupport.URLParams
5100 ifNoneMatch_ string
5101 ctx_ context.Context
5102 header_ http.Header
5103 }
5104
5105
5106
5107
5108 func (r *ProjectsLocationsService) Get(name string) *ProjectsLocationsGetCall {
5109 c := &ProjectsLocationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5110 c.name = name
5111 return c
5112 }
5113
5114
5115
5116
5117 func (c *ProjectsLocationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsGetCall {
5118 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5119 return c
5120 }
5121
5122
5123
5124
5125 func (c *ProjectsLocationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsGetCall {
5126 c.ifNoneMatch_ = entityTag
5127 return c
5128 }
5129
5130
5131 func (c *ProjectsLocationsGetCall) Context(ctx context.Context) *ProjectsLocationsGetCall {
5132 c.ctx_ = ctx
5133 return c
5134 }
5135
5136
5137
5138 func (c *ProjectsLocationsGetCall) Header() http.Header {
5139 if c.header_ == nil {
5140 c.header_ = make(http.Header)
5141 }
5142 return c.header_
5143 }
5144
5145 func (c *ProjectsLocationsGetCall) doRequest(alt string) (*http.Response, error) {
5146 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5147 if c.ifNoneMatch_ != "" {
5148 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5149 }
5150 var body io.Reader = nil
5151 c.urlParams_.Set("alt", alt)
5152 c.urlParams_.Set("prettyPrint", "false")
5153 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
5154 urls += "?" + c.urlParams_.Encode()
5155 req, err := http.NewRequest("GET", urls, body)
5156 if err != nil {
5157 return nil, err
5158 }
5159 req.Header = reqHeaders
5160 googleapi.Expand(req.URL, map[string]string{
5161 "name": c.name,
5162 })
5163 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5164 }
5165
5166
5167
5168
5169
5170
5171 func (c *ProjectsLocationsGetCall) Do(opts ...googleapi.CallOption) (*Location, error) {
5172 gensupport.SetOptions(c.urlParams_, opts...)
5173 res, err := c.doRequest("json")
5174 if res != nil && res.StatusCode == http.StatusNotModified {
5175 if res.Body != nil {
5176 res.Body.Close()
5177 }
5178 return nil, gensupport.WrapError(&googleapi.Error{
5179 Code: res.StatusCode,
5180 Header: res.Header,
5181 })
5182 }
5183 if err != nil {
5184 return nil, err
5185 }
5186 defer googleapi.CloseBody(res)
5187 if err := googleapi.CheckResponse(res); err != nil {
5188 return nil, gensupport.WrapError(err)
5189 }
5190 ret := &Location{
5191 ServerResponse: googleapi.ServerResponse{
5192 Header: res.Header,
5193 HTTPStatusCode: res.StatusCode,
5194 },
5195 }
5196 target := &ret
5197 if err := gensupport.DecodeResponse(target, res); err != nil {
5198 return nil, err
5199 }
5200 return ret, nil
5201 }
5202
5203 type ProjectsLocationsGetConfigCall struct {
5204 s *Service
5205 name string
5206 urlParams_ gensupport.URLParams
5207 ifNoneMatch_ string
5208 ctx_ context.Context
5209 header_ http.Header
5210 }
5211
5212
5213
5214
5215 func (r *ProjectsLocationsService) GetConfig(name string) *ProjectsLocationsGetConfigCall {
5216 c := &ProjectsLocationsGetConfigCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5217 c.name = name
5218 return c
5219 }
5220
5221
5222
5223
5224 func (c *ProjectsLocationsGetConfigCall) Fields(s ...googleapi.Field) *ProjectsLocationsGetConfigCall {
5225 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5226 return c
5227 }
5228
5229
5230
5231
5232 func (c *ProjectsLocationsGetConfigCall) IfNoneMatch(entityTag string) *ProjectsLocationsGetConfigCall {
5233 c.ifNoneMatch_ = entityTag
5234 return c
5235 }
5236
5237
5238 func (c *ProjectsLocationsGetConfigCall) Context(ctx context.Context) *ProjectsLocationsGetConfigCall {
5239 c.ctx_ = ctx
5240 return c
5241 }
5242
5243
5244
5245 func (c *ProjectsLocationsGetConfigCall) Header() http.Header {
5246 if c.header_ == nil {
5247 c.header_ = make(http.Header)
5248 }
5249 return c.header_
5250 }
5251
5252 func (c *ProjectsLocationsGetConfigCall) doRequest(alt string) (*http.Response, error) {
5253 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5254 if c.ifNoneMatch_ != "" {
5255 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5256 }
5257 var body io.Reader = nil
5258 c.urlParams_.Set("alt", alt)
5259 c.urlParams_.Set("prettyPrint", "false")
5260 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
5261 urls += "?" + c.urlParams_.Encode()
5262 req, err := http.NewRequest("GET", urls, body)
5263 if err != nil {
5264 return nil, err
5265 }
5266 req.Header = reqHeaders
5267 googleapi.Expand(req.URL, map[string]string{
5268 "name": c.name,
5269 })
5270 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5271 }
5272
5273
5274
5275
5276
5277
5278 func (c *ProjectsLocationsGetConfigCall) Do(opts ...googleapi.CallOption) (*Config, error) {
5279 gensupport.SetOptions(c.urlParams_, opts...)
5280 res, err := c.doRequest("json")
5281 if res != nil && res.StatusCode == http.StatusNotModified {
5282 if res.Body != nil {
5283 res.Body.Close()
5284 }
5285 return nil, gensupport.WrapError(&googleapi.Error{
5286 Code: res.StatusCode,
5287 Header: res.Header,
5288 })
5289 }
5290 if err != nil {
5291 return nil, err
5292 }
5293 defer googleapi.CloseBody(res)
5294 if err := googleapi.CheckResponse(res); err != nil {
5295 return nil, gensupport.WrapError(err)
5296 }
5297 ret := &Config{
5298 ServerResponse: googleapi.ServerResponse{
5299 Header: res.Header,
5300 HTTPStatusCode: res.StatusCode,
5301 },
5302 }
5303 target := &ret
5304 if err := gensupport.DecodeResponse(target, res); err != nil {
5305 return nil, err
5306 }
5307 return ret, nil
5308 }
5309
5310 type ProjectsLocationsListCall struct {
5311 s *Service
5312 name string
5313 urlParams_ gensupport.URLParams
5314 ifNoneMatch_ string
5315 ctx_ context.Context
5316 header_ http.Header
5317 }
5318
5319
5320
5321
5322 func (r *ProjectsLocationsService) List(name string) *ProjectsLocationsListCall {
5323 c := &ProjectsLocationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5324 c.name = name
5325 return c
5326 }
5327
5328
5329
5330
5331
5332 func (c *ProjectsLocationsListCall) Filter(filter string) *ProjectsLocationsListCall {
5333 c.urlParams_.Set("filter", filter)
5334 return c
5335 }
5336
5337
5338
5339 func (c *ProjectsLocationsListCall) PageSize(pageSize int64) *ProjectsLocationsListCall {
5340 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
5341 return c
5342 }
5343
5344
5345
5346
5347 func (c *ProjectsLocationsListCall) PageToken(pageToken string) *ProjectsLocationsListCall {
5348 c.urlParams_.Set("pageToken", pageToken)
5349 return c
5350 }
5351
5352
5353
5354
5355 func (c *ProjectsLocationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsListCall {
5356 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5357 return c
5358 }
5359
5360
5361
5362
5363 func (c *ProjectsLocationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsListCall {
5364 c.ifNoneMatch_ = entityTag
5365 return c
5366 }
5367
5368
5369 func (c *ProjectsLocationsListCall) Context(ctx context.Context) *ProjectsLocationsListCall {
5370 c.ctx_ = ctx
5371 return c
5372 }
5373
5374
5375
5376 func (c *ProjectsLocationsListCall) Header() http.Header {
5377 if c.header_ == nil {
5378 c.header_ = make(http.Header)
5379 }
5380 return c.header_
5381 }
5382
5383 func (c *ProjectsLocationsListCall) doRequest(alt string) (*http.Response, error) {
5384 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5385 if c.ifNoneMatch_ != "" {
5386 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5387 }
5388 var body io.Reader = nil
5389 c.urlParams_.Set("alt", alt)
5390 c.urlParams_.Set("prettyPrint", "false")
5391 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/locations")
5392 urls += "?" + c.urlParams_.Encode()
5393 req, err := http.NewRequest("GET", urls, body)
5394 if err != nil {
5395 return nil, err
5396 }
5397 req.Header = reqHeaders
5398 googleapi.Expand(req.URL, map[string]string{
5399 "name": c.name,
5400 })
5401 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5402 }
5403
5404
5405
5406
5407
5408
5409
5410 func (c *ProjectsLocationsListCall) Do(opts ...googleapi.CallOption) (*ListLocationsResponse, error) {
5411 gensupport.SetOptions(c.urlParams_, opts...)
5412 res, err := c.doRequest("json")
5413 if res != nil && res.StatusCode == http.StatusNotModified {
5414 if res.Body != nil {
5415 res.Body.Close()
5416 }
5417 return nil, gensupport.WrapError(&googleapi.Error{
5418 Code: res.StatusCode,
5419 Header: res.Header,
5420 })
5421 }
5422 if err != nil {
5423 return nil, err
5424 }
5425 defer googleapi.CloseBody(res)
5426 if err := googleapi.CheckResponse(res); err != nil {
5427 return nil, gensupport.WrapError(err)
5428 }
5429 ret := &ListLocationsResponse{
5430 ServerResponse: googleapi.ServerResponse{
5431 Header: res.Header,
5432 HTTPStatusCode: res.StatusCode,
5433 },
5434 }
5435 target := &ret
5436 if err := gensupport.DecodeResponse(target, res); err != nil {
5437 return nil, err
5438 }
5439 return ret, nil
5440 }
5441
5442
5443
5444
5445 func (c *ProjectsLocationsListCall) Pages(ctx context.Context, f func(*ListLocationsResponse) error) error {
5446 c.ctx_ = ctx
5447 defer c.PageToken(c.urlParams_.Get("pageToken"))
5448 for {
5449 x, err := c.Do()
5450 if err != nil {
5451 return err
5452 }
5453 if err := f(x); err != nil {
5454 return err
5455 }
5456 if x.NextPageToken == "" {
5457 return nil
5458 }
5459 c.PageToken(x.NextPageToken)
5460 }
5461 }
5462
5463 type ProjectsLocationsCustomTargetTypesCreateCall struct {
5464 s *Service
5465 parent string
5466 customtargettype *CustomTargetType
5467 urlParams_ gensupport.URLParams
5468 ctx_ context.Context
5469 header_ http.Header
5470 }
5471
5472
5473
5474
5475
5476
5477 func (r *ProjectsLocationsCustomTargetTypesService) Create(parent string, customtargettype *CustomTargetType) *ProjectsLocationsCustomTargetTypesCreateCall {
5478 c := &ProjectsLocationsCustomTargetTypesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5479 c.parent = parent
5480 c.customtargettype = customtargettype
5481 return c
5482 }
5483
5484
5485
5486 func (c *ProjectsLocationsCustomTargetTypesCreateCall) CustomTargetTypeId(customTargetTypeId string) *ProjectsLocationsCustomTargetTypesCreateCall {
5487 c.urlParams_.Set("customTargetTypeId", customTargetTypeId)
5488 return c
5489 }
5490
5491
5492
5493
5494
5495
5496
5497
5498
5499
5500
5501
5502 func (c *ProjectsLocationsCustomTargetTypesCreateCall) RequestId(requestId string) *ProjectsLocationsCustomTargetTypesCreateCall {
5503 c.urlParams_.Set("requestId", requestId)
5504 return c
5505 }
5506
5507
5508
5509
5510 func (c *ProjectsLocationsCustomTargetTypesCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsCustomTargetTypesCreateCall {
5511 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
5512 return c
5513 }
5514
5515
5516
5517
5518 func (c *ProjectsLocationsCustomTargetTypesCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsCustomTargetTypesCreateCall {
5519 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5520 return c
5521 }
5522
5523
5524 func (c *ProjectsLocationsCustomTargetTypesCreateCall) Context(ctx context.Context) *ProjectsLocationsCustomTargetTypesCreateCall {
5525 c.ctx_ = ctx
5526 return c
5527 }
5528
5529
5530
5531 func (c *ProjectsLocationsCustomTargetTypesCreateCall) Header() http.Header {
5532 if c.header_ == nil {
5533 c.header_ = make(http.Header)
5534 }
5535 return c.header_
5536 }
5537
5538 func (c *ProjectsLocationsCustomTargetTypesCreateCall) doRequest(alt string) (*http.Response, error) {
5539 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5540 var body io.Reader = nil
5541 body, err := googleapi.WithoutDataWrapper.JSONReader(c.customtargettype)
5542 if err != nil {
5543 return nil, err
5544 }
5545 c.urlParams_.Set("alt", alt)
5546 c.urlParams_.Set("prettyPrint", "false")
5547 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/customTargetTypes")
5548 urls += "?" + c.urlParams_.Encode()
5549 req, err := http.NewRequest("POST", urls, body)
5550 if err != nil {
5551 return nil, err
5552 }
5553 req.Header = reqHeaders
5554 googleapi.Expand(req.URL, map[string]string{
5555 "parent": c.parent,
5556 })
5557 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5558 }
5559
5560
5561
5562
5563
5564
5565 func (c *ProjectsLocationsCustomTargetTypesCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
5566 gensupport.SetOptions(c.urlParams_, opts...)
5567 res, err := c.doRequest("json")
5568 if res != nil && res.StatusCode == http.StatusNotModified {
5569 if res.Body != nil {
5570 res.Body.Close()
5571 }
5572 return nil, gensupport.WrapError(&googleapi.Error{
5573 Code: res.StatusCode,
5574 Header: res.Header,
5575 })
5576 }
5577 if err != nil {
5578 return nil, err
5579 }
5580 defer googleapi.CloseBody(res)
5581 if err := googleapi.CheckResponse(res); err != nil {
5582 return nil, gensupport.WrapError(err)
5583 }
5584 ret := &Operation{
5585 ServerResponse: googleapi.ServerResponse{
5586 Header: res.Header,
5587 HTTPStatusCode: res.StatusCode,
5588 },
5589 }
5590 target := &ret
5591 if err := gensupport.DecodeResponse(target, res); err != nil {
5592 return nil, err
5593 }
5594 return ret, nil
5595 }
5596
5597 type ProjectsLocationsCustomTargetTypesDeleteCall struct {
5598 s *Service
5599 name string
5600 urlParams_ gensupport.URLParams
5601 ctx_ context.Context
5602 header_ http.Header
5603 }
5604
5605
5606
5607
5608
5609
5610 func (r *ProjectsLocationsCustomTargetTypesService) Delete(name string) *ProjectsLocationsCustomTargetTypesDeleteCall {
5611 c := &ProjectsLocationsCustomTargetTypesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5612 c.name = name
5613 return c
5614 }
5615
5616
5617
5618
5619 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) AllowMissing(allowMissing bool) *ProjectsLocationsCustomTargetTypesDeleteCall {
5620 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
5621 return c
5622 }
5623
5624
5625
5626
5627
5628 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) Etag(etag string) *ProjectsLocationsCustomTargetTypesDeleteCall {
5629 c.urlParams_.Set("etag", etag)
5630 return c
5631 }
5632
5633
5634
5635
5636
5637
5638
5639
5640
5641
5642
5643
5644 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) RequestId(requestId string) *ProjectsLocationsCustomTargetTypesDeleteCall {
5645 c.urlParams_.Set("requestId", requestId)
5646 return c
5647 }
5648
5649
5650
5651 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsCustomTargetTypesDeleteCall {
5652 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
5653 return c
5654 }
5655
5656
5657
5658
5659 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsCustomTargetTypesDeleteCall {
5660 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5661 return c
5662 }
5663
5664
5665 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) Context(ctx context.Context) *ProjectsLocationsCustomTargetTypesDeleteCall {
5666 c.ctx_ = ctx
5667 return c
5668 }
5669
5670
5671
5672 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) Header() http.Header {
5673 if c.header_ == nil {
5674 c.header_ = make(http.Header)
5675 }
5676 return c.header_
5677 }
5678
5679 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) doRequest(alt string) (*http.Response, error) {
5680 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5681 var body io.Reader = nil
5682 c.urlParams_.Set("alt", alt)
5683 c.urlParams_.Set("prettyPrint", "false")
5684 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
5685 urls += "?" + c.urlParams_.Encode()
5686 req, err := http.NewRequest("DELETE", urls, body)
5687 if err != nil {
5688 return nil, err
5689 }
5690 req.Header = reqHeaders
5691 googleapi.Expand(req.URL, map[string]string{
5692 "name": c.name,
5693 })
5694 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5695 }
5696
5697
5698
5699
5700
5701
5702 func (c *ProjectsLocationsCustomTargetTypesDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
5703 gensupport.SetOptions(c.urlParams_, opts...)
5704 res, err := c.doRequest("json")
5705 if res != nil && res.StatusCode == http.StatusNotModified {
5706 if res.Body != nil {
5707 res.Body.Close()
5708 }
5709 return nil, gensupport.WrapError(&googleapi.Error{
5710 Code: res.StatusCode,
5711 Header: res.Header,
5712 })
5713 }
5714 if err != nil {
5715 return nil, err
5716 }
5717 defer googleapi.CloseBody(res)
5718 if err := googleapi.CheckResponse(res); err != nil {
5719 return nil, gensupport.WrapError(err)
5720 }
5721 ret := &Operation{
5722 ServerResponse: googleapi.ServerResponse{
5723 Header: res.Header,
5724 HTTPStatusCode: res.StatusCode,
5725 },
5726 }
5727 target := &ret
5728 if err := gensupport.DecodeResponse(target, res); err != nil {
5729 return nil, err
5730 }
5731 return ret, nil
5732 }
5733
5734 type ProjectsLocationsCustomTargetTypesGetCall struct {
5735 s *Service
5736 name string
5737 urlParams_ gensupport.URLParams
5738 ifNoneMatch_ string
5739 ctx_ context.Context
5740 header_ http.Header
5741 }
5742
5743
5744
5745
5746
5747
5748 func (r *ProjectsLocationsCustomTargetTypesService) Get(name string) *ProjectsLocationsCustomTargetTypesGetCall {
5749 c := &ProjectsLocationsCustomTargetTypesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5750 c.name = name
5751 return c
5752 }
5753
5754
5755
5756
5757 func (c *ProjectsLocationsCustomTargetTypesGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsCustomTargetTypesGetCall {
5758 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5759 return c
5760 }
5761
5762
5763
5764
5765 func (c *ProjectsLocationsCustomTargetTypesGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsCustomTargetTypesGetCall {
5766 c.ifNoneMatch_ = entityTag
5767 return c
5768 }
5769
5770
5771 func (c *ProjectsLocationsCustomTargetTypesGetCall) Context(ctx context.Context) *ProjectsLocationsCustomTargetTypesGetCall {
5772 c.ctx_ = ctx
5773 return c
5774 }
5775
5776
5777
5778 func (c *ProjectsLocationsCustomTargetTypesGetCall) Header() http.Header {
5779 if c.header_ == nil {
5780 c.header_ = make(http.Header)
5781 }
5782 return c.header_
5783 }
5784
5785 func (c *ProjectsLocationsCustomTargetTypesGetCall) doRequest(alt string) (*http.Response, error) {
5786 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5787 if c.ifNoneMatch_ != "" {
5788 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5789 }
5790 var body io.Reader = nil
5791 c.urlParams_.Set("alt", alt)
5792 c.urlParams_.Set("prettyPrint", "false")
5793 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
5794 urls += "?" + c.urlParams_.Encode()
5795 req, err := http.NewRequest("GET", urls, body)
5796 if err != nil {
5797 return nil, err
5798 }
5799 req.Header = reqHeaders
5800 googleapi.Expand(req.URL, map[string]string{
5801 "name": c.name,
5802 })
5803 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5804 }
5805
5806
5807
5808
5809
5810
5811
5812 func (c *ProjectsLocationsCustomTargetTypesGetCall) Do(opts ...googleapi.CallOption) (*CustomTargetType, error) {
5813 gensupport.SetOptions(c.urlParams_, opts...)
5814 res, err := c.doRequest("json")
5815 if res != nil && res.StatusCode == http.StatusNotModified {
5816 if res.Body != nil {
5817 res.Body.Close()
5818 }
5819 return nil, gensupport.WrapError(&googleapi.Error{
5820 Code: res.StatusCode,
5821 Header: res.Header,
5822 })
5823 }
5824 if err != nil {
5825 return nil, err
5826 }
5827 defer googleapi.CloseBody(res)
5828 if err := googleapi.CheckResponse(res); err != nil {
5829 return nil, gensupport.WrapError(err)
5830 }
5831 ret := &CustomTargetType{
5832 ServerResponse: googleapi.ServerResponse{
5833 Header: res.Header,
5834 HTTPStatusCode: res.StatusCode,
5835 },
5836 }
5837 target := &ret
5838 if err := gensupport.DecodeResponse(target, res); err != nil {
5839 return nil, err
5840 }
5841 return ret, nil
5842 }
5843
5844 type ProjectsLocationsCustomTargetTypesGetIamPolicyCall struct {
5845 s *Service
5846 resource string
5847 urlParams_ gensupport.URLParams
5848 ifNoneMatch_ string
5849 ctx_ context.Context
5850 header_ http.Header
5851 }
5852
5853
5854
5855
5856
5857
5858
5859 func (r *ProjectsLocationsCustomTargetTypesService) GetIamPolicy(resource string) *ProjectsLocationsCustomTargetTypesGetIamPolicyCall {
5860 c := &ProjectsLocationsCustomTargetTypesGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5861 c.resource = resource
5862 return c
5863 }
5864
5865
5866
5867
5868
5869
5870
5871
5872
5873
5874
5875
5876
5877 func (c *ProjectsLocationsCustomTargetTypesGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsCustomTargetTypesGetIamPolicyCall {
5878 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
5879 return c
5880 }
5881
5882
5883
5884
5885 func (c *ProjectsLocationsCustomTargetTypesGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsCustomTargetTypesGetIamPolicyCall {
5886 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5887 return c
5888 }
5889
5890
5891
5892
5893 func (c *ProjectsLocationsCustomTargetTypesGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsCustomTargetTypesGetIamPolicyCall {
5894 c.ifNoneMatch_ = entityTag
5895 return c
5896 }
5897
5898
5899 func (c *ProjectsLocationsCustomTargetTypesGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsCustomTargetTypesGetIamPolicyCall {
5900 c.ctx_ = ctx
5901 return c
5902 }
5903
5904
5905
5906 func (c *ProjectsLocationsCustomTargetTypesGetIamPolicyCall) Header() http.Header {
5907 if c.header_ == nil {
5908 c.header_ = make(http.Header)
5909 }
5910 return c.header_
5911 }
5912
5913 func (c *ProjectsLocationsCustomTargetTypesGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
5914 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5915 if c.ifNoneMatch_ != "" {
5916 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5917 }
5918 var body io.Reader = nil
5919 c.urlParams_.Set("alt", alt)
5920 c.urlParams_.Set("prettyPrint", "false")
5921 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
5922 urls += "?" + c.urlParams_.Encode()
5923 req, err := http.NewRequest("GET", urls, body)
5924 if err != nil {
5925 return nil, err
5926 }
5927 req.Header = reqHeaders
5928 googleapi.Expand(req.URL, map[string]string{
5929 "resource": c.resource,
5930 })
5931 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5932 }
5933
5934
5935
5936
5937
5938
5939 func (c *ProjectsLocationsCustomTargetTypesGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
5940 gensupport.SetOptions(c.urlParams_, opts...)
5941 res, err := c.doRequest("json")
5942 if res != nil && res.StatusCode == http.StatusNotModified {
5943 if res.Body != nil {
5944 res.Body.Close()
5945 }
5946 return nil, gensupport.WrapError(&googleapi.Error{
5947 Code: res.StatusCode,
5948 Header: res.Header,
5949 })
5950 }
5951 if err != nil {
5952 return nil, err
5953 }
5954 defer googleapi.CloseBody(res)
5955 if err := googleapi.CheckResponse(res); err != nil {
5956 return nil, gensupport.WrapError(err)
5957 }
5958 ret := &Policy{
5959 ServerResponse: googleapi.ServerResponse{
5960 Header: res.Header,
5961 HTTPStatusCode: res.StatusCode,
5962 },
5963 }
5964 target := &ret
5965 if err := gensupport.DecodeResponse(target, res); err != nil {
5966 return nil, err
5967 }
5968 return ret, nil
5969 }
5970
5971 type ProjectsLocationsCustomTargetTypesListCall struct {
5972 s *Service
5973 parent string
5974 urlParams_ gensupport.URLParams
5975 ifNoneMatch_ string
5976 ctx_ context.Context
5977 header_ http.Header
5978 }
5979
5980
5981
5982
5983
5984 func (r *ProjectsLocationsCustomTargetTypesService) List(parent string) *ProjectsLocationsCustomTargetTypesListCall {
5985 c := &ProjectsLocationsCustomTargetTypesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5986 c.parent = parent
5987 return c
5988 }
5989
5990
5991
5992 func (c *ProjectsLocationsCustomTargetTypesListCall) Filter(filter string) *ProjectsLocationsCustomTargetTypesListCall {
5993 c.urlParams_.Set("filter", filter)
5994 return c
5995 }
5996
5997
5998
5999 func (c *ProjectsLocationsCustomTargetTypesListCall) OrderBy(orderBy string) *ProjectsLocationsCustomTargetTypesListCall {
6000 c.urlParams_.Set("orderBy", orderBy)
6001 return c
6002 }
6003
6004
6005
6006
6007
6008 func (c *ProjectsLocationsCustomTargetTypesListCall) PageSize(pageSize int64) *ProjectsLocationsCustomTargetTypesListCall {
6009 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6010 return c
6011 }
6012
6013
6014
6015
6016
6017 func (c *ProjectsLocationsCustomTargetTypesListCall) PageToken(pageToken string) *ProjectsLocationsCustomTargetTypesListCall {
6018 c.urlParams_.Set("pageToken", pageToken)
6019 return c
6020 }
6021
6022
6023
6024
6025 func (c *ProjectsLocationsCustomTargetTypesListCall) Fields(s ...googleapi.Field) *ProjectsLocationsCustomTargetTypesListCall {
6026 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6027 return c
6028 }
6029
6030
6031
6032
6033 func (c *ProjectsLocationsCustomTargetTypesListCall) IfNoneMatch(entityTag string) *ProjectsLocationsCustomTargetTypesListCall {
6034 c.ifNoneMatch_ = entityTag
6035 return c
6036 }
6037
6038
6039 func (c *ProjectsLocationsCustomTargetTypesListCall) Context(ctx context.Context) *ProjectsLocationsCustomTargetTypesListCall {
6040 c.ctx_ = ctx
6041 return c
6042 }
6043
6044
6045
6046 func (c *ProjectsLocationsCustomTargetTypesListCall) Header() http.Header {
6047 if c.header_ == nil {
6048 c.header_ = make(http.Header)
6049 }
6050 return c.header_
6051 }
6052
6053 func (c *ProjectsLocationsCustomTargetTypesListCall) doRequest(alt string) (*http.Response, error) {
6054 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6055 if c.ifNoneMatch_ != "" {
6056 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6057 }
6058 var body io.Reader = nil
6059 c.urlParams_.Set("alt", alt)
6060 c.urlParams_.Set("prettyPrint", "false")
6061 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/customTargetTypes")
6062 urls += "?" + c.urlParams_.Encode()
6063 req, err := http.NewRequest("GET", urls, body)
6064 if err != nil {
6065 return nil, err
6066 }
6067 req.Header = reqHeaders
6068 googleapi.Expand(req.URL, map[string]string{
6069 "parent": c.parent,
6070 })
6071 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6072 }
6073
6074
6075
6076
6077
6078
6079
6080 func (c *ProjectsLocationsCustomTargetTypesListCall) Do(opts ...googleapi.CallOption) (*ListCustomTargetTypesResponse, error) {
6081 gensupport.SetOptions(c.urlParams_, opts...)
6082 res, err := c.doRequest("json")
6083 if res != nil && res.StatusCode == http.StatusNotModified {
6084 if res.Body != nil {
6085 res.Body.Close()
6086 }
6087 return nil, gensupport.WrapError(&googleapi.Error{
6088 Code: res.StatusCode,
6089 Header: res.Header,
6090 })
6091 }
6092 if err != nil {
6093 return nil, err
6094 }
6095 defer googleapi.CloseBody(res)
6096 if err := googleapi.CheckResponse(res); err != nil {
6097 return nil, gensupport.WrapError(err)
6098 }
6099 ret := &ListCustomTargetTypesResponse{
6100 ServerResponse: googleapi.ServerResponse{
6101 Header: res.Header,
6102 HTTPStatusCode: res.StatusCode,
6103 },
6104 }
6105 target := &ret
6106 if err := gensupport.DecodeResponse(target, res); err != nil {
6107 return nil, err
6108 }
6109 return ret, nil
6110 }
6111
6112
6113
6114
6115 func (c *ProjectsLocationsCustomTargetTypesListCall) Pages(ctx context.Context, f func(*ListCustomTargetTypesResponse) error) error {
6116 c.ctx_ = ctx
6117 defer c.PageToken(c.urlParams_.Get("pageToken"))
6118 for {
6119 x, err := c.Do()
6120 if err != nil {
6121 return err
6122 }
6123 if err := f(x); err != nil {
6124 return err
6125 }
6126 if x.NextPageToken == "" {
6127 return nil
6128 }
6129 c.PageToken(x.NextPageToken)
6130 }
6131 }
6132
6133 type ProjectsLocationsCustomTargetTypesPatchCall struct {
6134 s *Service
6135 name string
6136 customtargettype *CustomTargetType
6137 urlParams_ gensupport.URLParams
6138 ctx_ context.Context
6139 header_ http.Header
6140 }
6141
6142
6143
6144
6145
6146
6147
6148 func (r *ProjectsLocationsCustomTargetTypesService) Patch(name string, customtargettype *CustomTargetType) *ProjectsLocationsCustomTargetTypesPatchCall {
6149 c := &ProjectsLocationsCustomTargetTypesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6150 c.name = name
6151 c.customtargettype = customtargettype
6152 return c
6153 }
6154
6155
6156
6157
6158 func (c *ProjectsLocationsCustomTargetTypesPatchCall) AllowMissing(allowMissing bool) *ProjectsLocationsCustomTargetTypesPatchCall {
6159 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
6160 return c
6161 }
6162
6163
6164
6165
6166
6167
6168
6169
6170
6171
6172
6173
6174 func (c *ProjectsLocationsCustomTargetTypesPatchCall) RequestId(requestId string) *ProjectsLocationsCustomTargetTypesPatchCall {
6175 c.urlParams_.Set("requestId", requestId)
6176 return c
6177 }
6178
6179
6180
6181
6182
6183
6184
6185 func (c *ProjectsLocationsCustomTargetTypesPatchCall) UpdateMask(updateMask string) *ProjectsLocationsCustomTargetTypesPatchCall {
6186 c.urlParams_.Set("updateMask", updateMask)
6187 return c
6188 }
6189
6190
6191
6192
6193 func (c *ProjectsLocationsCustomTargetTypesPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsCustomTargetTypesPatchCall {
6194 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
6195 return c
6196 }
6197
6198
6199
6200
6201 func (c *ProjectsLocationsCustomTargetTypesPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsCustomTargetTypesPatchCall {
6202 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6203 return c
6204 }
6205
6206
6207 func (c *ProjectsLocationsCustomTargetTypesPatchCall) Context(ctx context.Context) *ProjectsLocationsCustomTargetTypesPatchCall {
6208 c.ctx_ = ctx
6209 return c
6210 }
6211
6212
6213
6214 func (c *ProjectsLocationsCustomTargetTypesPatchCall) Header() http.Header {
6215 if c.header_ == nil {
6216 c.header_ = make(http.Header)
6217 }
6218 return c.header_
6219 }
6220
6221 func (c *ProjectsLocationsCustomTargetTypesPatchCall) doRequest(alt string) (*http.Response, error) {
6222 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6223 var body io.Reader = nil
6224 body, err := googleapi.WithoutDataWrapper.JSONReader(c.customtargettype)
6225 if err != nil {
6226 return nil, err
6227 }
6228 c.urlParams_.Set("alt", alt)
6229 c.urlParams_.Set("prettyPrint", "false")
6230 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
6231 urls += "?" + c.urlParams_.Encode()
6232 req, err := http.NewRequest("PATCH", urls, body)
6233 if err != nil {
6234 return nil, err
6235 }
6236 req.Header = reqHeaders
6237 googleapi.Expand(req.URL, map[string]string{
6238 "name": c.name,
6239 })
6240 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6241 }
6242
6243
6244
6245
6246
6247
6248 func (c *ProjectsLocationsCustomTargetTypesPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
6249 gensupport.SetOptions(c.urlParams_, opts...)
6250 res, err := c.doRequest("json")
6251 if res != nil && res.StatusCode == http.StatusNotModified {
6252 if res.Body != nil {
6253 res.Body.Close()
6254 }
6255 return nil, gensupport.WrapError(&googleapi.Error{
6256 Code: res.StatusCode,
6257 Header: res.Header,
6258 })
6259 }
6260 if err != nil {
6261 return nil, err
6262 }
6263 defer googleapi.CloseBody(res)
6264 if err := googleapi.CheckResponse(res); err != nil {
6265 return nil, gensupport.WrapError(err)
6266 }
6267 ret := &Operation{
6268 ServerResponse: googleapi.ServerResponse{
6269 Header: res.Header,
6270 HTTPStatusCode: res.StatusCode,
6271 },
6272 }
6273 target := &ret
6274 if err := gensupport.DecodeResponse(target, res); err != nil {
6275 return nil, err
6276 }
6277 return ret, nil
6278 }
6279
6280 type ProjectsLocationsCustomTargetTypesSetIamPolicyCall struct {
6281 s *Service
6282 resource string
6283 setiampolicyrequest *SetIamPolicyRequest
6284 urlParams_ gensupport.URLParams
6285 ctx_ context.Context
6286 header_ http.Header
6287 }
6288
6289
6290
6291
6292
6293
6294
6295
6296 func (r *ProjectsLocationsCustomTargetTypesService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsCustomTargetTypesSetIamPolicyCall {
6297 c := &ProjectsLocationsCustomTargetTypesSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6298 c.resource = resource
6299 c.setiampolicyrequest = setiampolicyrequest
6300 return c
6301 }
6302
6303
6304
6305
6306 func (c *ProjectsLocationsCustomTargetTypesSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsCustomTargetTypesSetIamPolicyCall {
6307 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6308 return c
6309 }
6310
6311
6312 func (c *ProjectsLocationsCustomTargetTypesSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsCustomTargetTypesSetIamPolicyCall {
6313 c.ctx_ = ctx
6314 return c
6315 }
6316
6317
6318
6319 func (c *ProjectsLocationsCustomTargetTypesSetIamPolicyCall) Header() http.Header {
6320 if c.header_ == nil {
6321 c.header_ = make(http.Header)
6322 }
6323 return c.header_
6324 }
6325
6326 func (c *ProjectsLocationsCustomTargetTypesSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
6327 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6328 var body io.Reader = nil
6329 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
6330 if err != nil {
6331 return nil, err
6332 }
6333 c.urlParams_.Set("alt", alt)
6334 c.urlParams_.Set("prettyPrint", "false")
6335 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
6336 urls += "?" + c.urlParams_.Encode()
6337 req, err := http.NewRequest("POST", urls, body)
6338 if err != nil {
6339 return nil, err
6340 }
6341 req.Header = reqHeaders
6342 googleapi.Expand(req.URL, map[string]string{
6343 "resource": c.resource,
6344 })
6345 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6346 }
6347
6348
6349
6350
6351
6352
6353 func (c *ProjectsLocationsCustomTargetTypesSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
6354 gensupport.SetOptions(c.urlParams_, opts...)
6355 res, err := c.doRequest("json")
6356 if res != nil && res.StatusCode == http.StatusNotModified {
6357 if res.Body != nil {
6358 res.Body.Close()
6359 }
6360 return nil, gensupport.WrapError(&googleapi.Error{
6361 Code: res.StatusCode,
6362 Header: res.Header,
6363 })
6364 }
6365 if err != nil {
6366 return nil, err
6367 }
6368 defer googleapi.CloseBody(res)
6369 if err := googleapi.CheckResponse(res); err != nil {
6370 return nil, gensupport.WrapError(err)
6371 }
6372 ret := &Policy{
6373 ServerResponse: googleapi.ServerResponse{
6374 Header: res.Header,
6375 HTTPStatusCode: res.StatusCode,
6376 },
6377 }
6378 target := &ret
6379 if err := gensupport.DecodeResponse(target, res); err != nil {
6380 return nil, err
6381 }
6382 return ret, nil
6383 }
6384
6385 type ProjectsLocationsDeliveryPipelinesCreateCall struct {
6386 s *Service
6387 parent string
6388 deliverypipeline *DeliveryPipeline
6389 urlParams_ gensupport.URLParams
6390 ctx_ context.Context
6391 header_ http.Header
6392 }
6393
6394
6395
6396
6397
6398
6399 func (r *ProjectsLocationsDeliveryPipelinesService) Create(parent string, deliverypipeline *DeliveryPipeline) *ProjectsLocationsDeliveryPipelinesCreateCall {
6400 c := &ProjectsLocationsDeliveryPipelinesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6401 c.parent = parent
6402 c.deliverypipeline = deliverypipeline
6403 return c
6404 }
6405
6406
6407
6408 func (c *ProjectsLocationsDeliveryPipelinesCreateCall) DeliveryPipelineId(deliveryPipelineId string) *ProjectsLocationsDeliveryPipelinesCreateCall {
6409 c.urlParams_.Set("deliveryPipelineId", deliveryPipelineId)
6410 return c
6411 }
6412
6413
6414
6415
6416
6417
6418
6419
6420
6421
6422
6423
6424 func (c *ProjectsLocationsDeliveryPipelinesCreateCall) RequestId(requestId string) *ProjectsLocationsDeliveryPipelinesCreateCall {
6425 c.urlParams_.Set("requestId", requestId)
6426 return c
6427 }
6428
6429
6430
6431
6432 func (c *ProjectsLocationsDeliveryPipelinesCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsDeliveryPipelinesCreateCall {
6433 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
6434 return c
6435 }
6436
6437
6438
6439
6440 func (c *ProjectsLocationsDeliveryPipelinesCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesCreateCall {
6441 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6442 return c
6443 }
6444
6445
6446 func (c *ProjectsLocationsDeliveryPipelinesCreateCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesCreateCall {
6447 c.ctx_ = ctx
6448 return c
6449 }
6450
6451
6452
6453 func (c *ProjectsLocationsDeliveryPipelinesCreateCall) Header() http.Header {
6454 if c.header_ == nil {
6455 c.header_ = make(http.Header)
6456 }
6457 return c.header_
6458 }
6459
6460 func (c *ProjectsLocationsDeliveryPipelinesCreateCall) doRequest(alt string) (*http.Response, error) {
6461 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6462 var body io.Reader = nil
6463 body, err := googleapi.WithoutDataWrapper.JSONReader(c.deliverypipeline)
6464 if err != nil {
6465 return nil, err
6466 }
6467 c.urlParams_.Set("alt", alt)
6468 c.urlParams_.Set("prettyPrint", "false")
6469 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/deliveryPipelines")
6470 urls += "?" + c.urlParams_.Encode()
6471 req, err := http.NewRequest("POST", urls, body)
6472 if err != nil {
6473 return nil, err
6474 }
6475 req.Header = reqHeaders
6476 googleapi.Expand(req.URL, map[string]string{
6477 "parent": c.parent,
6478 })
6479 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6480 }
6481
6482
6483
6484
6485
6486
6487 func (c *ProjectsLocationsDeliveryPipelinesCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
6488 gensupport.SetOptions(c.urlParams_, opts...)
6489 res, err := c.doRequest("json")
6490 if res != nil && res.StatusCode == http.StatusNotModified {
6491 if res.Body != nil {
6492 res.Body.Close()
6493 }
6494 return nil, gensupport.WrapError(&googleapi.Error{
6495 Code: res.StatusCode,
6496 Header: res.Header,
6497 })
6498 }
6499 if err != nil {
6500 return nil, err
6501 }
6502 defer googleapi.CloseBody(res)
6503 if err := googleapi.CheckResponse(res); err != nil {
6504 return nil, gensupport.WrapError(err)
6505 }
6506 ret := &Operation{
6507 ServerResponse: googleapi.ServerResponse{
6508 Header: res.Header,
6509 HTTPStatusCode: res.StatusCode,
6510 },
6511 }
6512 target := &ret
6513 if err := gensupport.DecodeResponse(target, res); err != nil {
6514 return nil, err
6515 }
6516 return ret, nil
6517 }
6518
6519 type ProjectsLocationsDeliveryPipelinesDeleteCall struct {
6520 s *Service
6521 name string
6522 urlParams_ gensupport.URLParams
6523 ctx_ context.Context
6524 header_ http.Header
6525 }
6526
6527
6528
6529
6530
6531
6532 func (r *ProjectsLocationsDeliveryPipelinesService) Delete(name string) *ProjectsLocationsDeliveryPipelinesDeleteCall {
6533 c := &ProjectsLocationsDeliveryPipelinesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6534 c.name = name
6535 return c
6536 }
6537
6538
6539
6540
6541 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) AllowMissing(allowMissing bool) *ProjectsLocationsDeliveryPipelinesDeleteCall {
6542 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
6543 return c
6544 }
6545
6546
6547
6548
6549
6550 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) Etag(etag string) *ProjectsLocationsDeliveryPipelinesDeleteCall {
6551 c.urlParams_.Set("etag", etag)
6552 return c
6553 }
6554
6555
6556
6557
6558 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) Force(force bool) *ProjectsLocationsDeliveryPipelinesDeleteCall {
6559 c.urlParams_.Set("force", fmt.Sprint(force))
6560 return c
6561 }
6562
6563
6564
6565
6566
6567
6568
6569
6570
6571
6572
6573
6574 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) RequestId(requestId string) *ProjectsLocationsDeliveryPipelinesDeleteCall {
6575 c.urlParams_.Set("requestId", requestId)
6576 return c
6577 }
6578
6579
6580
6581 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsDeliveryPipelinesDeleteCall {
6582 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
6583 return c
6584 }
6585
6586
6587
6588
6589 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesDeleteCall {
6590 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6591 return c
6592 }
6593
6594
6595 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesDeleteCall {
6596 c.ctx_ = ctx
6597 return c
6598 }
6599
6600
6601
6602 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) Header() http.Header {
6603 if c.header_ == nil {
6604 c.header_ = make(http.Header)
6605 }
6606 return c.header_
6607 }
6608
6609 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) doRequest(alt string) (*http.Response, error) {
6610 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6611 var body io.Reader = nil
6612 c.urlParams_.Set("alt", alt)
6613 c.urlParams_.Set("prettyPrint", "false")
6614 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
6615 urls += "?" + c.urlParams_.Encode()
6616 req, err := http.NewRequest("DELETE", urls, body)
6617 if err != nil {
6618 return nil, err
6619 }
6620 req.Header = reqHeaders
6621 googleapi.Expand(req.URL, map[string]string{
6622 "name": c.name,
6623 })
6624 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6625 }
6626
6627
6628
6629
6630
6631
6632 func (c *ProjectsLocationsDeliveryPipelinesDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
6633 gensupport.SetOptions(c.urlParams_, opts...)
6634 res, err := c.doRequest("json")
6635 if res != nil && res.StatusCode == http.StatusNotModified {
6636 if res.Body != nil {
6637 res.Body.Close()
6638 }
6639 return nil, gensupport.WrapError(&googleapi.Error{
6640 Code: res.StatusCode,
6641 Header: res.Header,
6642 })
6643 }
6644 if err != nil {
6645 return nil, err
6646 }
6647 defer googleapi.CloseBody(res)
6648 if err := googleapi.CheckResponse(res); err != nil {
6649 return nil, gensupport.WrapError(err)
6650 }
6651 ret := &Operation{
6652 ServerResponse: googleapi.ServerResponse{
6653 Header: res.Header,
6654 HTTPStatusCode: res.StatusCode,
6655 },
6656 }
6657 target := &ret
6658 if err := gensupport.DecodeResponse(target, res); err != nil {
6659 return nil, err
6660 }
6661 return ret, nil
6662 }
6663
6664 type ProjectsLocationsDeliveryPipelinesGetCall struct {
6665 s *Service
6666 name string
6667 urlParams_ gensupport.URLParams
6668 ifNoneMatch_ string
6669 ctx_ context.Context
6670 header_ http.Header
6671 }
6672
6673
6674
6675
6676
6677
6678 func (r *ProjectsLocationsDeliveryPipelinesService) Get(name string) *ProjectsLocationsDeliveryPipelinesGetCall {
6679 c := &ProjectsLocationsDeliveryPipelinesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6680 c.name = name
6681 return c
6682 }
6683
6684
6685
6686
6687 func (c *ProjectsLocationsDeliveryPipelinesGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesGetCall {
6688 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6689 return c
6690 }
6691
6692
6693
6694
6695 func (c *ProjectsLocationsDeliveryPipelinesGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesGetCall {
6696 c.ifNoneMatch_ = entityTag
6697 return c
6698 }
6699
6700
6701 func (c *ProjectsLocationsDeliveryPipelinesGetCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesGetCall {
6702 c.ctx_ = ctx
6703 return c
6704 }
6705
6706
6707
6708 func (c *ProjectsLocationsDeliveryPipelinesGetCall) Header() http.Header {
6709 if c.header_ == nil {
6710 c.header_ = make(http.Header)
6711 }
6712 return c.header_
6713 }
6714
6715 func (c *ProjectsLocationsDeliveryPipelinesGetCall) doRequest(alt string) (*http.Response, error) {
6716 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6717 if c.ifNoneMatch_ != "" {
6718 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6719 }
6720 var body io.Reader = nil
6721 c.urlParams_.Set("alt", alt)
6722 c.urlParams_.Set("prettyPrint", "false")
6723 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
6724 urls += "?" + c.urlParams_.Encode()
6725 req, err := http.NewRequest("GET", urls, body)
6726 if err != nil {
6727 return nil, err
6728 }
6729 req.Header = reqHeaders
6730 googleapi.Expand(req.URL, map[string]string{
6731 "name": c.name,
6732 })
6733 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6734 }
6735
6736
6737
6738
6739
6740
6741
6742 func (c *ProjectsLocationsDeliveryPipelinesGetCall) Do(opts ...googleapi.CallOption) (*DeliveryPipeline, error) {
6743 gensupport.SetOptions(c.urlParams_, opts...)
6744 res, err := c.doRequest("json")
6745 if res != nil && res.StatusCode == http.StatusNotModified {
6746 if res.Body != nil {
6747 res.Body.Close()
6748 }
6749 return nil, gensupport.WrapError(&googleapi.Error{
6750 Code: res.StatusCode,
6751 Header: res.Header,
6752 })
6753 }
6754 if err != nil {
6755 return nil, err
6756 }
6757 defer googleapi.CloseBody(res)
6758 if err := googleapi.CheckResponse(res); err != nil {
6759 return nil, gensupport.WrapError(err)
6760 }
6761 ret := &DeliveryPipeline{
6762 ServerResponse: googleapi.ServerResponse{
6763 Header: res.Header,
6764 HTTPStatusCode: res.StatusCode,
6765 },
6766 }
6767 target := &ret
6768 if err := gensupport.DecodeResponse(target, res); err != nil {
6769 return nil, err
6770 }
6771 return ret, nil
6772 }
6773
6774 type ProjectsLocationsDeliveryPipelinesGetIamPolicyCall struct {
6775 s *Service
6776 resource string
6777 urlParams_ gensupport.URLParams
6778 ifNoneMatch_ string
6779 ctx_ context.Context
6780 header_ http.Header
6781 }
6782
6783
6784
6785
6786
6787
6788
6789 func (r *ProjectsLocationsDeliveryPipelinesService) GetIamPolicy(resource string) *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall {
6790 c := &ProjectsLocationsDeliveryPipelinesGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6791 c.resource = resource
6792 return c
6793 }
6794
6795
6796
6797
6798
6799
6800
6801
6802
6803
6804
6805
6806
6807 func (c *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall {
6808 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
6809 return c
6810 }
6811
6812
6813
6814
6815 func (c *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall {
6816 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6817 return c
6818 }
6819
6820
6821
6822
6823 func (c *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall {
6824 c.ifNoneMatch_ = entityTag
6825 return c
6826 }
6827
6828
6829 func (c *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall {
6830 c.ctx_ = ctx
6831 return c
6832 }
6833
6834
6835
6836 func (c *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall) Header() http.Header {
6837 if c.header_ == nil {
6838 c.header_ = make(http.Header)
6839 }
6840 return c.header_
6841 }
6842
6843 func (c *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
6844 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6845 if c.ifNoneMatch_ != "" {
6846 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6847 }
6848 var body io.Reader = nil
6849 c.urlParams_.Set("alt", alt)
6850 c.urlParams_.Set("prettyPrint", "false")
6851 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
6852 urls += "?" + c.urlParams_.Encode()
6853 req, err := http.NewRequest("GET", urls, body)
6854 if err != nil {
6855 return nil, err
6856 }
6857 req.Header = reqHeaders
6858 googleapi.Expand(req.URL, map[string]string{
6859 "resource": c.resource,
6860 })
6861 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6862 }
6863
6864
6865
6866
6867
6868
6869 func (c *ProjectsLocationsDeliveryPipelinesGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
6870 gensupport.SetOptions(c.urlParams_, opts...)
6871 res, err := c.doRequest("json")
6872 if res != nil && res.StatusCode == http.StatusNotModified {
6873 if res.Body != nil {
6874 res.Body.Close()
6875 }
6876 return nil, gensupport.WrapError(&googleapi.Error{
6877 Code: res.StatusCode,
6878 Header: res.Header,
6879 })
6880 }
6881 if err != nil {
6882 return nil, err
6883 }
6884 defer googleapi.CloseBody(res)
6885 if err := googleapi.CheckResponse(res); err != nil {
6886 return nil, gensupport.WrapError(err)
6887 }
6888 ret := &Policy{
6889 ServerResponse: googleapi.ServerResponse{
6890 Header: res.Header,
6891 HTTPStatusCode: res.StatusCode,
6892 },
6893 }
6894 target := &ret
6895 if err := gensupport.DecodeResponse(target, res); err != nil {
6896 return nil, err
6897 }
6898 return ret, nil
6899 }
6900
6901 type ProjectsLocationsDeliveryPipelinesListCall struct {
6902 s *Service
6903 parent string
6904 urlParams_ gensupport.URLParams
6905 ifNoneMatch_ string
6906 ctx_ context.Context
6907 header_ http.Header
6908 }
6909
6910
6911
6912
6913
6914 func (r *ProjectsLocationsDeliveryPipelinesService) List(parent string) *ProjectsLocationsDeliveryPipelinesListCall {
6915 c := &ProjectsLocationsDeliveryPipelinesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6916 c.parent = parent
6917 return c
6918 }
6919
6920
6921
6922 func (c *ProjectsLocationsDeliveryPipelinesListCall) Filter(filter string) *ProjectsLocationsDeliveryPipelinesListCall {
6923 c.urlParams_.Set("filter", filter)
6924 return c
6925 }
6926
6927
6928
6929 func (c *ProjectsLocationsDeliveryPipelinesListCall) OrderBy(orderBy string) *ProjectsLocationsDeliveryPipelinesListCall {
6930 c.urlParams_.Set("orderBy", orderBy)
6931 return c
6932 }
6933
6934
6935
6936
6937
6938 func (c *ProjectsLocationsDeliveryPipelinesListCall) PageSize(pageSize int64) *ProjectsLocationsDeliveryPipelinesListCall {
6939 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6940 return c
6941 }
6942
6943
6944
6945
6946
6947 func (c *ProjectsLocationsDeliveryPipelinesListCall) PageToken(pageToken string) *ProjectsLocationsDeliveryPipelinesListCall {
6948 c.urlParams_.Set("pageToken", pageToken)
6949 return c
6950 }
6951
6952
6953
6954
6955 func (c *ProjectsLocationsDeliveryPipelinesListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesListCall {
6956 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6957 return c
6958 }
6959
6960
6961
6962
6963 func (c *ProjectsLocationsDeliveryPipelinesListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesListCall {
6964 c.ifNoneMatch_ = entityTag
6965 return c
6966 }
6967
6968
6969 func (c *ProjectsLocationsDeliveryPipelinesListCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesListCall {
6970 c.ctx_ = ctx
6971 return c
6972 }
6973
6974
6975
6976 func (c *ProjectsLocationsDeliveryPipelinesListCall) Header() http.Header {
6977 if c.header_ == nil {
6978 c.header_ = make(http.Header)
6979 }
6980 return c.header_
6981 }
6982
6983 func (c *ProjectsLocationsDeliveryPipelinesListCall) doRequest(alt string) (*http.Response, error) {
6984 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6985 if c.ifNoneMatch_ != "" {
6986 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6987 }
6988 var body io.Reader = nil
6989 c.urlParams_.Set("alt", alt)
6990 c.urlParams_.Set("prettyPrint", "false")
6991 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/deliveryPipelines")
6992 urls += "?" + c.urlParams_.Encode()
6993 req, err := http.NewRequest("GET", urls, body)
6994 if err != nil {
6995 return nil, err
6996 }
6997 req.Header = reqHeaders
6998 googleapi.Expand(req.URL, map[string]string{
6999 "parent": c.parent,
7000 })
7001 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7002 }
7003
7004
7005
7006
7007
7008
7009
7010 func (c *ProjectsLocationsDeliveryPipelinesListCall) Do(opts ...googleapi.CallOption) (*ListDeliveryPipelinesResponse, error) {
7011 gensupport.SetOptions(c.urlParams_, opts...)
7012 res, err := c.doRequest("json")
7013 if res != nil && res.StatusCode == http.StatusNotModified {
7014 if res.Body != nil {
7015 res.Body.Close()
7016 }
7017 return nil, gensupport.WrapError(&googleapi.Error{
7018 Code: res.StatusCode,
7019 Header: res.Header,
7020 })
7021 }
7022 if err != nil {
7023 return nil, err
7024 }
7025 defer googleapi.CloseBody(res)
7026 if err := googleapi.CheckResponse(res); err != nil {
7027 return nil, gensupport.WrapError(err)
7028 }
7029 ret := &ListDeliveryPipelinesResponse{
7030 ServerResponse: googleapi.ServerResponse{
7031 Header: res.Header,
7032 HTTPStatusCode: res.StatusCode,
7033 },
7034 }
7035 target := &ret
7036 if err := gensupport.DecodeResponse(target, res); err != nil {
7037 return nil, err
7038 }
7039 return ret, nil
7040 }
7041
7042
7043
7044
7045 func (c *ProjectsLocationsDeliveryPipelinesListCall) Pages(ctx context.Context, f func(*ListDeliveryPipelinesResponse) error) error {
7046 c.ctx_ = ctx
7047 defer c.PageToken(c.urlParams_.Get("pageToken"))
7048 for {
7049 x, err := c.Do()
7050 if err != nil {
7051 return err
7052 }
7053 if err := f(x); err != nil {
7054 return err
7055 }
7056 if x.NextPageToken == "" {
7057 return nil
7058 }
7059 c.PageToken(x.NextPageToken)
7060 }
7061 }
7062
7063 type ProjectsLocationsDeliveryPipelinesPatchCall struct {
7064 s *Service
7065 name string
7066 deliverypipeline *DeliveryPipeline
7067 urlParams_ gensupport.URLParams
7068 ctx_ context.Context
7069 header_ http.Header
7070 }
7071
7072
7073
7074
7075
7076
7077
7078 func (r *ProjectsLocationsDeliveryPipelinesService) Patch(name string, deliverypipeline *DeliveryPipeline) *ProjectsLocationsDeliveryPipelinesPatchCall {
7079 c := &ProjectsLocationsDeliveryPipelinesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7080 c.name = name
7081 c.deliverypipeline = deliverypipeline
7082 return c
7083 }
7084
7085
7086
7087
7088 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) AllowMissing(allowMissing bool) *ProjectsLocationsDeliveryPipelinesPatchCall {
7089 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
7090 return c
7091 }
7092
7093
7094
7095
7096
7097
7098
7099
7100
7101
7102
7103
7104 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) RequestId(requestId string) *ProjectsLocationsDeliveryPipelinesPatchCall {
7105 c.urlParams_.Set("requestId", requestId)
7106 return c
7107 }
7108
7109
7110
7111
7112
7113
7114
7115 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDeliveryPipelinesPatchCall {
7116 c.urlParams_.Set("updateMask", updateMask)
7117 return c
7118 }
7119
7120
7121
7122
7123 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsDeliveryPipelinesPatchCall {
7124 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
7125 return c
7126 }
7127
7128
7129
7130
7131 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesPatchCall {
7132 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7133 return c
7134 }
7135
7136
7137 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesPatchCall {
7138 c.ctx_ = ctx
7139 return c
7140 }
7141
7142
7143
7144 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) Header() http.Header {
7145 if c.header_ == nil {
7146 c.header_ = make(http.Header)
7147 }
7148 return c.header_
7149 }
7150
7151 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) doRequest(alt string) (*http.Response, error) {
7152 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7153 var body io.Reader = nil
7154 body, err := googleapi.WithoutDataWrapper.JSONReader(c.deliverypipeline)
7155 if err != nil {
7156 return nil, err
7157 }
7158 c.urlParams_.Set("alt", alt)
7159 c.urlParams_.Set("prettyPrint", "false")
7160 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
7161 urls += "?" + c.urlParams_.Encode()
7162 req, err := http.NewRequest("PATCH", urls, body)
7163 if err != nil {
7164 return nil, err
7165 }
7166 req.Header = reqHeaders
7167 googleapi.Expand(req.URL, map[string]string{
7168 "name": c.name,
7169 })
7170 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7171 }
7172
7173
7174
7175
7176
7177
7178 func (c *ProjectsLocationsDeliveryPipelinesPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
7179 gensupport.SetOptions(c.urlParams_, opts...)
7180 res, err := c.doRequest("json")
7181 if res != nil && res.StatusCode == http.StatusNotModified {
7182 if res.Body != nil {
7183 res.Body.Close()
7184 }
7185 return nil, gensupport.WrapError(&googleapi.Error{
7186 Code: res.StatusCode,
7187 Header: res.Header,
7188 })
7189 }
7190 if err != nil {
7191 return nil, err
7192 }
7193 defer googleapi.CloseBody(res)
7194 if err := googleapi.CheckResponse(res); err != nil {
7195 return nil, gensupport.WrapError(err)
7196 }
7197 ret := &Operation{
7198 ServerResponse: googleapi.ServerResponse{
7199 Header: res.Header,
7200 HTTPStatusCode: res.StatusCode,
7201 },
7202 }
7203 target := &ret
7204 if err := gensupport.DecodeResponse(target, res); err != nil {
7205 return nil, err
7206 }
7207 return ret, nil
7208 }
7209
7210 type ProjectsLocationsDeliveryPipelinesRollbackTargetCall struct {
7211 s *Service
7212 name string
7213 rollbacktargetrequest *RollbackTargetRequest
7214 urlParams_ gensupport.URLParams
7215 ctx_ context.Context
7216 header_ http.Header
7217 }
7218
7219
7220
7221
7222
7223
7224
7225 func (r *ProjectsLocationsDeliveryPipelinesService) RollbackTarget(name string, rollbacktargetrequest *RollbackTargetRequest) *ProjectsLocationsDeliveryPipelinesRollbackTargetCall {
7226 c := &ProjectsLocationsDeliveryPipelinesRollbackTargetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7227 c.name = name
7228 c.rollbacktargetrequest = rollbacktargetrequest
7229 return c
7230 }
7231
7232
7233
7234
7235 func (c *ProjectsLocationsDeliveryPipelinesRollbackTargetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesRollbackTargetCall {
7236 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7237 return c
7238 }
7239
7240
7241 func (c *ProjectsLocationsDeliveryPipelinesRollbackTargetCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesRollbackTargetCall {
7242 c.ctx_ = ctx
7243 return c
7244 }
7245
7246
7247
7248 func (c *ProjectsLocationsDeliveryPipelinesRollbackTargetCall) Header() http.Header {
7249 if c.header_ == nil {
7250 c.header_ = make(http.Header)
7251 }
7252 return c.header_
7253 }
7254
7255 func (c *ProjectsLocationsDeliveryPipelinesRollbackTargetCall) doRequest(alt string) (*http.Response, error) {
7256 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7257 var body io.Reader = nil
7258 body, err := googleapi.WithoutDataWrapper.JSONReader(c.rollbacktargetrequest)
7259 if err != nil {
7260 return nil, err
7261 }
7262 c.urlParams_.Set("alt", alt)
7263 c.urlParams_.Set("prettyPrint", "false")
7264 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:rollbackTarget")
7265 urls += "?" + c.urlParams_.Encode()
7266 req, err := http.NewRequest("POST", urls, body)
7267 if err != nil {
7268 return nil, err
7269 }
7270 req.Header = reqHeaders
7271 googleapi.Expand(req.URL, map[string]string{
7272 "name": c.name,
7273 })
7274 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7275 }
7276
7277
7278
7279
7280
7281
7282
7283 func (c *ProjectsLocationsDeliveryPipelinesRollbackTargetCall) Do(opts ...googleapi.CallOption) (*RollbackTargetResponse, error) {
7284 gensupport.SetOptions(c.urlParams_, opts...)
7285 res, err := c.doRequest("json")
7286 if res != nil && res.StatusCode == http.StatusNotModified {
7287 if res.Body != nil {
7288 res.Body.Close()
7289 }
7290 return nil, gensupport.WrapError(&googleapi.Error{
7291 Code: res.StatusCode,
7292 Header: res.Header,
7293 })
7294 }
7295 if err != nil {
7296 return nil, err
7297 }
7298 defer googleapi.CloseBody(res)
7299 if err := googleapi.CheckResponse(res); err != nil {
7300 return nil, gensupport.WrapError(err)
7301 }
7302 ret := &RollbackTargetResponse{
7303 ServerResponse: googleapi.ServerResponse{
7304 Header: res.Header,
7305 HTTPStatusCode: res.StatusCode,
7306 },
7307 }
7308 target := &ret
7309 if err := gensupport.DecodeResponse(target, res); err != nil {
7310 return nil, err
7311 }
7312 return ret, nil
7313 }
7314
7315 type ProjectsLocationsDeliveryPipelinesSetIamPolicyCall struct {
7316 s *Service
7317 resource string
7318 setiampolicyrequest *SetIamPolicyRequest
7319 urlParams_ gensupport.URLParams
7320 ctx_ context.Context
7321 header_ http.Header
7322 }
7323
7324
7325
7326
7327
7328
7329
7330
7331 func (r *ProjectsLocationsDeliveryPipelinesService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDeliveryPipelinesSetIamPolicyCall {
7332 c := &ProjectsLocationsDeliveryPipelinesSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7333 c.resource = resource
7334 c.setiampolicyrequest = setiampolicyrequest
7335 return c
7336 }
7337
7338
7339
7340
7341 func (c *ProjectsLocationsDeliveryPipelinesSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesSetIamPolicyCall {
7342 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7343 return c
7344 }
7345
7346
7347 func (c *ProjectsLocationsDeliveryPipelinesSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesSetIamPolicyCall {
7348 c.ctx_ = ctx
7349 return c
7350 }
7351
7352
7353
7354 func (c *ProjectsLocationsDeliveryPipelinesSetIamPolicyCall) Header() http.Header {
7355 if c.header_ == nil {
7356 c.header_ = make(http.Header)
7357 }
7358 return c.header_
7359 }
7360
7361 func (c *ProjectsLocationsDeliveryPipelinesSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
7362 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7363 var body io.Reader = nil
7364 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
7365 if err != nil {
7366 return nil, err
7367 }
7368 c.urlParams_.Set("alt", alt)
7369 c.urlParams_.Set("prettyPrint", "false")
7370 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
7371 urls += "?" + c.urlParams_.Encode()
7372 req, err := http.NewRequest("POST", urls, body)
7373 if err != nil {
7374 return nil, err
7375 }
7376 req.Header = reqHeaders
7377 googleapi.Expand(req.URL, map[string]string{
7378 "resource": c.resource,
7379 })
7380 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7381 }
7382
7383
7384
7385
7386
7387
7388 func (c *ProjectsLocationsDeliveryPipelinesSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
7389 gensupport.SetOptions(c.urlParams_, opts...)
7390 res, err := c.doRequest("json")
7391 if res != nil && res.StatusCode == http.StatusNotModified {
7392 if res.Body != nil {
7393 res.Body.Close()
7394 }
7395 return nil, gensupport.WrapError(&googleapi.Error{
7396 Code: res.StatusCode,
7397 Header: res.Header,
7398 })
7399 }
7400 if err != nil {
7401 return nil, err
7402 }
7403 defer googleapi.CloseBody(res)
7404 if err := googleapi.CheckResponse(res); err != nil {
7405 return nil, gensupport.WrapError(err)
7406 }
7407 ret := &Policy{
7408 ServerResponse: googleapi.ServerResponse{
7409 Header: res.Header,
7410 HTTPStatusCode: res.StatusCode,
7411 },
7412 }
7413 target := &ret
7414 if err := gensupport.DecodeResponse(target, res); err != nil {
7415 return nil, err
7416 }
7417 return ret, nil
7418 }
7419
7420 type ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall struct {
7421 s *Service
7422 resource string
7423 testiampermissionsrequest *TestIamPermissionsRequest
7424 urlParams_ gensupport.URLParams
7425 ctx_ context.Context
7426 header_ http.Header
7427 }
7428
7429
7430
7431
7432
7433
7434
7435
7436
7437
7438
7439 func (r *ProjectsLocationsDeliveryPipelinesService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall {
7440 c := &ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7441 c.resource = resource
7442 c.testiampermissionsrequest = testiampermissionsrequest
7443 return c
7444 }
7445
7446
7447
7448
7449 func (c *ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall {
7450 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7451 return c
7452 }
7453
7454
7455 func (c *ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall {
7456 c.ctx_ = ctx
7457 return c
7458 }
7459
7460
7461
7462 func (c *ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall) Header() http.Header {
7463 if c.header_ == nil {
7464 c.header_ = make(http.Header)
7465 }
7466 return c.header_
7467 }
7468
7469 func (c *ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
7470 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7471 var body io.Reader = nil
7472 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
7473 if err != nil {
7474 return nil, err
7475 }
7476 c.urlParams_.Set("alt", alt)
7477 c.urlParams_.Set("prettyPrint", "false")
7478 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
7479 urls += "?" + c.urlParams_.Encode()
7480 req, err := http.NewRequest("POST", urls, body)
7481 if err != nil {
7482 return nil, err
7483 }
7484 req.Header = reqHeaders
7485 googleapi.Expand(req.URL, map[string]string{
7486 "resource": c.resource,
7487 })
7488 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7489 }
7490
7491
7492
7493
7494
7495
7496
7497 func (c *ProjectsLocationsDeliveryPipelinesTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
7498 gensupport.SetOptions(c.urlParams_, opts...)
7499 res, err := c.doRequest("json")
7500 if res != nil && res.StatusCode == http.StatusNotModified {
7501 if res.Body != nil {
7502 res.Body.Close()
7503 }
7504 return nil, gensupport.WrapError(&googleapi.Error{
7505 Code: res.StatusCode,
7506 Header: res.Header,
7507 })
7508 }
7509 if err != nil {
7510 return nil, err
7511 }
7512 defer googleapi.CloseBody(res)
7513 if err := googleapi.CheckResponse(res); err != nil {
7514 return nil, gensupport.WrapError(err)
7515 }
7516 ret := &TestIamPermissionsResponse{
7517 ServerResponse: googleapi.ServerResponse{
7518 Header: res.Header,
7519 HTTPStatusCode: res.StatusCode,
7520 },
7521 }
7522 target := &ret
7523 if err := gensupport.DecodeResponse(target, res); err != nil {
7524 return nil, err
7525 }
7526 return ret, nil
7527 }
7528
7529 type ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall struct {
7530 s *Service
7531 name string
7532 cancelautomationrunrequest *CancelAutomationRunRequest
7533 urlParams_ gensupport.URLParams
7534 ctx_ context.Context
7535 header_ http.Header
7536 }
7537
7538
7539
7540
7541
7542
7543
7544
7545
7546 func (r *ProjectsLocationsDeliveryPipelinesAutomationRunsService) Cancel(name string, cancelautomationrunrequest *CancelAutomationRunRequest) *ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall {
7547 c := &ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7548 c.name = name
7549 c.cancelautomationrunrequest = cancelautomationrunrequest
7550 return c
7551 }
7552
7553
7554
7555
7556 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall {
7557 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7558 return c
7559 }
7560
7561
7562 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall {
7563 c.ctx_ = ctx
7564 return c
7565 }
7566
7567
7568
7569 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall) Header() http.Header {
7570 if c.header_ == nil {
7571 c.header_ = make(http.Header)
7572 }
7573 return c.header_
7574 }
7575
7576 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall) doRequest(alt string) (*http.Response, error) {
7577 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7578 var body io.Reader = nil
7579 body, err := googleapi.WithoutDataWrapper.JSONReader(c.cancelautomationrunrequest)
7580 if err != nil {
7581 return nil, err
7582 }
7583 c.urlParams_.Set("alt", alt)
7584 c.urlParams_.Set("prettyPrint", "false")
7585 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:cancel")
7586 urls += "?" + c.urlParams_.Encode()
7587 req, err := http.NewRequest("POST", urls, body)
7588 if err != nil {
7589 return nil, err
7590 }
7591 req.Header = reqHeaders
7592 googleapi.Expand(req.URL, map[string]string{
7593 "name": c.name,
7594 })
7595 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7596 }
7597
7598
7599
7600
7601
7602
7603
7604 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsCancelCall) Do(opts ...googleapi.CallOption) (*CancelAutomationRunResponse, error) {
7605 gensupport.SetOptions(c.urlParams_, opts...)
7606 res, err := c.doRequest("json")
7607 if res != nil && res.StatusCode == http.StatusNotModified {
7608 if res.Body != nil {
7609 res.Body.Close()
7610 }
7611 return nil, gensupport.WrapError(&googleapi.Error{
7612 Code: res.StatusCode,
7613 Header: res.Header,
7614 })
7615 }
7616 if err != nil {
7617 return nil, err
7618 }
7619 defer googleapi.CloseBody(res)
7620 if err := googleapi.CheckResponse(res); err != nil {
7621 return nil, gensupport.WrapError(err)
7622 }
7623 ret := &CancelAutomationRunResponse{
7624 ServerResponse: googleapi.ServerResponse{
7625 Header: res.Header,
7626 HTTPStatusCode: res.StatusCode,
7627 },
7628 }
7629 target := &ret
7630 if err := gensupport.DecodeResponse(target, res); err != nil {
7631 return nil, err
7632 }
7633 return ret, nil
7634 }
7635
7636 type ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall struct {
7637 s *Service
7638 name string
7639 urlParams_ gensupport.URLParams
7640 ifNoneMatch_ string
7641 ctx_ context.Context
7642 header_ http.Header
7643 }
7644
7645
7646
7647
7648
7649
7650 func (r *ProjectsLocationsDeliveryPipelinesAutomationRunsService) Get(name string) *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall {
7651 c := &ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7652 c.name = name
7653 return c
7654 }
7655
7656
7657
7658
7659 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall {
7660 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7661 return c
7662 }
7663
7664
7665
7666
7667 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall {
7668 c.ifNoneMatch_ = entityTag
7669 return c
7670 }
7671
7672
7673 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall {
7674 c.ctx_ = ctx
7675 return c
7676 }
7677
7678
7679
7680 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall) Header() http.Header {
7681 if c.header_ == nil {
7682 c.header_ = make(http.Header)
7683 }
7684 return c.header_
7685 }
7686
7687 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall) doRequest(alt string) (*http.Response, error) {
7688 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7689 if c.ifNoneMatch_ != "" {
7690 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7691 }
7692 var body io.Reader = nil
7693 c.urlParams_.Set("alt", alt)
7694 c.urlParams_.Set("prettyPrint", "false")
7695 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
7696 urls += "?" + c.urlParams_.Encode()
7697 req, err := http.NewRequest("GET", urls, body)
7698 if err != nil {
7699 return nil, err
7700 }
7701 req.Header = reqHeaders
7702 googleapi.Expand(req.URL, map[string]string{
7703 "name": c.name,
7704 })
7705 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7706 }
7707
7708
7709
7710
7711
7712
7713 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsGetCall) Do(opts ...googleapi.CallOption) (*AutomationRun, error) {
7714 gensupport.SetOptions(c.urlParams_, opts...)
7715 res, err := c.doRequest("json")
7716 if res != nil && res.StatusCode == http.StatusNotModified {
7717 if res.Body != nil {
7718 res.Body.Close()
7719 }
7720 return nil, gensupport.WrapError(&googleapi.Error{
7721 Code: res.StatusCode,
7722 Header: res.Header,
7723 })
7724 }
7725 if err != nil {
7726 return nil, err
7727 }
7728 defer googleapi.CloseBody(res)
7729 if err := googleapi.CheckResponse(res); err != nil {
7730 return nil, gensupport.WrapError(err)
7731 }
7732 ret := &AutomationRun{
7733 ServerResponse: googleapi.ServerResponse{
7734 Header: res.Header,
7735 HTTPStatusCode: res.StatusCode,
7736 },
7737 }
7738 target := &ret
7739 if err := gensupport.DecodeResponse(target, res); err != nil {
7740 return nil, err
7741 }
7742 return ret, nil
7743 }
7744
7745 type ProjectsLocationsDeliveryPipelinesAutomationRunsListCall struct {
7746 s *Service
7747 parent string
7748 urlParams_ gensupport.URLParams
7749 ifNoneMatch_ string
7750 ctx_ context.Context
7751 header_ http.Header
7752 }
7753
7754
7755
7756
7757
7758
7759
7760 func (r *ProjectsLocationsDeliveryPipelinesAutomationRunsService) List(parent string) *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall {
7761 c := &ProjectsLocationsDeliveryPipelinesAutomationRunsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7762 c.parent = parent
7763 return c
7764 }
7765
7766
7767
7768 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) Filter(filter string) *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall {
7769 c.urlParams_.Set("filter", filter)
7770 return c
7771 }
7772
7773
7774 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) OrderBy(orderBy string) *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall {
7775 c.urlParams_.Set("orderBy", orderBy)
7776 return c
7777 }
7778
7779
7780
7781
7782
7783 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) PageSize(pageSize int64) *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall {
7784 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
7785 return c
7786 }
7787
7788
7789
7790
7791
7792 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) PageToken(pageToken string) *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall {
7793 c.urlParams_.Set("pageToken", pageToken)
7794 return c
7795 }
7796
7797
7798
7799
7800 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall {
7801 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7802 return c
7803 }
7804
7805
7806
7807
7808 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall {
7809 c.ifNoneMatch_ = entityTag
7810 return c
7811 }
7812
7813
7814 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall {
7815 c.ctx_ = ctx
7816 return c
7817 }
7818
7819
7820
7821 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) Header() http.Header {
7822 if c.header_ == nil {
7823 c.header_ = make(http.Header)
7824 }
7825 return c.header_
7826 }
7827
7828 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) doRequest(alt string) (*http.Response, error) {
7829 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7830 if c.ifNoneMatch_ != "" {
7831 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7832 }
7833 var body io.Reader = nil
7834 c.urlParams_.Set("alt", alt)
7835 c.urlParams_.Set("prettyPrint", "false")
7836 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/automationRuns")
7837 urls += "?" + c.urlParams_.Encode()
7838 req, err := http.NewRequest("GET", urls, body)
7839 if err != nil {
7840 return nil, err
7841 }
7842 req.Header = reqHeaders
7843 googleapi.Expand(req.URL, map[string]string{
7844 "parent": c.parent,
7845 })
7846 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7847 }
7848
7849
7850
7851
7852
7853
7854
7855 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) Do(opts ...googleapi.CallOption) (*ListAutomationRunsResponse, error) {
7856 gensupport.SetOptions(c.urlParams_, opts...)
7857 res, err := c.doRequest("json")
7858 if res != nil && res.StatusCode == http.StatusNotModified {
7859 if res.Body != nil {
7860 res.Body.Close()
7861 }
7862 return nil, gensupport.WrapError(&googleapi.Error{
7863 Code: res.StatusCode,
7864 Header: res.Header,
7865 })
7866 }
7867 if err != nil {
7868 return nil, err
7869 }
7870 defer googleapi.CloseBody(res)
7871 if err := googleapi.CheckResponse(res); err != nil {
7872 return nil, gensupport.WrapError(err)
7873 }
7874 ret := &ListAutomationRunsResponse{
7875 ServerResponse: googleapi.ServerResponse{
7876 Header: res.Header,
7877 HTTPStatusCode: res.StatusCode,
7878 },
7879 }
7880 target := &ret
7881 if err := gensupport.DecodeResponse(target, res); err != nil {
7882 return nil, err
7883 }
7884 return ret, nil
7885 }
7886
7887
7888
7889
7890 func (c *ProjectsLocationsDeliveryPipelinesAutomationRunsListCall) Pages(ctx context.Context, f func(*ListAutomationRunsResponse) error) error {
7891 c.ctx_ = ctx
7892 defer c.PageToken(c.urlParams_.Get("pageToken"))
7893 for {
7894 x, err := c.Do()
7895 if err != nil {
7896 return err
7897 }
7898 if err := f(x); err != nil {
7899 return err
7900 }
7901 if x.NextPageToken == "" {
7902 return nil
7903 }
7904 c.PageToken(x.NextPageToken)
7905 }
7906 }
7907
7908 type ProjectsLocationsDeliveryPipelinesAutomationsCreateCall struct {
7909 s *Service
7910 parent string
7911 automation *Automation
7912 urlParams_ gensupport.URLParams
7913 ctx_ context.Context
7914 header_ http.Header
7915 }
7916
7917
7918
7919
7920
7921
7922
7923 func (r *ProjectsLocationsDeliveryPipelinesAutomationsService) Create(parent string, automation *Automation) *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall {
7924 c := &ProjectsLocationsDeliveryPipelinesAutomationsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7925 c.parent = parent
7926 c.automation = automation
7927 return c
7928 }
7929
7930
7931
7932 func (c *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall) AutomationId(automationId string) *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall {
7933 c.urlParams_.Set("automationId", automationId)
7934 return c
7935 }
7936
7937
7938
7939
7940
7941
7942
7943
7944
7945
7946
7947
7948 func (c *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall) RequestId(requestId string) *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall {
7949 c.urlParams_.Set("requestId", requestId)
7950 return c
7951 }
7952
7953
7954
7955
7956 func (c *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall {
7957 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
7958 return c
7959 }
7960
7961
7962
7963
7964 func (c *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall {
7965 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7966 return c
7967 }
7968
7969
7970 func (c *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall {
7971 c.ctx_ = ctx
7972 return c
7973 }
7974
7975
7976
7977 func (c *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall) Header() http.Header {
7978 if c.header_ == nil {
7979 c.header_ = make(http.Header)
7980 }
7981 return c.header_
7982 }
7983
7984 func (c *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall) doRequest(alt string) (*http.Response, error) {
7985 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7986 var body io.Reader = nil
7987 body, err := googleapi.WithoutDataWrapper.JSONReader(c.automation)
7988 if err != nil {
7989 return nil, err
7990 }
7991 c.urlParams_.Set("alt", alt)
7992 c.urlParams_.Set("prettyPrint", "false")
7993 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/automations")
7994 urls += "?" + c.urlParams_.Encode()
7995 req, err := http.NewRequest("POST", urls, body)
7996 if err != nil {
7997 return nil, err
7998 }
7999 req.Header = reqHeaders
8000 googleapi.Expand(req.URL, map[string]string{
8001 "parent": c.parent,
8002 })
8003 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8004 }
8005
8006
8007
8008
8009
8010
8011 func (c *ProjectsLocationsDeliveryPipelinesAutomationsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
8012 gensupport.SetOptions(c.urlParams_, opts...)
8013 res, err := c.doRequest("json")
8014 if res != nil && res.StatusCode == http.StatusNotModified {
8015 if res.Body != nil {
8016 res.Body.Close()
8017 }
8018 return nil, gensupport.WrapError(&googleapi.Error{
8019 Code: res.StatusCode,
8020 Header: res.Header,
8021 })
8022 }
8023 if err != nil {
8024 return nil, err
8025 }
8026 defer googleapi.CloseBody(res)
8027 if err := googleapi.CheckResponse(res); err != nil {
8028 return nil, gensupport.WrapError(err)
8029 }
8030 ret := &Operation{
8031 ServerResponse: googleapi.ServerResponse{
8032 Header: res.Header,
8033 HTTPStatusCode: res.StatusCode,
8034 },
8035 }
8036 target := &ret
8037 if err := gensupport.DecodeResponse(target, res); err != nil {
8038 return nil, err
8039 }
8040 return ret, nil
8041 }
8042
8043 type ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall struct {
8044 s *Service
8045 name string
8046 urlParams_ gensupport.URLParams
8047 ctx_ context.Context
8048 header_ http.Header
8049 }
8050
8051
8052
8053
8054
8055
8056 func (r *ProjectsLocationsDeliveryPipelinesAutomationsService) Delete(name string) *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall {
8057 c := &ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8058 c.name = name
8059 return c
8060 }
8061
8062
8063
8064 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) AllowMissing(allowMissing bool) *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall {
8065 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
8066 return c
8067 }
8068
8069
8070
8071
8072
8073 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) Etag(etag string) *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall {
8074 c.urlParams_.Set("etag", etag)
8075 return c
8076 }
8077
8078
8079
8080
8081
8082
8083
8084
8085
8086
8087
8088
8089 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) RequestId(requestId string) *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall {
8090 c.urlParams_.Set("requestId", requestId)
8091 return c
8092 }
8093
8094
8095
8096
8097 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall {
8098 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
8099 return c
8100 }
8101
8102
8103
8104
8105 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall {
8106 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8107 return c
8108 }
8109
8110
8111 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall {
8112 c.ctx_ = ctx
8113 return c
8114 }
8115
8116
8117
8118 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) Header() http.Header {
8119 if c.header_ == nil {
8120 c.header_ = make(http.Header)
8121 }
8122 return c.header_
8123 }
8124
8125 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) doRequest(alt string) (*http.Response, error) {
8126 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8127 var body io.Reader = nil
8128 c.urlParams_.Set("alt", alt)
8129 c.urlParams_.Set("prettyPrint", "false")
8130 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8131 urls += "?" + c.urlParams_.Encode()
8132 req, err := http.NewRequest("DELETE", urls, body)
8133 if err != nil {
8134 return nil, err
8135 }
8136 req.Header = reqHeaders
8137 googleapi.Expand(req.URL, map[string]string{
8138 "name": c.name,
8139 })
8140 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8141 }
8142
8143
8144
8145
8146
8147
8148 func (c *ProjectsLocationsDeliveryPipelinesAutomationsDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
8149 gensupport.SetOptions(c.urlParams_, opts...)
8150 res, err := c.doRequest("json")
8151 if res != nil && res.StatusCode == http.StatusNotModified {
8152 if res.Body != nil {
8153 res.Body.Close()
8154 }
8155 return nil, gensupport.WrapError(&googleapi.Error{
8156 Code: res.StatusCode,
8157 Header: res.Header,
8158 })
8159 }
8160 if err != nil {
8161 return nil, err
8162 }
8163 defer googleapi.CloseBody(res)
8164 if err := googleapi.CheckResponse(res); err != nil {
8165 return nil, gensupport.WrapError(err)
8166 }
8167 ret := &Operation{
8168 ServerResponse: googleapi.ServerResponse{
8169 Header: res.Header,
8170 HTTPStatusCode: res.StatusCode,
8171 },
8172 }
8173 target := &ret
8174 if err := gensupport.DecodeResponse(target, res); err != nil {
8175 return nil, err
8176 }
8177 return ret, nil
8178 }
8179
8180 type ProjectsLocationsDeliveryPipelinesAutomationsGetCall struct {
8181 s *Service
8182 name string
8183 urlParams_ gensupport.URLParams
8184 ifNoneMatch_ string
8185 ctx_ context.Context
8186 header_ http.Header
8187 }
8188
8189
8190
8191
8192
8193
8194 func (r *ProjectsLocationsDeliveryPipelinesAutomationsService) Get(name string) *ProjectsLocationsDeliveryPipelinesAutomationsGetCall {
8195 c := &ProjectsLocationsDeliveryPipelinesAutomationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8196 c.name = name
8197 return c
8198 }
8199
8200
8201
8202
8203 func (c *ProjectsLocationsDeliveryPipelinesAutomationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesAutomationsGetCall {
8204 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8205 return c
8206 }
8207
8208
8209
8210
8211 func (c *ProjectsLocationsDeliveryPipelinesAutomationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesAutomationsGetCall {
8212 c.ifNoneMatch_ = entityTag
8213 return c
8214 }
8215
8216
8217 func (c *ProjectsLocationsDeliveryPipelinesAutomationsGetCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesAutomationsGetCall {
8218 c.ctx_ = ctx
8219 return c
8220 }
8221
8222
8223
8224 func (c *ProjectsLocationsDeliveryPipelinesAutomationsGetCall) Header() http.Header {
8225 if c.header_ == nil {
8226 c.header_ = make(http.Header)
8227 }
8228 return c.header_
8229 }
8230
8231 func (c *ProjectsLocationsDeliveryPipelinesAutomationsGetCall) doRequest(alt string) (*http.Response, error) {
8232 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8233 if c.ifNoneMatch_ != "" {
8234 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8235 }
8236 var body io.Reader = nil
8237 c.urlParams_.Set("alt", alt)
8238 c.urlParams_.Set("prettyPrint", "false")
8239 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8240 urls += "?" + c.urlParams_.Encode()
8241 req, err := http.NewRequest("GET", urls, body)
8242 if err != nil {
8243 return nil, err
8244 }
8245 req.Header = reqHeaders
8246 googleapi.Expand(req.URL, map[string]string{
8247 "name": c.name,
8248 })
8249 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8250 }
8251
8252
8253
8254
8255
8256
8257 func (c *ProjectsLocationsDeliveryPipelinesAutomationsGetCall) Do(opts ...googleapi.CallOption) (*Automation, error) {
8258 gensupport.SetOptions(c.urlParams_, opts...)
8259 res, err := c.doRequest("json")
8260 if res != nil && res.StatusCode == http.StatusNotModified {
8261 if res.Body != nil {
8262 res.Body.Close()
8263 }
8264 return nil, gensupport.WrapError(&googleapi.Error{
8265 Code: res.StatusCode,
8266 Header: res.Header,
8267 })
8268 }
8269 if err != nil {
8270 return nil, err
8271 }
8272 defer googleapi.CloseBody(res)
8273 if err := googleapi.CheckResponse(res); err != nil {
8274 return nil, gensupport.WrapError(err)
8275 }
8276 ret := &Automation{
8277 ServerResponse: googleapi.ServerResponse{
8278 Header: res.Header,
8279 HTTPStatusCode: res.StatusCode,
8280 },
8281 }
8282 target := &ret
8283 if err := gensupport.DecodeResponse(target, res); err != nil {
8284 return nil, err
8285 }
8286 return ret, nil
8287 }
8288
8289 type ProjectsLocationsDeliveryPipelinesAutomationsListCall struct {
8290 s *Service
8291 parent string
8292 urlParams_ gensupport.URLParams
8293 ifNoneMatch_ string
8294 ctx_ context.Context
8295 header_ http.Header
8296 }
8297
8298
8299
8300
8301
8302
8303
8304 func (r *ProjectsLocationsDeliveryPipelinesAutomationsService) List(parent string) *ProjectsLocationsDeliveryPipelinesAutomationsListCall {
8305 c := &ProjectsLocationsDeliveryPipelinesAutomationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8306 c.parent = parent
8307 return c
8308 }
8309
8310
8311
8312 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) Filter(filter string) *ProjectsLocationsDeliveryPipelinesAutomationsListCall {
8313 c.urlParams_.Set("filter", filter)
8314 return c
8315 }
8316
8317
8318 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) OrderBy(orderBy string) *ProjectsLocationsDeliveryPipelinesAutomationsListCall {
8319 c.urlParams_.Set("orderBy", orderBy)
8320 return c
8321 }
8322
8323
8324
8325
8326
8327 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) PageSize(pageSize int64) *ProjectsLocationsDeliveryPipelinesAutomationsListCall {
8328 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
8329 return c
8330 }
8331
8332
8333
8334
8335
8336 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) PageToken(pageToken string) *ProjectsLocationsDeliveryPipelinesAutomationsListCall {
8337 c.urlParams_.Set("pageToken", pageToken)
8338 return c
8339 }
8340
8341
8342
8343
8344 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesAutomationsListCall {
8345 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8346 return c
8347 }
8348
8349
8350
8351
8352 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesAutomationsListCall {
8353 c.ifNoneMatch_ = entityTag
8354 return c
8355 }
8356
8357
8358 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesAutomationsListCall {
8359 c.ctx_ = ctx
8360 return c
8361 }
8362
8363
8364
8365 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) Header() http.Header {
8366 if c.header_ == nil {
8367 c.header_ = make(http.Header)
8368 }
8369 return c.header_
8370 }
8371
8372 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) doRequest(alt string) (*http.Response, error) {
8373 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8374 if c.ifNoneMatch_ != "" {
8375 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8376 }
8377 var body io.Reader = nil
8378 c.urlParams_.Set("alt", alt)
8379 c.urlParams_.Set("prettyPrint", "false")
8380 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/automations")
8381 urls += "?" + c.urlParams_.Encode()
8382 req, err := http.NewRequest("GET", urls, body)
8383 if err != nil {
8384 return nil, err
8385 }
8386 req.Header = reqHeaders
8387 googleapi.Expand(req.URL, map[string]string{
8388 "parent": c.parent,
8389 })
8390 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8391 }
8392
8393
8394
8395
8396
8397
8398
8399 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) Do(opts ...googleapi.CallOption) (*ListAutomationsResponse, error) {
8400 gensupport.SetOptions(c.urlParams_, opts...)
8401 res, err := c.doRequest("json")
8402 if res != nil && res.StatusCode == http.StatusNotModified {
8403 if res.Body != nil {
8404 res.Body.Close()
8405 }
8406 return nil, gensupport.WrapError(&googleapi.Error{
8407 Code: res.StatusCode,
8408 Header: res.Header,
8409 })
8410 }
8411 if err != nil {
8412 return nil, err
8413 }
8414 defer googleapi.CloseBody(res)
8415 if err := googleapi.CheckResponse(res); err != nil {
8416 return nil, gensupport.WrapError(err)
8417 }
8418 ret := &ListAutomationsResponse{
8419 ServerResponse: googleapi.ServerResponse{
8420 Header: res.Header,
8421 HTTPStatusCode: res.StatusCode,
8422 },
8423 }
8424 target := &ret
8425 if err := gensupport.DecodeResponse(target, res); err != nil {
8426 return nil, err
8427 }
8428 return ret, nil
8429 }
8430
8431
8432
8433
8434 func (c *ProjectsLocationsDeliveryPipelinesAutomationsListCall) Pages(ctx context.Context, f func(*ListAutomationsResponse) error) error {
8435 c.ctx_ = ctx
8436 defer c.PageToken(c.urlParams_.Get("pageToken"))
8437 for {
8438 x, err := c.Do()
8439 if err != nil {
8440 return err
8441 }
8442 if err := f(x); err != nil {
8443 return err
8444 }
8445 if x.NextPageToken == "" {
8446 return nil
8447 }
8448 c.PageToken(x.NextPageToken)
8449 }
8450 }
8451
8452 type ProjectsLocationsDeliveryPipelinesAutomationsPatchCall struct {
8453 s *Service
8454 name string
8455 automation *Automation
8456 urlParams_ gensupport.URLParams
8457 ctx_ context.Context
8458 header_ http.Header
8459 }
8460
8461
8462
8463
8464
8465
8466 func (r *ProjectsLocationsDeliveryPipelinesAutomationsService) Patch(name string, automation *Automation) *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall {
8467 c := &ProjectsLocationsDeliveryPipelinesAutomationsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8468 c.name = name
8469 c.automation = automation
8470 return c
8471 }
8472
8473
8474
8475
8476 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) AllowMissing(allowMissing bool) *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall {
8477 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
8478 return c
8479 }
8480
8481
8482
8483
8484
8485
8486
8487
8488
8489
8490
8491
8492 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) RequestId(requestId string) *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall {
8493 c.urlParams_.Set("requestId", requestId)
8494 return c
8495 }
8496
8497
8498
8499
8500
8501
8502 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall {
8503 c.urlParams_.Set("updateMask", updateMask)
8504 return c
8505 }
8506
8507
8508
8509
8510 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall {
8511 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
8512 return c
8513 }
8514
8515
8516
8517
8518 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall {
8519 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8520 return c
8521 }
8522
8523
8524 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall {
8525 c.ctx_ = ctx
8526 return c
8527 }
8528
8529
8530
8531 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) Header() http.Header {
8532 if c.header_ == nil {
8533 c.header_ = make(http.Header)
8534 }
8535 return c.header_
8536 }
8537
8538 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) doRequest(alt string) (*http.Response, error) {
8539 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8540 var body io.Reader = nil
8541 body, err := googleapi.WithoutDataWrapper.JSONReader(c.automation)
8542 if err != nil {
8543 return nil, err
8544 }
8545 c.urlParams_.Set("alt", alt)
8546 c.urlParams_.Set("prettyPrint", "false")
8547 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8548 urls += "?" + c.urlParams_.Encode()
8549 req, err := http.NewRequest("PATCH", urls, body)
8550 if err != nil {
8551 return nil, err
8552 }
8553 req.Header = reqHeaders
8554 googleapi.Expand(req.URL, map[string]string{
8555 "name": c.name,
8556 })
8557 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8558 }
8559
8560
8561
8562
8563
8564
8565 func (c *ProjectsLocationsDeliveryPipelinesAutomationsPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
8566 gensupport.SetOptions(c.urlParams_, opts...)
8567 res, err := c.doRequest("json")
8568 if res != nil && res.StatusCode == http.StatusNotModified {
8569 if res.Body != nil {
8570 res.Body.Close()
8571 }
8572 return nil, gensupport.WrapError(&googleapi.Error{
8573 Code: res.StatusCode,
8574 Header: res.Header,
8575 })
8576 }
8577 if err != nil {
8578 return nil, err
8579 }
8580 defer googleapi.CloseBody(res)
8581 if err := googleapi.CheckResponse(res); err != nil {
8582 return nil, gensupport.WrapError(err)
8583 }
8584 ret := &Operation{
8585 ServerResponse: googleapi.ServerResponse{
8586 Header: res.Header,
8587 HTTPStatusCode: res.StatusCode,
8588 },
8589 }
8590 target := &ret
8591 if err := gensupport.DecodeResponse(target, res); err != nil {
8592 return nil, err
8593 }
8594 return ret, nil
8595 }
8596
8597 type ProjectsLocationsDeliveryPipelinesReleasesAbandonCall struct {
8598 s *Service
8599 name string
8600 abandonreleaserequest *AbandonReleaseRequest
8601 urlParams_ gensupport.URLParams
8602 ctx_ context.Context
8603 header_ http.Header
8604 }
8605
8606
8607
8608
8609
8610
8611 func (r *ProjectsLocationsDeliveryPipelinesReleasesService) Abandon(name string, abandonreleaserequest *AbandonReleaseRequest) *ProjectsLocationsDeliveryPipelinesReleasesAbandonCall {
8612 c := &ProjectsLocationsDeliveryPipelinesReleasesAbandonCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8613 c.name = name
8614 c.abandonreleaserequest = abandonreleaserequest
8615 return c
8616 }
8617
8618
8619
8620
8621 func (c *ProjectsLocationsDeliveryPipelinesReleasesAbandonCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesAbandonCall {
8622 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8623 return c
8624 }
8625
8626
8627 func (c *ProjectsLocationsDeliveryPipelinesReleasesAbandonCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesAbandonCall {
8628 c.ctx_ = ctx
8629 return c
8630 }
8631
8632
8633
8634 func (c *ProjectsLocationsDeliveryPipelinesReleasesAbandonCall) Header() http.Header {
8635 if c.header_ == nil {
8636 c.header_ = make(http.Header)
8637 }
8638 return c.header_
8639 }
8640
8641 func (c *ProjectsLocationsDeliveryPipelinesReleasesAbandonCall) doRequest(alt string) (*http.Response, error) {
8642 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8643 var body io.Reader = nil
8644 body, err := googleapi.WithoutDataWrapper.JSONReader(c.abandonreleaserequest)
8645 if err != nil {
8646 return nil, err
8647 }
8648 c.urlParams_.Set("alt", alt)
8649 c.urlParams_.Set("prettyPrint", "false")
8650 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:abandon")
8651 urls += "?" + c.urlParams_.Encode()
8652 req, err := http.NewRequest("POST", urls, body)
8653 if err != nil {
8654 return nil, err
8655 }
8656 req.Header = reqHeaders
8657 googleapi.Expand(req.URL, map[string]string{
8658 "name": c.name,
8659 })
8660 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8661 }
8662
8663
8664
8665
8666
8667
8668
8669 func (c *ProjectsLocationsDeliveryPipelinesReleasesAbandonCall) Do(opts ...googleapi.CallOption) (*AbandonReleaseResponse, error) {
8670 gensupport.SetOptions(c.urlParams_, opts...)
8671 res, err := c.doRequest("json")
8672 if res != nil && res.StatusCode == http.StatusNotModified {
8673 if res.Body != nil {
8674 res.Body.Close()
8675 }
8676 return nil, gensupport.WrapError(&googleapi.Error{
8677 Code: res.StatusCode,
8678 Header: res.Header,
8679 })
8680 }
8681 if err != nil {
8682 return nil, err
8683 }
8684 defer googleapi.CloseBody(res)
8685 if err := googleapi.CheckResponse(res); err != nil {
8686 return nil, gensupport.WrapError(err)
8687 }
8688 ret := &AbandonReleaseResponse{
8689 ServerResponse: googleapi.ServerResponse{
8690 Header: res.Header,
8691 HTTPStatusCode: res.StatusCode,
8692 },
8693 }
8694 target := &ret
8695 if err := gensupport.DecodeResponse(target, res); err != nil {
8696 return nil, err
8697 }
8698 return ret, nil
8699 }
8700
8701 type ProjectsLocationsDeliveryPipelinesReleasesCreateCall struct {
8702 s *Service
8703 parent string
8704 release *Release
8705 urlParams_ gensupport.URLParams
8706 ctx_ context.Context
8707 header_ http.Header
8708 }
8709
8710
8711
8712
8713
8714
8715
8716 func (r *ProjectsLocationsDeliveryPipelinesReleasesService) Create(parent string, release *Release) *ProjectsLocationsDeliveryPipelinesReleasesCreateCall {
8717 c := &ProjectsLocationsDeliveryPipelinesReleasesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8718 c.parent = parent
8719 c.release = release
8720 return c
8721 }
8722
8723
8724
8725 func (c *ProjectsLocationsDeliveryPipelinesReleasesCreateCall) ReleaseId(releaseId string) *ProjectsLocationsDeliveryPipelinesReleasesCreateCall {
8726 c.urlParams_.Set("releaseId", releaseId)
8727 return c
8728 }
8729
8730
8731
8732
8733
8734
8735
8736
8737
8738
8739
8740
8741 func (c *ProjectsLocationsDeliveryPipelinesReleasesCreateCall) RequestId(requestId string) *ProjectsLocationsDeliveryPipelinesReleasesCreateCall {
8742 c.urlParams_.Set("requestId", requestId)
8743 return c
8744 }
8745
8746
8747
8748
8749 func (c *ProjectsLocationsDeliveryPipelinesReleasesCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsDeliveryPipelinesReleasesCreateCall {
8750 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
8751 return c
8752 }
8753
8754
8755
8756
8757 func (c *ProjectsLocationsDeliveryPipelinesReleasesCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesCreateCall {
8758 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8759 return c
8760 }
8761
8762
8763 func (c *ProjectsLocationsDeliveryPipelinesReleasesCreateCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesCreateCall {
8764 c.ctx_ = ctx
8765 return c
8766 }
8767
8768
8769
8770 func (c *ProjectsLocationsDeliveryPipelinesReleasesCreateCall) Header() http.Header {
8771 if c.header_ == nil {
8772 c.header_ = make(http.Header)
8773 }
8774 return c.header_
8775 }
8776
8777 func (c *ProjectsLocationsDeliveryPipelinesReleasesCreateCall) doRequest(alt string) (*http.Response, error) {
8778 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8779 var body io.Reader = nil
8780 body, err := googleapi.WithoutDataWrapper.JSONReader(c.release)
8781 if err != nil {
8782 return nil, err
8783 }
8784 c.urlParams_.Set("alt", alt)
8785 c.urlParams_.Set("prettyPrint", "false")
8786 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/releases")
8787 urls += "?" + c.urlParams_.Encode()
8788 req, err := http.NewRequest("POST", urls, body)
8789 if err != nil {
8790 return nil, err
8791 }
8792 req.Header = reqHeaders
8793 googleapi.Expand(req.URL, map[string]string{
8794 "parent": c.parent,
8795 })
8796 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8797 }
8798
8799
8800
8801
8802
8803
8804 func (c *ProjectsLocationsDeliveryPipelinesReleasesCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
8805 gensupport.SetOptions(c.urlParams_, opts...)
8806 res, err := c.doRequest("json")
8807 if res != nil && res.StatusCode == http.StatusNotModified {
8808 if res.Body != nil {
8809 res.Body.Close()
8810 }
8811 return nil, gensupport.WrapError(&googleapi.Error{
8812 Code: res.StatusCode,
8813 Header: res.Header,
8814 })
8815 }
8816 if err != nil {
8817 return nil, err
8818 }
8819 defer googleapi.CloseBody(res)
8820 if err := googleapi.CheckResponse(res); err != nil {
8821 return nil, gensupport.WrapError(err)
8822 }
8823 ret := &Operation{
8824 ServerResponse: googleapi.ServerResponse{
8825 Header: res.Header,
8826 HTTPStatusCode: res.StatusCode,
8827 },
8828 }
8829 target := &ret
8830 if err := gensupport.DecodeResponse(target, res); err != nil {
8831 return nil, err
8832 }
8833 return ret, nil
8834 }
8835
8836 type ProjectsLocationsDeliveryPipelinesReleasesGetCall struct {
8837 s *Service
8838 name string
8839 urlParams_ gensupport.URLParams
8840 ifNoneMatch_ string
8841 ctx_ context.Context
8842 header_ http.Header
8843 }
8844
8845
8846
8847
8848
8849
8850 func (r *ProjectsLocationsDeliveryPipelinesReleasesService) Get(name string) *ProjectsLocationsDeliveryPipelinesReleasesGetCall {
8851 c := &ProjectsLocationsDeliveryPipelinesReleasesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8852 c.name = name
8853 return c
8854 }
8855
8856
8857
8858
8859 func (c *ProjectsLocationsDeliveryPipelinesReleasesGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesGetCall {
8860 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8861 return c
8862 }
8863
8864
8865
8866
8867 func (c *ProjectsLocationsDeliveryPipelinesReleasesGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesReleasesGetCall {
8868 c.ifNoneMatch_ = entityTag
8869 return c
8870 }
8871
8872
8873 func (c *ProjectsLocationsDeliveryPipelinesReleasesGetCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesGetCall {
8874 c.ctx_ = ctx
8875 return c
8876 }
8877
8878
8879
8880 func (c *ProjectsLocationsDeliveryPipelinesReleasesGetCall) Header() http.Header {
8881 if c.header_ == nil {
8882 c.header_ = make(http.Header)
8883 }
8884 return c.header_
8885 }
8886
8887 func (c *ProjectsLocationsDeliveryPipelinesReleasesGetCall) doRequest(alt string) (*http.Response, error) {
8888 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8889 if c.ifNoneMatch_ != "" {
8890 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8891 }
8892 var body io.Reader = nil
8893 c.urlParams_.Set("alt", alt)
8894 c.urlParams_.Set("prettyPrint", "false")
8895 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8896 urls += "?" + c.urlParams_.Encode()
8897 req, err := http.NewRequest("GET", urls, body)
8898 if err != nil {
8899 return nil, err
8900 }
8901 req.Header = reqHeaders
8902 googleapi.Expand(req.URL, map[string]string{
8903 "name": c.name,
8904 })
8905 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8906 }
8907
8908
8909
8910
8911
8912
8913 func (c *ProjectsLocationsDeliveryPipelinesReleasesGetCall) Do(opts ...googleapi.CallOption) (*Release, error) {
8914 gensupport.SetOptions(c.urlParams_, opts...)
8915 res, err := c.doRequest("json")
8916 if res != nil && res.StatusCode == http.StatusNotModified {
8917 if res.Body != nil {
8918 res.Body.Close()
8919 }
8920 return nil, gensupport.WrapError(&googleapi.Error{
8921 Code: res.StatusCode,
8922 Header: res.Header,
8923 })
8924 }
8925 if err != nil {
8926 return nil, err
8927 }
8928 defer googleapi.CloseBody(res)
8929 if err := googleapi.CheckResponse(res); err != nil {
8930 return nil, gensupport.WrapError(err)
8931 }
8932 ret := &Release{
8933 ServerResponse: googleapi.ServerResponse{
8934 Header: res.Header,
8935 HTTPStatusCode: res.StatusCode,
8936 },
8937 }
8938 target := &ret
8939 if err := gensupport.DecodeResponse(target, res); err != nil {
8940 return nil, err
8941 }
8942 return ret, nil
8943 }
8944
8945 type ProjectsLocationsDeliveryPipelinesReleasesListCall struct {
8946 s *Service
8947 parent string
8948 urlParams_ gensupport.URLParams
8949 ifNoneMatch_ string
8950 ctx_ context.Context
8951 header_ http.Header
8952 }
8953
8954
8955
8956
8957
8958 func (r *ProjectsLocationsDeliveryPipelinesReleasesService) List(parent string) *ProjectsLocationsDeliveryPipelinesReleasesListCall {
8959 c := &ProjectsLocationsDeliveryPipelinesReleasesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8960 c.parent = parent
8961 return c
8962 }
8963
8964
8965
8966 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) Filter(filter string) *ProjectsLocationsDeliveryPipelinesReleasesListCall {
8967 c.urlParams_.Set("filter", filter)
8968 return c
8969 }
8970
8971
8972
8973 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) OrderBy(orderBy string) *ProjectsLocationsDeliveryPipelinesReleasesListCall {
8974 c.urlParams_.Set("orderBy", orderBy)
8975 return c
8976 }
8977
8978
8979
8980
8981
8982 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) PageSize(pageSize int64) *ProjectsLocationsDeliveryPipelinesReleasesListCall {
8983 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
8984 return c
8985 }
8986
8987
8988
8989
8990
8991 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) PageToken(pageToken string) *ProjectsLocationsDeliveryPipelinesReleasesListCall {
8992 c.urlParams_.Set("pageToken", pageToken)
8993 return c
8994 }
8995
8996
8997
8998
8999 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesListCall {
9000 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9001 return c
9002 }
9003
9004
9005
9006
9007 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesReleasesListCall {
9008 c.ifNoneMatch_ = entityTag
9009 return c
9010 }
9011
9012
9013 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesListCall {
9014 c.ctx_ = ctx
9015 return c
9016 }
9017
9018
9019
9020 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) Header() http.Header {
9021 if c.header_ == nil {
9022 c.header_ = make(http.Header)
9023 }
9024 return c.header_
9025 }
9026
9027 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) doRequest(alt string) (*http.Response, error) {
9028 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9029 if c.ifNoneMatch_ != "" {
9030 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9031 }
9032 var body io.Reader = nil
9033 c.urlParams_.Set("alt", alt)
9034 c.urlParams_.Set("prettyPrint", "false")
9035 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/releases")
9036 urls += "?" + c.urlParams_.Encode()
9037 req, err := http.NewRequest("GET", urls, body)
9038 if err != nil {
9039 return nil, err
9040 }
9041 req.Header = reqHeaders
9042 googleapi.Expand(req.URL, map[string]string{
9043 "parent": c.parent,
9044 })
9045 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9046 }
9047
9048
9049
9050
9051
9052
9053
9054 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) Do(opts ...googleapi.CallOption) (*ListReleasesResponse, error) {
9055 gensupport.SetOptions(c.urlParams_, opts...)
9056 res, err := c.doRequest("json")
9057 if res != nil && res.StatusCode == http.StatusNotModified {
9058 if res.Body != nil {
9059 res.Body.Close()
9060 }
9061 return nil, gensupport.WrapError(&googleapi.Error{
9062 Code: res.StatusCode,
9063 Header: res.Header,
9064 })
9065 }
9066 if err != nil {
9067 return nil, err
9068 }
9069 defer googleapi.CloseBody(res)
9070 if err := googleapi.CheckResponse(res); err != nil {
9071 return nil, gensupport.WrapError(err)
9072 }
9073 ret := &ListReleasesResponse{
9074 ServerResponse: googleapi.ServerResponse{
9075 Header: res.Header,
9076 HTTPStatusCode: res.StatusCode,
9077 },
9078 }
9079 target := &ret
9080 if err := gensupport.DecodeResponse(target, res); err != nil {
9081 return nil, err
9082 }
9083 return ret, nil
9084 }
9085
9086
9087
9088
9089 func (c *ProjectsLocationsDeliveryPipelinesReleasesListCall) Pages(ctx context.Context, f func(*ListReleasesResponse) error) error {
9090 c.ctx_ = ctx
9091 defer c.PageToken(c.urlParams_.Get("pageToken"))
9092 for {
9093 x, err := c.Do()
9094 if err != nil {
9095 return err
9096 }
9097 if err := f(x); err != nil {
9098 return err
9099 }
9100 if x.NextPageToken == "" {
9101 return nil
9102 }
9103 c.PageToken(x.NextPageToken)
9104 }
9105 }
9106
9107 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall struct {
9108 s *Service
9109 name string
9110 advancerolloutrequest *AdvanceRolloutRequest
9111 urlParams_ gensupport.URLParams
9112 ctx_ context.Context
9113 header_ http.Header
9114 }
9115
9116
9117
9118
9119
9120
9121 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService) Advance(name string, advancerolloutrequest *AdvanceRolloutRequest) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall {
9122 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9123 c.name = name
9124 c.advancerolloutrequest = advancerolloutrequest
9125 return c
9126 }
9127
9128
9129
9130
9131 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall {
9132 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9133 return c
9134 }
9135
9136
9137 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall {
9138 c.ctx_ = ctx
9139 return c
9140 }
9141
9142
9143
9144 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall) Header() http.Header {
9145 if c.header_ == nil {
9146 c.header_ = make(http.Header)
9147 }
9148 return c.header_
9149 }
9150
9151 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall) doRequest(alt string) (*http.Response, error) {
9152 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9153 var body io.Reader = nil
9154 body, err := googleapi.WithoutDataWrapper.JSONReader(c.advancerolloutrequest)
9155 if err != nil {
9156 return nil, err
9157 }
9158 c.urlParams_.Set("alt", alt)
9159 c.urlParams_.Set("prettyPrint", "false")
9160 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:advance")
9161 urls += "?" + c.urlParams_.Encode()
9162 req, err := http.NewRequest("POST", urls, body)
9163 if err != nil {
9164 return nil, err
9165 }
9166 req.Header = reqHeaders
9167 googleapi.Expand(req.URL, map[string]string{
9168 "name": c.name,
9169 })
9170 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9171 }
9172
9173
9174
9175
9176
9177
9178
9179 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsAdvanceCall) Do(opts ...googleapi.CallOption) (*AdvanceRolloutResponse, error) {
9180 gensupport.SetOptions(c.urlParams_, opts...)
9181 res, err := c.doRequest("json")
9182 if res != nil && res.StatusCode == http.StatusNotModified {
9183 if res.Body != nil {
9184 res.Body.Close()
9185 }
9186 return nil, gensupport.WrapError(&googleapi.Error{
9187 Code: res.StatusCode,
9188 Header: res.Header,
9189 })
9190 }
9191 if err != nil {
9192 return nil, err
9193 }
9194 defer googleapi.CloseBody(res)
9195 if err := googleapi.CheckResponse(res); err != nil {
9196 return nil, gensupport.WrapError(err)
9197 }
9198 ret := &AdvanceRolloutResponse{
9199 ServerResponse: googleapi.ServerResponse{
9200 Header: res.Header,
9201 HTTPStatusCode: res.StatusCode,
9202 },
9203 }
9204 target := &ret
9205 if err := gensupport.DecodeResponse(target, res); err != nil {
9206 return nil, err
9207 }
9208 return ret, nil
9209 }
9210
9211 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall struct {
9212 s *Service
9213 name string
9214 approverolloutrequest *ApproveRolloutRequest
9215 urlParams_ gensupport.URLParams
9216 ctx_ context.Context
9217 header_ http.Header
9218 }
9219
9220
9221
9222
9223
9224
9225 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService) Approve(name string, approverolloutrequest *ApproveRolloutRequest) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall {
9226 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9227 c.name = name
9228 c.approverolloutrequest = approverolloutrequest
9229 return c
9230 }
9231
9232
9233
9234
9235 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall {
9236 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9237 return c
9238 }
9239
9240
9241 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall {
9242 c.ctx_ = ctx
9243 return c
9244 }
9245
9246
9247
9248 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall) Header() http.Header {
9249 if c.header_ == nil {
9250 c.header_ = make(http.Header)
9251 }
9252 return c.header_
9253 }
9254
9255 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall) doRequest(alt string) (*http.Response, error) {
9256 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9257 var body io.Reader = nil
9258 body, err := googleapi.WithoutDataWrapper.JSONReader(c.approverolloutrequest)
9259 if err != nil {
9260 return nil, err
9261 }
9262 c.urlParams_.Set("alt", alt)
9263 c.urlParams_.Set("prettyPrint", "false")
9264 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:approve")
9265 urls += "?" + c.urlParams_.Encode()
9266 req, err := http.NewRequest("POST", urls, body)
9267 if err != nil {
9268 return nil, err
9269 }
9270 req.Header = reqHeaders
9271 googleapi.Expand(req.URL, map[string]string{
9272 "name": c.name,
9273 })
9274 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9275 }
9276
9277
9278
9279
9280
9281
9282
9283 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsApproveCall) Do(opts ...googleapi.CallOption) (*ApproveRolloutResponse, error) {
9284 gensupport.SetOptions(c.urlParams_, opts...)
9285 res, err := c.doRequest("json")
9286 if res != nil && res.StatusCode == http.StatusNotModified {
9287 if res.Body != nil {
9288 res.Body.Close()
9289 }
9290 return nil, gensupport.WrapError(&googleapi.Error{
9291 Code: res.StatusCode,
9292 Header: res.Header,
9293 })
9294 }
9295 if err != nil {
9296 return nil, err
9297 }
9298 defer googleapi.CloseBody(res)
9299 if err := googleapi.CheckResponse(res); err != nil {
9300 return nil, gensupport.WrapError(err)
9301 }
9302 ret := &ApproveRolloutResponse{
9303 ServerResponse: googleapi.ServerResponse{
9304 Header: res.Header,
9305 HTTPStatusCode: res.StatusCode,
9306 },
9307 }
9308 target := &ret
9309 if err := gensupport.DecodeResponse(target, res); err != nil {
9310 return nil, err
9311 }
9312 return ret, nil
9313 }
9314
9315 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall struct {
9316 s *Service
9317 name string
9318 cancelrolloutrequest *CancelRolloutRequest
9319 urlParams_ gensupport.URLParams
9320 ctx_ context.Context
9321 header_ http.Header
9322 }
9323
9324
9325
9326
9327
9328
9329 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService) Cancel(name string, cancelrolloutrequest *CancelRolloutRequest) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall {
9330 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9331 c.name = name
9332 c.cancelrolloutrequest = cancelrolloutrequest
9333 return c
9334 }
9335
9336
9337
9338
9339 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall {
9340 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9341 return c
9342 }
9343
9344
9345 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall {
9346 c.ctx_ = ctx
9347 return c
9348 }
9349
9350
9351
9352 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall) Header() http.Header {
9353 if c.header_ == nil {
9354 c.header_ = make(http.Header)
9355 }
9356 return c.header_
9357 }
9358
9359 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall) doRequest(alt string) (*http.Response, error) {
9360 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9361 var body io.Reader = nil
9362 body, err := googleapi.WithoutDataWrapper.JSONReader(c.cancelrolloutrequest)
9363 if err != nil {
9364 return nil, err
9365 }
9366 c.urlParams_.Set("alt", alt)
9367 c.urlParams_.Set("prettyPrint", "false")
9368 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:cancel")
9369 urls += "?" + c.urlParams_.Encode()
9370 req, err := http.NewRequest("POST", urls, body)
9371 if err != nil {
9372 return nil, err
9373 }
9374 req.Header = reqHeaders
9375 googleapi.Expand(req.URL, map[string]string{
9376 "name": c.name,
9377 })
9378 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9379 }
9380
9381
9382
9383
9384
9385
9386
9387 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCancelCall) Do(opts ...googleapi.CallOption) (*CancelRolloutResponse, error) {
9388 gensupport.SetOptions(c.urlParams_, opts...)
9389 res, err := c.doRequest("json")
9390 if res != nil && res.StatusCode == http.StatusNotModified {
9391 if res.Body != nil {
9392 res.Body.Close()
9393 }
9394 return nil, gensupport.WrapError(&googleapi.Error{
9395 Code: res.StatusCode,
9396 Header: res.Header,
9397 })
9398 }
9399 if err != nil {
9400 return nil, err
9401 }
9402 defer googleapi.CloseBody(res)
9403 if err := googleapi.CheckResponse(res); err != nil {
9404 return nil, gensupport.WrapError(err)
9405 }
9406 ret := &CancelRolloutResponse{
9407 ServerResponse: googleapi.ServerResponse{
9408 Header: res.Header,
9409 HTTPStatusCode: res.StatusCode,
9410 },
9411 }
9412 target := &ret
9413 if err := gensupport.DecodeResponse(target, res); err != nil {
9414 return nil, err
9415 }
9416 return ret, nil
9417 }
9418
9419 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall struct {
9420 s *Service
9421 parent string
9422 rollout *Rollout
9423 urlParams_ gensupport.URLParams
9424 ctx_ context.Context
9425 header_ http.Header
9426 }
9427
9428
9429
9430
9431
9432
9433
9434 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService) Create(parent string, rollout *Rollout) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall {
9435 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9436 c.parent = parent
9437 c.rollout = rollout
9438 return c
9439 }
9440
9441
9442
9443
9444
9445
9446
9447
9448
9449
9450
9451
9452 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) RequestId(requestId string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall {
9453 c.urlParams_.Set("requestId", requestId)
9454 return c
9455 }
9456
9457
9458
9459 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) RolloutId(rolloutId string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall {
9460 c.urlParams_.Set("rolloutId", rolloutId)
9461 return c
9462 }
9463
9464
9465
9466
9467 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) StartingPhaseId(startingPhaseId string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall {
9468 c.urlParams_.Set("startingPhaseId", startingPhaseId)
9469 return c
9470 }
9471
9472
9473
9474
9475 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall {
9476 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
9477 return c
9478 }
9479
9480
9481
9482
9483 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall {
9484 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9485 return c
9486 }
9487
9488
9489 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall {
9490 c.ctx_ = ctx
9491 return c
9492 }
9493
9494
9495
9496 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) Header() http.Header {
9497 if c.header_ == nil {
9498 c.header_ = make(http.Header)
9499 }
9500 return c.header_
9501 }
9502
9503 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) doRequest(alt string) (*http.Response, error) {
9504 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9505 var body io.Reader = nil
9506 body, err := googleapi.WithoutDataWrapper.JSONReader(c.rollout)
9507 if err != nil {
9508 return nil, err
9509 }
9510 c.urlParams_.Set("alt", alt)
9511 c.urlParams_.Set("prettyPrint", "false")
9512 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/rollouts")
9513 urls += "?" + c.urlParams_.Encode()
9514 req, err := http.NewRequest("POST", urls, body)
9515 if err != nil {
9516 return nil, err
9517 }
9518 req.Header = reqHeaders
9519 googleapi.Expand(req.URL, map[string]string{
9520 "parent": c.parent,
9521 })
9522 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9523 }
9524
9525
9526
9527
9528
9529
9530 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
9531 gensupport.SetOptions(c.urlParams_, opts...)
9532 res, err := c.doRequest("json")
9533 if res != nil && res.StatusCode == http.StatusNotModified {
9534 if res.Body != nil {
9535 res.Body.Close()
9536 }
9537 return nil, gensupport.WrapError(&googleapi.Error{
9538 Code: res.StatusCode,
9539 Header: res.Header,
9540 })
9541 }
9542 if err != nil {
9543 return nil, err
9544 }
9545 defer googleapi.CloseBody(res)
9546 if err := googleapi.CheckResponse(res); err != nil {
9547 return nil, gensupport.WrapError(err)
9548 }
9549 ret := &Operation{
9550 ServerResponse: googleapi.ServerResponse{
9551 Header: res.Header,
9552 HTTPStatusCode: res.StatusCode,
9553 },
9554 }
9555 target := &ret
9556 if err := gensupport.DecodeResponse(target, res); err != nil {
9557 return nil, err
9558 }
9559 return ret, nil
9560 }
9561
9562 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall struct {
9563 s *Service
9564 name string
9565 urlParams_ gensupport.URLParams
9566 ifNoneMatch_ string
9567 ctx_ context.Context
9568 header_ http.Header
9569 }
9570
9571
9572
9573
9574
9575
9576 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService) Get(name string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall {
9577 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9578 c.name = name
9579 return c
9580 }
9581
9582
9583
9584
9585 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall {
9586 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9587 return c
9588 }
9589
9590
9591
9592
9593 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall {
9594 c.ifNoneMatch_ = entityTag
9595 return c
9596 }
9597
9598
9599 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall {
9600 c.ctx_ = ctx
9601 return c
9602 }
9603
9604
9605
9606 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall) Header() http.Header {
9607 if c.header_ == nil {
9608 c.header_ = make(http.Header)
9609 }
9610 return c.header_
9611 }
9612
9613 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall) doRequest(alt string) (*http.Response, error) {
9614 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9615 if c.ifNoneMatch_ != "" {
9616 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9617 }
9618 var body io.Reader = nil
9619 c.urlParams_.Set("alt", alt)
9620 c.urlParams_.Set("prettyPrint", "false")
9621 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
9622 urls += "?" + c.urlParams_.Encode()
9623 req, err := http.NewRequest("GET", urls, body)
9624 if err != nil {
9625 return nil, err
9626 }
9627 req.Header = reqHeaders
9628 googleapi.Expand(req.URL, map[string]string{
9629 "name": c.name,
9630 })
9631 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9632 }
9633
9634
9635
9636
9637
9638
9639 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsGetCall) Do(opts ...googleapi.CallOption) (*Rollout, error) {
9640 gensupport.SetOptions(c.urlParams_, opts...)
9641 res, err := c.doRequest("json")
9642 if res != nil && res.StatusCode == http.StatusNotModified {
9643 if res.Body != nil {
9644 res.Body.Close()
9645 }
9646 return nil, gensupport.WrapError(&googleapi.Error{
9647 Code: res.StatusCode,
9648 Header: res.Header,
9649 })
9650 }
9651 if err != nil {
9652 return nil, err
9653 }
9654 defer googleapi.CloseBody(res)
9655 if err := googleapi.CheckResponse(res); err != nil {
9656 return nil, gensupport.WrapError(err)
9657 }
9658 ret := &Rollout{
9659 ServerResponse: googleapi.ServerResponse{
9660 Header: res.Header,
9661 HTTPStatusCode: res.StatusCode,
9662 },
9663 }
9664 target := &ret
9665 if err := gensupport.DecodeResponse(target, res); err != nil {
9666 return nil, err
9667 }
9668 return ret, nil
9669 }
9670
9671 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall struct {
9672 s *Service
9673 rollout string
9674 ignorejobrequest *IgnoreJobRequest
9675 urlParams_ gensupport.URLParams
9676 ctx_ context.Context
9677 header_ http.Header
9678 }
9679
9680
9681
9682
9683
9684
9685 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService) IgnoreJob(rollout string, ignorejobrequest *IgnoreJobRequest) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall {
9686 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9687 c.rollout = rollout
9688 c.ignorejobrequest = ignorejobrequest
9689 return c
9690 }
9691
9692
9693
9694
9695 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall {
9696 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9697 return c
9698 }
9699
9700
9701 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall {
9702 c.ctx_ = ctx
9703 return c
9704 }
9705
9706
9707
9708 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall) Header() http.Header {
9709 if c.header_ == nil {
9710 c.header_ = make(http.Header)
9711 }
9712 return c.header_
9713 }
9714
9715 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall) doRequest(alt string) (*http.Response, error) {
9716 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9717 var body io.Reader = nil
9718 body, err := googleapi.WithoutDataWrapper.JSONReader(c.ignorejobrequest)
9719 if err != nil {
9720 return nil, err
9721 }
9722 c.urlParams_.Set("alt", alt)
9723 c.urlParams_.Set("prettyPrint", "false")
9724 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+rollout}:ignoreJob")
9725 urls += "?" + c.urlParams_.Encode()
9726 req, err := http.NewRequest("POST", urls, body)
9727 if err != nil {
9728 return nil, err
9729 }
9730 req.Header = reqHeaders
9731 googleapi.Expand(req.URL, map[string]string{
9732 "rollout": c.rollout,
9733 })
9734 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9735 }
9736
9737
9738
9739
9740
9741
9742
9743 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsIgnoreJobCall) Do(opts ...googleapi.CallOption) (*IgnoreJobResponse, error) {
9744 gensupport.SetOptions(c.urlParams_, opts...)
9745 res, err := c.doRequest("json")
9746 if res != nil && res.StatusCode == http.StatusNotModified {
9747 if res.Body != nil {
9748 res.Body.Close()
9749 }
9750 return nil, gensupport.WrapError(&googleapi.Error{
9751 Code: res.StatusCode,
9752 Header: res.Header,
9753 })
9754 }
9755 if err != nil {
9756 return nil, err
9757 }
9758 defer googleapi.CloseBody(res)
9759 if err := googleapi.CheckResponse(res); err != nil {
9760 return nil, gensupport.WrapError(err)
9761 }
9762 ret := &IgnoreJobResponse{
9763 ServerResponse: googleapi.ServerResponse{
9764 Header: res.Header,
9765 HTTPStatusCode: res.StatusCode,
9766 },
9767 }
9768 target := &ret
9769 if err := gensupport.DecodeResponse(target, res); err != nil {
9770 return nil, err
9771 }
9772 return ret, nil
9773 }
9774
9775 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall struct {
9776 s *Service
9777 parent string
9778 urlParams_ gensupport.URLParams
9779 ifNoneMatch_ string
9780 ctx_ context.Context
9781 header_ http.Header
9782 }
9783
9784
9785
9786
9787 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService) List(parent string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall {
9788 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9789 c.parent = parent
9790 return c
9791 }
9792
9793
9794
9795 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) Filter(filter string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall {
9796 c.urlParams_.Set("filter", filter)
9797 return c
9798 }
9799
9800
9801
9802 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) OrderBy(orderBy string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall {
9803 c.urlParams_.Set("orderBy", orderBy)
9804 return c
9805 }
9806
9807
9808
9809
9810
9811 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) PageSize(pageSize int64) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall {
9812 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9813 return c
9814 }
9815
9816
9817
9818
9819
9820 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) PageToken(pageToken string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall {
9821 c.urlParams_.Set("pageToken", pageToken)
9822 return c
9823 }
9824
9825
9826
9827
9828 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall {
9829 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9830 return c
9831 }
9832
9833
9834
9835
9836 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall {
9837 c.ifNoneMatch_ = entityTag
9838 return c
9839 }
9840
9841
9842 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall {
9843 c.ctx_ = ctx
9844 return c
9845 }
9846
9847
9848
9849 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) Header() http.Header {
9850 if c.header_ == nil {
9851 c.header_ = make(http.Header)
9852 }
9853 return c.header_
9854 }
9855
9856 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) doRequest(alt string) (*http.Response, error) {
9857 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9858 if c.ifNoneMatch_ != "" {
9859 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9860 }
9861 var body io.Reader = nil
9862 c.urlParams_.Set("alt", alt)
9863 c.urlParams_.Set("prettyPrint", "false")
9864 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/rollouts")
9865 urls += "?" + c.urlParams_.Encode()
9866 req, err := http.NewRequest("GET", urls, body)
9867 if err != nil {
9868 return nil, err
9869 }
9870 req.Header = reqHeaders
9871 googleapi.Expand(req.URL, map[string]string{
9872 "parent": c.parent,
9873 })
9874 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9875 }
9876
9877
9878
9879
9880
9881
9882
9883 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) Do(opts ...googleapi.CallOption) (*ListRolloutsResponse, error) {
9884 gensupport.SetOptions(c.urlParams_, opts...)
9885 res, err := c.doRequest("json")
9886 if res != nil && res.StatusCode == http.StatusNotModified {
9887 if res.Body != nil {
9888 res.Body.Close()
9889 }
9890 return nil, gensupport.WrapError(&googleapi.Error{
9891 Code: res.StatusCode,
9892 Header: res.Header,
9893 })
9894 }
9895 if err != nil {
9896 return nil, err
9897 }
9898 defer googleapi.CloseBody(res)
9899 if err := googleapi.CheckResponse(res); err != nil {
9900 return nil, gensupport.WrapError(err)
9901 }
9902 ret := &ListRolloutsResponse{
9903 ServerResponse: googleapi.ServerResponse{
9904 Header: res.Header,
9905 HTTPStatusCode: res.StatusCode,
9906 },
9907 }
9908 target := &ret
9909 if err := gensupport.DecodeResponse(target, res); err != nil {
9910 return nil, err
9911 }
9912 return ret, nil
9913 }
9914
9915
9916
9917
9918 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsListCall) Pages(ctx context.Context, f func(*ListRolloutsResponse) error) error {
9919 c.ctx_ = ctx
9920 defer c.PageToken(c.urlParams_.Get("pageToken"))
9921 for {
9922 x, err := c.Do()
9923 if err != nil {
9924 return err
9925 }
9926 if err := f(x); err != nil {
9927 return err
9928 }
9929 if x.NextPageToken == "" {
9930 return nil
9931 }
9932 c.PageToken(x.NextPageToken)
9933 }
9934 }
9935
9936 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall struct {
9937 s *Service
9938 rollout string
9939 retryjobrequest *RetryJobRequest
9940 urlParams_ gensupport.URLParams
9941 ctx_ context.Context
9942 header_ http.Header
9943 }
9944
9945
9946
9947
9948
9949
9950 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsService) RetryJob(rollout string, retryjobrequest *RetryJobRequest) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall {
9951 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9952 c.rollout = rollout
9953 c.retryjobrequest = retryjobrequest
9954 return c
9955 }
9956
9957
9958
9959
9960 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall {
9961 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9962 return c
9963 }
9964
9965
9966 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall {
9967 c.ctx_ = ctx
9968 return c
9969 }
9970
9971
9972
9973 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall) Header() http.Header {
9974 if c.header_ == nil {
9975 c.header_ = make(http.Header)
9976 }
9977 return c.header_
9978 }
9979
9980 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall) doRequest(alt string) (*http.Response, error) {
9981 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9982 var body io.Reader = nil
9983 body, err := googleapi.WithoutDataWrapper.JSONReader(c.retryjobrequest)
9984 if err != nil {
9985 return nil, err
9986 }
9987 c.urlParams_.Set("alt", alt)
9988 c.urlParams_.Set("prettyPrint", "false")
9989 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+rollout}:retryJob")
9990 urls += "?" + c.urlParams_.Encode()
9991 req, err := http.NewRequest("POST", urls, body)
9992 if err != nil {
9993 return nil, err
9994 }
9995 req.Header = reqHeaders
9996 googleapi.Expand(req.URL, map[string]string{
9997 "rollout": c.rollout,
9998 })
9999 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10000 }
10001
10002
10003
10004
10005
10006
10007
10008 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsRetryJobCall) Do(opts ...googleapi.CallOption) (*RetryJobResponse, error) {
10009 gensupport.SetOptions(c.urlParams_, opts...)
10010 res, err := c.doRequest("json")
10011 if res != nil && res.StatusCode == http.StatusNotModified {
10012 if res.Body != nil {
10013 res.Body.Close()
10014 }
10015 return nil, gensupport.WrapError(&googleapi.Error{
10016 Code: res.StatusCode,
10017 Header: res.Header,
10018 })
10019 }
10020 if err != nil {
10021 return nil, err
10022 }
10023 defer googleapi.CloseBody(res)
10024 if err := googleapi.CheckResponse(res); err != nil {
10025 return nil, gensupport.WrapError(err)
10026 }
10027 ret := &RetryJobResponse{
10028 ServerResponse: googleapi.ServerResponse{
10029 Header: res.Header,
10030 HTTPStatusCode: res.StatusCode,
10031 },
10032 }
10033 target := &ret
10034 if err := gensupport.DecodeResponse(target, res); err != nil {
10035 return nil, err
10036 }
10037 return ret, nil
10038 }
10039
10040 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall struct {
10041 s *Service
10042 name string
10043 urlParams_ gensupport.URLParams
10044 ifNoneMatch_ string
10045 ctx_ context.Context
10046 header_ http.Header
10047 }
10048
10049
10050
10051
10052
10053
10054
10055 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService) Get(name string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall {
10056 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10057 c.name = name
10058 return c
10059 }
10060
10061
10062
10063
10064 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall {
10065 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10066 return c
10067 }
10068
10069
10070
10071
10072 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall {
10073 c.ifNoneMatch_ = entityTag
10074 return c
10075 }
10076
10077
10078 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall {
10079 c.ctx_ = ctx
10080 return c
10081 }
10082
10083
10084
10085 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall) Header() http.Header {
10086 if c.header_ == nil {
10087 c.header_ = make(http.Header)
10088 }
10089 return c.header_
10090 }
10091
10092 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall) doRequest(alt string) (*http.Response, error) {
10093 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10094 if c.ifNoneMatch_ != "" {
10095 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10096 }
10097 var body io.Reader = nil
10098 c.urlParams_.Set("alt", alt)
10099 c.urlParams_.Set("prettyPrint", "false")
10100 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10101 urls += "?" + c.urlParams_.Encode()
10102 req, err := http.NewRequest("GET", urls, body)
10103 if err != nil {
10104 return nil, err
10105 }
10106 req.Header = reqHeaders
10107 googleapi.Expand(req.URL, map[string]string{
10108 "name": c.name,
10109 })
10110 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10111 }
10112
10113
10114
10115
10116
10117
10118 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsGetCall) Do(opts ...googleapi.CallOption) (*JobRun, error) {
10119 gensupport.SetOptions(c.urlParams_, opts...)
10120 res, err := c.doRequest("json")
10121 if res != nil && res.StatusCode == http.StatusNotModified {
10122 if res.Body != nil {
10123 res.Body.Close()
10124 }
10125 return nil, gensupport.WrapError(&googleapi.Error{
10126 Code: res.StatusCode,
10127 Header: res.Header,
10128 })
10129 }
10130 if err != nil {
10131 return nil, err
10132 }
10133 defer googleapi.CloseBody(res)
10134 if err := googleapi.CheckResponse(res); err != nil {
10135 return nil, gensupport.WrapError(err)
10136 }
10137 ret := &JobRun{
10138 ServerResponse: googleapi.ServerResponse{
10139 Header: res.Header,
10140 HTTPStatusCode: res.StatusCode,
10141 },
10142 }
10143 target := &ret
10144 if err := gensupport.DecodeResponse(target, res); err != nil {
10145 return nil, err
10146 }
10147 return ret, nil
10148 }
10149
10150 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall struct {
10151 s *Service
10152 parent string
10153 urlParams_ gensupport.URLParams
10154 ifNoneMatch_ string
10155 ctx_ context.Context
10156 header_ http.Header
10157 }
10158
10159
10160
10161
10162 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService) List(parent string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall {
10163 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10164 c.parent = parent
10165 return c
10166 }
10167
10168
10169
10170 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) Filter(filter string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall {
10171 c.urlParams_.Set("filter", filter)
10172 return c
10173 }
10174
10175
10176
10177 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) OrderBy(orderBy string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall {
10178 c.urlParams_.Set("orderBy", orderBy)
10179 return c
10180 }
10181
10182
10183
10184
10185
10186 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) PageSize(pageSize int64) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall {
10187 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
10188 return c
10189 }
10190
10191
10192
10193
10194
10195 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) PageToken(pageToken string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall {
10196 c.urlParams_.Set("pageToken", pageToken)
10197 return c
10198 }
10199
10200
10201
10202
10203 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall {
10204 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10205 return c
10206 }
10207
10208
10209
10210
10211 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall {
10212 c.ifNoneMatch_ = entityTag
10213 return c
10214 }
10215
10216
10217 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall {
10218 c.ctx_ = ctx
10219 return c
10220 }
10221
10222
10223
10224 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) Header() http.Header {
10225 if c.header_ == nil {
10226 c.header_ = make(http.Header)
10227 }
10228 return c.header_
10229 }
10230
10231 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) doRequest(alt string) (*http.Response, error) {
10232 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10233 if c.ifNoneMatch_ != "" {
10234 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10235 }
10236 var body io.Reader = nil
10237 c.urlParams_.Set("alt", alt)
10238 c.urlParams_.Set("prettyPrint", "false")
10239 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/jobRuns")
10240 urls += "?" + c.urlParams_.Encode()
10241 req, err := http.NewRequest("GET", urls, body)
10242 if err != nil {
10243 return nil, err
10244 }
10245 req.Header = reqHeaders
10246 googleapi.Expand(req.URL, map[string]string{
10247 "parent": c.parent,
10248 })
10249 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10250 }
10251
10252
10253
10254
10255
10256
10257
10258 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) Do(opts ...googleapi.CallOption) (*ListJobRunsResponse, error) {
10259 gensupport.SetOptions(c.urlParams_, opts...)
10260 res, err := c.doRequest("json")
10261 if res != nil && res.StatusCode == http.StatusNotModified {
10262 if res.Body != nil {
10263 res.Body.Close()
10264 }
10265 return nil, gensupport.WrapError(&googleapi.Error{
10266 Code: res.StatusCode,
10267 Header: res.Header,
10268 })
10269 }
10270 if err != nil {
10271 return nil, err
10272 }
10273 defer googleapi.CloseBody(res)
10274 if err := googleapi.CheckResponse(res); err != nil {
10275 return nil, gensupport.WrapError(err)
10276 }
10277 ret := &ListJobRunsResponse{
10278 ServerResponse: googleapi.ServerResponse{
10279 Header: res.Header,
10280 HTTPStatusCode: res.StatusCode,
10281 },
10282 }
10283 target := &ret
10284 if err := gensupport.DecodeResponse(target, res); err != nil {
10285 return nil, err
10286 }
10287 return ret, nil
10288 }
10289
10290
10291
10292
10293 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsListCall) Pages(ctx context.Context, f func(*ListJobRunsResponse) error) error {
10294 c.ctx_ = ctx
10295 defer c.PageToken(c.urlParams_.Get("pageToken"))
10296 for {
10297 x, err := c.Do()
10298 if err != nil {
10299 return err
10300 }
10301 if err := f(x); err != nil {
10302 return err
10303 }
10304 if x.NextPageToken == "" {
10305 return nil
10306 }
10307 c.PageToken(x.NextPageToken)
10308 }
10309 }
10310
10311 type ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall struct {
10312 s *Service
10313 name string
10314 terminatejobrunrequest *TerminateJobRunRequest
10315 urlParams_ gensupport.URLParams
10316 ctx_ context.Context
10317 header_ http.Header
10318 }
10319
10320
10321
10322
10323
10324
10325 func (r *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsService) Terminate(name string, terminatejobrunrequest *TerminateJobRunRequest) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall {
10326 c := &ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10327 c.name = name
10328 c.terminatejobrunrequest = terminatejobrunrequest
10329 return c
10330 }
10331
10332
10333
10334
10335 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall {
10336 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10337 return c
10338 }
10339
10340
10341 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall) Context(ctx context.Context) *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall {
10342 c.ctx_ = ctx
10343 return c
10344 }
10345
10346
10347
10348 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall) Header() http.Header {
10349 if c.header_ == nil {
10350 c.header_ = make(http.Header)
10351 }
10352 return c.header_
10353 }
10354
10355 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall) doRequest(alt string) (*http.Response, error) {
10356 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10357 var body io.Reader = nil
10358 body, err := googleapi.WithoutDataWrapper.JSONReader(c.terminatejobrunrequest)
10359 if err != nil {
10360 return nil, err
10361 }
10362 c.urlParams_.Set("alt", alt)
10363 c.urlParams_.Set("prettyPrint", "false")
10364 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:terminate")
10365 urls += "?" + c.urlParams_.Encode()
10366 req, err := http.NewRequest("POST", urls, body)
10367 if err != nil {
10368 return nil, err
10369 }
10370 req.Header = reqHeaders
10371 googleapi.Expand(req.URL, map[string]string{
10372 "name": c.name,
10373 })
10374 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10375 }
10376
10377
10378
10379
10380
10381
10382
10383 func (c *ProjectsLocationsDeliveryPipelinesReleasesRolloutsJobRunsTerminateCall) Do(opts ...googleapi.CallOption) (*TerminateJobRunResponse, error) {
10384 gensupport.SetOptions(c.urlParams_, opts...)
10385 res, err := c.doRequest("json")
10386 if res != nil && res.StatusCode == http.StatusNotModified {
10387 if res.Body != nil {
10388 res.Body.Close()
10389 }
10390 return nil, gensupport.WrapError(&googleapi.Error{
10391 Code: res.StatusCode,
10392 Header: res.Header,
10393 })
10394 }
10395 if err != nil {
10396 return nil, err
10397 }
10398 defer googleapi.CloseBody(res)
10399 if err := googleapi.CheckResponse(res); err != nil {
10400 return nil, gensupport.WrapError(err)
10401 }
10402 ret := &TerminateJobRunResponse{
10403 ServerResponse: googleapi.ServerResponse{
10404 Header: res.Header,
10405 HTTPStatusCode: res.StatusCode,
10406 },
10407 }
10408 target := &ret
10409 if err := gensupport.DecodeResponse(target, res); err != nil {
10410 return nil, err
10411 }
10412 return ret, nil
10413 }
10414
10415 type ProjectsLocationsOperationsCancelCall struct {
10416 s *Service
10417 name string
10418 canceloperationrequest *CancelOperationRequest
10419 urlParams_ gensupport.URLParams
10420 ctx_ context.Context
10421 header_ http.Header
10422 }
10423
10424
10425
10426
10427
10428
10429
10430
10431
10432
10433
10434
10435 func (r *ProjectsLocationsOperationsService) Cancel(name string, canceloperationrequest *CancelOperationRequest) *ProjectsLocationsOperationsCancelCall {
10436 c := &ProjectsLocationsOperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10437 c.name = name
10438 c.canceloperationrequest = canceloperationrequest
10439 return c
10440 }
10441
10442
10443
10444
10445 func (c *ProjectsLocationsOperationsCancelCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsCancelCall {
10446 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10447 return c
10448 }
10449
10450
10451 func (c *ProjectsLocationsOperationsCancelCall) Context(ctx context.Context) *ProjectsLocationsOperationsCancelCall {
10452 c.ctx_ = ctx
10453 return c
10454 }
10455
10456
10457
10458 func (c *ProjectsLocationsOperationsCancelCall) Header() http.Header {
10459 if c.header_ == nil {
10460 c.header_ = make(http.Header)
10461 }
10462 return c.header_
10463 }
10464
10465 func (c *ProjectsLocationsOperationsCancelCall) doRequest(alt string) (*http.Response, error) {
10466 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10467 var body io.Reader = nil
10468 body, err := googleapi.WithoutDataWrapper.JSONReader(c.canceloperationrequest)
10469 if err != nil {
10470 return nil, err
10471 }
10472 c.urlParams_.Set("alt", alt)
10473 c.urlParams_.Set("prettyPrint", "false")
10474 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:cancel")
10475 urls += "?" + c.urlParams_.Encode()
10476 req, err := http.NewRequest("POST", urls, body)
10477 if err != nil {
10478 return nil, err
10479 }
10480 req.Header = reqHeaders
10481 googleapi.Expand(req.URL, map[string]string{
10482 "name": c.name,
10483 })
10484 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10485 }
10486
10487
10488
10489
10490
10491
10492 func (c *ProjectsLocationsOperationsCancelCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
10493 gensupport.SetOptions(c.urlParams_, opts...)
10494 res, err := c.doRequest("json")
10495 if res != nil && res.StatusCode == http.StatusNotModified {
10496 if res.Body != nil {
10497 res.Body.Close()
10498 }
10499 return nil, gensupport.WrapError(&googleapi.Error{
10500 Code: res.StatusCode,
10501 Header: res.Header,
10502 })
10503 }
10504 if err != nil {
10505 return nil, err
10506 }
10507 defer googleapi.CloseBody(res)
10508 if err := googleapi.CheckResponse(res); err != nil {
10509 return nil, gensupport.WrapError(err)
10510 }
10511 ret := &Empty{
10512 ServerResponse: googleapi.ServerResponse{
10513 Header: res.Header,
10514 HTTPStatusCode: res.StatusCode,
10515 },
10516 }
10517 target := &ret
10518 if err := gensupport.DecodeResponse(target, res); err != nil {
10519 return nil, err
10520 }
10521 return ret, nil
10522 }
10523
10524 type ProjectsLocationsOperationsDeleteCall struct {
10525 s *Service
10526 name string
10527 urlParams_ gensupport.URLParams
10528 ctx_ context.Context
10529 header_ http.Header
10530 }
10531
10532
10533
10534
10535
10536
10537
10538 func (r *ProjectsLocationsOperationsService) Delete(name string) *ProjectsLocationsOperationsDeleteCall {
10539 c := &ProjectsLocationsOperationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10540 c.name = name
10541 return c
10542 }
10543
10544
10545
10546
10547 func (c *ProjectsLocationsOperationsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsDeleteCall {
10548 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10549 return c
10550 }
10551
10552
10553 func (c *ProjectsLocationsOperationsDeleteCall) Context(ctx context.Context) *ProjectsLocationsOperationsDeleteCall {
10554 c.ctx_ = ctx
10555 return c
10556 }
10557
10558
10559
10560 func (c *ProjectsLocationsOperationsDeleteCall) Header() http.Header {
10561 if c.header_ == nil {
10562 c.header_ = make(http.Header)
10563 }
10564 return c.header_
10565 }
10566
10567 func (c *ProjectsLocationsOperationsDeleteCall) doRequest(alt string) (*http.Response, error) {
10568 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10569 var body io.Reader = nil
10570 c.urlParams_.Set("alt", alt)
10571 c.urlParams_.Set("prettyPrint", "false")
10572 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10573 urls += "?" + c.urlParams_.Encode()
10574 req, err := http.NewRequest("DELETE", urls, body)
10575 if err != nil {
10576 return nil, err
10577 }
10578 req.Header = reqHeaders
10579 googleapi.Expand(req.URL, map[string]string{
10580 "name": c.name,
10581 })
10582 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10583 }
10584
10585
10586
10587
10588
10589
10590 func (c *ProjectsLocationsOperationsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
10591 gensupport.SetOptions(c.urlParams_, opts...)
10592 res, err := c.doRequest("json")
10593 if res != nil && res.StatusCode == http.StatusNotModified {
10594 if res.Body != nil {
10595 res.Body.Close()
10596 }
10597 return nil, gensupport.WrapError(&googleapi.Error{
10598 Code: res.StatusCode,
10599 Header: res.Header,
10600 })
10601 }
10602 if err != nil {
10603 return nil, err
10604 }
10605 defer googleapi.CloseBody(res)
10606 if err := googleapi.CheckResponse(res); err != nil {
10607 return nil, gensupport.WrapError(err)
10608 }
10609 ret := &Empty{
10610 ServerResponse: googleapi.ServerResponse{
10611 Header: res.Header,
10612 HTTPStatusCode: res.StatusCode,
10613 },
10614 }
10615 target := &ret
10616 if err := gensupport.DecodeResponse(target, res); err != nil {
10617 return nil, err
10618 }
10619 return ret, nil
10620 }
10621
10622 type ProjectsLocationsOperationsGetCall struct {
10623 s *Service
10624 name string
10625 urlParams_ gensupport.URLParams
10626 ifNoneMatch_ string
10627 ctx_ context.Context
10628 header_ http.Header
10629 }
10630
10631
10632
10633
10634
10635
10636 func (r *ProjectsLocationsOperationsService) Get(name string) *ProjectsLocationsOperationsGetCall {
10637 c := &ProjectsLocationsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10638 c.name = name
10639 return c
10640 }
10641
10642
10643
10644
10645 func (c *ProjectsLocationsOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsGetCall {
10646 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10647 return c
10648 }
10649
10650
10651
10652
10653 func (c *ProjectsLocationsOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsOperationsGetCall {
10654 c.ifNoneMatch_ = entityTag
10655 return c
10656 }
10657
10658
10659 func (c *ProjectsLocationsOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsOperationsGetCall {
10660 c.ctx_ = ctx
10661 return c
10662 }
10663
10664
10665
10666 func (c *ProjectsLocationsOperationsGetCall) Header() http.Header {
10667 if c.header_ == nil {
10668 c.header_ = make(http.Header)
10669 }
10670 return c.header_
10671 }
10672
10673 func (c *ProjectsLocationsOperationsGetCall) doRequest(alt string) (*http.Response, error) {
10674 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10675 if c.ifNoneMatch_ != "" {
10676 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10677 }
10678 var body io.Reader = nil
10679 c.urlParams_.Set("alt", alt)
10680 c.urlParams_.Set("prettyPrint", "false")
10681 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10682 urls += "?" + c.urlParams_.Encode()
10683 req, err := http.NewRequest("GET", urls, body)
10684 if err != nil {
10685 return nil, err
10686 }
10687 req.Header = reqHeaders
10688 googleapi.Expand(req.URL, map[string]string{
10689 "name": c.name,
10690 })
10691 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10692 }
10693
10694
10695
10696
10697
10698
10699 func (c *ProjectsLocationsOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
10700 gensupport.SetOptions(c.urlParams_, opts...)
10701 res, err := c.doRequest("json")
10702 if res != nil && res.StatusCode == http.StatusNotModified {
10703 if res.Body != nil {
10704 res.Body.Close()
10705 }
10706 return nil, gensupport.WrapError(&googleapi.Error{
10707 Code: res.StatusCode,
10708 Header: res.Header,
10709 })
10710 }
10711 if err != nil {
10712 return nil, err
10713 }
10714 defer googleapi.CloseBody(res)
10715 if err := googleapi.CheckResponse(res); err != nil {
10716 return nil, gensupport.WrapError(err)
10717 }
10718 ret := &Operation{
10719 ServerResponse: googleapi.ServerResponse{
10720 Header: res.Header,
10721 HTTPStatusCode: res.StatusCode,
10722 },
10723 }
10724 target := &ret
10725 if err := gensupport.DecodeResponse(target, res); err != nil {
10726 return nil, err
10727 }
10728 return ret, nil
10729 }
10730
10731 type ProjectsLocationsOperationsListCall struct {
10732 s *Service
10733 name string
10734 urlParams_ gensupport.URLParams
10735 ifNoneMatch_ string
10736 ctx_ context.Context
10737 header_ http.Header
10738 }
10739
10740
10741
10742
10743
10744 func (r *ProjectsLocationsOperationsService) List(name string) *ProjectsLocationsOperationsListCall {
10745 c := &ProjectsLocationsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10746 c.name = name
10747 return c
10748 }
10749
10750
10751 func (c *ProjectsLocationsOperationsListCall) Filter(filter string) *ProjectsLocationsOperationsListCall {
10752 c.urlParams_.Set("filter", filter)
10753 return c
10754 }
10755
10756
10757
10758 func (c *ProjectsLocationsOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsOperationsListCall {
10759 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
10760 return c
10761 }
10762
10763
10764
10765 func (c *ProjectsLocationsOperationsListCall) PageToken(pageToken string) *ProjectsLocationsOperationsListCall {
10766 c.urlParams_.Set("pageToken", pageToken)
10767 return c
10768 }
10769
10770
10771
10772
10773 func (c *ProjectsLocationsOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsListCall {
10774 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10775 return c
10776 }
10777
10778
10779
10780
10781 func (c *ProjectsLocationsOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsOperationsListCall {
10782 c.ifNoneMatch_ = entityTag
10783 return c
10784 }
10785
10786
10787 func (c *ProjectsLocationsOperationsListCall) Context(ctx context.Context) *ProjectsLocationsOperationsListCall {
10788 c.ctx_ = ctx
10789 return c
10790 }
10791
10792
10793
10794 func (c *ProjectsLocationsOperationsListCall) Header() http.Header {
10795 if c.header_ == nil {
10796 c.header_ = make(http.Header)
10797 }
10798 return c.header_
10799 }
10800
10801 func (c *ProjectsLocationsOperationsListCall) doRequest(alt string) (*http.Response, error) {
10802 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10803 if c.ifNoneMatch_ != "" {
10804 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10805 }
10806 var body io.Reader = nil
10807 c.urlParams_.Set("alt", alt)
10808 c.urlParams_.Set("prettyPrint", "false")
10809 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
10810 urls += "?" + c.urlParams_.Encode()
10811 req, err := http.NewRequest("GET", urls, body)
10812 if err != nil {
10813 return nil, err
10814 }
10815 req.Header = reqHeaders
10816 googleapi.Expand(req.URL, map[string]string{
10817 "name": c.name,
10818 })
10819 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10820 }
10821
10822
10823
10824
10825
10826
10827
10828 func (c *ProjectsLocationsOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
10829 gensupport.SetOptions(c.urlParams_, opts...)
10830 res, err := c.doRequest("json")
10831 if res != nil && res.StatusCode == http.StatusNotModified {
10832 if res.Body != nil {
10833 res.Body.Close()
10834 }
10835 return nil, gensupport.WrapError(&googleapi.Error{
10836 Code: res.StatusCode,
10837 Header: res.Header,
10838 })
10839 }
10840 if err != nil {
10841 return nil, err
10842 }
10843 defer googleapi.CloseBody(res)
10844 if err := googleapi.CheckResponse(res); err != nil {
10845 return nil, gensupport.WrapError(err)
10846 }
10847 ret := &ListOperationsResponse{
10848 ServerResponse: googleapi.ServerResponse{
10849 Header: res.Header,
10850 HTTPStatusCode: res.StatusCode,
10851 },
10852 }
10853 target := &ret
10854 if err := gensupport.DecodeResponse(target, res); err != nil {
10855 return nil, err
10856 }
10857 return ret, nil
10858 }
10859
10860
10861
10862
10863 func (c *ProjectsLocationsOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
10864 c.ctx_ = ctx
10865 defer c.PageToken(c.urlParams_.Get("pageToken"))
10866 for {
10867 x, err := c.Do()
10868 if err != nil {
10869 return err
10870 }
10871 if err := f(x); err != nil {
10872 return err
10873 }
10874 if x.NextPageToken == "" {
10875 return nil
10876 }
10877 c.PageToken(x.NextPageToken)
10878 }
10879 }
10880
10881 type ProjectsLocationsTargetsCreateCall struct {
10882 s *Service
10883 parent string
10884 target *Target
10885 urlParams_ gensupport.URLParams
10886 ctx_ context.Context
10887 header_ http.Header
10888 }
10889
10890
10891
10892
10893
10894 func (r *ProjectsLocationsTargetsService) Create(parent string, target *Target) *ProjectsLocationsTargetsCreateCall {
10895 c := &ProjectsLocationsTargetsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10896 c.parent = parent
10897 c.target = target
10898 return c
10899 }
10900
10901
10902
10903
10904
10905
10906
10907
10908
10909
10910
10911
10912 func (c *ProjectsLocationsTargetsCreateCall) RequestId(requestId string) *ProjectsLocationsTargetsCreateCall {
10913 c.urlParams_.Set("requestId", requestId)
10914 return c
10915 }
10916
10917
10918
10919 func (c *ProjectsLocationsTargetsCreateCall) TargetId(targetId string) *ProjectsLocationsTargetsCreateCall {
10920 c.urlParams_.Set("targetId", targetId)
10921 return c
10922 }
10923
10924
10925
10926
10927 func (c *ProjectsLocationsTargetsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsTargetsCreateCall {
10928 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
10929 return c
10930 }
10931
10932
10933
10934
10935 func (c *ProjectsLocationsTargetsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsTargetsCreateCall {
10936 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10937 return c
10938 }
10939
10940
10941 func (c *ProjectsLocationsTargetsCreateCall) Context(ctx context.Context) *ProjectsLocationsTargetsCreateCall {
10942 c.ctx_ = ctx
10943 return c
10944 }
10945
10946
10947
10948 func (c *ProjectsLocationsTargetsCreateCall) Header() http.Header {
10949 if c.header_ == nil {
10950 c.header_ = make(http.Header)
10951 }
10952 return c.header_
10953 }
10954
10955 func (c *ProjectsLocationsTargetsCreateCall) doRequest(alt string) (*http.Response, error) {
10956 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10957 var body io.Reader = nil
10958 body, err := googleapi.WithoutDataWrapper.JSONReader(c.target)
10959 if err != nil {
10960 return nil, err
10961 }
10962 c.urlParams_.Set("alt", alt)
10963 c.urlParams_.Set("prettyPrint", "false")
10964 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/targets")
10965 urls += "?" + c.urlParams_.Encode()
10966 req, err := http.NewRequest("POST", urls, body)
10967 if err != nil {
10968 return nil, err
10969 }
10970 req.Header = reqHeaders
10971 googleapi.Expand(req.URL, map[string]string{
10972 "parent": c.parent,
10973 })
10974 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10975 }
10976
10977
10978
10979
10980
10981
10982 func (c *ProjectsLocationsTargetsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
10983 gensupport.SetOptions(c.urlParams_, opts...)
10984 res, err := c.doRequest("json")
10985 if res != nil && res.StatusCode == http.StatusNotModified {
10986 if res.Body != nil {
10987 res.Body.Close()
10988 }
10989 return nil, gensupport.WrapError(&googleapi.Error{
10990 Code: res.StatusCode,
10991 Header: res.Header,
10992 })
10993 }
10994 if err != nil {
10995 return nil, err
10996 }
10997 defer googleapi.CloseBody(res)
10998 if err := googleapi.CheckResponse(res); err != nil {
10999 return nil, gensupport.WrapError(err)
11000 }
11001 ret := &Operation{
11002 ServerResponse: googleapi.ServerResponse{
11003 Header: res.Header,
11004 HTTPStatusCode: res.StatusCode,
11005 },
11006 }
11007 target := &ret
11008 if err := gensupport.DecodeResponse(target, res); err != nil {
11009 return nil, err
11010 }
11011 return ret, nil
11012 }
11013
11014 type ProjectsLocationsTargetsDeleteCall struct {
11015 s *Service
11016 name string
11017 urlParams_ gensupport.URLParams
11018 ctx_ context.Context
11019 header_ http.Header
11020 }
11021
11022
11023
11024
11025
11026 func (r *ProjectsLocationsTargetsService) Delete(name string) *ProjectsLocationsTargetsDeleteCall {
11027 c := &ProjectsLocationsTargetsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11028 c.name = name
11029 return c
11030 }
11031
11032
11033
11034 func (c *ProjectsLocationsTargetsDeleteCall) AllowMissing(allowMissing bool) *ProjectsLocationsTargetsDeleteCall {
11035 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
11036 return c
11037 }
11038
11039
11040
11041
11042
11043 func (c *ProjectsLocationsTargetsDeleteCall) Etag(etag string) *ProjectsLocationsTargetsDeleteCall {
11044 c.urlParams_.Set("etag", etag)
11045 return c
11046 }
11047
11048
11049
11050
11051
11052
11053
11054
11055
11056
11057
11058
11059 func (c *ProjectsLocationsTargetsDeleteCall) RequestId(requestId string) *ProjectsLocationsTargetsDeleteCall {
11060 c.urlParams_.Set("requestId", requestId)
11061 return c
11062 }
11063
11064
11065
11066 func (c *ProjectsLocationsTargetsDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsTargetsDeleteCall {
11067 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
11068 return c
11069 }
11070
11071
11072
11073
11074 func (c *ProjectsLocationsTargetsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsTargetsDeleteCall {
11075 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11076 return c
11077 }
11078
11079
11080 func (c *ProjectsLocationsTargetsDeleteCall) Context(ctx context.Context) *ProjectsLocationsTargetsDeleteCall {
11081 c.ctx_ = ctx
11082 return c
11083 }
11084
11085
11086
11087 func (c *ProjectsLocationsTargetsDeleteCall) Header() http.Header {
11088 if c.header_ == nil {
11089 c.header_ = make(http.Header)
11090 }
11091 return c.header_
11092 }
11093
11094 func (c *ProjectsLocationsTargetsDeleteCall) doRequest(alt string) (*http.Response, error) {
11095 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11096 var body io.Reader = nil
11097 c.urlParams_.Set("alt", alt)
11098 c.urlParams_.Set("prettyPrint", "false")
11099 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
11100 urls += "?" + c.urlParams_.Encode()
11101 req, err := http.NewRequest("DELETE", urls, body)
11102 if err != nil {
11103 return nil, err
11104 }
11105 req.Header = reqHeaders
11106 googleapi.Expand(req.URL, map[string]string{
11107 "name": c.name,
11108 })
11109 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11110 }
11111
11112
11113
11114
11115
11116
11117 func (c *ProjectsLocationsTargetsDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
11118 gensupport.SetOptions(c.urlParams_, opts...)
11119 res, err := c.doRequest("json")
11120 if res != nil && res.StatusCode == http.StatusNotModified {
11121 if res.Body != nil {
11122 res.Body.Close()
11123 }
11124 return nil, gensupport.WrapError(&googleapi.Error{
11125 Code: res.StatusCode,
11126 Header: res.Header,
11127 })
11128 }
11129 if err != nil {
11130 return nil, err
11131 }
11132 defer googleapi.CloseBody(res)
11133 if err := googleapi.CheckResponse(res); err != nil {
11134 return nil, gensupport.WrapError(err)
11135 }
11136 ret := &Operation{
11137 ServerResponse: googleapi.ServerResponse{
11138 Header: res.Header,
11139 HTTPStatusCode: res.StatusCode,
11140 },
11141 }
11142 target := &ret
11143 if err := gensupport.DecodeResponse(target, res); err != nil {
11144 return nil, err
11145 }
11146 return ret, nil
11147 }
11148
11149 type ProjectsLocationsTargetsGetCall struct {
11150 s *Service
11151 name string
11152 urlParams_ gensupport.URLParams
11153 ifNoneMatch_ string
11154 ctx_ context.Context
11155 header_ http.Header
11156 }
11157
11158
11159
11160
11161
11162 func (r *ProjectsLocationsTargetsService) Get(name string) *ProjectsLocationsTargetsGetCall {
11163 c := &ProjectsLocationsTargetsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11164 c.name = name
11165 return c
11166 }
11167
11168
11169
11170
11171 func (c *ProjectsLocationsTargetsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsTargetsGetCall {
11172 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11173 return c
11174 }
11175
11176
11177
11178
11179 func (c *ProjectsLocationsTargetsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsTargetsGetCall {
11180 c.ifNoneMatch_ = entityTag
11181 return c
11182 }
11183
11184
11185 func (c *ProjectsLocationsTargetsGetCall) Context(ctx context.Context) *ProjectsLocationsTargetsGetCall {
11186 c.ctx_ = ctx
11187 return c
11188 }
11189
11190
11191
11192 func (c *ProjectsLocationsTargetsGetCall) Header() http.Header {
11193 if c.header_ == nil {
11194 c.header_ = make(http.Header)
11195 }
11196 return c.header_
11197 }
11198
11199 func (c *ProjectsLocationsTargetsGetCall) doRequest(alt string) (*http.Response, error) {
11200 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11201 if c.ifNoneMatch_ != "" {
11202 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11203 }
11204 var body io.Reader = nil
11205 c.urlParams_.Set("alt", alt)
11206 c.urlParams_.Set("prettyPrint", "false")
11207 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
11208 urls += "?" + c.urlParams_.Encode()
11209 req, err := http.NewRequest("GET", urls, body)
11210 if err != nil {
11211 return nil, err
11212 }
11213 req.Header = reqHeaders
11214 googleapi.Expand(req.URL, map[string]string{
11215 "name": c.name,
11216 })
11217 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11218 }
11219
11220
11221
11222
11223
11224
11225 func (c *ProjectsLocationsTargetsGetCall) Do(opts ...googleapi.CallOption) (*Target, error) {
11226 gensupport.SetOptions(c.urlParams_, opts...)
11227 res, err := c.doRequest("json")
11228 if res != nil && res.StatusCode == http.StatusNotModified {
11229 if res.Body != nil {
11230 res.Body.Close()
11231 }
11232 return nil, gensupport.WrapError(&googleapi.Error{
11233 Code: res.StatusCode,
11234 Header: res.Header,
11235 })
11236 }
11237 if err != nil {
11238 return nil, err
11239 }
11240 defer googleapi.CloseBody(res)
11241 if err := googleapi.CheckResponse(res); err != nil {
11242 return nil, gensupport.WrapError(err)
11243 }
11244 ret := &Target{
11245 ServerResponse: googleapi.ServerResponse{
11246 Header: res.Header,
11247 HTTPStatusCode: res.StatusCode,
11248 },
11249 }
11250 target := &ret
11251 if err := gensupport.DecodeResponse(target, res); err != nil {
11252 return nil, err
11253 }
11254 return ret, nil
11255 }
11256
11257 type ProjectsLocationsTargetsGetIamPolicyCall struct {
11258 s *Service
11259 resource string
11260 urlParams_ gensupport.URLParams
11261 ifNoneMatch_ string
11262 ctx_ context.Context
11263 header_ http.Header
11264 }
11265
11266
11267
11268
11269
11270
11271
11272 func (r *ProjectsLocationsTargetsService) GetIamPolicy(resource string) *ProjectsLocationsTargetsGetIamPolicyCall {
11273 c := &ProjectsLocationsTargetsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11274 c.resource = resource
11275 return c
11276 }
11277
11278
11279
11280
11281
11282
11283
11284
11285
11286
11287
11288
11289
11290 func (c *ProjectsLocationsTargetsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsTargetsGetIamPolicyCall {
11291 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
11292 return c
11293 }
11294
11295
11296
11297
11298 func (c *ProjectsLocationsTargetsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsTargetsGetIamPolicyCall {
11299 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11300 return c
11301 }
11302
11303
11304
11305
11306 func (c *ProjectsLocationsTargetsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsTargetsGetIamPolicyCall {
11307 c.ifNoneMatch_ = entityTag
11308 return c
11309 }
11310
11311
11312 func (c *ProjectsLocationsTargetsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsTargetsGetIamPolicyCall {
11313 c.ctx_ = ctx
11314 return c
11315 }
11316
11317
11318
11319 func (c *ProjectsLocationsTargetsGetIamPolicyCall) Header() http.Header {
11320 if c.header_ == nil {
11321 c.header_ = make(http.Header)
11322 }
11323 return c.header_
11324 }
11325
11326 func (c *ProjectsLocationsTargetsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
11327 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11328 if c.ifNoneMatch_ != "" {
11329 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11330 }
11331 var body io.Reader = nil
11332 c.urlParams_.Set("alt", alt)
11333 c.urlParams_.Set("prettyPrint", "false")
11334 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
11335 urls += "?" + c.urlParams_.Encode()
11336 req, err := http.NewRequest("GET", urls, body)
11337 if err != nil {
11338 return nil, err
11339 }
11340 req.Header = reqHeaders
11341 googleapi.Expand(req.URL, map[string]string{
11342 "resource": c.resource,
11343 })
11344 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11345 }
11346
11347
11348
11349
11350
11351
11352 func (c *ProjectsLocationsTargetsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
11353 gensupport.SetOptions(c.urlParams_, opts...)
11354 res, err := c.doRequest("json")
11355 if res != nil && res.StatusCode == http.StatusNotModified {
11356 if res.Body != nil {
11357 res.Body.Close()
11358 }
11359 return nil, gensupport.WrapError(&googleapi.Error{
11360 Code: res.StatusCode,
11361 Header: res.Header,
11362 })
11363 }
11364 if err != nil {
11365 return nil, err
11366 }
11367 defer googleapi.CloseBody(res)
11368 if err := googleapi.CheckResponse(res); err != nil {
11369 return nil, gensupport.WrapError(err)
11370 }
11371 ret := &Policy{
11372 ServerResponse: googleapi.ServerResponse{
11373 Header: res.Header,
11374 HTTPStatusCode: res.StatusCode,
11375 },
11376 }
11377 target := &ret
11378 if err := gensupport.DecodeResponse(target, res); err != nil {
11379 return nil, err
11380 }
11381 return ret, nil
11382 }
11383
11384 type ProjectsLocationsTargetsListCall struct {
11385 s *Service
11386 parent string
11387 urlParams_ gensupport.URLParams
11388 ifNoneMatch_ string
11389 ctx_ context.Context
11390 header_ http.Header
11391 }
11392
11393
11394
11395
11396
11397 func (r *ProjectsLocationsTargetsService) List(parent string) *ProjectsLocationsTargetsListCall {
11398 c := &ProjectsLocationsTargetsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11399 c.parent = parent
11400 return c
11401 }
11402
11403
11404
11405 func (c *ProjectsLocationsTargetsListCall) Filter(filter string) *ProjectsLocationsTargetsListCall {
11406 c.urlParams_.Set("filter", filter)
11407 return c
11408 }
11409
11410
11411
11412 func (c *ProjectsLocationsTargetsListCall) OrderBy(orderBy string) *ProjectsLocationsTargetsListCall {
11413 c.urlParams_.Set("orderBy", orderBy)
11414 return c
11415 }
11416
11417
11418
11419
11420
11421 func (c *ProjectsLocationsTargetsListCall) PageSize(pageSize int64) *ProjectsLocationsTargetsListCall {
11422 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
11423 return c
11424 }
11425
11426
11427
11428
11429
11430 func (c *ProjectsLocationsTargetsListCall) PageToken(pageToken string) *ProjectsLocationsTargetsListCall {
11431 c.urlParams_.Set("pageToken", pageToken)
11432 return c
11433 }
11434
11435
11436
11437
11438 func (c *ProjectsLocationsTargetsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsTargetsListCall {
11439 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11440 return c
11441 }
11442
11443
11444
11445
11446 func (c *ProjectsLocationsTargetsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsTargetsListCall {
11447 c.ifNoneMatch_ = entityTag
11448 return c
11449 }
11450
11451
11452 func (c *ProjectsLocationsTargetsListCall) Context(ctx context.Context) *ProjectsLocationsTargetsListCall {
11453 c.ctx_ = ctx
11454 return c
11455 }
11456
11457
11458
11459 func (c *ProjectsLocationsTargetsListCall) Header() http.Header {
11460 if c.header_ == nil {
11461 c.header_ = make(http.Header)
11462 }
11463 return c.header_
11464 }
11465
11466 func (c *ProjectsLocationsTargetsListCall) doRequest(alt string) (*http.Response, error) {
11467 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11468 if c.ifNoneMatch_ != "" {
11469 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11470 }
11471 var body io.Reader = nil
11472 c.urlParams_.Set("alt", alt)
11473 c.urlParams_.Set("prettyPrint", "false")
11474 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/targets")
11475 urls += "?" + c.urlParams_.Encode()
11476 req, err := http.NewRequest("GET", urls, body)
11477 if err != nil {
11478 return nil, err
11479 }
11480 req.Header = reqHeaders
11481 googleapi.Expand(req.URL, map[string]string{
11482 "parent": c.parent,
11483 })
11484 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11485 }
11486
11487
11488
11489
11490
11491
11492
11493 func (c *ProjectsLocationsTargetsListCall) Do(opts ...googleapi.CallOption) (*ListTargetsResponse, error) {
11494 gensupport.SetOptions(c.urlParams_, opts...)
11495 res, err := c.doRequest("json")
11496 if res != nil && res.StatusCode == http.StatusNotModified {
11497 if res.Body != nil {
11498 res.Body.Close()
11499 }
11500 return nil, gensupport.WrapError(&googleapi.Error{
11501 Code: res.StatusCode,
11502 Header: res.Header,
11503 })
11504 }
11505 if err != nil {
11506 return nil, err
11507 }
11508 defer googleapi.CloseBody(res)
11509 if err := googleapi.CheckResponse(res); err != nil {
11510 return nil, gensupport.WrapError(err)
11511 }
11512 ret := &ListTargetsResponse{
11513 ServerResponse: googleapi.ServerResponse{
11514 Header: res.Header,
11515 HTTPStatusCode: res.StatusCode,
11516 },
11517 }
11518 target := &ret
11519 if err := gensupport.DecodeResponse(target, res); err != nil {
11520 return nil, err
11521 }
11522 return ret, nil
11523 }
11524
11525
11526
11527
11528 func (c *ProjectsLocationsTargetsListCall) Pages(ctx context.Context, f func(*ListTargetsResponse) error) error {
11529 c.ctx_ = ctx
11530 defer c.PageToken(c.urlParams_.Get("pageToken"))
11531 for {
11532 x, err := c.Do()
11533 if err != nil {
11534 return err
11535 }
11536 if err := f(x); err != nil {
11537 return err
11538 }
11539 if x.NextPageToken == "" {
11540 return nil
11541 }
11542 c.PageToken(x.NextPageToken)
11543 }
11544 }
11545
11546 type ProjectsLocationsTargetsPatchCall struct {
11547 s *Service
11548 name string
11549 target *Target
11550 urlParams_ gensupport.URLParams
11551 ctx_ context.Context
11552 header_ http.Header
11553 }
11554
11555
11556
11557
11558
11559
11560 func (r *ProjectsLocationsTargetsService) Patch(name string, target *Target) *ProjectsLocationsTargetsPatchCall {
11561 c := &ProjectsLocationsTargetsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11562 c.name = name
11563 c.target = target
11564 return c
11565 }
11566
11567
11568
11569
11570 func (c *ProjectsLocationsTargetsPatchCall) AllowMissing(allowMissing bool) *ProjectsLocationsTargetsPatchCall {
11571 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
11572 return c
11573 }
11574
11575
11576
11577
11578
11579
11580
11581
11582
11583
11584
11585
11586 func (c *ProjectsLocationsTargetsPatchCall) RequestId(requestId string) *ProjectsLocationsTargetsPatchCall {
11587 c.urlParams_.Set("requestId", requestId)
11588 return c
11589 }
11590
11591
11592
11593
11594
11595
11596 func (c *ProjectsLocationsTargetsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsTargetsPatchCall {
11597 c.urlParams_.Set("updateMask", updateMask)
11598 return c
11599 }
11600
11601
11602
11603
11604 func (c *ProjectsLocationsTargetsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsTargetsPatchCall {
11605 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
11606 return c
11607 }
11608
11609
11610
11611
11612 func (c *ProjectsLocationsTargetsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsTargetsPatchCall {
11613 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11614 return c
11615 }
11616
11617
11618 func (c *ProjectsLocationsTargetsPatchCall) Context(ctx context.Context) *ProjectsLocationsTargetsPatchCall {
11619 c.ctx_ = ctx
11620 return c
11621 }
11622
11623
11624
11625 func (c *ProjectsLocationsTargetsPatchCall) Header() http.Header {
11626 if c.header_ == nil {
11627 c.header_ = make(http.Header)
11628 }
11629 return c.header_
11630 }
11631
11632 func (c *ProjectsLocationsTargetsPatchCall) doRequest(alt string) (*http.Response, error) {
11633 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11634 var body io.Reader = nil
11635 body, err := googleapi.WithoutDataWrapper.JSONReader(c.target)
11636 if err != nil {
11637 return nil, err
11638 }
11639 c.urlParams_.Set("alt", alt)
11640 c.urlParams_.Set("prettyPrint", "false")
11641 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
11642 urls += "?" + c.urlParams_.Encode()
11643 req, err := http.NewRequest("PATCH", urls, body)
11644 if err != nil {
11645 return nil, err
11646 }
11647 req.Header = reqHeaders
11648 googleapi.Expand(req.URL, map[string]string{
11649 "name": c.name,
11650 })
11651 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11652 }
11653
11654
11655
11656
11657
11658
11659 func (c *ProjectsLocationsTargetsPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
11660 gensupport.SetOptions(c.urlParams_, opts...)
11661 res, err := c.doRequest("json")
11662 if res != nil && res.StatusCode == http.StatusNotModified {
11663 if res.Body != nil {
11664 res.Body.Close()
11665 }
11666 return nil, gensupport.WrapError(&googleapi.Error{
11667 Code: res.StatusCode,
11668 Header: res.Header,
11669 })
11670 }
11671 if err != nil {
11672 return nil, err
11673 }
11674 defer googleapi.CloseBody(res)
11675 if err := googleapi.CheckResponse(res); err != nil {
11676 return nil, gensupport.WrapError(err)
11677 }
11678 ret := &Operation{
11679 ServerResponse: googleapi.ServerResponse{
11680 Header: res.Header,
11681 HTTPStatusCode: res.StatusCode,
11682 },
11683 }
11684 target := &ret
11685 if err := gensupport.DecodeResponse(target, res); err != nil {
11686 return nil, err
11687 }
11688 return ret, nil
11689 }
11690
11691 type ProjectsLocationsTargetsSetIamPolicyCall struct {
11692 s *Service
11693 resource string
11694 setiampolicyrequest *SetIamPolicyRequest
11695 urlParams_ gensupport.URLParams
11696 ctx_ context.Context
11697 header_ http.Header
11698 }
11699
11700
11701
11702
11703
11704
11705
11706
11707 func (r *ProjectsLocationsTargetsService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsTargetsSetIamPolicyCall {
11708 c := &ProjectsLocationsTargetsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11709 c.resource = resource
11710 c.setiampolicyrequest = setiampolicyrequest
11711 return c
11712 }
11713
11714
11715
11716
11717 func (c *ProjectsLocationsTargetsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsTargetsSetIamPolicyCall {
11718 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11719 return c
11720 }
11721
11722
11723 func (c *ProjectsLocationsTargetsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsTargetsSetIamPolicyCall {
11724 c.ctx_ = ctx
11725 return c
11726 }
11727
11728
11729
11730 func (c *ProjectsLocationsTargetsSetIamPolicyCall) Header() http.Header {
11731 if c.header_ == nil {
11732 c.header_ = make(http.Header)
11733 }
11734 return c.header_
11735 }
11736
11737 func (c *ProjectsLocationsTargetsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
11738 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11739 var body io.Reader = nil
11740 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
11741 if err != nil {
11742 return nil, err
11743 }
11744 c.urlParams_.Set("alt", alt)
11745 c.urlParams_.Set("prettyPrint", "false")
11746 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
11747 urls += "?" + c.urlParams_.Encode()
11748 req, err := http.NewRequest("POST", urls, body)
11749 if err != nil {
11750 return nil, err
11751 }
11752 req.Header = reqHeaders
11753 googleapi.Expand(req.URL, map[string]string{
11754 "resource": c.resource,
11755 })
11756 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11757 }
11758
11759
11760
11761
11762
11763
11764 func (c *ProjectsLocationsTargetsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
11765 gensupport.SetOptions(c.urlParams_, opts...)
11766 res, err := c.doRequest("json")
11767 if res != nil && res.StatusCode == http.StatusNotModified {
11768 if res.Body != nil {
11769 res.Body.Close()
11770 }
11771 return nil, gensupport.WrapError(&googleapi.Error{
11772 Code: res.StatusCode,
11773 Header: res.Header,
11774 })
11775 }
11776 if err != nil {
11777 return nil, err
11778 }
11779 defer googleapi.CloseBody(res)
11780 if err := googleapi.CheckResponse(res); err != nil {
11781 return nil, gensupport.WrapError(err)
11782 }
11783 ret := &Policy{
11784 ServerResponse: googleapi.ServerResponse{
11785 Header: res.Header,
11786 HTTPStatusCode: res.StatusCode,
11787 },
11788 }
11789 target := &ret
11790 if err := gensupport.DecodeResponse(target, res); err != nil {
11791 return nil, err
11792 }
11793 return ret, nil
11794 }
11795
11796 type ProjectsLocationsTargetsTestIamPermissionsCall struct {
11797 s *Service
11798 resource string
11799 testiampermissionsrequest *TestIamPermissionsRequest
11800 urlParams_ gensupport.URLParams
11801 ctx_ context.Context
11802 header_ http.Header
11803 }
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
11815 func (r *ProjectsLocationsTargetsService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsTargetsTestIamPermissionsCall {
11816 c := &ProjectsLocationsTargetsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11817 c.resource = resource
11818 c.testiampermissionsrequest = testiampermissionsrequest
11819 return c
11820 }
11821
11822
11823
11824
11825 func (c *ProjectsLocationsTargetsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsTargetsTestIamPermissionsCall {
11826 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11827 return c
11828 }
11829
11830
11831 func (c *ProjectsLocationsTargetsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsTargetsTestIamPermissionsCall {
11832 c.ctx_ = ctx
11833 return c
11834 }
11835
11836
11837
11838 func (c *ProjectsLocationsTargetsTestIamPermissionsCall) Header() http.Header {
11839 if c.header_ == nil {
11840 c.header_ = make(http.Header)
11841 }
11842 return c.header_
11843 }
11844
11845 func (c *ProjectsLocationsTargetsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
11846 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11847 var body io.Reader = nil
11848 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
11849 if err != nil {
11850 return nil, err
11851 }
11852 c.urlParams_.Set("alt", alt)
11853 c.urlParams_.Set("prettyPrint", "false")
11854 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
11855 urls += "?" + c.urlParams_.Encode()
11856 req, err := http.NewRequest("POST", urls, body)
11857 if err != nil {
11858 return nil, err
11859 }
11860 req.Header = reqHeaders
11861 googleapi.Expand(req.URL, map[string]string{
11862 "resource": c.resource,
11863 })
11864 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11865 }
11866
11867
11868
11869
11870
11871
11872
11873 func (c *ProjectsLocationsTargetsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
11874 gensupport.SetOptions(c.urlParams_, opts...)
11875 res, err := c.doRequest("json")
11876 if res != nil && res.StatusCode == http.StatusNotModified {
11877 if res.Body != nil {
11878 res.Body.Close()
11879 }
11880 return nil, gensupport.WrapError(&googleapi.Error{
11881 Code: res.StatusCode,
11882 Header: res.Header,
11883 })
11884 }
11885 if err != nil {
11886 return nil, err
11887 }
11888 defer googleapi.CloseBody(res)
11889 if err := googleapi.CheckResponse(res); err != nil {
11890 return nil, gensupport.WrapError(err)
11891 }
11892 ret := &TestIamPermissionsResponse{
11893 ServerResponse: googleapi.ServerResponse{
11894 Header: res.Header,
11895 HTTPStatusCode: res.StatusCode,
11896 },
11897 }
11898 target := &ret
11899 if err := gensupport.DecodeResponse(target, res); err != nil {
11900 return nil, err
11901 }
11902 return ret, nil
11903 }
11904
View as plain text