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 cloudcontrolspartner
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 = "cloudcontrolspartner:v1beta"
90 const apiName = "cloudcontrolspartner"
91 const apiVersion = "v1beta"
92 const basePath = "https://cloudcontrolspartner.googleapis.com/"
93 const basePathTemplate = "https://cloudcontrolspartner.UNIVERSE_DOMAIN/"
94 const mtlsBasePath = "https://cloudcontrolspartner.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.Organizations = NewOrganizationsService(s)
139 return s, nil
140 }
141
142 type Service struct {
143 client *http.Client
144 BasePath string
145 UserAgent string
146
147 Organizations *OrganizationsService
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 NewOrganizationsService(s *Service) *OrganizationsService {
158 rs := &OrganizationsService{s: s}
159 rs.Locations = NewOrganizationsLocationsService(s)
160 return rs
161 }
162
163 type OrganizationsService struct {
164 s *Service
165
166 Locations *OrganizationsLocationsService
167 }
168
169 func NewOrganizationsLocationsService(s *Service) *OrganizationsLocationsService {
170 rs := &OrganizationsLocationsService{s: s}
171 rs.Customers = NewOrganizationsLocationsCustomersService(s)
172 return rs
173 }
174
175 type OrganizationsLocationsService struct {
176 s *Service
177
178 Customers *OrganizationsLocationsCustomersService
179 }
180
181 func NewOrganizationsLocationsCustomersService(s *Service) *OrganizationsLocationsCustomersService {
182 rs := &OrganizationsLocationsCustomersService{s: s}
183 rs.Workloads = NewOrganizationsLocationsCustomersWorkloadsService(s)
184 return rs
185 }
186
187 type OrganizationsLocationsCustomersService struct {
188 s *Service
189
190 Workloads *OrganizationsLocationsCustomersWorkloadsService
191 }
192
193 func NewOrganizationsLocationsCustomersWorkloadsService(s *Service) *OrganizationsLocationsCustomersWorkloadsService {
194 rs := &OrganizationsLocationsCustomersWorkloadsService{s: s}
195 rs.AccessApprovalRequests = NewOrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsService(s)
196 rs.Violations = NewOrganizationsLocationsCustomersWorkloadsViolationsService(s)
197 return rs
198 }
199
200 type OrganizationsLocationsCustomersWorkloadsService struct {
201 s *Service
202
203 AccessApprovalRequests *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsService
204
205 Violations *OrganizationsLocationsCustomersWorkloadsViolationsService
206 }
207
208 func NewOrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsService(s *Service) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsService {
209 rs := &OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsService{s: s}
210 return rs
211 }
212
213 type OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsService struct {
214 s *Service
215 }
216
217 func NewOrganizationsLocationsCustomersWorkloadsViolationsService(s *Service) *OrganizationsLocationsCustomersWorkloadsViolationsService {
218 rs := &OrganizationsLocationsCustomersWorkloadsViolationsService{s: s}
219 return rs
220 }
221
222 type OrganizationsLocationsCustomersWorkloadsViolationsService struct {
223 s *Service
224 }
225
226
227 type AccessApprovalRequest struct {
228
229
230
231 Name string `json:"name,omitempty"`
232
233 RequestTime string `json:"requestTime,omitempty"`
234
235
236
237 RequestedExpirationTime string `json:"requestedExpirationTime,omitempty"`
238
239 RequestedReason *AccessReason `json:"requestedReason,omitempty"`
240
241
242
243
244
245 ForceSendFields []string `json:"-"`
246
247
248
249
250 NullFields []string `json:"-"`
251 }
252
253 func (s *AccessApprovalRequest) MarshalJSON() ([]byte, error) {
254 type NoMethod AccessApprovalRequest
255 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
256 }
257
258
259 type AccessReason struct {
260
261
262 Detail string `json:"detail,omitempty"`
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288 Type string `json:"type,omitempty"`
289
290
291
292
293
294 ForceSendFields []string `json:"-"`
295
296
297
298
299 NullFields []string `json:"-"`
300 }
301
302 func (s *AccessReason) MarshalJSON() ([]byte, error) {
303 type NoMethod AccessReason
304 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
305 }
306
307
308
309 type ConnectionError struct {
310
311 ErrorDomain string `json:"errorDomain,omitempty"`
312
313 ErrorMessage string `json:"errorMessage,omitempty"`
314
315
316
317
318
319 ForceSendFields []string `json:"-"`
320
321
322
323
324 NullFields []string `json:"-"`
325 }
326
327 func (s *ConnectionError) MarshalJSON() ([]byte, error) {
328 type NoMethod ConnectionError
329 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
330 }
331
332
333 type Console struct {
334
335 AdditionalLinks []string `json:"additionalLinks,omitempty"`
336
337 ConsoleUris []string `json:"consoleUris,omitempty"`
338
339 Steps []string `json:"steps,omitempty"`
340
341
342
343
344
345 ForceSendFields []string `json:"-"`
346
347
348
349
350 NullFields []string `json:"-"`
351 }
352
353 func (s *Console) MarshalJSON() ([]byte, error) {
354 type NoMethod Console
355 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
356 }
357
358
359 type Customer struct {
360
361 CustomerOnboardingState *CustomerOnboardingState `json:"customerOnboardingState,omitempty"`
362
363 DisplayName string `json:"displayName,omitempty"`
364
365 IsOnboarded bool `json:"isOnboarded,omitempty"`
366
367
368 Name string `json:"name,omitempty"`
369
370
371 googleapi.ServerResponse `json:"-"`
372
373
374
375
376
377 ForceSendFields []string `json:"-"`
378
379
380
381
382 NullFields []string `json:"-"`
383 }
384
385 func (s *Customer) MarshalJSON() ([]byte, error) {
386 type NoMethod Customer
387 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
388 }
389
390
391 type CustomerOnboardingState struct {
392
393 OnboardingSteps []*CustomerOnboardingStep `json:"onboardingSteps,omitempty"`
394
395
396
397
398
399 ForceSendFields []string `json:"-"`
400
401
402
403
404 NullFields []string `json:"-"`
405 }
406
407 func (s *CustomerOnboardingState) MarshalJSON() ([]byte, error) {
408 type NoMethod CustomerOnboardingState
409 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
410 }
411
412
413 type CustomerOnboardingStep struct {
414
415
416
417
418
419
420
421
422 CompletionState string `json:"completionState,omitempty"`
423
424 CompletionTime string `json:"completionTime,omitempty"`
425
426 StartTime string `json:"startTime,omitempty"`
427
428
429
430
431
432
433 Step string `json:"step,omitempty"`
434
435
436
437
438
439 ForceSendFields []string `json:"-"`
440
441
442
443
444 NullFields []string `json:"-"`
445 }
446
447 func (s *CustomerOnboardingStep) MarshalJSON() ([]byte, error) {
448 type NoMethod CustomerOnboardingStep
449 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
450 }
451
452
453 type EkmConnection struct {
454
455 ConnectionError *ConnectionError `json:"connectionError,omitempty"`
456
457
458 ConnectionName string `json:"connectionName,omitempty"`
459
460
461
462
463
464
465
466
467 ConnectionState string `json:"connectionState,omitempty"`
468
469
470
471
472
473 ForceSendFields []string `json:"-"`
474
475
476
477
478 NullFields []string `json:"-"`
479 }
480
481 func (s *EkmConnection) MarshalJSON() ([]byte, error) {
482 type NoMethod EkmConnection
483 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
484 }
485
486
487 type EkmConnections struct {
488
489 EkmConnections []*EkmConnection `json:"ekmConnections,omitempty"`
490
491
492
493 Name string `json:"name,omitempty"`
494
495
496 googleapi.ServerResponse `json:"-"`
497
498
499
500
501
502 ForceSendFields []string `json:"-"`
503
504
505
506
507 NullFields []string `json:"-"`
508 }
509
510 func (s *EkmConnections) MarshalJSON() ([]byte, error) {
511 type NoMethod EkmConnections
512 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
513 }
514
515
516
517 type EkmMetadata struct {
518
519
520 EkmEndpointUri string `json:"ekmEndpointUri,omitempty"`
521
522
523
524
525
526
527
528
529 EkmSolution string `json:"ekmSolution,omitempty"`
530
531
532
533
534
535 ForceSendFields []string `json:"-"`
536
537
538
539
540 NullFields []string `json:"-"`
541 }
542
543 func (s *EkmMetadata) MarshalJSON() ([]byte, error) {
544 type NoMethod EkmMetadata
545 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
546 }
547
548
549 type Gcloud struct {
550
551 AdditionalLinks []string `json:"additionalLinks,omitempty"`
552
553 GcloudCommands []string `json:"gcloudCommands,omitempty"`
554
555 Steps []string `json:"steps,omitempty"`
556
557
558
559
560
561 ForceSendFields []string `json:"-"`
562
563
564
565
566 NullFields []string `json:"-"`
567 }
568
569 func (s *Gcloud) MarshalJSON() ([]byte, error) {
570 type NoMethod Gcloud
571 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
572 }
573
574
575 type Instructions struct {
576
577
578 ConsoleInstructions *Console `json:"consoleInstructions,omitempty"`
579
580
581 GcloudInstructions *Gcloud `json:"gcloudInstructions,omitempty"`
582
583
584
585
586
587 ForceSendFields []string `json:"-"`
588
589
590
591
592 NullFields []string `json:"-"`
593 }
594
595 func (s *Instructions) MarshalJSON() ([]byte, error) {
596 type NoMethod Instructions
597 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
598 }
599
600
601
602 type ListAccessApprovalRequestsResponse struct {
603
604 AccessApprovalRequests []*AccessApprovalRequest `json:"accessApprovalRequests,omitempty"`
605
606
607 NextPageToken string `json:"nextPageToken,omitempty"`
608
609 Unreachable []string `json:"unreachable,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 *ListAccessApprovalRequestsResponse) MarshalJSON() ([]byte, error) {
627 type NoMethod ListAccessApprovalRequestsResponse
628 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
629 }
630
631
632 type ListCustomersResponse struct {
633
634 Customers []*Customer `json:"customers,omitempty"`
635
636
637 NextPageToken string `json:"nextPageToken,omitempty"`
638
639 Unreachable []string `json:"unreachable,omitempty"`
640
641
642 googleapi.ServerResponse `json:"-"`
643
644
645
646
647
648 ForceSendFields []string `json:"-"`
649
650
651
652
653 NullFields []string `json:"-"`
654 }
655
656 func (s *ListCustomersResponse) MarshalJSON() ([]byte, error) {
657 type NoMethod ListCustomersResponse
658 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
659 }
660
661
662
663 type ListViolationsResponse struct {
664
665
666 NextPageToken string `json:"nextPageToken,omitempty"`
667
668
669 Unreachable []string `json:"unreachable,omitempty"`
670
671 Violations []*Violation `json:"violations,omitempty"`
672
673
674 googleapi.ServerResponse `json:"-"`
675
676
677
678
679
680 ForceSendFields []string `json:"-"`
681
682
683
684
685 NullFields []string `json:"-"`
686 }
687
688 func (s *ListViolationsResponse) MarshalJSON() ([]byte, error) {
689 type NoMethod ListViolationsResponse
690 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
691 }
692
693
694
695 type ListWorkloadsResponse struct {
696
697
698 NextPageToken string `json:"nextPageToken,omitempty"`
699
700 Unreachable []string `json:"unreachable,omitempty"`
701
702 Workloads []*Workload `json:"workloads,omitempty"`
703
704
705 googleapi.ServerResponse `json:"-"`
706
707
708
709
710
711 ForceSendFields []string `json:"-"`
712
713
714
715
716 NullFields []string `json:"-"`
717 }
718
719 func (s *ListWorkloadsResponse) MarshalJSON() ([]byte, error) {
720 type NoMethod ListWorkloadsResponse
721 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
722 }
723
724
725 type OperationMetadata struct {
726
727 ApiVersion string `json:"apiVersion,omitempty"`
728
729 CreateTime string `json:"createTime,omitempty"`
730
731 EndTime string `json:"endTime,omitempty"`
732
733
734
735
736 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
737
738 StatusMessage string `json:"statusMessage,omitempty"`
739
740
741 Target string `json:"target,omitempty"`
742
743 Verb string `json:"verb,omitempty"`
744
745
746
747
748
749 ForceSendFields []string `json:"-"`
750
751
752
753
754 NullFields []string `json:"-"`
755 }
756
757 func (s *OperationMetadata) MarshalJSON() ([]byte, error) {
758 type NoMethod OperationMetadata
759 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
760 }
761
762
763 type Partner struct {
764
765 CreateTime string `json:"createTime,omitempty"`
766
767
768 EkmSolutions []*EkmMetadata `json:"ekmSolutions,omitempty"`
769
770
771
772 Name string `json:"name,omitempty"`
773
774
775
776 OperatedCloudRegions []string `json:"operatedCloudRegions,omitempty"`
777
778
779 PartnerProjectId string `json:"partnerProjectId,omitempty"`
780
781 Skus []*Sku `json:"skus,omitempty"`
782
783 UpdateTime string `json:"updateTime,omitempty"`
784
785
786 googleapi.ServerResponse `json:"-"`
787
788
789
790
791
792 ForceSendFields []string `json:"-"`
793
794
795
796
797 NullFields []string `json:"-"`
798 }
799
800 func (s *Partner) MarshalJSON() ([]byte, error) {
801 type NoMethod Partner
802 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
803 }
804
805
806 type PartnerPermissions struct {
807
808
809
810 Name string `json:"name,omitempty"`
811
812
813
814
815
816
817
818
819
820
821
822 PartnerPermissions []string `json:"partnerPermissions,omitempty"`
823
824
825 googleapi.ServerResponse `json:"-"`
826
827
828
829
830
831 ForceSendFields []string `json:"-"`
832
833
834
835
836 NullFields []string `json:"-"`
837 }
838
839 func (s *PartnerPermissions) MarshalJSON() ([]byte, error) {
840 type NoMethod PartnerPermissions
841 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
842 }
843
844
845
846 type Remediation struct {
847
848
849
850 CompliantValues []string `json:"compliantValues,omitempty"`
851
852 Instructions *Instructions `json:"instructions,omitempty"`
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868 RemediationType string `json:"remediationType,omitempty"`
869
870
871
872
873
874 ForceSendFields []string `json:"-"`
875
876
877
878
879 NullFields []string `json:"-"`
880 }
881
882 func (s *Remediation) MarshalJSON() ([]byte, error) {
883 type NoMethod Remediation
884 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
885 }
886
887
888
889 type Sku struct {
890
891
892
893 DisplayName string `json:"displayName,omitempty"`
894
895
896
897 Id string `json:"id,omitempty"`
898
899
900
901
902
903 ForceSendFields []string `json:"-"`
904
905
906
907
908 NullFields []string `json:"-"`
909 }
910
911 func (s *Sku) MarshalJSON() ([]byte, error) {
912 type NoMethod Sku
913 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
914 }
915
916
917 type Violation struct {
918
919 BeginTime string `json:"beginTime,omitempty"`
920
921
922 Category string `json:"category,omitempty"`
923
924
925 Description string `json:"description,omitempty"`
926
927 FolderId int64 `json:"folderId,omitempty,string"`
928
929
930
931 Name string `json:"name,omitempty"`
932
933
934
935
936
937 NonCompliantOrgPolicy string `json:"nonCompliantOrgPolicy,omitempty"`
938
939 Remediation *Remediation `json:"remediation,omitempty"`
940
941
942 ResolveTime string `json:"resolveTime,omitempty"`
943
944
945
946
947
948
949
950 State string `json:"state,omitempty"`
951
952
953 UpdateTime string `json:"updateTime,omitempty"`
954
955
956 googleapi.ServerResponse `json:"-"`
957
958
959
960
961
962 ForceSendFields []string `json:"-"`
963
964
965
966
967 NullFields []string `json:"-"`
968 }
969
970 func (s *Violation) MarshalJSON() ([]byte, error) {
971 type NoMethod Violation
972 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
973 }
974
975
976
977
978 type Workload struct {
979
980 CreateTime string `json:"createTime,omitempty"`
981
982 Folder string `json:"folder,omitempty"`
983
984 FolderId int64 `json:"folderId,omitempty,string"`
985
986 IsOnboarded bool `json:"isOnboarded,omitempty"`
987
988
989 KeyManagementProjectId string `json:"keyManagementProjectId,omitempty"`
990
991 Location string `json:"location,omitempty"`
992
993
994
995 Name string `json:"name,omitempty"`
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011 Partner string `json:"partner,omitempty"`
1012
1013 WorkloadOnboardingState *WorkloadOnboardingState `json:"workloadOnboardingState,omitempty"`
1014
1015
1016 googleapi.ServerResponse `json:"-"`
1017
1018
1019
1020
1021
1022 ForceSendFields []string `json:"-"`
1023
1024
1025
1026
1027 NullFields []string `json:"-"`
1028 }
1029
1030 func (s *Workload) MarshalJSON() ([]byte, error) {
1031 type NoMethod Workload
1032 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1033 }
1034
1035
1036 type WorkloadOnboardingState struct {
1037
1038 OnboardingSteps []*WorkloadOnboardingStep `json:"onboardingSteps,omitempty"`
1039
1040
1041
1042
1043
1044 ForceSendFields []string `json:"-"`
1045
1046
1047
1048
1049 NullFields []string `json:"-"`
1050 }
1051
1052 func (s *WorkloadOnboardingState) MarshalJSON() ([]byte, error) {
1053 type NoMethod WorkloadOnboardingState
1054 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1055 }
1056
1057
1058 type WorkloadOnboardingStep struct {
1059
1060
1061
1062
1063
1064
1065
1066
1067 CompletionState string `json:"completionState,omitempty"`
1068
1069 CompletionTime string `json:"completionTime,omitempty"`
1070
1071 StartTime string `json:"startTime,omitempty"`
1072
1073
1074
1075
1076
1077
1078 Step string `json:"step,omitempty"`
1079
1080
1081
1082
1083
1084 ForceSendFields []string `json:"-"`
1085
1086
1087
1088
1089 NullFields []string `json:"-"`
1090 }
1091
1092 func (s *WorkloadOnboardingStep) MarshalJSON() ([]byte, error) {
1093 type NoMethod WorkloadOnboardingStep
1094 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1095 }
1096
1097 type OrganizationsLocationsGetPartnerCall struct {
1098 s *Service
1099 name string
1100 urlParams_ gensupport.URLParams
1101 ifNoneMatch_ string
1102 ctx_ context.Context
1103 header_ http.Header
1104 }
1105
1106
1107
1108
1109 func (r *OrganizationsLocationsService) GetPartner(name string) *OrganizationsLocationsGetPartnerCall {
1110 c := &OrganizationsLocationsGetPartnerCall{s: r.s, urlParams_: make(gensupport.URLParams)}
1111 c.name = name
1112 return c
1113 }
1114
1115
1116
1117
1118 func (c *OrganizationsLocationsGetPartnerCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGetPartnerCall {
1119 c.urlParams_.Set("fields", googleapi.CombineFields(s))
1120 return c
1121 }
1122
1123
1124
1125
1126 func (c *OrganizationsLocationsGetPartnerCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGetPartnerCall {
1127 c.ifNoneMatch_ = entityTag
1128 return c
1129 }
1130
1131
1132 func (c *OrganizationsLocationsGetPartnerCall) Context(ctx context.Context) *OrganizationsLocationsGetPartnerCall {
1133 c.ctx_ = ctx
1134 return c
1135 }
1136
1137
1138
1139 func (c *OrganizationsLocationsGetPartnerCall) Header() http.Header {
1140 if c.header_ == nil {
1141 c.header_ = make(http.Header)
1142 }
1143 return c.header_
1144 }
1145
1146 func (c *OrganizationsLocationsGetPartnerCall) doRequest(alt string) (*http.Response, error) {
1147 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
1148 if c.ifNoneMatch_ != "" {
1149 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
1150 }
1151 var body io.Reader = nil
1152 c.urlParams_.Set("alt", alt)
1153 c.urlParams_.Set("prettyPrint", "false")
1154 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+name}")
1155 urls += "?" + c.urlParams_.Encode()
1156 req, err := http.NewRequest("GET", urls, body)
1157 if err != nil {
1158 return nil, err
1159 }
1160 req.Header = reqHeaders
1161 googleapi.Expand(req.URL, map[string]string{
1162 "name": c.name,
1163 })
1164 return gensupport.SendRequest(c.ctx_, c.s.client, req)
1165 }
1166
1167
1168
1169
1170
1171
1172 func (c *OrganizationsLocationsGetPartnerCall) Do(opts ...googleapi.CallOption) (*Partner, error) {
1173 gensupport.SetOptions(c.urlParams_, opts...)
1174 res, err := c.doRequest("json")
1175 if res != nil && res.StatusCode == http.StatusNotModified {
1176 if res.Body != nil {
1177 res.Body.Close()
1178 }
1179 return nil, gensupport.WrapError(&googleapi.Error{
1180 Code: res.StatusCode,
1181 Header: res.Header,
1182 })
1183 }
1184 if err != nil {
1185 return nil, err
1186 }
1187 defer googleapi.CloseBody(res)
1188 if err := googleapi.CheckResponse(res); err != nil {
1189 return nil, gensupport.WrapError(err)
1190 }
1191 ret := &Partner{
1192 ServerResponse: googleapi.ServerResponse{
1193 Header: res.Header,
1194 HTTPStatusCode: res.StatusCode,
1195 },
1196 }
1197 target := &ret
1198 if err := gensupport.DecodeResponse(target, res); err != nil {
1199 return nil, err
1200 }
1201 return ret, nil
1202 }
1203
1204 type OrganizationsLocationsCustomersGetCall struct {
1205 s *Service
1206 name string
1207 urlParams_ gensupport.URLParams
1208 ifNoneMatch_ string
1209 ctx_ context.Context
1210 header_ http.Header
1211 }
1212
1213
1214
1215
1216
1217 func (r *OrganizationsLocationsCustomersService) Get(name string) *OrganizationsLocationsCustomersGetCall {
1218 c := &OrganizationsLocationsCustomersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
1219 c.name = name
1220 return c
1221 }
1222
1223
1224
1225
1226 func (c *OrganizationsLocationsCustomersGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersGetCall {
1227 c.urlParams_.Set("fields", googleapi.CombineFields(s))
1228 return c
1229 }
1230
1231
1232
1233
1234 func (c *OrganizationsLocationsCustomersGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersGetCall {
1235 c.ifNoneMatch_ = entityTag
1236 return c
1237 }
1238
1239
1240 func (c *OrganizationsLocationsCustomersGetCall) Context(ctx context.Context) *OrganizationsLocationsCustomersGetCall {
1241 c.ctx_ = ctx
1242 return c
1243 }
1244
1245
1246
1247 func (c *OrganizationsLocationsCustomersGetCall) Header() http.Header {
1248 if c.header_ == nil {
1249 c.header_ = make(http.Header)
1250 }
1251 return c.header_
1252 }
1253
1254 func (c *OrganizationsLocationsCustomersGetCall) doRequest(alt string) (*http.Response, error) {
1255 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
1256 if c.ifNoneMatch_ != "" {
1257 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
1258 }
1259 var body io.Reader = nil
1260 c.urlParams_.Set("alt", alt)
1261 c.urlParams_.Set("prettyPrint", "false")
1262 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+name}")
1263 urls += "?" + c.urlParams_.Encode()
1264 req, err := http.NewRequest("GET", urls, body)
1265 if err != nil {
1266 return nil, err
1267 }
1268 req.Header = reqHeaders
1269 googleapi.Expand(req.URL, map[string]string{
1270 "name": c.name,
1271 })
1272 return gensupport.SendRequest(c.ctx_, c.s.client, req)
1273 }
1274
1275
1276
1277
1278
1279
1280 func (c *OrganizationsLocationsCustomersGetCall) Do(opts ...googleapi.CallOption) (*Customer, error) {
1281 gensupport.SetOptions(c.urlParams_, opts...)
1282 res, err := c.doRequest("json")
1283 if res != nil && res.StatusCode == http.StatusNotModified {
1284 if res.Body != nil {
1285 res.Body.Close()
1286 }
1287 return nil, gensupport.WrapError(&googleapi.Error{
1288 Code: res.StatusCode,
1289 Header: res.Header,
1290 })
1291 }
1292 if err != nil {
1293 return nil, err
1294 }
1295 defer googleapi.CloseBody(res)
1296 if err := googleapi.CheckResponse(res); err != nil {
1297 return nil, gensupport.WrapError(err)
1298 }
1299 ret := &Customer{
1300 ServerResponse: googleapi.ServerResponse{
1301 Header: res.Header,
1302 HTTPStatusCode: res.StatusCode,
1303 },
1304 }
1305 target := &ret
1306 if err := gensupport.DecodeResponse(target, res); err != nil {
1307 return nil, err
1308 }
1309 return ret, nil
1310 }
1311
1312 type OrganizationsLocationsCustomersListCall struct {
1313 s *Service
1314 parent string
1315 urlParams_ gensupport.URLParams
1316 ifNoneMatch_ string
1317 ctx_ context.Context
1318 header_ http.Header
1319 }
1320
1321
1322
1323
1324
1325
1326 func (r *OrganizationsLocationsCustomersService) List(parent string) *OrganizationsLocationsCustomersListCall {
1327 c := &OrganizationsLocationsCustomersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
1328 c.parent = parent
1329 return c
1330 }
1331
1332
1333 func (c *OrganizationsLocationsCustomersListCall) Filter(filter string) *OrganizationsLocationsCustomersListCall {
1334 c.urlParams_.Set("filter", filter)
1335 return c
1336 }
1337
1338
1339
1340 func (c *OrganizationsLocationsCustomersListCall) OrderBy(orderBy string) *OrganizationsLocationsCustomersListCall {
1341 c.urlParams_.Set("orderBy", orderBy)
1342 return c
1343 }
1344
1345
1346
1347
1348 func (c *OrganizationsLocationsCustomersListCall) PageSize(pageSize int64) *OrganizationsLocationsCustomersListCall {
1349 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
1350 return c
1351 }
1352
1353
1354
1355
1356 func (c *OrganizationsLocationsCustomersListCall) PageToken(pageToken string) *OrganizationsLocationsCustomersListCall {
1357 c.urlParams_.Set("pageToken", pageToken)
1358 return c
1359 }
1360
1361
1362
1363
1364 func (c *OrganizationsLocationsCustomersListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersListCall {
1365 c.urlParams_.Set("fields", googleapi.CombineFields(s))
1366 return c
1367 }
1368
1369
1370
1371
1372 func (c *OrganizationsLocationsCustomersListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersListCall {
1373 c.ifNoneMatch_ = entityTag
1374 return c
1375 }
1376
1377
1378 func (c *OrganizationsLocationsCustomersListCall) Context(ctx context.Context) *OrganizationsLocationsCustomersListCall {
1379 c.ctx_ = ctx
1380 return c
1381 }
1382
1383
1384
1385 func (c *OrganizationsLocationsCustomersListCall) Header() http.Header {
1386 if c.header_ == nil {
1387 c.header_ = make(http.Header)
1388 }
1389 return c.header_
1390 }
1391
1392 func (c *OrganizationsLocationsCustomersListCall) doRequest(alt string) (*http.Response, error) {
1393 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
1394 if c.ifNoneMatch_ != "" {
1395 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
1396 }
1397 var body io.Reader = nil
1398 c.urlParams_.Set("alt", alt)
1399 c.urlParams_.Set("prettyPrint", "false")
1400 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+parent}/customers")
1401 urls += "?" + c.urlParams_.Encode()
1402 req, err := http.NewRequest("GET", urls, body)
1403 if err != nil {
1404 return nil, err
1405 }
1406 req.Header = reqHeaders
1407 googleapi.Expand(req.URL, map[string]string{
1408 "parent": c.parent,
1409 })
1410 return gensupport.SendRequest(c.ctx_, c.s.client, req)
1411 }
1412
1413
1414
1415
1416
1417
1418
1419 func (c *OrganizationsLocationsCustomersListCall) Do(opts ...googleapi.CallOption) (*ListCustomersResponse, error) {
1420 gensupport.SetOptions(c.urlParams_, opts...)
1421 res, err := c.doRequest("json")
1422 if res != nil && res.StatusCode == http.StatusNotModified {
1423 if res.Body != nil {
1424 res.Body.Close()
1425 }
1426 return nil, gensupport.WrapError(&googleapi.Error{
1427 Code: res.StatusCode,
1428 Header: res.Header,
1429 })
1430 }
1431 if err != nil {
1432 return nil, err
1433 }
1434 defer googleapi.CloseBody(res)
1435 if err := googleapi.CheckResponse(res); err != nil {
1436 return nil, gensupport.WrapError(err)
1437 }
1438 ret := &ListCustomersResponse{
1439 ServerResponse: googleapi.ServerResponse{
1440 Header: res.Header,
1441 HTTPStatusCode: res.StatusCode,
1442 },
1443 }
1444 target := &ret
1445 if err := gensupport.DecodeResponse(target, res); err != nil {
1446 return nil, err
1447 }
1448 return ret, nil
1449 }
1450
1451
1452
1453
1454 func (c *OrganizationsLocationsCustomersListCall) Pages(ctx context.Context, f func(*ListCustomersResponse) error) error {
1455 c.ctx_ = ctx
1456 defer c.PageToken(c.urlParams_.Get("pageToken"))
1457 for {
1458 x, err := c.Do()
1459 if err != nil {
1460 return err
1461 }
1462 if err := f(x); err != nil {
1463 return err
1464 }
1465 if x.NextPageToken == "" {
1466 return nil
1467 }
1468 c.PageToken(x.NextPageToken)
1469 }
1470 }
1471
1472 type OrganizationsLocationsCustomersWorkloadsGetCall struct {
1473 s *Service
1474 name string
1475 urlParams_ gensupport.URLParams
1476 ifNoneMatch_ string
1477 ctx_ context.Context
1478 header_ http.Header
1479 }
1480
1481
1482
1483
1484
1485
1486 func (r *OrganizationsLocationsCustomersWorkloadsService) Get(name string) *OrganizationsLocationsCustomersWorkloadsGetCall {
1487 c := &OrganizationsLocationsCustomersWorkloadsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
1488 c.name = name
1489 return c
1490 }
1491
1492
1493
1494
1495 func (c *OrganizationsLocationsCustomersWorkloadsGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersWorkloadsGetCall {
1496 c.urlParams_.Set("fields", googleapi.CombineFields(s))
1497 return c
1498 }
1499
1500
1501
1502
1503 func (c *OrganizationsLocationsCustomersWorkloadsGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersWorkloadsGetCall {
1504 c.ifNoneMatch_ = entityTag
1505 return c
1506 }
1507
1508
1509 func (c *OrganizationsLocationsCustomersWorkloadsGetCall) Context(ctx context.Context) *OrganizationsLocationsCustomersWorkloadsGetCall {
1510 c.ctx_ = ctx
1511 return c
1512 }
1513
1514
1515
1516 func (c *OrganizationsLocationsCustomersWorkloadsGetCall) Header() http.Header {
1517 if c.header_ == nil {
1518 c.header_ = make(http.Header)
1519 }
1520 return c.header_
1521 }
1522
1523 func (c *OrganizationsLocationsCustomersWorkloadsGetCall) doRequest(alt string) (*http.Response, error) {
1524 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
1525 if c.ifNoneMatch_ != "" {
1526 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
1527 }
1528 var body io.Reader = nil
1529 c.urlParams_.Set("alt", alt)
1530 c.urlParams_.Set("prettyPrint", "false")
1531 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+name}")
1532 urls += "?" + c.urlParams_.Encode()
1533 req, err := http.NewRequest("GET", urls, body)
1534 if err != nil {
1535 return nil, err
1536 }
1537 req.Header = reqHeaders
1538 googleapi.Expand(req.URL, map[string]string{
1539 "name": c.name,
1540 })
1541 return gensupport.SendRequest(c.ctx_, c.s.client, req)
1542 }
1543
1544
1545
1546
1547
1548
1549 func (c *OrganizationsLocationsCustomersWorkloadsGetCall) Do(opts ...googleapi.CallOption) (*Workload, error) {
1550 gensupport.SetOptions(c.urlParams_, opts...)
1551 res, err := c.doRequest("json")
1552 if res != nil && res.StatusCode == http.StatusNotModified {
1553 if res.Body != nil {
1554 res.Body.Close()
1555 }
1556 return nil, gensupport.WrapError(&googleapi.Error{
1557 Code: res.StatusCode,
1558 Header: res.Header,
1559 })
1560 }
1561 if err != nil {
1562 return nil, err
1563 }
1564 defer googleapi.CloseBody(res)
1565 if err := googleapi.CheckResponse(res); err != nil {
1566 return nil, gensupport.WrapError(err)
1567 }
1568 ret := &Workload{
1569 ServerResponse: googleapi.ServerResponse{
1570 Header: res.Header,
1571 HTTPStatusCode: res.StatusCode,
1572 },
1573 }
1574 target := &ret
1575 if err := gensupport.DecodeResponse(target, res); err != nil {
1576 return nil, err
1577 }
1578 return ret, nil
1579 }
1580
1581 type OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall struct {
1582 s *Service
1583 name string
1584 urlParams_ gensupport.URLParams
1585 ifNoneMatch_ string
1586 ctx_ context.Context
1587 header_ http.Header
1588 }
1589
1590
1591
1592
1593
1594
1595 func (r *OrganizationsLocationsCustomersWorkloadsService) GetEkmConnections(name string) *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall {
1596 c := &OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
1597 c.name = name
1598 return c
1599 }
1600
1601
1602
1603
1604 func (c *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall {
1605 c.urlParams_.Set("fields", googleapi.CombineFields(s))
1606 return c
1607 }
1608
1609
1610
1611
1612 func (c *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall {
1613 c.ifNoneMatch_ = entityTag
1614 return c
1615 }
1616
1617
1618 func (c *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall) Context(ctx context.Context) *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall {
1619 c.ctx_ = ctx
1620 return c
1621 }
1622
1623
1624
1625 func (c *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall) Header() http.Header {
1626 if c.header_ == nil {
1627 c.header_ = make(http.Header)
1628 }
1629 return c.header_
1630 }
1631
1632 func (c *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall) doRequest(alt string) (*http.Response, error) {
1633 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
1634 if c.ifNoneMatch_ != "" {
1635 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
1636 }
1637 var body io.Reader = nil
1638 c.urlParams_.Set("alt", alt)
1639 c.urlParams_.Set("prettyPrint", "false")
1640 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+name}")
1641 urls += "?" + c.urlParams_.Encode()
1642 req, err := http.NewRequest("GET", urls, body)
1643 if err != nil {
1644 return nil, err
1645 }
1646 req.Header = reqHeaders
1647 googleapi.Expand(req.URL, map[string]string{
1648 "name": c.name,
1649 })
1650 return gensupport.SendRequest(c.ctx_, c.s.client, req)
1651 }
1652
1653
1654
1655
1656
1657
1658 func (c *OrganizationsLocationsCustomersWorkloadsGetEkmConnectionsCall) Do(opts ...googleapi.CallOption) (*EkmConnections, error) {
1659 gensupport.SetOptions(c.urlParams_, opts...)
1660 res, err := c.doRequest("json")
1661 if res != nil && res.StatusCode == http.StatusNotModified {
1662 if res.Body != nil {
1663 res.Body.Close()
1664 }
1665 return nil, gensupport.WrapError(&googleapi.Error{
1666 Code: res.StatusCode,
1667 Header: res.Header,
1668 })
1669 }
1670 if err != nil {
1671 return nil, err
1672 }
1673 defer googleapi.CloseBody(res)
1674 if err := googleapi.CheckResponse(res); err != nil {
1675 return nil, gensupport.WrapError(err)
1676 }
1677 ret := &EkmConnections{
1678 ServerResponse: googleapi.ServerResponse{
1679 Header: res.Header,
1680 HTTPStatusCode: res.StatusCode,
1681 },
1682 }
1683 target := &ret
1684 if err := gensupport.DecodeResponse(target, res); err != nil {
1685 return nil, err
1686 }
1687 return ret, nil
1688 }
1689
1690 type OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall struct {
1691 s *Service
1692 name string
1693 urlParams_ gensupport.URLParams
1694 ifNoneMatch_ string
1695 ctx_ context.Context
1696 header_ http.Header
1697 }
1698
1699
1700
1701
1702
1703
1704 func (r *OrganizationsLocationsCustomersWorkloadsService) GetPartnerPermissions(name string) *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall {
1705 c := &OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
1706 c.name = name
1707 return c
1708 }
1709
1710
1711
1712
1713 func (c *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall {
1714 c.urlParams_.Set("fields", googleapi.CombineFields(s))
1715 return c
1716 }
1717
1718
1719
1720
1721 func (c *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall {
1722 c.ifNoneMatch_ = entityTag
1723 return c
1724 }
1725
1726
1727 func (c *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall) Context(ctx context.Context) *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall {
1728 c.ctx_ = ctx
1729 return c
1730 }
1731
1732
1733
1734 func (c *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall) Header() http.Header {
1735 if c.header_ == nil {
1736 c.header_ = make(http.Header)
1737 }
1738 return c.header_
1739 }
1740
1741 func (c *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall) doRequest(alt string) (*http.Response, error) {
1742 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
1743 if c.ifNoneMatch_ != "" {
1744 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
1745 }
1746 var body io.Reader = nil
1747 c.urlParams_.Set("alt", alt)
1748 c.urlParams_.Set("prettyPrint", "false")
1749 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+name}")
1750 urls += "?" + c.urlParams_.Encode()
1751 req, err := http.NewRequest("GET", urls, body)
1752 if err != nil {
1753 return nil, err
1754 }
1755 req.Header = reqHeaders
1756 googleapi.Expand(req.URL, map[string]string{
1757 "name": c.name,
1758 })
1759 return gensupport.SendRequest(c.ctx_, c.s.client, req)
1760 }
1761
1762
1763
1764
1765
1766
1767
1768 func (c *OrganizationsLocationsCustomersWorkloadsGetPartnerPermissionsCall) Do(opts ...googleapi.CallOption) (*PartnerPermissions, error) {
1769 gensupport.SetOptions(c.urlParams_, opts...)
1770 res, err := c.doRequest("json")
1771 if res != nil && res.StatusCode == http.StatusNotModified {
1772 if res.Body != nil {
1773 res.Body.Close()
1774 }
1775 return nil, gensupport.WrapError(&googleapi.Error{
1776 Code: res.StatusCode,
1777 Header: res.Header,
1778 })
1779 }
1780 if err != nil {
1781 return nil, err
1782 }
1783 defer googleapi.CloseBody(res)
1784 if err := googleapi.CheckResponse(res); err != nil {
1785 return nil, gensupport.WrapError(err)
1786 }
1787 ret := &PartnerPermissions{
1788 ServerResponse: googleapi.ServerResponse{
1789 Header: res.Header,
1790 HTTPStatusCode: res.StatusCode,
1791 },
1792 }
1793 target := &ret
1794 if err := gensupport.DecodeResponse(target, res); err != nil {
1795 return nil, err
1796 }
1797 return ret, nil
1798 }
1799
1800 type OrganizationsLocationsCustomersWorkloadsListCall struct {
1801 s *Service
1802 parent string
1803 urlParams_ gensupport.URLParams
1804 ifNoneMatch_ string
1805 ctx_ context.Context
1806 header_ http.Header
1807 }
1808
1809
1810
1811
1812
1813 func (r *OrganizationsLocationsCustomersWorkloadsService) List(parent string) *OrganizationsLocationsCustomersWorkloadsListCall {
1814 c := &OrganizationsLocationsCustomersWorkloadsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
1815 c.parent = parent
1816 return c
1817 }
1818
1819
1820 func (c *OrganizationsLocationsCustomersWorkloadsListCall) Filter(filter string) *OrganizationsLocationsCustomersWorkloadsListCall {
1821 c.urlParams_.Set("filter", filter)
1822 return c
1823 }
1824
1825
1826
1827 func (c *OrganizationsLocationsCustomersWorkloadsListCall) OrderBy(orderBy string) *OrganizationsLocationsCustomersWorkloadsListCall {
1828 c.urlParams_.Set("orderBy", orderBy)
1829 return c
1830 }
1831
1832
1833
1834
1835 func (c *OrganizationsLocationsCustomersWorkloadsListCall) PageSize(pageSize int64) *OrganizationsLocationsCustomersWorkloadsListCall {
1836 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
1837 return c
1838 }
1839
1840
1841
1842
1843 func (c *OrganizationsLocationsCustomersWorkloadsListCall) PageToken(pageToken string) *OrganizationsLocationsCustomersWorkloadsListCall {
1844 c.urlParams_.Set("pageToken", pageToken)
1845 return c
1846 }
1847
1848
1849
1850
1851 func (c *OrganizationsLocationsCustomersWorkloadsListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersWorkloadsListCall {
1852 c.urlParams_.Set("fields", googleapi.CombineFields(s))
1853 return c
1854 }
1855
1856
1857
1858
1859 func (c *OrganizationsLocationsCustomersWorkloadsListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersWorkloadsListCall {
1860 c.ifNoneMatch_ = entityTag
1861 return c
1862 }
1863
1864
1865 func (c *OrganizationsLocationsCustomersWorkloadsListCall) Context(ctx context.Context) *OrganizationsLocationsCustomersWorkloadsListCall {
1866 c.ctx_ = ctx
1867 return c
1868 }
1869
1870
1871
1872 func (c *OrganizationsLocationsCustomersWorkloadsListCall) Header() http.Header {
1873 if c.header_ == nil {
1874 c.header_ = make(http.Header)
1875 }
1876 return c.header_
1877 }
1878
1879 func (c *OrganizationsLocationsCustomersWorkloadsListCall) doRequest(alt string) (*http.Response, error) {
1880 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
1881 if c.ifNoneMatch_ != "" {
1882 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
1883 }
1884 var body io.Reader = nil
1885 c.urlParams_.Set("alt", alt)
1886 c.urlParams_.Set("prettyPrint", "false")
1887 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+parent}/workloads")
1888 urls += "?" + c.urlParams_.Encode()
1889 req, err := http.NewRequest("GET", urls, body)
1890 if err != nil {
1891 return nil, err
1892 }
1893 req.Header = reqHeaders
1894 googleapi.Expand(req.URL, map[string]string{
1895 "parent": c.parent,
1896 })
1897 return gensupport.SendRequest(c.ctx_, c.s.client, req)
1898 }
1899
1900
1901
1902
1903
1904
1905
1906 func (c *OrganizationsLocationsCustomersWorkloadsListCall) Do(opts ...googleapi.CallOption) (*ListWorkloadsResponse, error) {
1907 gensupport.SetOptions(c.urlParams_, opts...)
1908 res, err := c.doRequest("json")
1909 if res != nil && res.StatusCode == http.StatusNotModified {
1910 if res.Body != nil {
1911 res.Body.Close()
1912 }
1913 return nil, gensupport.WrapError(&googleapi.Error{
1914 Code: res.StatusCode,
1915 Header: res.Header,
1916 })
1917 }
1918 if err != nil {
1919 return nil, err
1920 }
1921 defer googleapi.CloseBody(res)
1922 if err := googleapi.CheckResponse(res); err != nil {
1923 return nil, gensupport.WrapError(err)
1924 }
1925 ret := &ListWorkloadsResponse{
1926 ServerResponse: googleapi.ServerResponse{
1927 Header: res.Header,
1928 HTTPStatusCode: res.StatusCode,
1929 },
1930 }
1931 target := &ret
1932 if err := gensupport.DecodeResponse(target, res); err != nil {
1933 return nil, err
1934 }
1935 return ret, nil
1936 }
1937
1938
1939
1940
1941 func (c *OrganizationsLocationsCustomersWorkloadsListCall) Pages(ctx context.Context, f func(*ListWorkloadsResponse) error) error {
1942 c.ctx_ = ctx
1943 defer c.PageToken(c.urlParams_.Get("pageToken"))
1944 for {
1945 x, err := c.Do()
1946 if err != nil {
1947 return err
1948 }
1949 if err := f(x); err != nil {
1950 return err
1951 }
1952 if x.NextPageToken == "" {
1953 return nil
1954 }
1955 c.PageToken(x.NextPageToken)
1956 }
1957 }
1958
1959 type OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall struct {
1960 s *Service
1961 parent string
1962 urlParams_ gensupport.URLParams
1963 ifNoneMatch_ string
1964 ctx_ context.Context
1965 header_ http.Header
1966 }
1967
1968
1969
1970
1971
1972
1973 func (r *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsService) List(parent string) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall {
1974 c := &OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
1975 c.parent = parent
1976 return c
1977 }
1978
1979
1980 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) Filter(filter string) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall {
1981 c.urlParams_.Set("filter", filter)
1982 return c
1983 }
1984
1985
1986
1987 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) OrderBy(orderBy string) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall {
1988 c.urlParams_.Set("orderBy", orderBy)
1989 return c
1990 }
1991
1992
1993
1994
1995 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) PageSize(pageSize int64) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall {
1996 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
1997 return c
1998 }
1999
2000
2001
2002
2003 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) PageToken(pageToken string) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall {
2004 c.urlParams_.Set("pageToken", pageToken)
2005 return c
2006 }
2007
2008
2009
2010
2011 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall {
2012 c.urlParams_.Set("fields", googleapi.CombineFields(s))
2013 return c
2014 }
2015
2016
2017
2018
2019 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall {
2020 c.ifNoneMatch_ = entityTag
2021 return c
2022 }
2023
2024
2025 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) Context(ctx context.Context) *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall {
2026 c.ctx_ = ctx
2027 return c
2028 }
2029
2030
2031
2032 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) Header() http.Header {
2033 if c.header_ == nil {
2034 c.header_ = make(http.Header)
2035 }
2036 return c.header_
2037 }
2038
2039 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) doRequest(alt string) (*http.Response, error) {
2040 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
2041 if c.ifNoneMatch_ != "" {
2042 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
2043 }
2044 var body io.Reader = nil
2045 c.urlParams_.Set("alt", alt)
2046 c.urlParams_.Set("prettyPrint", "false")
2047 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+parent}/accessApprovalRequests")
2048 urls += "?" + c.urlParams_.Encode()
2049 req, err := http.NewRequest("GET", urls, body)
2050 if err != nil {
2051 return nil, err
2052 }
2053 req.Header = reqHeaders
2054 googleapi.Expand(req.URL, map[string]string{
2055 "parent": c.parent,
2056 })
2057 return gensupport.SendRequest(c.ctx_, c.s.client, req)
2058 }
2059
2060
2061
2062
2063
2064
2065
2066 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) Do(opts ...googleapi.CallOption) (*ListAccessApprovalRequestsResponse, error) {
2067 gensupport.SetOptions(c.urlParams_, opts...)
2068 res, err := c.doRequest("json")
2069 if res != nil && res.StatusCode == http.StatusNotModified {
2070 if res.Body != nil {
2071 res.Body.Close()
2072 }
2073 return nil, gensupport.WrapError(&googleapi.Error{
2074 Code: res.StatusCode,
2075 Header: res.Header,
2076 })
2077 }
2078 if err != nil {
2079 return nil, err
2080 }
2081 defer googleapi.CloseBody(res)
2082 if err := googleapi.CheckResponse(res); err != nil {
2083 return nil, gensupport.WrapError(err)
2084 }
2085 ret := &ListAccessApprovalRequestsResponse{
2086 ServerResponse: googleapi.ServerResponse{
2087 Header: res.Header,
2088 HTTPStatusCode: res.StatusCode,
2089 },
2090 }
2091 target := &ret
2092 if err := gensupport.DecodeResponse(target, res); err != nil {
2093 return nil, err
2094 }
2095 return ret, nil
2096 }
2097
2098
2099
2100
2101 func (c *OrganizationsLocationsCustomersWorkloadsAccessApprovalRequestsListCall) Pages(ctx context.Context, f func(*ListAccessApprovalRequestsResponse) error) error {
2102 c.ctx_ = ctx
2103 defer c.PageToken(c.urlParams_.Get("pageToken"))
2104 for {
2105 x, err := c.Do()
2106 if err != nil {
2107 return err
2108 }
2109 if err := f(x); err != nil {
2110 return err
2111 }
2112 if x.NextPageToken == "" {
2113 return nil
2114 }
2115 c.PageToken(x.NextPageToken)
2116 }
2117 }
2118
2119 type OrganizationsLocationsCustomersWorkloadsViolationsGetCall struct {
2120 s *Service
2121 name string
2122 urlParams_ gensupport.URLParams
2123 ifNoneMatch_ string
2124 ctx_ context.Context
2125 header_ http.Header
2126 }
2127
2128
2129
2130
2131
2132
2133 func (r *OrganizationsLocationsCustomersWorkloadsViolationsService) Get(name string) *OrganizationsLocationsCustomersWorkloadsViolationsGetCall {
2134 c := &OrganizationsLocationsCustomersWorkloadsViolationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
2135 c.name = name
2136 return c
2137 }
2138
2139
2140
2141
2142 func (c *OrganizationsLocationsCustomersWorkloadsViolationsGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersWorkloadsViolationsGetCall {
2143 c.urlParams_.Set("fields", googleapi.CombineFields(s))
2144 return c
2145 }
2146
2147
2148
2149
2150 func (c *OrganizationsLocationsCustomersWorkloadsViolationsGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersWorkloadsViolationsGetCall {
2151 c.ifNoneMatch_ = entityTag
2152 return c
2153 }
2154
2155
2156 func (c *OrganizationsLocationsCustomersWorkloadsViolationsGetCall) Context(ctx context.Context) *OrganizationsLocationsCustomersWorkloadsViolationsGetCall {
2157 c.ctx_ = ctx
2158 return c
2159 }
2160
2161
2162
2163 func (c *OrganizationsLocationsCustomersWorkloadsViolationsGetCall) Header() http.Header {
2164 if c.header_ == nil {
2165 c.header_ = make(http.Header)
2166 }
2167 return c.header_
2168 }
2169
2170 func (c *OrganizationsLocationsCustomersWorkloadsViolationsGetCall) doRequest(alt string) (*http.Response, error) {
2171 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
2172 if c.ifNoneMatch_ != "" {
2173 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
2174 }
2175 var body io.Reader = nil
2176 c.urlParams_.Set("alt", alt)
2177 c.urlParams_.Set("prettyPrint", "false")
2178 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+name}")
2179 urls += "?" + c.urlParams_.Encode()
2180 req, err := http.NewRequest("GET", urls, body)
2181 if err != nil {
2182 return nil, err
2183 }
2184 req.Header = reqHeaders
2185 googleapi.Expand(req.URL, map[string]string{
2186 "name": c.name,
2187 })
2188 return gensupport.SendRequest(c.ctx_, c.s.client, req)
2189 }
2190
2191
2192
2193
2194
2195
2196 func (c *OrganizationsLocationsCustomersWorkloadsViolationsGetCall) Do(opts ...googleapi.CallOption) (*Violation, error) {
2197 gensupport.SetOptions(c.urlParams_, opts...)
2198 res, err := c.doRequest("json")
2199 if res != nil && res.StatusCode == http.StatusNotModified {
2200 if res.Body != nil {
2201 res.Body.Close()
2202 }
2203 return nil, gensupport.WrapError(&googleapi.Error{
2204 Code: res.StatusCode,
2205 Header: res.Header,
2206 })
2207 }
2208 if err != nil {
2209 return nil, err
2210 }
2211 defer googleapi.CloseBody(res)
2212 if err := googleapi.CheckResponse(res); err != nil {
2213 return nil, gensupport.WrapError(err)
2214 }
2215 ret := &Violation{
2216 ServerResponse: googleapi.ServerResponse{
2217 Header: res.Header,
2218 HTTPStatusCode: res.StatusCode,
2219 },
2220 }
2221 target := &ret
2222 if err := gensupport.DecodeResponse(target, res); err != nil {
2223 return nil, err
2224 }
2225 return ret, nil
2226 }
2227
2228 type OrganizationsLocationsCustomersWorkloadsViolationsListCall struct {
2229 s *Service
2230 parent string
2231 urlParams_ gensupport.URLParams
2232 ifNoneMatch_ string
2233 ctx_ context.Context
2234 header_ http.Header
2235 }
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247 func (r *OrganizationsLocationsCustomersWorkloadsViolationsService) List(parent string) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2248 c := &OrganizationsLocationsCustomersWorkloadsViolationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
2249 c.parent = parent
2250 return c
2251 }
2252
2253
2254 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) Filter(filter string) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2255 c.urlParams_.Set("filter", filter)
2256 return c
2257 }
2258
2259
2260
2261
2262 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) IntervalEndTime(intervalEndTime string) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2263 c.urlParams_.Set("interval.endTime", intervalEndTime)
2264 return c
2265 }
2266
2267
2268
2269
2270 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) IntervalStartTime(intervalStartTime string) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2271 c.urlParams_.Set("interval.startTime", intervalStartTime)
2272 return c
2273 }
2274
2275
2276
2277 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) OrderBy(orderBy string) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2278 c.urlParams_.Set("orderBy", orderBy)
2279 return c
2280 }
2281
2282
2283
2284
2285 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) PageSize(pageSize int64) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2286 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
2287 return c
2288 }
2289
2290
2291
2292
2293 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) PageToken(pageToken string) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2294 c.urlParams_.Set("pageToken", pageToken)
2295 return c
2296 }
2297
2298
2299
2300
2301 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2302 c.urlParams_.Set("fields", googleapi.CombineFields(s))
2303 return c
2304 }
2305
2306
2307
2308
2309 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2310 c.ifNoneMatch_ = entityTag
2311 return c
2312 }
2313
2314
2315 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) Context(ctx context.Context) *OrganizationsLocationsCustomersWorkloadsViolationsListCall {
2316 c.ctx_ = ctx
2317 return c
2318 }
2319
2320
2321
2322 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) Header() http.Header {
2323 if c.header_ == nil {
2324 c.header_ = make(http.Header)
2325 }
2326 return c.header_
2327 }
2328
2329 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) doRequest(alt string) (*http.Response, error) {
2330 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
2331 if c.ifNoneMatch_ != "" {
2332 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
2333 }
2334 var body io.Reader = nil
2335 c.urlParams_.Set("alt", alt)
2336 c.urlParams_.Set("prettyPrint", "false")
2337 urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/{+parent}/violations")
2338 urls += "?" + c.urlParams_.Encode()
2339 req, err := http.NewRequest("GET", urls, body)
2340 if err != nil {
2341 return nil, err
2342 }
2343 req.Header = reqHeaders
2344 googleapi.Expand(req.URL, map[string]string{
2345 "parent": c.parent,
2346 })
2347 return gensupport.SendRequest(c.ctx_, c.s.client, req)
2348 }
2349
2350
2351
2352
2353
2354
2355
2356 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) Do(opts ...googleapi.CallOption) (*ListViolationsResponse, error) {
2357 gensupport.SetOptions(c.urlParams_, opts...)
2358 res, err := c.doRequest("json")
2359 if res != nil && res.StatusCode == http.StatusNotModified {
2360 if res.Body != nil {
2361 res.Body.Close()
2362 }
2363 return nil, gensupport.WrapError(&googleapi.Error{
2364 Code: res.StatusCode,
2365 Header: res.Header,
2366 })
2367 }
2368 if err != nil {
2369 return nil, err
2370 }
2371 defer googleapi.CloseBody(res)
2372 if err := googleapi.CheckResponse(res); err != nil {
2373 return nil, gensupport.WrapError(err)
2374 }
2375 ret := &ListViolationsResponse{
2376 ServerResponse: googleapi.ServerResponse{
2377 Header: res.Header,
2378 HTTPStatusCode: res.StatusCode,
2379 },
2380 }
2381 target := &ret
2382 if err := gensupport.DecodeResponse(target, res); err != nil {
2383 return nil, err
2384 }
2385 return ret, nil
2386 }
2387
2388
2389
2390
2391 func (c *OrganizationsLocationsCustomersWorkloadsViolationsListCall) Pages(ctx context.Context, f func(*ListViolationsResponse) error) error {
2392 c.ctx_ = ctx
2393 defer c.PageToken(c.urlParams_.Get("pageToken"))
2394 for {
2395 x, err := c.Do()
2396 if err != nil {
2397 return err
2398 }
2399 if err := f(x); err != nil {
2400 return err
2401 }
2402 if x.NextPageToken == "" {
2403 return nil
2404 }
2405 c.PageToken(x.NextPageToken)
2406 }
2407 }
2408
View as plain text