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 gkeonprem
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 = "gkeonprem:v1"
90 const apiName = "gkeonprem"
91 const apiVersion = "v1"
92 const basePath = "https://gkeonprem.googleapis.com/"
93 const basePathTemplate = "https://gkeonprem.UNIVERSE_DOMAIN/"
94 const mtlsBasePath = "https://gkeonprem.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.BareMetalAdminClusters = NewProjectsLocationsBareMetalAdminClustersService(s)
172 rs.BareMetalClusters = NewProjectsLocationsBareMetalClustersService(s)
173 rs.Operations = NewProjectsLocationsOperationsService(s)
174 rs.VmwareAdminClusters = NewProjectsLocationsVmwareAdminClustersService(s)
175 rs.VmwareClusters = NewProjectsLocationsVmwareClustersService(s)
176 return rs
177 }
178
179 type ProjectsLocationsService struct {
180 s *Service
181
182 BareMetalAdminClusters *ProjectsLocationsBareMetalAdminClustersService
183
184 BareMetalClusters *ProjectsLocationsBareMetalClustersService
185
186 Operations *ProjectsLocationsOperationsService
187
188 VmwareAdminClusters *ProjectsLocationsVmwareAdminClustersService
189
190 VmwareClusters *ProjectsLocationsVmwareClustersService
191 }
192
193 func NewProjectsLocationsBareMetalAdminClustersService(s *Service) *ProjectsLocationsBareMetalAdminClustersService {
194 rs := &ProjectsLocationsBareMetalAdminClustersService{s: s}
195 rs.Operations = NewProjectsLocationsBareMetalAdminClustersOperationsService(s)
196 return rs
197 }
198
199 type ProjectsLocationsBareMetalAdminClustersService struct {
200 s *Service
201
202 Operations *ProjectsLocationsBareMetalAdminClustersOperationsService
203 }
204
205 func NewProjectsLocationsBareMetalAdminClustersOperationsService(s *Service) *ProjectsLocationsBareMetalAdminClustersOperationsService {
206 rs := &ProjectsLocationsBareMetalAdminClustersOperationsService{s: s}
207 return rs
208 }
209
210 type ProjectsLocationsBareMetalAdminClustersOperationsService struct {
211 s *Service
212 }
213
214 func NewProjectsLocationsBareMetalClustersService(s *Service) *ProjectsLocationsBareMetalClustersService {
215 rs := &ProjectsLocationsBareMetalClustersService{s: s}
216 rs.BareMetalNodePools = NewProjectsLocationsBareMetalClustersBareMetalNodePoolsService(s)
217 rs.Operations = NewProjectsLocationsBareMetalClustersOperationsService(s)
218 return rs
219 }
220
221 type ProjectsLocationsBareMetalClustersService struct {
222 s *Service
223
224 BareMetalNodePools *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService
225
226 Operations *ProjectsLocationsBareMetalClustersOperationsService
227 }
228
229 func NewProjectsLocationsBareMetalClustersBareMetalNodePoolsService(s *Service) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService {
230 rs := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsService{s: s}
231 rs.Operations = NewProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsService(s)
232 return rs
233 }
234
235 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsService struct {
236 s *Service
237
238 Operations *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsService
239 }
240
241 func NewProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsService(s *Service) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsService {
242 rs := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsService{s: s}
243 return rs
244 }
245
246 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsService struct {
247 s *Service
248 }
249
250 func NewProjectsLocationsBareMetalClustersOperationsService(s *Service) *ProjectsLocationsBareMetalClustersOperationsService {
251 rs := &ProjectsLocationsBareMetalClustersOperationsService{s: s}
252 return rs
253 }
254
255 type ProjectsLocationsBareMetalClustersOperationsService struct {
256 s *Service
257 }
258
259 func NewProjectsLocationsOperationsService(s *Service) *ProjectsLocationsOperationsService {
260 rs := &ProjectsLocationsOperationsService{s: s}
261 return rs
262 }
263
264 type ProjectsLocationsOperationsService struct {
265 s *Service
266 }
267
268 func NewProjectsLocationsVmwareAdminClustersService(s *Service) *ProjectsLocationsVmwareAdminClustersService {
269 rs := &ProjectsLocationsVmwareAdminClustersService{s: s}
270 rs.Operations = NewProjectsLocationsVmwareAdminClustersOperationsService(s)
271 return rs
272 }
273
274 type ProjectsLocationsVmwareAdminClustersService struct {
275 s *Service
276
277 Operations *ProjectsLocationsVmwareAdminClustersOperationsService
278 }
279
280 func NewProjectsLocationsVmwareAdminClustersOperationsService(s *Service) *ProjectsLocationsVmwareAdminClustersOperationsService {
281 rs := &ProjectsLocationsVmwareAdminClustersOperationsService{s: s}
282 return rs
283 }
284
285 type ProjectsLocationsVmwareAdminClustersOperationsService struct {
286 s *Service
287 }
288
289 func NewProjectsLocationsVmwareClustersService(s *Service) *ProjectsLocationsVmwareClustersService {
290 rs := &ProjectsLocationsVmwareClustersService{s: s}
291 rs.Operations = NewProjectsLocationsVmwareClustersOperationsService(s)
292 rs.VmwareNodePools = NewProjectsLocationsVmwareClustersVmwareNodePoolsService(s)
293 return rs
294 }
295
296 type ProjectsLocationsVmwareClustersService struct {
297 s *Service
298
299 Operations *ProjectsLocationsVmwareClustersOperationsService
300
301 VmwareNodePools *ProjectsLocationsVmwareClustersVmwareNodePoolsService
302 }
303
304 func NewProjectsLocationsVmwareClustersOperationsService(s *Service) *ProjectsLocationsVmwareClustersOperationsService {
305 rs := &ProjectsLocationsVmwareClustersOperationsService{s: s}
306 return rs
307 }
308
309 type ProjectsLocationsVmwareClustersOperationsService struct {
310 s *Service
311 }
312
313 func NewProjectsLocationsVmwareClustersVmwareNodePoolsService(s *Service) *ProjectsLocationsVmwareClustersVmwareNodePoolsService {
314 rs := &ProjectsLocationsVmwareClustersVmwareNodePoolsService{s: s}
315 rs.Operations = NewProjectsLocationsVmwareClustersVmwareNodePoolsOperationsService(s)
316 return rs
317 }
318
319 type ProjectsLocationsVmwareClustersVmwareNodePoolsService struct {
320 s *Service
321
322 Operations *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsService
323 }
324
325 func NewProjectsLocationsVmwareClustersVmwareNodePoolsOperationsService(s *Service) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsService {
326 rs := &ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsService{s: s}
327 return rs
328 }
329
330 type ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsService struct {
331 s *Service
332 }
333
334
335
336 type Authorization struct {
337
338
339
340
341 AdminUsers []*ClusterUser `json:"adminUsers,omitempty"`
342
343
344
345
346
347 ForceSendFields []string `json:"-"`
348
349
350
351
352 NullFields []string `json:"-"`
353 }
354
355 func (s *Authorization) MarshalJSON() ([]byte, error) {
356 type NoMethod Authorization
357 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
358 }
359
360
361
362
363
364 type BareMetalAdminApiServerArgument struct {
365
366
367 Argument string `json:"argument,omitempty"`
368
369
370 Value string `json:"value,omitempty"`
371
372
373
374
375
376 ForceSendFields []string `json:"-"`
377
378
379
380
381 NullFields []string `json:"-"`
382 }
383
384 func (s *BareMetalAdminApiServerArgument) MarshalJSON() ([]byte, error) {
385 type NoMethod BareMetalAdminApiServerArgument
386 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
387 }
388
389
390 type BareMetalAdminCluster struct {
391
392
393
394
395
396
397
398 Annotations map[string]string `json:"annotations,omitempty"`
399
400
401 BareMetalVersion string `json:"bareMetalVersion,omitempty"`
402
403 BinaryAuthorization *BinaryAuthorization `json:"binaryAuthorization,omitempty"`
404
405 ClusterOperations *BareMetalAdminClusterOperationsConfig `json:"clusterOperations,omitempty"`
406
407 ControlPlane *BareMetalAdminControlPlaneConfig `json:"controlPlane,omitempty"`
408
409
410 CreateTime string `json:"createTime,omitempty"`
411
412
413 DeleteTime string `json:"deleteTime,omitempty"`
414
415 Description string `json:"description,omitempty"`
416
417
418 Endpoint string `json:"endpoint,omitempty"`
419
420
421
422
423 Etag string `json:"etag,omitempty"`
424
425 Fleet *Fleet `json:"fleet,omitempty"`
426
427 LoadBalancer *BareMetalAdminLoadBalancerConfig `json:"loadBalancer,omitempty"`
428
429
430
431
432
433
434
435
436 LocalName string `json:"localName,omitempty"`
437
438 MaintenanceConfig *BareMetalAdminMaintenanceConfig `json:"maintenanceConfig,omitempty"`
439
440
441 MaintenanceStatus *BareMetalAdminMaintenanceStatus `json:"maintenanceStatus,omitempty"`
442
443 Name string `json:"name,omitempty"`
444
445 NetworkConfig *BareMetalAdminNetworkConfig `json:"networkConfig,omitempty"`
446
447 NodeAccessConfig *BareMetalAdminNodeAccessConfig `json:"nodeAccessConfig,omitempty"`
448
449 NodeConfig *BareMetalAdminWorkloadNodeConfig `json:"nodeConfig,omitempty"`
450
451 OsEnvironmentConfig *BareMetalAdminOsEnvironmentConfig `json:"osEnvironmentConfig,omitempty"`
452
453 Proxy *BareMetalAdminProxyConfig `json:"proxy,omitempty"`
454
455
456 Reconciling bool `json:"reconciling,omitempty"`
457
458 SecurityConfig *BareMetalAdminSecurityConfig `json:"securityConfig,omitempty"`
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474 State string `json:"state,omitempty"`
475
476 Status *ResourceStatus `json:"status,omitempty"`
477
478 Storage *BareMetalAdminStorageConfig `json:"storage,omitempty"`
479
480 Uid string `json:"uid,omitempty"`
481
482
483 UpdateTime string `json:"updateTime,omitempty"`
484
485
486 ValidationCheck *ValidationCheck `json:"validationCheck,omitempty"`
487
488
489 googleapi.ServerResponse `json:"-"`
490
491
492
493
494
495 ForceSendFields []string `json:"-"`
496
497
498
499
500 NullFields []string `json:"-"`
501 }
502
503 func (s *BareMetalAdminCluster) MarshalJSON() ([]byte, error) {
504 type NoMethod BareMetalAdminCluster
505 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
506 }
507
508
509
510 type BareMetalAdminClusterOperationsConfig struct {
511
512
513 EnableApplicationLogs bool `json:"enableApplicationLogs,omitempty"`
514
515
516
517
518
519 ForceSendFields []string `json:"-"`
520
521
522
523
524 NullFields []string `json:"-"`
525 }
526
527 func (s *BareMetalAdminClusterOperationsConfig) MarshalJSON() ([]byte, error) {
528 type NoMethod BareMetalAdminClusterOperationsConfig
529 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
530 }
531
532
533
534 type BareMetalAdminControlPlaneConfig struct {
535
536
537
538
539 ApiServerArgs []*BareMetalAdminApiServerArgument `json:"apiServerArgs,omitempty"`
540
541
542
543
544 ControlPlaneNodePoolConfig *BareMetalAdminControlPlaneNodePoolConfig `json:"controlPlaneNodePoolConfig,omitempty"`
545
546
547
548
549
550 ForceSendFields []string `json:"-"`
551
552
553
554
555 NullFields []string `json:"-"`
556 }
557
558 func (s *BareMetalAdminControlPlaneConfig) MarshalJSON() ([]byte, error) {
559 type NoMethod BareMetalAdminControlPlaneConfig
560 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
561 }
562
563
564
565
566
567
568 type BareMetalAdminControlPlaneNodePoolConfig struct {
569
570
571 NodePoolConfig *BareMetalNodePoolConfig `json:"nodePoolConfig,omitempty"`
572
573
574
575
576
577 ForceSendFields []string `json:"-"`
578
579
580
581
582 NullFields []string `json:"-"`
583 }
584
585 func (s *BareMetalAdminControlPlaneNodePoolConfig) MarshalJSON() ([]byte, error) {
586 type NoMethod BareMetalAdminControlPlaneNodePoolConfig
587 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
588 }
589
590
591
592 type BareMetalAdminDrainedMachine struct {
593
594 NodeIp string `json:"nodeIp,omitempty"`
595
596
597
598
599
600 ForceSendFields []string `json:"-"`
601
602
603
604
605 NullFields []string `json:"-"`
606 }
607
608 func (s *BareMetalAdminDrainedMachine) MarshalJSON() ([]byte, error) {
609 type NoMethod BareMetalAdminDrainedMachine
610 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
611 }
612
613
614
615 type BareMetalAdminDrainingMachine struct {
616
617 NodeIp string `json:"nodeIp,omitempty"`
618
619 PodCount int64 `json:"podCount,omitempty"`
620
621
622
623
624
625 ForceSendFields []string `json:"-"`
626
627
628
629
630 NullFields []string `json:"-"`
631 }
632
633 func (s *BareMetalAdminDrainingMachine) MarshalJSON() ([]byte, error) {
634 type NoMethod BareMetalAdminDrainingMachine
635 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
636 }
637
638
639
640 type BareMetalAdminIslandModeCidrConfig struct {
641
642
643
644 PodAddressCidrBlocks []string `json:"podAddressCidrBlocks,omitempty"`
645
646
647
648 ServiceAddressCidrBlocks []string `json:"serviceAddressCidrBlocks,omitempty"`
649
650
651
652
653
654 ForceSendFields []string `json:"-"`
655
656
657
658
659 NullFields []string `json:"-"`
660 }
661
662 func (s *BareMetalAdminIslandModeCidrConfig) MarshalJSON() ([]byte, error) {
663 type NoMethod BareMetalAdminIslandModeCidrConfig
664 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
665 }
666
667
668
669 type BareMetalAdminLoadBalancerConfig struct {
670
671 ManualLbConfig *BareMetalAdminManualLbConfig `json:"manualLbConfig,omitempty"`
672
673 PortConfig *BareMetalAdminPortConfig `json:"portConfig,omitempty"`
674
675 VipConfig *BareMetalAdminVipConfig `json:"vipConfig,omitempty"`
676
677
678
679
680
681 ForceSendFields []string `json:"-"`
682
683
684
685
686 NullFields []string `json:"-"`
687 }
688
689 func (s *BareMetalAdminLoadBalancerConfig) MarshalJSON() ([]byte, error) {
690 type NoMethod BareMetalAdminLoadBalancerConfig
691 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
692 }
693
694
695
696
697 type BareMetalAdminMachineDrainStatus struct {
698
699 DrainedMachines []*BareMetalAdminDrainedMachine `json:"drainedMachines,omitempty"`
700
701 DrainingMachines []*BareMetalAdminDrainingMachine `json:"drainingMachines,omitempty"`
702
703
704
705
706
707 ForceSendFields []string `json:"-"`
708
709
710
711
712 NullFields []string `json:"-"`
713 }
714
715 func (s *BareMetalAdminMachineDrainStatus) MarshalJSON() ([]byte, error) {
716 type NoMethod BareMetalAdminMachineDrainStatus
717 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
718 }
719
720
721
722
723 type BareMetalAdminMaintenanceConfig struct {
724
725
726
727
728
729 MaintenanceAddressCidrBlocks []string `json:"maintenanceAddressCidrBlocks,omitempty"`
730
731
732
733
734
735 ForceSendFields []string `json:"-"`
736
737
738
739
740 NullFields []string `json:"-"`
741 }
742
743 func (s *BareMetalAdminMaintenanceConfig) MarshalJSON() ([]byte, error) {
744 type NoMethod BareMetalAdminMaintenanceConfig
745 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
746 }
747
748
749
750 type BareMetalAdminMaintenanceStatus struct {
751
752
753 MachineDrainStatus *BareMetalAdminMachineDrainStatus `json:"machineDrainStatus,omitempty"`
754
755
756
757
758
759 ForceSendFields []string `json:"-"`
760
761
762
763
764 NullFields []string `json:"-"`
765 }
766
767 func (s *BareMetalAdminMaintenanceStatus) MarshalJSON() ([]byte, error) {
768 type NoMethod BareMetalAdminMaintenanceStatus
769 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
770 }
771
772
773
774 type BareMetalAdminManualLbConfig struct {
775
776 Enabled bool `json:"enabled,omitempty"`
777
778
779
780
781
782 ForceSendFields []string `json:"-"`
783
784
785
786
787 NullFields []string `json:"-"`
788 }
789
790 func (s *BareMetalAdminManualLbConfig) MarshalJSON() ([]byte, error) {
791 type NoMethod BareMetalAdminManualLbConfig
792 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
793 }
794
795
796
797 type BareMetalAdminNetworkConfig struct {
798
799 IslandModeCidr *BareMetalAdminIslandModeCidrConfig `json:"islandModeCidr,omitempty"`
800
801
802
803
804
805 ForceSendFields []string `json:"-"`
806
807
808
809
810 NullFields []string `json:"-"`
811 }
812
813 func (s *BareMetalAdminNetworkConfig) MarshalJSON() ([]byte, error) {
814 type NoMethod BareMetalAdminNetworkConfig
815 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
816 }
817
818
819
820 type BareMetalAdminNodeAccessConfig struct {
821
822
823 LoginUser string `json:"loginUser,omitempty"`
824
825
826
827
828
829 ForceSendFields []string `json:"-"`
830
831
832
833
834 NullFields []string `json:"-"`
835 }
836
837 func (s *BareMetalAdminNodeAccessConfig) MarshalJSON() ([]byte, error) {
838 type NoMethod BareMetalAdminNodeAccessConfig
839 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
840 }
841
842
843
844 type BareMetalAdminOsEnvironmentConfig struct {
845
846
847 PackageRepoExcluded bool `json:"packageRepoExcluded,omitempty"`
848
849
850
851
852
853 ForceSendFields []string `json:"-"`
854
855
856
857
858 NullFields []string `json:"-"`
859 }
860
861 func (s *BareMetalAdminOsEnvironmentConfig) MarshalJSON() ([]byte, error) {
862 type NoMethod BareMetalAdminOsEnvironmentConfig
863 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
864 }
865
866
867
868 type BareMetalAdminPortConfig struct {
869
870
871 ControlPlaneLoadBalancerPort int64 `json:"controlPlaneLoadBalancerPort,omitempty"`
872
873
874
875
876
877 ForceSendFields []string `json:"-"`
878
879
880
881
882 NullFields []string `json:"-"`
883 }
884
885 func (s *BareMetalAdminPortConfig) MarshalJSON() ([]byte, error) {
886 type NoMethod BareMetalAdminPortConfig
887 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
888 }
889
890
891
892 type BareMetalAdminProxyConfig struct {
893
894
895 NoProxy []string `json:"noProxy,omitempty"`
896
897
898
899 Uri string `json:"uri,omitempty"`
900
901
902
903
904
905 ForceSendFields []string `json:"-"`
906
907
908
909
910 NullFields []string `json:"-"`
911 }
912
913 func (s *BareMetalAdminProxyConfig) MarshalJSON() ([]byte, error) {
914 type NoMethod BareMetalAdminProxyConfig
915 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
916 }
917
918
919
920 type BareMetalAdminSecurityConfig struct {
921
922 Authorization *Authorization `json:"authorization,omitempty"`
923
924
925
926
927
928 ForceSendFields []string `json:"-"`
929
930
931
932
933 NullFields []string `json:"-"`
934 }
935
936 func (s *BareMetalAdminSecurityConfig) MarshalJSON() ([]byte, error) {
937 type NoMethod BareMetalAdminSecurityConfig
938 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
939 }
940
941
942
943 type BareMetalAdminStorageConfig struct {
944
945
946
947
948 LvpNodeMountsConfig *BareMetalLvpConfig `json:"lvpNodeMountsConfig,omitempty"`
949
950
951
952 LvpShareConfig *BareMetalLvpShareConfig `json:"lvpShareConfig,omitempty"`
953
954
955
956
957
958 ForceSendFields []string `json:"-"`
959
960
961
962
963 NullFields []string `json:"-"`
964 }
965
966 func (s *BareMetalAdminStorageConfig) MarshalJSON() ([]byte, error) {
967 type NoMethod BareMetalAdminStorageConfig
968 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
969 }
970
971
972
973 type BareMetalAdminVipConfig struct {
974
975
976 ControlPlaneVip string `json:"controlPlaneVip,omitempty"`
977
978
979
980
981
982 ForceSendFields []string `json:"-"`
983
984
985
986
987 NullFields []string `json:"-"`
988 }
989
990 func (s *BareMetalAdminVipConfig) MarshalJSON() ([]byte, error) {
991 type NoMethod BareMetalAdminVipConfig
992 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
993 }
994
995
996
997 type BareMetalAdminWorkloadNodeConfig struct {
998
999
1000
1001
1002
1003 MaxPodsPerNode int64 `json:"maxPodsPerNode,omitempty,string"`
1004
1005
1006
1007
1008
1009 ForceSendFields []string `json:"-"`
1010
1011
1012
1013
1014 NullFields []string `json:"-"`
1015 }
1016
1017 func (s *BareMetalAdminWorkloadNodeConfig) MarshalJSON() ([]byte, error) {
1018 type NoMethod BareMetalAdminWorkloadNodeConfig
1019 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1020 }
1021
1022
1023
1024
1025
1026 type BareMetalApiServerArgument struct {
1027
1028
1029 Argument string `json:"argument,omitempty"`
1030
1031
1032 Value string `json:"value,omitempty"`
1033
1034
1035
1036
1037
1038 ForceSendFields []string `json:"-"`
1039
1040
1041
1042
1043 NullFields []string `json:"-"`
1044 }
1045
1046 func (s *BareMetalApiServerArgument) MarshalJSON() ([]byte, error) {
1047 type NoMethod BareMetalApiServerArgument
1048 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1049 }
1050
1051
1052
1053 type BareMetalBgpLbConfig struct {
1054
1055
1056
1057 AddressPools []*BareMetalLoadBalancerAddressPool `json:"addressPools,omitempty"`
1058
1059
1060 Asn int64 `json:"asn,omitempty,string"`
1061
1062
1063
1064
1065
1066 BgpPeerConfigs []*BareMetalBgpPeerConfig `json:"bgpPeerConfigs,omitempty"`
1067
1068
1069
1070 LoadBalancerNodePoolConfig *BareMetalLoadBalancerNodePoolConfig `json:"loadBalancerNodePoolConfig,omitempty"`
1071
1072
1073
1074
1075
1076 ForceSendFields []string `json:"-"`
1077
1078
1079
1080
1081 NullFields []string `json:"-"`
1082 }
1083
1084 func (s *BareMetalBgpLbConfig) MarshalJSON() ([]byte, error) {
1085 type NoMethod BareMetalBgpLbConfig
1086 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1087 }
1088
1089
1090
1091 type BareMetalBgpPeerConfig struct {
1092
1093
1094 Asn int64 `json:"asn,omitempty,string"`
1095
1096
1097
1098
1099 ControlPlaneNodes []string `json:"controlPlaneNodes,omitempty"`
1100
1101 IpAddress string `json:"ipAddress,omitempty"`
1102
1103
1104
1105
1106
1107 ForceSendFields []string `json:"-"`
1108
1109
1110
1111
1112 NullFields []string `json:"-"`
1113 }
1114
1115 func (s *BareMetalBgpPeerConfig) MarshalJSON() ([]byte, error) {
1116 type NoMethod BareMetalBgpPeerConfig
1117 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1118 }
1119
1120
1121 type BareMetalCluster struct {
1122
1123
1124
1125 AdminClusterMembership string `json:"adminClusterMembership,omitempty"`
1126
1127
1128 AdminClusterName string `json:"adminClusterName,omitempty"`
1129
1130
1131
1132
1133
1134
1135
1136 Annotations map[string]string `json:"annotations,omitempty"`
1137
1138
1139 BareMetalVersion string `json:"bareMetalVersion,omitempty"`
1140
1141 BinaryAuthorization *BinaryAuthorization `json:"binaryAuthorization,omitempty"`
1142
1143 ClusterOperations *BareMetalClusterOperationsConfig `json:"clusterOperations,omitempty"`
1144
1145 ControlPlane *BareMetalControlPlaneConfig `json:"controlPlane,omitempty"`
1146
1147
1148 CreateTime string `json:"createTime,omitempty"`
1149
1150
1151 DeleteTime string `json:"deleteTime,omitempty"`
1152
1153 Description string `json:"description,omitempty"`
1154
1155
1156 Endpoint string `json:"endpoint,omitempty"`
1157
1158
1159
1160
1161
1162 Etag string `json:"etag,omitempty"`
1163
1164 Fleet *Fleet `json:"fleet,omitempty"`
1165
1166 LoadBalancer *BareMetalLoadBalancerConfig `json:"loadBalancer,omitempty"`
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176 LocalName string `json:"localName,omitempty"`
1177
1178 MaintenanceConfig *BareMetalMaintenanceConfig `json:"maintenanceConfig,omitempty"`
1179
1180 MaintenanceStatus *BareMetalMaintenanceStatus `json:"maintenanceStatus,omitempty"`
1181
1182 Name string `json:"name,omitempty"`
1183
1184 NetworkConfig *BareMetalNetworkConfig `json:"networkConfig,omitempty"`
1185
1186 NodeAccessConfig *BareMetalNodeAccessConfig `json:"nodeAccessConfig,omitempty"`
1187
1188 NodeConfig *BareMetalWorkloadNodeConfig `json:"nodeConfig,omitempty"`
1189
1190 OsEnvironmentConfig *BareMetalOsEnvironmentConfig `json:"osEnvironmentConfig,omitempty"`
1191
1192 Proxy *BareMetalProxyConfig `json:"proxy,omitempty"`
1193
1194
1195 Reconciling bool `json:"reconciling,omitempty"`
1196
1197 SecurityConfig *BareMetalSecurityConfig `json:"securityConfig,omitempty"`
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213 State string `json:"state,omitempty"`
1214
1215 Status *ResourceStatus `json:"status,omitempty"`
1216
1217 Storage *BareMetalStorageConfig `json:"storage,omitempty"`
1218
1219 Uid string `json:"uid,omitempty"`
1220
1221
1222 UpdateTime string `json:"updateTime,omitempty"`
1223
1224 UpgradePolicy *BareMetalClusterUpgradePolicy `json:"upgradePolicy,omitempty"`
1225
1226 ValidationCheck *ValidationCheck `json:"validationCheck,omitempty"`
1227
1228
1229 googleapi.ServerResponse `json:"-"`
1230
1231
1232
1233
1234
1235 ForceSendFields []string `json:"-"`
1236
1237
1238
1239
1240 NullFields []string `json:"-"`
1241 }
1242
1243 func (s *BareMetalCluster) MarshalJSON() ([]byte, error) {
1244 type NoMethod BareMetalCluster
1245 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1246 }
1247
1248
1249
1250 type BareMetalClusterOperationsConfig struct {
1251
1252
1253 EnableApplicationLogs bool `json:"enableApplicationLogs,omitempty"`
1254
1255
1256
1257
1258
1259 ForceSendFields []string `json:"-"`
1260
1261
1262
1263
1264 NullFields []string `json:"-"`
1265 }
1266
1267 func (s *BareMetalClusterOperationsConfig) MarshalJSON() ([]byte, error) {
1268 type NoMethod BareMetalClusterOperationsConfig
1269 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1270 }
1271
1272
1273
1274 type BareMetalClusterUpgradePolicy struct {
1275
1276
1277
1278
1279
1280
1281 Policy string `json:"policy,omitempty"`
1282
1283
1284
1285
1286
1287 ForceSendFields []string `json:"-"`
1288
1289
1290
1291
1292 NullFields []string `json:"-"`
1293 }
1294
1295 func (s *BareMetalClusterUpgradePolicy) MarshalJSON() ([]byte, error) {
1296 type NoMethod BareMetalClusterUpgradePolicy
1297 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1298 }
1299
1300
1301 type BareMetalControlPlaneConfig struct {
1302
1303
1304
1305
1306 ApiServerArgs []*BareMetalApiServerArgument `json:"apiServerArgs,omitempty"`
1307
1308
1309 ControlPlaneNodePoolConfig *BareMetalControlPlaneNodePoolConfig `json:"controlPlaneNodePoolConfig,omitempty"`
1310
1311
1312
1313
1314
1315 ForceSendFields []string `json:"-"`
1316
1317
1318
1319
1320 NullFields []string `json:"-"`
1321 }
1322
1323 func (s *BareMetalControlPlaneConfig) MarshalJSON() ([]byte, error) {
1324 type NoMethod BareMetalControlPlaneConfig
1325 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1326 }
1327
1328
1329
1330 type BareMetalControlPlaneNodePoolConfig struct {
1331
1332
1333 NodePoolConfig *BareMetalNodePoolConfig `json:"nodePoolConfig,omitempty"`
1334
1335
1336
1337
1338
1339 ForceSendFields []string `json:"-"`
1340
1341
1342
1343
1344 NullFields []string `json:"-"`
1345 }
1346
1347 func (s *BareMetalControlPlaneNodePoolConfig) MarshalJSON() ([]byte, error) {
1348 type NoMethod BareMetalControlPlaneNodePoolConfig
1349 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1350 }
1351
1352
1353 type BareMetalDrainedMachine struct {
1354
1355 NodeIp string `json:"nodeIp,omitempty"`
1356
1357
1358
1359
1360
1361 ForceSendFields []string `json:"-"`
1362
1363
1364
1365
1366 NullFields []string `json:"-"`
1367 }
1368
1369 func (s *BareMetalDrainedMachine) MarshalJSON() ([]byte, error) {
1370 type NoMethod BareMetalDrainedMachine
1371 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1372 }
1373
1374
1375 type BareMetalDrainingMachine struct {
1376
1377 NodeIp string `json:"nodeIp,omitempty"`
1378
1379 PodCount int64 `json:"podCount,omitempty"`
1380
1381
1382
1383
1384
1385 ForceSendFields []string `json:"-"`
1386
1387
1388
1389
1390 NullFields []string `json:"-"`
1391 }
1392
1393 func (s *BareMetalDrainingMachine) MarshalJSON() ([]byte, error) {
1394 type NoMethod BareMetalDrainingMachine
1395 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1396 }
1397
1398
1399
1400 type BareMetalIslandModeCidrConfig struct {
1401
1402
1403
1404 PodAddressCidrBlocks []string `json:"podAddressCidrBlocks,omitempty"`
1405
1406
1407
1408 ServiceAddressCidrBlocks []string `json:"serviceAddressCidrBlocks,omitempty"`
1409
1410
1411
1412
1413
1414 ForceSendFields []string `json:"-"`
1415
1416
1417
1418
1419 NullFields []string `json:"-"`
1420 }
1421
1422 func (s *BareMetalIslandModeCidrConfig) MarshalJSON() ([]byte, error) {
1423 type NoMethod BareMetalIslandModeCidrConfig
1424 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1425 }
1426
1427
1428
1429
1430
1431 type BareMetalKubeletConfig struct {
1432
1433
1434
1435
1436 RegistryBurst int64 `json:"registryBurst,omitempty"`
1437
1438
1439
1440 RegistryPullQps int64 `json:"registryPullQps,omitempty"`
1441
1442
1443
1444
1445
1446 SerializeImagePullsDisabled bool `json:"serializeImagePullsDisabled,omitempty"`
1447
1448
1449
1450
1451
1452 ForceSendFields []string `json:"-"`
1453
1454
1455
1456
1457 NullFields []string `json:"-"`
1458 }
1459
1460 func (s *BareMetalKubeletConfig) MarshalJSON() ([]byte, error) {
1461 type NoMethod BareMetalKubeletConfig
1462 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1463 }
1464
1465
1466
1467 type BareMetalLoadBalancerAddressPool struct {
1468
1469
1470
1471 Addresses []string `json:"addresses,omitempty"`
1472
1473
1474
1475 AvoidBuggyIps bool `json:"avoidBuggyIps,omitempty"`
1476
1477
1478 ManualAssign bool `json:"manualAssign,omitempty"`
1479
1480 Pool string `json:"pool,omitempty"`
1481
1482
1483
1484
1485
1486 ForceSendFields []string `json:"-"`
1487
1488
1489
1490
1491 NullFields []string `json:"-"`
1492 }
1493
1494 func (s *BareMetalLoadBalancerAddressPool) MarshalJSON() ([]byte, error) {
1495 type NoMethod BareMetalLoadBalancerAddressPool
1496 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1497 }
1498
1499
1500 type BareMetalLoadBalancerConfig struct {
1501
1502
1503 BgpLbConfig *BareMetalBgpLbConfig `json:"bgpLbConfig,omitempty"`
1504
1505 ManualLbConfig *BareMetalManualLbConfig `json:"manualLbConfig,omitempty"`
1506
1507 MetalLbConfig *BareMetalMetalLbConfig `json:"metalLbConfig,omitempty"`
1508
1509 PortConfig *BareMetalPortConfig `json:"portConfig,omitempty"`
1510
1511 VipConfig *BareMetalVipConfig `json:"vipConfig,omitempty"`
1512
1513
1514
1515
1516
1517 ForceSendFields []string `json:"-"`
1518
1519
1520
1521
1522 NullFields []string `json:"-"`
1523 }
1524
1525 func (s *BareMetalLoadBalancerConfig) MarshalJSON() ([]byte, error) {
1526 type NoMethod BareMetalLoadBalancerConfig
1527 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1528 }
1529
1530
1531
1532 type BareMetalLoadBalancerNodePoolConfig struct {
1533
1534
1535 NodePoolConfig *BareMetalNodePoolConfig `json:"nodePoolConfig,omitempty"`
1536
1537
1538
1539
1540
1541 ForceSendFields []string `json:"-"`
1542
1543
1544
1545
1546 NullFields []string `json:"-"`
1547 }
1548
1549 func (s *BareMetalLoadBalancerNodePoolConfig) MarshalJSON() ([]byte, error) {
1550 type NoMethod BareMetalLoadBalancerNodePoolConfig
1551 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1552 }
1553
1554
1555
1556 type BareMetalLvpConfig struct {
1557
1558 Path string `json:"path,omitempty"`
1559
1560 StorageClass string `json:"storageClass,omitempty"`
1561
1562
1563
1564
1565
1566 ForceSendFields []string `json:"-"`
1567
1568
1569
1570
1571 NullFields []string `json:"-"`
1572 }
1573
1574 func (s *BareMetalLvpConfig) MarshalJSON() ([]byte, error) {
1575 type NoMethod BareMetalLvpConfig
1576 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1577 }
1578
1579
1580
1581 type BareMetalLvpShareConfig struct {
1582
1583
1584 LvpConfig *BareMetalLvpConfig `json:"lvpConfig,omitempty"`
1585
1586 SharedPathPvCount int64 `json:"sharedPathPvCount,omitempty"`
1587
1588
1589
1590
1591
1592 ForceSendFields []string `json:"-"`
1593
1594
1595
1596
1597 NullFields []string `json:"-"`
1598 }
1599
1600 func (s *BareMetalLvpShareConfig) MarshalJSON() ([]byte, error) {
1601 type NoMethod BareMetalLvpShareConfig
1602 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1603 }
1604
1605
1606
1607 type BareMetalMachineDrainStatus struct {
1608
1609 DrainedMachines []*BareMetalDrainedMachine `json:"drainedMachines,omitempty"`
1610
1611 DrainingMachines []*BareMetalDrainingMachine `json:"drainingMachines,omitempty"`
1612
1613
1614
1615
1616
1617 ForceSendFields []string `json:"-"`
1618
1619
1620
1621
1622 NullFields []string `json:"-"`
1623 }
1624
1625 func (s *BareMetalMachineDrainStatus) MarshalJSON() ([]byte, error) {
1626 type NoMethod BareMetalMachineDrainStatus
1627 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1628 }
1629
1630
1631
1632 type BareMetalMaintenanceConfig struct {
1633
1634
1635
1636
1637
1638 MaintenanceAddressCidrBlocks []string `json:"maintenanceAddressCidrBlocks,omitempty"`
1639
1640
1641
1642
1643
1644 ForceSendFields []string `json:"-"`
1645
1646
1647
1648
1649 NullFields []string `json:"-"`
1650 }
1651
1652 func (s *BareMetalMaintenanceConfig) MarshalJSON() ([]byte, error) {
1653 type NoMethod BareMetalMaintenanceConfig
1654 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1655 }
1656
1657
1658
1659 type BareMetalMaintenanceStatus struct {
1660
1661 MachineDrainStatus *BareMetalMachineDrainStatus `json:"machineDrainStatus,omitempty"`
1662
1663
1664
1665
1666
1667 ForceSendFields []string `json:"-"`
1668
1669
1670
1671
1672 NullFields []string `json:"-"`
1673 }
1674
1675 func (s *BareMetalMaintenanceStatus) MarshalJSON() ([]byte, error) {
1676 type NoMethod BareMetalMaintenanceStatus
1677 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1678 }
1679
1680
1681
1682 type BareMetalManualLbConfig struct {
1683
1684 Enabled bool `json:"enabled,omitempty"`
1685
1686
1687
1688
1689
1690 ForceSendFields []string `json:"-"`
1691
1692
1693
1694
1695 NullFields []string `json:"-"`
1696 }
1697
1698 func (s *BareMetalManualLbConfig) MarshalJSON() ([]byte, error) {
1699 type NoMethod BareMetalManualLbConfig
1700 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1701 }
1702
1703
1704
1705 type BareMetalMetalLbConfig struct {
1706
1707
1708
1709 AddressPools []*BareMetalLoadBalancerAddressPool `json:"addressPools,omitempty"`
1710
1711
1712
1713 LoadBalancerNodePoolConfig *BareMetalLoadBalancerNodePoolConfig `json:"loadBalancerNodePoolConfig,omitempty"`
1714
1715
1716
1717
1718
1719 ForceSendFields []string `json:"-"`
1720
1721
1722
1723
1724 NullFields []string `json:"-"`
1725 }
1726
1727 func (s *BareMetalMetalLbConfig) MarshalJSON() ([]byte, error) {
1728 type NoMethod BareMetalMetalLbConfig
1729 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1730 }
1731
1732
1733
1734 type BareMetalMultipleNetworkInterfacesConfig struct {
1735
1736
1737 Enabled bool `json:"enabled,omitempty"`
1738
1739
1740
1741
1742
1743 ForceSendFields []string `json:"-"`
1744
1745
1746
1747
1748 NullFields []string `json:"-"`
1749 }
1750
1751 func (s *BareMetalMultipleNetworkInterfacesConfig) MarshalJSON() ([]byte, error) {
1752 type NoMethod BareMetalMultipleNetworkInterfacesConfig
1753 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1754 }
1755
1756
1757 type BareMetalNetworkConfig struct {
1758
1759
1760
1761
1762 AdvancedNetworking bool `json:"advancedNetworking,omitempty"`
1763
1764
1765
1766
1767
1768
1769 IslandModeCidr *BareMetalIslandModeCidrConfig `json:"islandModeCidr,omitempty"`
1770
1771
1772 MultipleNetworkInterfacesConfig *BareMetalMultipleNetworkInterfacesConfig `json:"multipleNetworkInterfacesConfig,omitempty"`
1773
1774 SrIovConfig *BareMetalSrIovConfig `json:"srIovConfig,omitempty"`
1775
1776
1777
1778
1779
1780 ForceSendFields []string `json:"-"`
1781
1782
1783
1784
1785 NullFields []string `json:"-"`
1786 }
1787
1788 func (s *BareMetalNetworkConfig) MarshalJSON() ([]byte, error) {
1789 type NoMethod BareMetalNetworkConfig
1790 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1791 }
1792
1793
1794
1795 type BareMetalNodeAccessConfig struct {
1796
1797
1798 LoginUser string `json:"loginUser,omitempty"`
1799
1800
1801
1802
1803
1804 ForceSendFields []string `json:"-"`
1805
1806
1807
1808
1809 NullFields []string `json:"-"`
1810 }
1811
1812 func (s *BareMetalNodeAccessConfig) MarshalJSON() ([]byte, error) {
1813 type NoMethod BareMetalNodeAccessConfig
1814 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1815 }
1816
1817
1818
1819 type BareMetalNodeConfig struct {
1820
1821
1822
1823
1824
1825 Labels map[string]string `json:"labels,omitempty"`
1826
1827
1828 NodeIp string `json:"nodeIp,omitempty"`
1829
1830
1831
1832
1833
1834 ForceSendFields []string `json:"-"`
1835
1836
1837
1838
1839 NullFields []string `json:"-"`
1840 }
1841
1842 func (s *BareMetalNodeConfig) MarshalJSON() ([]byte, error) {
1843 type NoMethod BareMetalNodeConfig
1844 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1845 }
1846
1847
1848 type BareMetalNodePool struct {
1849
1850
1851
1852
1853
1854
1855
1856 Annotations map[string]string `json:"annotations,omitempty"`
1857
1858
1859 CreateTime string `json:"createTime,omitempty"`
1860
1861
1862 DeleteTime string `json:"deleteTime,omitempty"`
1863
1864 DisplayName string `json:"displayName,omitempty"`
1865
1866
1867
1868
1869 Etag string `json:"etag,omitempty"`
1870
1871 Name string `json:"name,omitempty"`
1872
1873 NodePoolConfig *BareMetalNodePoolConfig `json:"nodePoolConfig,omitempty"`
1874
1875
1876 Reconciling bool `json:"reconciling,omitempty"`
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894 State string `json:"state,omitempty"`
1895
1896
1897 Status *ResourceStatus `json:"status,omitempty"`
1898
1899 Uid string `json:"uid,omitempty"`
1900
1901
1902 UpdateTime string `json:"updateTime,omitempty"`
1903
1904 UpgradePolicy *BareMetalNodePoolUpgradePolicy `json:"upgradePolicy,omitempty"`
1905
1906
1907 googleapi.ServerResponse `json:"-"`
1908
1909
1910
1911
1912
1913 ForceSendFields []string `json:"-"`
1914
1915
1916
1917
1918 NullFields []string `json:"-"`
1919 }
1920
1921 func (s *BareMetalNodePool) MarshalJSON() ([]byte, error) {
1922 type NoMethod BareMetalNodePool
1923 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1924 }
1925
1926
1927
1928 type BareMetalNodePoolConfig struct {
1929
1930
1931 KubeletConfig *BareMetalKubeletConfig `json:"kubeletConfig,omitempty"`
1932
1933
1934
1935 Labels map[string]string `json:"labels,omitempty"`
1936
1937
1938 NodeConfigs []*BareMetalNodeConfig `json:"nodeConfigs,omitempty"`
1939
1940
1941
1942
1943
1944 OperatingSystem string `json:"operatingSystem,omitempty"`
1945
1946 Taints []*NodeTaint `json:"taints,omitempty"`
1947
1948
1949
1950
1951
1952 ForceSendFields []string `json:"-"`
1953
1954
1955
1956
1957 NullFields []string `json:"-"`
1958 }
1959
1960 func (s *BareMetalNodePoolConfig) MarshalJSON() ([]byte, error) {
1961 type NoMethod BareMetalNodePoolConfig
1962 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1963 }
1964
1965
1966
1967 type BareMetalNodePoolUpgradePolicy struct {
1968
1969 ParallelUpgradeConfig *BareMetalParallelUpgradeConfig `json:"parallelUpgradeConfig,omitempty"`
1970
1971
1972
1973
1974
1975 ForceSendFields []string `json:"-"`
1976
1977
1978
1979
1980 NullFields []string `json:"-"`
1981 }
1982
1983 func (s *BareMetalNodePoolUpgradePolicy) MarshalJSON() ([]byte, error) {
1984 type NoMethod BareMetalNodePoolUpgradePolicy
1985 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1986 }
1987
1988
1989
1990 type BareMetalOsEnvironmentConfig struct {
1991
1992
1993 PackageRepoExcluded bool `json:"packageRepoExcluded,omitempty"`
1994
1995
1996
1997
1998
1999 ForceSendFields []string `json:"-"`
2000
2001
2002
2003
2004 NullFields []string `json:"-"`
2005 }
2006
2007 func (s *BareMetalOsEnvironmentConfig) MarshalJSON() ([]byte, error) {
2008 type NoMethod BareMetalOsEnvironmentConfig
2009 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2010 }
2011
2012
2013
2014 type BareMetalParallelUpgradeConfig struct {
2015
2016 ConcurrentNodes int64 `json:"concurrentNodes,omitempty"`
2017
2018
2019
2020 MinimumAvailableNodes int64 `json:"minimumAvailableNodes,omitempty"`
2021
2022
2023
2024
2025
2026 ForceSendFields []string `json:"-"`
2027
2028
2029
2030
2031 NullFields []string `json:"-"`
2032 }
2033
2034 func (s *BareMetalParallelUpgradeConfig) MarshalJSON() ([]byte, error) {
2035 type NoMethod BareMetalParallelUpgradeConfig
2036 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2037 }
2038
2039
2040
2041 type BareMetalPortConfig struct {
2042
2043
2044 ControlPlaneLoadBalancerPort int64 `json:"controlPlaneLoadBalancerPort,omitempty"`
2045
2046
2047
2048
2049
2050 ForceSendFields []string `json:"-"`
2051
2052
2053
2054
2055 NullFields []string `json:"-"`
2056 }
2057
2058 func (s *BareMetalPortConfig) MarshalJSON() ([]byte, error) {
2059 type NoMethod BareMetalPortConfig
2060 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2061 }
2062
2063
2064 type BareMetalProxyConfig struct {
2065
2066
2067 NoProxy []string `json:"noProxy,omitempty"`
2068
2069
2070
2071 Uri string `json:"uri,omitempty"`
2072
2073
2074
2075
2076
2077 ForceSendFields []string `json:"-"`
2078
2079
2080
2081
2082 NullFields []string `json:"-"`
2083 }
2084
2085 func (s *BareMetalProxyConfig) MarshalJSON() ([]byte, error) {
2086 type NoMethod BareMetalProxyConfig
2087 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2088 }
2089
2090
2091
2092 type BareMetalSecurityConfig struct {
2093
2094 Authorization *Authorization `json:"authorization,omitempty"`
2095
2096
2097
2098
2099
2100 ForceSendFields []string `json:"-"`
2101
2102
2103
2104
2105 NullFields []string `json:"-"`
2106 }
2107
2108 func (s *BareMetalSecurityConfig) MarshalJSON() ([]byte, error) {
2109 type NoMethod BareMetalSecurityConfig
2110 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2111 }
2112
2113
2114 type BareMetalSrIovConfig struct {
2115
2116 Enabled bool `json:"enabled,omitempty"`
2117
2118
2119
2120
2121
2122 ForceSendFields []string `json:"-"`
2123
2124
2125
2126
2127 NullFields []string `json:"-"`
2128 }
2129
2130 func (s *BareMetalSrIovConfig) MarshalJSON() ([]byte, error) {
2131 type NoMethod BareMetalSrIovConfig
2132 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2133 }
2134
2135
2136
2137 type BareMetalStorageConfig struct {
2138
2139
2140
2141
2142 LvpNodeMountsConfig *BareMetalLvpConfig `json:"lvpNodeMountsConfig,omitempty"`
2143
2144
2145
2146 LvpShareConfig *BareMetalLvpShareConfig `json:"lvpShareConfig,omitempty"`
2147
2148
2149
2150
2151
2152 ForceSendFields []string `json:"-"`
2153
2154
2155
2156
2157 NullFields []string `json:"-"`
2158 }
2159
2160 func (s *BareMetalStorageConfig) MarshalJSON() ([]byte, error) {
2161 type NoMethod BareMetalStorageConfig
2162 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2163 }
2164
2165
2166
2167 type BareMetalVersionInfo struct {
2168
2169 Dependencies []*UpgradeDependency `json:"dependencies,omitempty"`
2170
2171
2172
2173 HasDependencies bool `json:"hasDependencies,omitempty"`
2174
2175 Version string `json:"version,omitempty"`
2176
2177
2178
2179
2180
2181 ForceSendFields []string `json:"-"`
2182
2183
2184
2185
2186 NullFields []string `json:"-"`
2187 }
2188
2189 func (s *BareMetalVersionInfo) MarshalJSON() ([]byte, error) {
2190 type NoMethod BareMetalVersionInfo
2191 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2192 }
2193
2194
2195
2196 type BareMetalVipConfig struct {
2197
2198
2199 ControlPlaneVip string `json:"controlPlaneVip,omitempty"`
2200
2201
2202 IngressVip string `json:"ingressVip,omitempty"`
2203
2204
2205
2206
2207
2208 ForceSendFields []string `json:"-"`
2209
2210
2211
2212
2213 NullFields []string `json:"-"`
2214 }
2215
2216 func (s *BareMetalVipConfig) MarshalJSON() ([]byte, error) {
2217 type NoMethod BareMetalVipConfig
2218 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2219 }
2220
2221
2222 type BareMetalWorkloadNodeConfig struct {
2223
2224
2225
2226
2227
2228 ContainerRuntime string `json:"containerRuntime,omitempty"`
2229
2230
2231 MaxPodsPerNode int64 `json:"maxPodsPerNode,omitempty,string"`
2232
2233
2234
2235
2236
2237 ForceSendFields []string `json:"-"`
2238
2239
2240
2241
2242 NullFields []string `json:"-"`
2243 }
2244
2245 func (s *BareMetalWorkloadNodeConfig) MarshalJSON() ([]byte, error) {
2246 type NoMethod BareMetalWorkloadNodeConfig
2247 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2248 }
2249
2250
2251 type BinaryAuthorization struct {
2252
2253
2254
2255
2256
2257
2258
2259
2260 EvaluationMode string `json:"evaluationMode,omitempty"`
2261
2262
2263
2264
2265
2266 ForceSendFields []string `json:"-"`
2267
2268
2269
2270
2271 NullFields []string `json:"-"`
2272 }
2273
2274 func (s *BinaryAuthorization) MarshalJSON() ([]byte, error) {
2275 type NoMethod BinaryAuthorization
2276 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2277 }
2278
2279
2280 type Binding struct {
2281
2282
2283
2284
2285
2286
2287
2288
2289 Condition *Expr `json:"condition,omitempty"`
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352 Members []string `json:"members,omitempty"`
2353
2354
2355
2356
2357
2358
2359 Role string `json:"role,omitempty"`
2360
2361
2362
2363
2364
2365 ForceSendFields []string `json:"-"`
2366
2367
2368
2369
2370 NullFields []string `json:"-"`
2371 }
2372
2373 func (s *Binding) MarshalJSON() ([]byte, error) {
2374 type NoMethod Binding
2375 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2376 }
2377
2378
2379 type CancelOperationRequest struct {
2380 }
2381
2382
2383 type ClusterUser struct {
2384
2385 Username string `json:"username,omitempty"`
2386
2387
2388
2389
2390
2391 ForceSendFields []string `json:"-"`
2392
2393
2394
2395
2396 NullFields []string `json:"-"`
2397 }
2398
2399 func (s *ClusterUser) MarshalJSON() ([]byte, error) {
2400 type NoMethod ClusterUser
2401 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2402 }
2403
2404
2405
2406
2407
2408 type Empty struct {
2409
2410 googleapi.ServerResponse `json:"-"`
2411 }
2412
2413
2414
2415 type EnrollBareMetalAdminClusterRequest struct {
2416
2417
2418
2419
2420 BareMetalAdminClusterId string `json:"bareMetalAdminClusterId,omitempty"`
2421
2422
2423 Membership string `json:"membership,omitempty"`
2424
2425
2426
2427
2428
2429 ForceSendFields []string `json:"-"`
2430
2431
2432
2433
2434 NullFields []string `json:"-"`
2435 }
2436
2437 func (s *EnrollBareMetalAdminClusterRequest) MarshalJSON() ([]byte, error) {
2438 type NoMethod EnrollBareMetalAdminClusterRequest
2439 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2440 }
2441
2442
2443
2444 type EnrollBareMetalClusterRequest struct {
2445
2446
2447
2448
2449 AdminClusterMembership string `json:"adminClusterMembership,omitempty"`
2450
2451
2452
2453
2454 BareMetalClusterId string `json:"bareMetalClusterId,omitempty"`
2455
2456
2457
2458
2459
2460
2461 LocalName string `json:"localName,omitempty"`
2462
2463
2464
2465
2466
2467 ForceSendFields []string `json:"-"`
2468
2469
2470
2471
2472 NullFields []string `json:"-"`
2473 }
2474
2475 func (s *EnrollBareMetalClusterRequest) MarshalJSON() ([]byte, error) {
2476 type NoMethod EnrollBareMetalClusterRequest
2477 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2478 }
2479
2480
2481
2482 type EnrollBareMetalNodePoolRequest struct {
2483
2484
2485 BareMetalNodePoolId string `json:"bareMetalNodePoolId,omitempty"`
2486
2487
2488 ValidateOnly bool `json:"validateOnly,omitempty"`
2489
2490
2491
2492
2493
2494 ForceSendFields []string `json:"-"`
2495
2496
2497
2498
2499 NullFields []string `json:"-"`
2500 }
2501
2502 func (s *EnrollBareMetalNodePoolRequest) MarshalJSON() ([]byte, error) {
2503 type NoMethod EnrollBareMetalNodePoolRequest
2504 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2505 }
2506
2507
2508
2509 type EnrollVmwareAdminClusterRequest struct {
2510
2511
2512 Membership string `json:"membership,omitempty"`
2513
2514
2515
2516
2517 VmwareAdminClusterId string `json:"vmwareAdminClusterId,omitempty"`
2518
2519
2520
2521
2522
2523 ForceSendFields []string `json:"-"`
2524
2525
2526
2527
2528 NullFields []string `json:"-"`
2529 }
2530
2531 func (s *EnrollVmwareAdminClusterRequest) MarshalJSON() ([]byte, error) {
2532 type NoMethod EnrollVmwareAdminClusterRequest
2533 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2534 }
2535
2536
2537
2538 type EnrollVmwareClusterRequest struct {
2539
2540
2541
2542
2543 AdminClusterMembership string `json:"adminClusterMembership,omitempty"`
2544
2545
2546
2547
2548
2549
2550 LocalName string `json:"localName,omitempty"`
2551
2552 ValidateOnly bool `json:"validateOnly,omitempty"`
2553
2554
2555
2556
2557 VmwareClusterId string `json:"vmwareClusterId,omitempty"`
2558
2559
2560
2561
2562
2563 ForceSendFields []string `json:"-"`
2564
2565
2566
2567
2568 NullFields []string `json:"-"`
2569 }
2570
2571 func (s *EnrollVmwareClusterRequest) MarshalJSON() ([]byte, error) {
2572 type NoMethod EnrollVmwareClusterRequest
2573 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2574 }
2575
2576
2577 type EnrollVmwareNodePoolRequest struct {
2578
2579 VmwareNodePoolId string `json:"vmwareNodePoolId,omitempty"`
2580
2581
2582
2583
2584
2585 ForceSendFields []string `json:"-"`
2586
2587
2588
2589
2590 NullFields []string `json:"-"`
2591 }
2592
2593 func (s *EnrollVmwareNodePoolRequest) MarshalJSON() ([]byte, error) {
2594 type NoMethod EnrollVmwareNodePoolRequest
2595 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2596 }
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614 type Expr struct {
2615
2616
2617 Description string `json:"description,omitempty"`
2618
2619
2620 Expression string `json:"expression,omitempty"`
2621
2622
2623 Location string `json:"location,omitempty"`
2624
2625
2626
2627 Title string `json:"title,omitempty"`
2628
2629
2630
2631
2632
2633 ForceSendFields []string `json:"-"`
2634
2635
2636
2637
2638 NullFields []string `json:"-"`
2639 }
2640
2641 func (s *Expr) MarshalJSON() ([]byte, error) {
2642 type NoMethod Expr
2643 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2644 }
2645
2646
2647
2648
2649
2650
2651 type Fleet struct {
2652
2653
2654
2655 Membership string `json:"membership,omitempty"`
2656
2657
2658
2659
2660
2661 ForceSendFields []string `json:"-"`
2662
2663
2664
2665
2666 NullFields []string `json:"-"`
2667 }
2668
2669 func (s *Fleet) MarshalJSON() ([]byte, error) {
2670 type NoMethod Fleet
2671 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2672 }
2673
2674
2675
2676 type ListBareMetalAdminClustersResponse struct {
2677
2678 BareMetalAdminClusters []*BareMetalAdminCluster `json:"bareMetalAdminClusters,omitempty"`
2679
2680
2681
2682
2683 NextPageToken string `json:"nextPageToken,omitempty"`
2684
2685 Unreachable []string `json:"unreachable,omitempty"`
2686
2687
2688 googleapi.ServerResponse `json:"-"`
2689
2690
2691
2692
2693
2694 ForceSendFields []string `json:"-"`
2695
2696
2697
2698
2699 NullFields []string `json:"-"`
2700 }
2701
2702 func (s *ListBareMetalAdminClustersResponse) MarshalJSON() ([]byte, error) {
2703 type NoMethod ListBareMetalAdminClustersResponse
2704 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2705 }
2706
2707
2708
2709 type ListBareMetalClustersResponse struct {
2710
2711 BareMetalClusters []*BareMetalCluster `json:"bareMetalClusters,omitempty"`
2712
2713
2714
2715
2716 NextPageToken string `json:"nextPageToken,omitempty"`
2717
2718 Unreachable []string `json:"unreachable,omitempty"`
2719
2720
2721 googleapi.ServerResponse `json:"-"`
2722
2723
2724
2725
2726
2727 ForceSendFields []string `json:"-"`
2728
2729
2730
2731
2732 NullFields []string `json:"-"`
2733 }
2734
2735 func (s *ListBareMetalClustersResponse) MarshalJSON() ([]byte, error) {
2736 type NoMethod ListBareMetalClustersResponse
2737 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2738 }
2739
2740
2741
2742 type ListBareMetalNodePoolsResponse struct {
2743
2744 BareMetalNodePools []*BareMetalNodePool `json:"bareMetalNodePools,omitempty"`
2745
2746
2747 NextPageToken string `json:"nextPageToken,omitempty"`
2748
2749 Unreachable []string `json:"unreachable,omitempty"`
2750
2751
2752 googleapi.ServerResponse `json:"-"`
2753
2754
2755
2756
2757
2758 ForceSendFields []string `json:"-"`
2759
2760
2761
2762
2763 NullFields []string `json:"-"`
2764 }
2765
2766 func (s *ListBareMetalNodePoolsResponse) MarshalJSON() ([]byte, error) {
2767 type NoMethod ListBareMetalNodePoolsResponse
2768 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2769 }
2770
2771
2772 type ListLocationsResponse struct {
2773
2774
2775 Locations []*Location `json:"locations,omitempty"`
2776
2777 NextPageToken string `json:"nextPageToken,omitempty"`
2778
2779
2780 googleapi.ServerResponse `json:"-"`
2781
2782
2783
2784
2785
2786 ForceSendFields []string `json:"-"`
2787
2788
2789
2790
2791 NullFields []string `json:"-"`
2792 }
2793
2794 func (s *ListLocationsResponse) MarshalJSON() ([]byte, error) {
2795 type NoMethod ListLocationsResponse
2796 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2797 }
2798
2799
2800 type ListOperationsResponse struct {
2801
2802 NextPageToken string `json:"nextPageToken,omitempty"`
2803
2804
2805 Operations []*Operation `json:"operations,omitempty"`
2806
2807
2808 googleapi.ServerResponse `json:"-"`
2809
2810
2811
2812
2813
2814 ForceSendFields []string `json:"-"`
2815
2816
2817
2818
2819 NullFields []string `json:"-"`
2820 }
2821
2822 func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) {
2823 type NoMethod ListOperationsResponse
2824 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2825 }
2826
2827
2828
2829 type ListVmwareAdminClustersResponse struct {
2830
2831
2832
2833
2834 NextPageToken string `json:"nextPageToken,omitempty"`
2835
2836 Unreachable []string `json:"unreachable,omitempty"`
2837
2838 VmwareAdminClusters []*VmwareAdminCluster `json:"vmwareAdminClusters,omitempty"`
2839
2840
2841 googleapi.ServerResponse `json:"-"`
2842
2843
2844
2845
2846
2847 ForceSendFields []string `json:"-"`
2848
2849
2850
2851
2852 NullFields []string `json:"-"`
2853 }
2854
2855 func (s *ListVmwareAdminClustersResponse) MarshalJSON() ([]byte, error) {
2856 type NoMethod ListVmwareAdminClustersResponse
2857 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2858 }
2859
2860
2861 type ListVmwareClustersResponse struct {
2862
2863
2864
2865
2866 NextPageToken string `json:"nextPageToken,omitempty"`
2867
2868 Unreachable []string `json:"unreachable,omitempty"`
2869
2870 VmwareClusters []*VmwareCluster `json:"vmwareClusters,omitempty"`
2871
2872
2873 googleapi.ServerResponse `json:"-"`
2874
2875
2876
2877
2878
2879 ForceSendFields []string `json:"-"`
2880
2881
2882
2883
2884 NullFields []string `json:"-"`
2885 }
2886
2887 func (s *ListVmwareClustersResponse) MarshalJSON() ([]byte, error) {
2888 type NoMethod ListVmwareClustersResponse
2889 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2890 }
2891
2892
2893 type ListVmwareNodePoolsResponse struct {
2894
2895
2896 NextPageToken string `json:"nextPageToken,omitempty"`
2897
2898 Unreachable []string `json:"unreachable,omitempty"`
2899
2900 VmwareNodePools []*VmwareNodePool `json:"vmwareNodePools,omitempty"`
2901
2902
2903 googleapi.ServerResponse `json:"-"`
2904
2905
2906
2907
2908
2909 ForceSendFields []string `json:"-"`
2910
2911
2912
2913
2914 NullFields []string `json:"-"`
2915 }
2916
2917 func (s *ListVmwareNodePoolsResponse) MarshalJSON() ([]byte, error) {
2918 type NoMethod ListVmwareNodePoolsResponse
2919 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2920 }
2921
2922
2923 type Location struct {
2924
2925
2926 DisplayName string `json:"displayName,omitempty"`
2927
2928
2929 Labels map[string]string `json:"labels,omitempty"`
2930
2931 LocationId string `json:"locationId,omitempty"`
2932
2933
2934 Metadata googleapi.RawMessage `json:"metadata,omitempty"`
2935
2936
2937
2938 Name string `json:"name,omitempty"`
2939
2940
2941 googleapi.ServerResponse `json:"-"`
2942
2943
2944
2945
2946
2947 ForceSendFields []string `json:"-"`
2948
2949
2950
2951
2952 NullFields []string `json:"-"`
2953 }
2954
2955 func (s *Location) MarshalJSON() ([]byte, error) {
2956 type NoMethod Location
2957 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2958 }
2959
2960
2961 type Metric struct {
2962
2963 DoubleValue float64 `json:"doubleValue,omitempty"`
2964
2965 IntValue int64 `json:"intValue,omitempty,string"`
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983 Metric string `json:"metric,omitempty"`
2984
2985 StringValue string `json:"stringValue,omitempty"`
2986
2987
2988
2989
2990
2991 ForceSendFields []string `json:"-"`
2992
2993
2994
2995
2996 NullFields []string `json:"-"`
2997 }
2998
2999 func (s *Metric) MarshalJSON() ([]byte, error) {
3000 type NoMethod Metric
3001 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3002 }
3003
3004 func (s *Metric) UnmarshalJSON(data []byte) error {
3005 type NoMethod Metric
3006 var s1 struct {
3007 DoubleValue gensupport.JSONFloat64 `json:"doubleValue"`
3008 *NoMethod
3009 }
3010 s1.NoMethod = (*NoMethod)(s)
3011 if err := json.Unmarshal(data, &s1); err != nil {
3012 return err
3013 }
3014 s.DoubleValue = float64(s1.DoubleValue)
3015 return nil
3016 }
3017
3018
3019
3020
3021 type NodeTaint struct {
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035 Effect string `json:"effect,omitempty"`
3036
3037 Key string `json:"key,omitempty"`
3038
3039 Value string `json:"value,omitempty"`
3040
3041
3042
3043
3044
3045 ForceSendFields []string `json:"-"`
3046
3047
3048
3049
3050 NullFields []string `json:"-"`
3051 }
3052
3053 func (s *NodeTaint) MarshalJSON() ([]byte, error) {
3054 type NoMethod NodeTaint
3055 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3056 }
3057
3058
3059
3060 type Operation struct {
3061
3062
3063
3064 Done bool `json:"done,omitempty"`
3065
3066 Error *Status `json:"error,omitempty"`
3067
3068
3069
3070
3071 Metadata googleapi.RawMessage `json:"metadata,omitempty"`
3072
3073
3074
3075 Name string `json:"name,omitempty"`
3076
3077
3078
3079
3080
3081
3082
3083 Response googleapi.RawMessage `json:"response,omitempty"`
3084
3085
3086 googleapi.ServerResponse `json:"-"`
3087
3088
3089
3090
3091
3092 ForceSendFields []string `json:"-"`
3093
3094
3095
3096
3097 NullFields []string `json:"-"`
3098 }
3099
3100 func (s *Operation) MarshalJSON() ([]byte, error) {
3101 type NoMethod Operation
3102 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3103 }
3104
3105
3106 type OperationMetadata struct {
3107
3108 ApiVersion string `json:"apiVersion,omitempty"`
3109
3110
3111
3112 ControlPlaneDisconnected bool `json:"controlPlaneDisconnected,omitempty"`
3113
3114 CreateTime string `json:"createTime,omitempty"`
3115
3116 EndTime string `json:"endTime,omitempty"`
3117
3118 Progress *OperationProgress `json:"progress,omitempty"`
3119
3120
3121
3122
3123 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
3124
3125 StatusMessage string `json:"statusMessage,omitempty"`
3126
3127
3128 Target string `json:"target,omitempty"`
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138 Type string `json:"type,omitempty"`
3139
3140 Verb string `json:"verb,omitempty"`
3141
3142
3143
3144
3145
3146 ForceSendFields []string `json:"-"`
3147
3148
3149
3150
3151 NullFields []string `json:"-"`
3152 }
3153
3154 func (s *OperationMetadata) MarshalJSON() ([]byte, error) {
3155 type NoMethod OperationMetadata
3156 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3157 }
3158
3159
3160 type OperationProgress struct {
3161
3162 Stages []*OperationStage `json:"stages,omitempty"`
3163
3164
3165
3166
3167
3168 ForceSendFields []string `json:"-"`
3169
3170
3171
3172
3173 NullFields []string `json:"-"`
3174 }
3175
3176 func (s *OperationProgress) MarshalJSON() ([]byte, error) {
3177 type NoMethod OperationProgress
3178 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3179 }
3180
3181
3182 type OperationStage struct {
3183
3184 EndTime string `json:"endTime,omitempty"`
3185
3186 Metrics []*Metric `json:"metrics,omitempty"`
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196 Stage string `json:"stage,omitempty"`
3197
3198 StartTime string `json:"startTime,omitempty"`
3199
3200
3201
3202
3203
3204
3205
3206
3207 State string `json:"state,omitempty"`
3208
3209
3210
3211
3212
3213 ForceSendFields []string `json:"-"`
3214
3215
3216
3217
3218 NullFields []string `json:"-"`
3219 }
3220
3221 func (s *OperationStage) MarshalJSON() ([]byte, error) {
3222 type NoMethod OperationStage
3223 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3224 }
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256 type Policy struct {
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266 Bindings []*Binding `json:"bindings,omitempty"`
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278 Etag string `json:"etag,omitempty"`
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294 Version int64 `json:"version,omitempty"`
3295
3296
3297 googleapi.ServerResponse `json:"-"`
3298
3299
3300
3301
3302
3303 ForceSendFields []string `json:"-"`
3304
3305
3306
3307
3308 NullFields []string `json:"-"`
3309 }
3310
3311 func (s *Policy) MarshalJSON() ([]byte, error) {
3312 type NoMethod Policy
3313 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3314 }
3315
3316
3317
3318 type QueryBareMetalAdminVersionConfigResponse struct {
3319
3320 Versions []*BareMetalVersionInfo `json:"versions,omitempty"`
3321
3322
3323 googleapi.ServerResponse `json:"-"`
3324
3325
3326
3327
3328
3329 ForceSendFields []string `json:"-"`
3330
3331
3332
3333
3334 NullFields []string `json:"-"`
3335 }
3336
3337 func (s *QueryBareMetalAdminVersionConfigResponse) MarshalJSON() ([]byte, error) {
3338 type NoMethod QueryBareMetalAdminVersionConfigResponse
3339 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3340 }
3341
3342
3343
3344 type QueryBareMetalVersionConfigResponse struct {
3345
3346 Versions []*BareMetalVersionInfo `json:"versions,omitempty"`
3347
3348
3349 googleapi.ServerResponse `json:"-"`
3350
3351
3352
3353
3354
3355 ForceSendFields []string `json:"-"`
3356
3357
3358
3359
3360 NullFields []string `json:"-"`
3361 }
3362
3363 func (s *QueryBareMetalVersionConfigResponse) MarshalJSON() ([]byte, error) {
3364 type NoMethod QueryBareMetalVersionConfigResponse
3365 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3366 }
3367
3368
3369
3370 type QueryVmwareVersionConfigResponse struct {
3371
3372 Versions []*VmwareVersionInfo `json:"versions,omitempty"`
3373
3374
3375 googleapi.ServerResponse `json:"-"`
3376
3377
3378
3379
3380
3381 ForceSendFields []string `json:"-"`
3382
3383
3384
3385
3386 NullFields []string `json:"-"`
3387 }
3388
3389 func (s *QueryVmwareVersionConfigResponse) MarshalJSON() ([]byte, error) {
3390 type NoMethod QueryVmwareVersionConfigResponse
3391 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3392 }
3393
3394
3395
3396 type ResourceCondition struct {
3397
3398
3399 LastTransitionTime string `json:"lastTransitionTime,omitempty"`
3400
3401 Message string `json:"message,omitempty"`
3402
3403 Reason string `json:"reason,omitempty"`
3404
3405
3406
3407
3408
3409
3410
3411
3412 State string `json:"state,omitempty"`
3413
3414
3415 Type string `json:"type,omitempty"`
3416
3417
3418
3419
3420
3421 ForceSendFields []string `json:"-"`
3422
3423
3424
3425
3426 NullFields []string `json:"-"`
3427 }
3428
3429 func (s *ResourceCondition) MarshalJSON() ([]byte, error) {
3430 type NoMethod ResourceCondition
3431 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3432 }
3433
3434
3435
3436 type ResourceStatus struct {
3437
3438
3439 Conditions []*ResourceCondition `json:"conditions,omitempty"`
3440
3441
3442
3443
3444
3445 ErrorMessage string `json:"errorMessage,omitempty"`
3446
3447
3448
3449
3450
3451 ForceSendFields []string `json:"-"`
3452
3453
3454
3455
3456 NullFields []string `json:"-"`
3457 }
3458
3459 func (s *ResourceStatus) MarshalJSON() ([]byte, error) {
3460 type NoMethod ResourceStatus
3461 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3462 }
3463
3464
3465 type SetIamPolicyRequest struct {
3466
3467
3468
3469
3470 Policy *Policy `json:"policy,omitempty"`
3471
3472
3473
3474
3475
3476 ForceSendFields []string `json:"-"`
3477
3478
3479
3480
3481 NullFields []string `json:"-"`
3482 }
3483
3484 func (s *SetIamPolicyRequest) MarshalJSON() ([]byte, error) {
3485 type NoMethod SetIamPolicyRequest
3486 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3487 }
3488
3489
3490
3491
3492
3493
3494
3495 type Status struct {
3496
3497 Code int64 `json:"code,omitempty"`
3498
3499
3500 Details []googleapi.RawMessage `json:"details,omitempty"`
3501
3502
3503
3504 Message string `json:"message,omitempty"`
3505
3506
3507
3508
3509
3510 ForceSendFields []string `json:"-"`
3511
3512
3513
3514
3515 NullFields []string `json:"-"`
3516 }
3517
3518 func (s *Status) MarshalJSON() ([]byte, error) {
3519 type NoMethod Status
3520 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3521 }
3522
3523
3524 type TestIamPermissionsRequest struct {
3525
3526
3527
3528
3529 Permissions []string `json:"permissions,omitempty"`
3530
3531
3532
3533
3534
3535 ForceSendFields []string `json:"-"`
3536
3537
3538
3539
3540 NullFields []string `json:"-"`
3541 }
3542
3543 func (s *TestIamPermissionsRequest) MarshalJSON() ([]byte, error) {
3544 type NoMethod TestIamPermissionsRequest
3545 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3546 }
3547
3548
3549
3550 type TestIamPermissionsResponse struct {
3551
3552
3553 Permissions []string `json:"permissions,omitempty"`
3554
3555
3556 googleapi.ServerResponse `json:"-"`
3557
3558
3559
3560
3561
3562 ForceSendFields []string `json:"-"`
3563
3564
3565
3566
3567 NullFields []string `json:"-"`
3568 }
3569
3570 func (s *TestIamPermissionsResponse) MarshalJSON() ([]byte, error) {
3571 type NoMethod TestIamPermissionsResponse
3572 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3573 }
3574
3575
3576
3577 type UpgradeDependency struct {
3578
3579 CurrentVersion string `json:"currentVersion,omitempty"`
3580
3581
3582 Membership string `json:"membership,omitempty"`
3583
3584 ResourceName string `json:"resourceName,omitempty"`
3585
3586
3587
3588 TargetVersion string `json:"targetVersion,omitempty"`
3589
3590
3591
3592
3593
3594 ForceSendFields []string `json:"-"`
3595
3596
3597
3598
3599 NullFields []string `json:"-"`
3600 }
3601
3602 func (s *UpgradeDependency) MarshalJSON() ([]byte, error) {
3603 type NoMethod UpgradeDependency
3604 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3605 }
3606
3607
3608 type ValidationCheck struct {
3609
3610
3611
3612
3613
3614
3615
3616
3617 Option string `json:"option,omitempty"`
3618
3619
3620
3621
3622
3623
3624 Scenario string `json:"scenario,omitempty"`
3625
3626 Status *ValidationCheckStatus `json:"status,omitempty"`
3627
3628
3629
3630
3631
3632 ForceSendFields []string `json:"-"`
3633
3634
3635
3636
3637 NullFields []string `json:"-"`
3638 }
3639
3640 func (s *ValidationCheck) MarshalJSON() ([]byte, error) {
3641 type NoMethod ValidationCheck
3642 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3643 }
3644
3645
3646
3647 type ValidationCheckResult struct {
3648
3649 Category string `json:"category,omitempty"`
3650
3651 Description string `json:"description,omitempty"`
3652
3653 Details string `json:"details,omitempty"`
3654
3655 Reason string `json:"reason,omitempty"`
3656
3657
3658
3659
3660
3661
3662
3663
3664 State string `json:"state,omitempty"`
3665
3666
3667
3668
3669
3670 ForceSendFields []string `json:"-"`
3671
3672
3673
3674
3675 NullFields []string `json:"-"`
3676 }
3677
3678 func (s *ValidationCheckResult) MarshalJSON() ([]byte, error) {
3679 type NoMethod ValidationCheckResult
3680 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3681 }
3682
3683
3684
3685 type ValidationCheckStatus struct {
3686
3687
3688 Result []*ValidationCheckResult `json:"result,omitempty"`
3689
3690
3691
3692
3693
3694 ForceSendFields []string `json:"-"`
3695
3696
3697
3698
3699 NullFields []string `json:"-"`
3700 }
3701
3702 func (s *ValidationCheckStatus) MarshalJSON() ([]byte, error) {
3703 type NoMethod ValidationCheckStatus
3704 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3705 }
3706
3707
3708
3709 type VmwareAAGConfig struct {
3710
3711
3712 AagConfigDisabled bool `json:"aagConfigDisabled,omitempty"`
3713
3714
3715
3716
3717
3718 ForceSendFields []string `json:"-"`
3719
3720
3721
3722
3723 NullFields []string `json:"-"`
3724 }
3725
3726 func (s *VmwareAAGConfig) MarshalJSON() ([]byte, error) {
3727 type NoMethod VmwareAAGConfig
3728 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3729 }
3730
3731
3732 type VmwareAddressPool struct {
3733
3734
3735
3736 Addresses []string `json:"addresses,omitempty"`
3737
3738
3739
3740 AvoidBuggyIps bool `json:"avoidBuggyIps,omitempty"`
3741
3742
3743 ManualAssign bool `json:"manualAssign,omitempty"`
3744
3745 Pool string `json:"pool,omitempty"`
3746
3747
3748
3749
3750
3751 ForceSendFields []string `json:"-"`
3752
3753
3754
3755
3756 NullFields []string `json:"-"`
3757 }
3758
3759 func (s *VmwareAddressPool) MarshalJSON() ([]byte, error) {
3760 type NoMethod VmwareAddressPool
3761 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3762 }
3763
3764
3765
3766 type VmwareAdminAddonNodeConfig struct {
3767
3768
3769 AutoResizeConfig *VmwareAutoResizeConfig `json:"autoResizeConfig,omitempty"`
3770
3771
3772
3773
3774
3775 ForceSendFields []string `json:"-"`
3776
3777
3778
3779
3780 NullFields []string `json:"-"`
3781 }
3782
3783 func (s *VmwareAdminAddonNodeConfig) MarshalJSON() ([]byte, error) {
3784 type NoMethod VmwareAdminAddonNodeConfig
3785 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3786 }
3787
3788
3789
3790 type VmwareAdminAuthorizationConfig struct {
3791
3792
3793 ViewerUsers []*ClusterUser `json:"viewerUsers,omitempty"`
3794
3795
3796
3797
3798
3799 ForceSendFields []string `json:"-"`
3800
3801
3802
3803
3804 NullFields []string `json:"-"`
3805 }
3806
3807 func (s *VmwareAdminAuthorizationConfig) MarshalJSON() ([]byte, error) {
3808 type NoMethod VmwareAdminAuthorizationConfig
3809 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3810 }
3811
3812
3813 type VmwareAdminCluster struct {
3814
3815 AddonNode *VmwareAdminAddonNodeConfig `json:"addonNode,omitempty"`
3816
3817
3818
3819
3820
3821
3822
3823 Annotations map[string]string `json:"annotations,omitempty"`
3824
3825
3826 AntiAffinityGroups *VmwareAAGConfig `json:"antiAffinityGroups,omitempty"`
3827
3828 Authorization *VmwareAdminAuthorizationConfig `json:"authorization,omitempty"`
3829
3830 AutoRepairConfig *VmwareAutoRepairConfig `json:"autoRepairConfig,omitempty"`
3831
3832
3833 BootstrapClusterMembership string `json:"bootstrapClusterMembership,omitempty"`
3834
3835 ControlPlaneNode *VmwareAdminControlPlaneNodeConfig `json:"controlPlaneNode,omitempty"`
3836
3837 CreateTime string `json:"createTime,omitempty"`
3838
3839 Description string `json:"description,omitempty"`
3840
3841 Endpoint string `json:"endpoint,omitempty"`
3842
3843
3844
3845
3846 Etag string `json:"etag,omitempty"`
3847
3848 Fleet *Fleet `json:"fleet,omitempty"`
3849
3850 ImageType string `json:"imageType,omitempty"`
3851
3852 LoadBalancer *VmwareAdminLoadBalancerConfig `json:"loadBalancer,omitempty"`
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862 LocalName string `json:"localName,omitempty"`
3863
3864 Name string `json:"name,omitempty"`
3865
3866 NetworkConfig *VmwareAdminNetworkConfig `json:"networkConfig,omitempty"`
3867
3868
3869 OnPremVersion string `json:"onPremVersion,omitempty"`
3870
3871 PlatformConfig *VmwarePlatformConfig `json:"platformConfig,omitempty"`
3872
3873
3874
3875 PreparedSecrets *VmwareAdminPreparedSecretsConfig `json:"preparedSecrets,omitempty"`
3876
3877
3878 Reconciling bool `json:"reconciling,omitempty"`
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894 State string `json:"state,omitempty"`
3895
3896 Status *ResourceStatus `json:"status,omitempty"`
3897
3898 Uid string `json:"uid,omitempty"`
3899
3900
3901 UpdateTime string `json:"updateTime,omitempty"`
3902
3903 Vcenter *VmwareAdminVCenterConfig `json:"vcenter,omitempty"`
3904
3905
3906 googleapi.ServerResponse `json:"-"`
3907
3908
3909
3910
3911
3912 ForceSendFields []string `json:"-"`
3913
3914
3915
3916
3917 NullFields []string `json:"-"`
3918 }
3919
3920 func (s *VmwareAdminCluster) MarshalJSON() ([]byte, error) {
3921 type NoMethod VmwareAdminCluster
3922 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3923 }
3924
3925
3926
3927 type VmwareAdminControlPlaneNodeConfig struct {
3928
3929 Cpus int64 `json:"cpus,omitempty,string"`
3930
3931
3932 Memory int64 `json:"memory,omitempty,string"`
3933
3934
3935 Replicas int64 `json:"replicas,omitempty,string"`
3936
3937
3938
3939
3940
3941 ForceSendFields []string `json:"-"`
3942
3943
3944
3945
3946 NullFields []string `json:"-"`
3947 }
3948
3949 func (s *VmwareAdminControlPlaneNodeConfig) MarshalJSON() ([]byte, error) {
3950 type NoMethod VmwareAdminControlPlaneNodeConfig
3951 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3952 }
3953
3954
3955
3956 type VmwareAdminF5BigIpConfig struct {
3957
3958 Address string `json:"address,omitempty"`
3959
3960
3961
3962 Partition string `json:"partition,omitempty"`
3963
3964 SnatPool string `json:"snatPool,omitempty"`
3965
3966
3967
3968
3969
3970 ForceSendFields []string `json:"-"`
3971
3972
3973
3974
3975 NullFields []string `json:"-"`
3976 }
3977
3978 func (s *VmwareAdminF5BigIpConfig) MarshalJSON() ([]byte, error) {
3979 type NoMethod VmwareAdminF5BigIpConfig
3980 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3981 }
3982
3983
3984 type VmwareAdminHAControlPlaneConfig struct {
3985
3986 ControlPlaneIpBlock *VmwareIpBlock `json:"controlPlaneIpBlock,omitempty"`
3987
3988
3989
3990
3991
3992 ForceSendFields []string `json:"-"`
3993
3994
3995
3996
3997 NullFields []string `json:"-"`
3998 }
3999
4000 func (s *VmwareAdminHAControlPlaneConfig) MarshalJSON() ([]byte, error) {
4001 type NoMethod VmwareAdminHAControlPlaneConfig
4002 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4003 }
4004
4005
4006
4007 type VmwareAdminLoadBalancerConfig struct {
4008
4009 F5Config *VmwareAdminF5BigIpConfig `json:"f5Config,omitempty"`
4010
4011 ManualLbConfig *VmwareAdminManualLbConfig `json:"manualLbConfig,omitempty"`
4012
4013 MetalLbConfig *VmwareAdminMetalLbConfig `json:"metalLbConfig,omitempty"`
4014
4015 SeesawConfig *VmwareAdminSeesawConfig `json:"seesawConfig,omitempty"`
4016
4017 VipConfig *VmwareAdminVipConfig `json:"vipConfig,omitempty"`
4018
4019
4020
4021
4022
4023 ForceSendFields []string `json:"-"`
4024
4025
4026
4027
4028 NullFields []string `json:"-"`
4029 }
4030
4031 func (s *VmwareAdminLoadBalancerConfig) MarshalJSON() ([]byte, error) {
4032 type NoMethod VmwareAdminLoadBalancerConfig
4033 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4034 }
4035
4036 type VmwareAdminManualLbConfig struct {
4037
4038 AddonsNodePort int64 `json:"addonsNodePort,omitempty"`
4039
4040
4041
4042 ControlPlaneNodePort int64 `json:"controlPlaneNodePort,omitempty"`
4043
4044
4045
4046 IngressHttpNodePort int64 `json:"ingressHttpNodePort,omitempty"`
4047
4048
4049
4050 IngressHttpsNodePort int64 `json:"ingressHttpsNodePort,omitempty"`
4051
4052
4053 KonnectivityServerNodePort int64 `json:"konnectivityServerNodePort,omitempty"`
4054
4055
4056
4057
4058
4059 ForceSendFields []string `json:"-"`
4060
4061
4062
4063
4064 NullFields []string `json:"-"`
4065 }
4066
4067 func (s *VmwareAdminManualLbConfig) MarshalJSON() ([]byte, error) {
4068 type NoMethod VmwareAdminManualLbConfig
4069 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4070 }
4071
4072
4073
4074
4075 type VmwareAdminMetalLbConfig struct {
4076 }
4077
4078
4079
4080 type VmwareAdminNetworkConfig struct {
4081
4082 DhcpIpConfig *VmwareDhcpIpConfig `json:"dhcpIpConfig,omitempty"`
4083
4084 HaControlPlaneConfig *VmwareAdminHAControlPlaneConfig `json:"haControlPlaneConfig,omitempty"`
4085
4086
4087 HostConfig *VmwareHostConfig `json:"hostConfig,omitempty"`
4088
4089
4090
4091 PodAddressCidrBlocks []string `json:"podAddressCidrBlocks,omitempty"`
4092
4093
4094
4095 ServiceAddressCidrBlocks []string `json:"serviceAddressCidrBlocks,omitempty"`
4096
4097 StaticIpConfig *VmwareStaticIpConfig `json:"staticIpConfig,omitempty"`
4098
4099 VcenterNetwork string `json:"vcenterNetwork,omitempty"`
4100
4101
4102
4103
4104
4105 ForceSendFields []string `json:"-"`
4106
4107
4108
4109
4110 NullFields []string `json:"-"`
4111 }
4112
4113 func (s *VmwareAdminNetworkConfig) MarshalJSON() ([]byte, error) {
4114 type NoMethod VmwareAdminNetworkConfig
4115 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4116 }
4117
4118
4119
4120 type VmwareAdminPreparedSecretsConfig struct {
4121
4122 Enabled bool `json:"enabled,omitempty"`
4123
4124
4125
4126
4127
4128 ForceSendFields []string `json:"-"`
4129
4130
4131
4132
4133 NullFields []string `json:"-"`
4134 }
4135
4136 func (s *VmwareAdminPreparedSecretsConfig) MarshalJSON() ([]byte, error) {
4137 type NoMethod VmwareAdminPreparedSecretsConfig
4138 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4139 }
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149
4150
4151
4152
4153
4154
4155
4156
4157
4158
4159 type VmwareAdminSeesawConfig struct {
4160
4161
4162 EnableHa bool `json:"enableHa,omitempty"`
4163
4164
4165 Group string `json:"group,omitempty"`
4166
4167 IpBlocks []*VmwareIpBlock `json:"ipBlocks,omitempty"`
4168
4169 MasterIp string `json:"masterIp,omitempty"`
4170
4171 StackdriverName string `json:"stackdriverName,omitempty"`
4172
4173 Vms []string `json:"vms,omitempty"`
4174
4175
4176
4177
4178
4179 ForceSendFields []string `json:"-"`
4180
4181
4182
4183
4184 NullFields []string `json:"-"`
4185 }
4186
4187 func (s *VmwareAdminSeesawConfig) MarshalJSON() ([]byte, error) {
4188 type NoMethod VmwareAdminSeesawConfig
4189 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4190 }
4191
4192
4193
4194 type VmwareAdminVCenterConfig struct {
4195
4196 Address string `json:"address,omitempty"`
4197
4198
4199 CaCertData string `json:"caCertData,omitempty"`
4200
4201 Cluster string `json:"cluster,omitempty"`
4202
4203 DataDisk string `json:"dataDisk,omitempty"`
4204
4205 Datacenter string `json:"datacenter,omitempty"`
4206
4207 Datastore string `json:"datastore,omitempty"`
4208
4209 Folder string `json:"folder,omitempty"`
4210
4211 ResourcePool string `json:"resourcePool,omitempty"`
4212
4213
4214 StoragePolicyName string `json:"storagePolicyName,omitempty"`
4215
4216
4217
4218
4219
4220 ForceSendFields []string `json:"-"`
4221
4222
4223
4224
4225 NullFields []string `json:"-"`
4226 }
4227
4228 func (s *VmwareAdminVCenterConfig) MarshalJSON() ([]byte, error) {
4229 type NoMethod VmwareAdminVCenterConfig
4230 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4231 }
4232
4233
4234
4235 type VmwareAdminVipConfig struct {
4236
4237 AddonsVip string `json:"addonsVip,omitempty"`
4238
4239
4240 ControlPlaneVip string `json:"controlPlaneVip,omitempty"`
4241
4242
4243
4244
4245
4246 ForceSendFields []string `json:"-"`
4247
4248
4249
4250
4251 NullFields []string `json:"-"`
4252 }
4253
4254 func (s *VmwareAdminVipConfig) MarshalJSON() ([]byte, error) {
4255 type NoMethod VmwareAdminVipConfig
4256 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4257 }
4258
4259
4260
4261 type VmwareAutoRepairConfig struct {
4262
4263 Enabled bool `json:"enabled,omitempty"`
4264
4265
4266
4267
4268
4269 ForceSendFields []string `json:"-"`
4270
4271
4272
4273
4274 NullFields []string `json:"-"`
4275 }
4276
4277 func (s *VmwareAutoRepairConfig) MarshalJSON() ([]byte, error) {
4278 type NoMethod VmwareAutoRepairConfig
4279 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4280 }
4281
4282
4283
4284 type VmwareAutoResizeConfig struct {
4285
4286 Enabled bool `json:"enabled,omitempty"`
4287
4288
4289
4290
4291
4292 ForceSendFields []string `json:"-"`
4293
4294
4295
4296
4297 NullFields []string `json:"-"`
4298 }
4299
4300 func (s *VmwareAutoResizeConfig) MarshalJSON() ([]byte, error) {
4301 type NoMethod VmwareAutoResizeConfig
4302 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4303 }
4304
4305
4306
4307 type VmwareBundleConfig struct {
4308
4309 Status *ResourceStatus `json:"status,omitempty"`
4310
4311 Version string `json:"version,omitempty"`
4312
4313
4314
4315
4316
4317 ForceSendFields []string `json:"-"`
4318
4319
4320
4321
4322 NullFields []string `json:"-"`
4323 }
4324
4325 func (s *VmwareBundleConfig) MarshalJSON() ([]byte, error) {
4326 type NoMethod VmwareBundleConfig
4327 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4328 }
4329
4330
4331 type VmwareCluster struct {
4332
4333
4334
4335
4336 AdminClusterMembership string `json:"adminClusterMembership,omitempty"`
4337
4338
4339 AdminClusterName string `json:"adminClusterName,omitempty"`
4340
4341
4342
4343
4344
4345
4346
4347 Annotations map[string]string `json:"annotations,omitempty"`
4348
4349
4350 AntiAffinityGroups *VmwareAAGConfig `json:"antiAffinityGroups,omitempty"`
4351
4352
4353 Authorization *Authorization `json:"authorization,omitempty"`
4354
4355 AutoRepairConfig *VmwareAutoRepairConfig `json:"autoRepairConfig,omitempty"`
4356
4357 BinaryAuthorization *BinaryAuthorization `json:"binaryAuthorization,omitempty"`
4358
4359
4360 ControlPlaneNode *VmwareControlPlaneNodeConfig `json:"controlPlaneNode,omitempty"`
4361
4362 CreateTime string `json:"createTime,omitempty"`
4363
4364
4365 DataplaneV2 *VmwareDataplaneV2Config `json:"dataplaneV2,omitempty"`
4366
4367 DeleteTime string `json:"deleteTime,omitempty"`
4368
4369 Description string `json:"description,omitempty"`
4370
4371 DisableBundledIngress bool `json:"disableBundledIngress,omitempty"`
4372
4373 EnableControlPlaneV2 bool `json:"enableControlPlaneV2,omitempty"`
4374
4375 Endpoint string `json:"endpoint,omitempty"`
4376
4377
4378
4379
4380 Etag string `json:"etag,omitempty"`
4381
4382 Fleet *Fleet `json:"fleet,omitempty"`
4383
4384 LoadBalancer *VmwareLoadBalancerConfig `json:"loadBalancer,omitempty"`
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394 LocalName string `json:"localName,omitempty"`
4395
4396 Name string `json:"name,omitempty"`
4397
4398 NetworkConfig *VmwareNetworkConfig `json:"networkConfig,omitempty"`
4399
4400
4401 OnPremVersion string `json:"onPremVersion,omitempty"`
4402
4403
4404 Reconciling bool `json:"reconciling,omitempty"`
4405
4406
4407
4408
4409
4410
4411
4412
4413
4414
4415
4416
4417
4418
4419
4420 State string `json:"state,omitempty"`
4421
4422 Status *ResourceStatus `json:"status,omitempty"`
4423
4424 Storage *VmwareStorageConfig `json:"storage,omitempty"`
4425
4426 Uid string `json:"uid,omitempty"`
4427
4428
4429 UpdateTime string `json:"updateTime,omitempty"`
4430
4431 UpgradePolicy *VmwareClusterUpgradePolicy `json:"upgradePolicy,omitempty"`
4432
4433
4434 ValidationCheck *ValidationCheck `json:"validationCheck,omitempty"`
4435
4436
4437 Vcenter *VmwareVCenterConfig `json:"vcenter,omitempty"`
4438
4439 VmTrackingEnabled bool `json:"vmTrackingEnabled,omitempty"`
4440
4441
4442 googleapi.ServerResponse `json:"-"`
4443
4444
4445
4446
4447
4448 ForceSendFields []string `json:"-"`
4449
4450
4451
4452
4453 NullFields []string `json:"-"`
4454 }
4455
4456 func (s *VmwareCluster) MarshalJSON() ([]byte, error) {
4457 type NoMethod VmwareCluster
4458 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4459 }
4460
4461
4462
4463 type VmwareClusterUpgradePolicy struct {
4464
4465
4466 ControlPlaneOnly bool `json:"controlPlaneOnly,omitempty"`
4467
4468
4469
4470
4471
4472 ForceSendFields []string `json:"-"`
4473
4474
4475
4476
4477 NullFields []string `json:"-"`
4478 }
4479
4480 func (s *VmwareClusterUpgradePolicy) MarshalJSON() ([]byte, error) {
4481 type NoMethod VmwareClusterUpgradePolicy
4482 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4483 }
4484
4485
4486
4487 type VmwareControlPlaneNodeConfig struct {
4488
4489 AutoResizeConfig *VmwareAutoResizeConfig `json:"autoResizeConfig,omitempty"`
4490
4491
4492 Cpus int64 `json:"cpus,omitempty,string"`
4493
4494
4495 Memory int64 `json:"memory,omitempty,string"`
4496
4497
4498 Replicas int64 `json:"replicas,omitempty,string"`
4499
4500 VsphereConfig *VmwareControlPlaneVsphereConfig `json:"vsphereConfig,omitempty"`
4501
4502
4503
4504
4505
4506 ForceSendFields []string `json:"-"`
4507
4508
4509
4510
4511 NullFields []string `json:"-"`
4512 }
4513
4514 func (s *VmwareControlPlaneNodeConfig) MarshalJSON() ([]byte, error) {
4515 type NoMethod VmwareControlPlaneNodeConfig
4516 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4517 }
4518
4519
4520 type VmwareControlPlaneV2Config struct {
4521
4522 ControlPlaneIpBlock *VmwareIpBlock `json:"controlPlaneIpBlock,omitempty"`
4523
4524
4525
4526
4527
4528 ForceSendFields []string `json:"-"`
4529
4530
4531
4532
4533 NullFields []string `json:"-"`
4534 }
4535
4536 func (s *VmwareControlPlaneV2Config) MarshalJSON() ([]byte, error) {
4537 type NoMethod VmwareControlPlaneV2Config
4538 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4539 }
4540
4541
4542 type VmwareControlPlaneVsphereConfig struct {
4543
4544 Datastore string `json:"datastore,omitempty"`
4545
4546
4547 StoragePolicyName string `json:"storagePolicyName,omitempty"`
4548
4549
4550
4551
4552
4553 ForceSendFields []string `json:"-"`
4554
4555
4556
4557
4558 NullFields []string `json:"-"`
4559 }
4560
4561 func (s *VmwareControlPlaneVsphereConfig) MarshalJSON() ([]byte, error) {
4562 type NoMethod VmwareControlPlaneVsphereConfig
4563 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4564 }
4565
4566
4567
4568
4569 type VmwareDataplaneV2Config struct {
4570
4571
4572 AdvancedNetworking bool `json:"advancedNetworking,omitempty"`
4573
4574 DataplaneV2Enabled bool `json:"dataplaneV2Enabled,omitempty"`
4575
4576 ForwardMode string `json:"forwardMode,omitempty"`
4577
4578
4579 WindowsDataplaneV2Enabled bool `json:"windowsDataplaneV2Enabled,omitempty"`
4580
4581
4582
4583
4584
4585 ForceSendFields []string `json:"-"`
4586
4587
4588
4589
4590 NullFields []string `json:"-"`
4591 }
4592
4593 func (s *VmwareDataplaneV2Config) MarshalJSON() ([]byte, error) {
4594 type NoMethod VmwareDataplaneV2Config
4595 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4596 }
4597
4598
4599
4600 type VmwareDhcpIpConfig struct {
4601
4602
4603 Enabled bool `json:"enabled,omitempty"`
4604
4605
4606
4607
4608
4609 ForceSendFields []string `json:"-"`
4610
4611
4612
4613
4614 NullFields []string `json:"-"`
4615 }
4616
4617 func (s *VmwareDhcpIpConfig) MarshalJSON() ([]byte, error) {
4618 type NoMethod VmwareDhcpIpConfig
4619 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4620 }
4621
4622
4623
4624 type VmwareF5BigIpConfig struct {
4625
4626 Address string `json:"address,omitempty"`
4627
4628
4629
4630 Partition string `json:"partition,omitempty"`
4631
4632 SnatPool string `json:"snatPool,omitempty"`
4633
4634
4635
4636
4637
4638 ForceSendFields []string `json:"-"`
4639
4640
4641
4642
4643 NullFields []string `json:"-"`
4644 }
4645
4646 func (s *VmwareF5BigIpConfig) MarshalJSON() ([]byte, error) {
4647 type NoMethod VmwareF5BigIpConfig
4648 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4649 }
4650
4651
4652
4653 type VmwareHostConfig struct {
4654
4655 DnsSearchDomains []string `json:"dnsSearchDomains,omitempty"`
4656
4657 DnsServers []string `json:"dnsServers,omitempty"`
4658
4659 NtpServers []string `json:"ntpServers,omitempty"`
4660
4661
4662
4663
4664
4665 ForceSendFields []string `json:"-"`
4666
4667
4668
4669
4670 NullFields []string `json:"-"`
4671 }
4672
4673 func (s *VmwareHostConfig) MarshalJSON() ([]byte, error) {
4674 type NoMethod VmwareHostConfig
4675 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4676 }
4677
4678
4679 type VmwareHostIp struct {
4680
4681
4682 Hostname string `json:"hostname,omitempty"`
4683
4684 Ip string `json:"ip,omitempty"`
4685
4686
4687
4688
4689
4690 ForceSendFields []string `json:"-"`
4691
4692
4693
4694
4695 NullFields []string `json:"-"`
4696 }
4697
4698 func (s *VmwareHostIp) MarshalJSON() ([]byte, error) {
4699 type NoMethod VmwareHostIp
4700 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4701 }
4702
4703
4704 type VmwareIpBlock struct {
4705
4706 Gateway string `json:"gateway,omitempty"`
4707
4708 Ips []*VmwareHostIp `json:"ips,omitempty"`
4709
4710 Netmask string `json:"netmask,omitempty"`
4711
4712
4713
4714
4715
4716 ForceSendFields []string `json:"-"`
4717
4718
4719
4720
4721 NullFields []string `json:"-"`
4722 }
4723
4724 func (s *VmwareIpBlock) MarshalJSON() ([]byte, error) {
4725 type NoMethod VmwareIpBlock
4726 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4727 }
4728
4729
4730
4731 type VmwareLoadBalancerConfig struct {
4732
4733 F5Config *VmwareF5BigIpConfig `json:"f5Config,omitempty"`
4734
4735 ManualLbConfig *VmwareManualLbConfig `json:"manualLbConfig,omitempty"`
4736
4737 MetalLbConfig *VmwareMetalLbConfig `json:"metalLbConfig,omitempty"`
4738
4739 SeesawConfig *VmwareSeesawConfig `json:"seesawConfig,omitempty"`
4740
4741 VipConfig *VmwareVipConfig `json:"vipConfig,omitempty"`
4742
4743
4744
4745
4746
4747 ForceSendFields []string `json:"-"`
4748
4749
4750
4751
4752 NullFields []string `json:"-"`
4753 }
4754
4755 func (s *VmwareLoadBalancerConfig) MarshalJSON() ([]byte, error) {
4756 type NoMethod VmwareLoadBalancerConfig
4757 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4758 }
4759
4760
4761
4762
4763
4764
4765
4766 type VmwareManualLbConfig struct {
4767
4768
4769
4770 ControlPlaneNodePort int64 `json:"controlPlaneNodePort,omitempty"`
4771
4772
4773
4774 IngressHttpNodePort int64 `json:"ingressHttpNodePort,omitempty"`
4775
4776
4777
4778 IngressHttpsNodePort int64 `json:"ingressHttpsNodePort,omitempty"`
4779
4780
4781 KonnectivityServerNodePort int64 `json:"konnectivityServerNodePort,omitempty"`
4782
4783
4784
4785
4786
4787 ForceSendFields []string `json:"-"`
4788
4789
4790
4791
4792 NullFields []string `json:"-"`
4793 }
4794
4795 func (s *VmwareManualLbConfig) MarshalJSON() ([]byte, error) {
4796 type NoMethod VmwareManualLbConfig
4797 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4798 }
4799
4800
4801
4802 type VmwareMetalLbConfig struct {
4803
4804
4805
4806 AddressPools []*VmwareAddressPool `json:"addressPools,omitempty"`
4807
4808
4809
4810
4811
4812 ForceSendFields []string `json:"-"`
4813
4814
4815
4816
4817 NullFields []string `json:"-"`
4818 }
4819
4820 func (s *VmwareMetalLbConfig) MarshalJSON() ([]byte, error) {
4821 type NoMethod VmwareMetalLbConfig
4822 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4823 }
4824
4825
4826 type VmwareNetworkConfig struct {
4827
4828 ControlPlaneV2Config *VmwareControlPlaneV2Config `json:"controlPlaneV2Config,omitempty"`
4829
4830 DhcpIpConfig *VmwareDhcpIpConfig `json:"dhcpIpConfig,omitempty"`
4831
4832
4833 HostConfig *VmwareHostConfig `json:"hostConfig,omitempty"`
4834
4835
4836
4837 PodAddressCidrBlocks []string `json:"podAddressCidrBlocks,omitempty"`
4838
4839
4840
4841 ServiceAddressCidrBlocks []string `json:"serviceAddressCidrBlocks,omitempty"`
4842
4843 StaticIpConfig *VmwareStaticIpConfig `json:"staticIpConfig,omitempty"`
4844
4845
4846 VcenterNetwork string `json:"vcenterNetwork,omitempty"`
4847
4848
4849
4850
4851
4852 ForceSendFields []string `json:"-"`
4853
4854
4855
4856
4857 NullFields []string `json:"-"`
4858 }
4859
4860 func (s *VmwareNetworkConfig) MarshalJSON() ([]byte, error) {
4861 type NoMethod VmwareNetworkConfig
4862 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4863 }
4864
4865
4866
4867 type VmwareNodeConfig struct {
4868
4869 BootDiskSizeGb int64 `json:"bootDiskSizeGb,omitempty,string"`
4870
4871 Cpus int64 `json:"cpus,omitempty,string"`
4872
4873
4874 EnableLoadBalancer bool `json:"enableLoadBalancer,omitempty"`
4875
4876 Image string `json:"image,omitempty"`
4877
4878
4879
4880 ImageType string `json:"imageType,omitempty"`
4881
4882
4883
4884
4885
4886
4887
4888 Labels map[string]string `json:"labels,omitempty"`
4889
4890 MemoryMb int64 `json:"memoryMb,omitempty,string"`
4891
4892 Replicas int64 `json:"replicas,omitempty,string"`
4893
4894 Taints []*NodeTaint `json:"taints,omitempty"`
4895
4896 VsphereConfig *VmwareVsphereConfig `json:"vsphereConfig,omitempty"`
4897
4898
4899
4900
4901
4902 ForceSendFields []string `json:"-"`
4903
4904
4905
4906
4907 NullFields []string `json:"-"`
4908 }
4909
4910 func (s *VmwareNodeConfig) MarshalJSON() ([]byte, error) {
4911 type NoMethod VmwareNodeConfig
4912 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4913 }
4914
4915
4916 type VmwareNodePool struct {
4917
4918
4919
4920
4921
4922
4923
4924 Annotations map[string]string `json:"annotations,omitempty"`
4925
4926 Config *VmwareNodeConfig `json:"config,omitempty"`
4927
4928 CreateTime string `json:"createTime,omitempty"`
4929
4930
4931 DeleteTime string `json:"deleteTime,omitempty"`
4932
4933 DisplayName string `json:"displayName,omitempty"`
4934
4935
4936
4937
4938 Etag string `json:"etag,omitempty"`
4939
4940 Name string `json:"name,omitempty"`
4941
4942 NodePoolAutoscaling *VmwareNodePoolAutoscalingConfig `json:"nodePoolAutoscaling,omitempty"`
4943
4944
4945 OnPremVersion string `json:"onPremVersion,omitempty"`
4946
4947
4948 Reconciling bool `json:"reconciling,omitempty"`
4949
4950
4951
4952
4953
4954
4955
4956
4957
4958
4959
4960
4961
4962
4963
4964
4965 State string `json:"state,omitempty"`
4966
4967
4968 Status *ResourceStatus `json:"status,omitempty"`
4969
4970 Uid string `json:"uid,omitempty"`
4971
4972 UpdateTime string `json:"updateTime,omitempty"`
4973
4974
4975 googleapi.ServerResponse `json:"-"`
4976
4977
4978
4979
4980
4981 ForceSendFields []string `json:"-"`
4982
4983
4984
4985
4986 NullFields []string `json:"-"`
4987 }
4988
4989 func (s *VmwareNodePool) MarshalJSON() ([]byte, error) {
4990 type NoMethod VmwareNodePool
4991 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4992 }
4993
4994
4995
4996 type VmwareNodePoolAutoscalingConfig struct {
4997
4998 MaxReplicas int64 `json:"maxReplicas,omitempty"`
4999
5000 MinReplicas int64 `json:"minReplicas,omitempty"`
5001
5002
5003
5004
5005
5006 ForceSendFields []string `json:"-"`
5007
5008
5009
5010
5011 NullFields []string `json:"-"`
5012 }
5013
5014 func (s *VmwareNodePoolAutoscalingConfig) MarshalJSON() ([]byte, error) {
5015 type NoMethod VmwareNodePoolAutoscalingConfig
5016 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5017 }
5018
5019
5020
5021 type VmwarePlatformConfig struct {
5022
5023 Bundles []*VmwareBundleConfig `json:"bundles,omitempty"`
5024
5025 PlatformVersion string `json:"platformVersion,omitempty"`
5026
5027
5028
5029
5030
5031 RequiredPlatformVersion string `json:"requiredPlatformVersion,omitempty"`
5032
5033 Status *ResourceStatus `json:"status,omitempty"`
5034
5035
5036
5037
5038
5039 ForceSendFields []string `json:"-"`
5040
5041
5042
5043
5044 NullFields []string `json:"-"`
5045 }
5046
5047 func (s *VmwarePlatformConfig) MarshalJSON() ([]byte, error) {
5048 type NoMethod VmwarePlatformConfig
5049 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5050 }
5051
5052
5053
5054
5055
5056
5057
5058
5059
5060
5061
5062
5063
5064
5065
5066
5067
5068
5069 type VmwareSeesawConfig struct {
5070
5071
5072 EnableHa bool `json:"enableHa,omitempty"`
5073
5074
5075 Group string `json:"group,omitempty"`
5076
5077 IpBlocks []*VmwareIpBlock `json:"ipBlocks,omitempty"`
5078
5079
5080 MasterIp string `json:"masterIp,omitempty"`
5081
5082 StackdriverName string `json:"stackdriverName,omitempty"`
5083
5084 Vms []string `json:"vms,omitempty"`
5085
5086
5087
5088
5089
5090 ForceSendFields []string `json:"-"`
5091
5092
5093
5094
5095 NullFields []string `json:"-"`
5096 }
5097
5098 func (s *VmwareSeesawConfig) MarshalJSON() ([]byte, error) {
5099 type NoMethod VmwareSeesawConfig
5100 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5101 }
5102
5103
5104
5105 type VmwareStaticIpConfig struct {
5106
5107
5108 IpBlocks []*VmwareIpBlock `json:"ipBlocks,omitempty"`
5109
5110
5111
5112
5113
5114 ForceSendFields []string `json:"-"`
5115
5116
5117
5118
5119 NullFields []string `json:"-"`
5120 }
5121
5122 func (s *VmwareStaticIpConfig) MarshalJSON() ([]byte, error) {
5123 type NoMethod VmwareStaticIpConfig
5124 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5125 }
5126
5127
5128
5129 type VmwareStorageConfig struct {
5130
5131
5132 VsphereCsiDisabled bool `json:"vsphereCsiDisabled,omitempty"`
5133
5134
5135
5136
5137
5138 ForceSendFields []string `json:"-"`
5139
5140
5141
5142
5143 NullFields []string `json:"-"`
5144 }
5145
5146 func (s *VmwareStorageConfig) MarshalJSON() ([]byte, error) {
5147 type NoMethod VmwareStorageConfig
5148 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5149 }
5150
5151
5152
5153 type VmwareVCenterConfig struct {
5154
5155 Address string `json:"address,omitempty"`
5156
5157
5158 CaCertData string `json:"caCertData,omitempty"`
5159
5160 Cluster string `json:"cluster,omitempty"`
5161
5162 Datacenter string `json:"datacenter,omitempty"`
5163
5164 Datastore string `json:"datastore,omitempty"`
5165
5166 Folder string `json:"folder,omitempty"`
5167
5168 ResourcePool string `json:"resourcePool,omitempty"`
5169
5170
5171 StoragePolicyName string `json:"storagePolicyName,omitempty"`
5172
5173
5174
5175
5176
5177 ForceSendFields []string `json:"-"`
5178
5179
5180
5181
5182 NullFields []string `json:"-"`
5183 }
5184
5185 func (s *VmwareVCenterConfig) MarshalJSON() ([]byte, error) {
5186 type NoMethod VmwareVCenterConfig
5187 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5188 }
5189
5190
5191
5192 type VmwareVersionInfo struct {
5193
5194 Dependencies []*UpgradeDependency `json:"dependencies,omitempty"`
5195
5196
5197
5198 HasDependencies bool `json:"hasDependencies,omitempty"`
5199
5200
5201
5202 IsInstalled bool `json:"isInstalled,omitempty"`
5203
5204 Version string `json:"version,omitempty"`
5205
5206
5207
5208
5209
5210 ForceSendFields []string `json:"-"`
5211
5212
5213
5214
5215 NullFields []string `json:"-"`
5216 }
5217
5218 func (s *VmwareVersionInfo) MarshalJSON() ([]byte, error) {
5219 type NoMethod VmwareVersionInfo
5220 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5221 }
5222
5223
5224
5225 type VmwareVipConfig struct {
5226
5227
5228 ControlPlaneVip string `json:"controlPlaneVip,omitempty"`
5229
5230
5231 IngressVip string `json:"ingressVip,omitempty"`
5232
5233
5234
5235
5236
5237 ForceSendFields []string `json:"-"`
5238
5239
5240
5241
5242 NullFields []string `json:"-"`
5243 }
5244
5245 func (s *VmwareVipConfig) MarshalJSON() ([]byte, error) {
5246 type NoMethod VmwareVipConfig
5247 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5248 }
5249
5250
5251
5252 type VmwareVsphereConfig struct {
5253
5254
5255 Datastore string `json:"datastore,omitempty"`
5256
5257 HostGroups []string `json:"hostGroups,omitempty"`
5258
5259 Tags []*VmwareVsphereTag `json:"tags,omitempty"`
5260
5261
5262
5263
5264
5265 ForceSendFields []string `json:"-"`
5266
5267
5268
5269
5270 NullFields []string `json:"-"`
5271 }
5272
5273 func (s *VmwareVsphereConfig) MarshalJSON() ([]byte, error) {
5274 type NoMethod VmwareVsphereConfig
5275 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5276 }
5277
5278
5279
5280
5281 type VmwareVsphereTag struct {
5282
5283 Category string `json:"category,omitempty"`
5284
5285 Tag string `json:"tag,omitempty"`
5286
5287
5288
5289
5290
5291 ForceSendFields []string `json:"-"`
5292
5293
5294
5295
5296 NullFields []string `json:"-"`
5297 }
5298
5299 func (s *VmwareVsphereTag) MarshalJSON() ([]byte, error) {
5300 type NoMethod VmwareVsphereTag
5301 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5302 }
5303
5304 type ProjectsLocationsGetCall struct {
5305 s *Service
5306 name string
5307 urlParams_ gensupport.URLParams
5308 ifNoneMatch_ string
5309 ctx_ context.Context
5310 header_ http.Header
5311 }
5312
5313
5314
5315
5316 func (r *ProjectsLocationsService) Get(name string) *ProjectsLocationsGetCall {
5317 c := &ProjectsLocationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5318 c.name = name
5319 return c
5320 }
5321
5322
5323
5324
5325 func (c *ProjectsLocationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsGetCall {
5326 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5327 return c
5328 }
5329
5330
5331
5332
5333 func (c *ProjectsLocationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsGetCall {
5334 c.ifNoneMatch_ = entityTag
5335 return c
5336 }
5337
5338
5339 func (c *ProjectsLocationsGetCall) Context(ctx context.Context) *ProjectsLocationsGetCall {
5340 c.ctx_ = ctx
5341 return c
5342 }
5343
5344
5345
5346 func (c *ProjectsLocationsGetCall) Header() http.Header {
5347 if c.header_ == nil {
5348 c.header_ = make(http.Header)
5349 }
5350 return c.header_
5351 }
5352
5353 func (c *ProjectsLocationsGetCall) doRequest(alt string) (*http.Response, error) {
5354 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5355 if c.ifNoneMatch_ != "" {
5356 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5357 }
5358 var body io.Reader = nil
5359 c.urlParams_.Set("alt", alt)
5360 c.urlParams_.Set("prettyPrint", "false")
5361 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
5362 urls += "?" + c.urlParams_.Encode()
5363 req, err := http.NewRequest("GET", urls, body)
5364 if err != nil {
5365 return nil, err
5366 }
5367 req.Header = reqHeaders
5368 googleapi.Expand(req.URL, map[string]string{
5369 "name": c.name,
5370 })
5371 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5372 }
5373
5374
5375
5376
5377
5378
5379 func (c *ProjectsLocationsGetCall) Do(opts ...googleapi.CallOption) (*Location, error) {
5380 gensupport.SetOptions(c.urlParams_, opts...)
5381 res, err := c.doRequest("json")
5382 if res != nil && res.StatusCode == http.StatusNotModified {
5383 if res.Body != nil {
5384 res.Body.Close()
5385 }
5386 return nil, gensupport.WrapError(&googleapi.Error{
5387 Code: res.StatusCode,
5388 Header: res.Header,
5389 })
5390 }
5391 if err != nil {
5392 return nil, err
5393 }
5394 defer googleapi.CloseBody(res)
5395 if err := googleapi.CheckResponse(res); err != nil {
5396 return nil, gensupport.WrapError(err)
5397 }
5398 ret := &Location{
5399 ServerResponse: googleapi.ServerResponse{
5400 Header: res.Header,
5401 HTTPStatusCode: res.StatusCode,
5402 },
5403 }
5404 target := &ret
5405 if err := gensupport.DecodeResponse(target, res); err != nil {
5406 return nil, err
5407 }
5408 return ret, nil
5409 }
5410
5411 type ProjectsLocationsListCall struct {
5412 s *Service
5413 name string
5414 urlParams_ gensupport.URLParams
5415 ifNoneMatch_ string
5416 ctx_ context.Context
5417 header_ http.Header
5418 }
5419
5420
5421
5422
5423 func (r *ProjectsLocationsService) List(name string) *ProjectsLocationsListCall {
5424 c := &ProjectsLocationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5425 c.name = name
5426 return c
5427 }
5428
5429
5430
5431
5432
5433 func (c *ProjectsLocationsListCall) Filter(filter string) *ProjectsLocationsListCall {
5434 c.urlParams_.Set("filter", filter)
5435 return c
5436 }
5437
5438
5439
5440 func (c *ProjectsLocationsListCall) PageSize(pageSize int64) *ProjectsLocationsListCall {
5441 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
5442 return c
5443 }
5444
5445
5446
5447
5448 func (c *ProjectsLocationsListCall) PageToken(pageToken string) *ProjectsLocationsListCall {
5449 c.urlParams_.Set("pageToken", pageToken)
5450 return c
5451 }
5452
5453
5454
5455
5456 func (c *ProjectsLocationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsListCall {
5457 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5458 return c
5459 }
5460
5461
5462
5463
5464 func (c *ProjectsLocationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsListCall {
5465 c.ifNoneMatch_ = entityTag
5466 return c
5467 }
5468
5469
5470 func (c *ProjectsLocationsListCall) Context(ctx context.Context) *ProjectsLocationsListCall {
5471 c.ctx_ = ctx
5472 return c
5473 }
5474
5475
5476
5477 func (c *ProjectsLocationsListCall) Header() http.Header {
5478 if c.header_ == nil {
5479 c.header_ = make(http.Header)
5480 }
5481 return c.header_
5482 }
5483
5484 func (c *ProjectsLocationsListCall) doRequest(alt string) (*http.Response, error) {
5485 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5486 if c.ifNoneMatch_ != "" {
5487 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5488 }
5489 var body io.Reader = nil
5490 c.urlParams_.Set("alt", alt)
5491 c.urlParams_.Set("prettyPrint", "false")
5492 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/locations")
5493 urls += "?" + c.urlParams_.Encode()
5494 req, err := http.NewRequest("GET", urls, body)
5495 if err != nil {
5496 return nil, err
5497 }
5498 req.Header = reqHeaders
5499 googleapi.Expand(req.URL, map[string]string{
5500 "name": c.name,
5501 })
5502 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5503 }
5504
5505
5506
5507
5508
5509
5510
5511 func (c *ProjectsLocationsListCall) Do(opts ...googleapi.CallOption) (*ListLocationsResponse, error) {
5512 gensupport.SetOptions(c.urlParams_, opts...)
5513 res, err := c.doRequest("json")
5514 if res != nil && res.StatusCode == http.StatusNotModified {
5515 if res.Body != nil {
5516 res.Body.Close()
5517 }
5518 return nil, gensupport.WrapError(&googleapi.Error{
5519 Code: res.StatusCode,
5520 Header: res.Header,
5521 })
5522 }
5523 if err != nil {
5524 return nil, err
5525 }
5526 defer googleapi.CloseBody(res)
5527 if err := googleapi.CheckResponse(res); err != nil {
5528 return nil, gensupport.WrapError(err)
5529 }
5530 ret := &ListLocationsResponse{
5531 ServerResponse: googleapi.ServerResponse{
5532 Header: res.Header,
5533 HTTPStatusCode: res.StatusCode,
5534 },
5535 }
5536 target := &ret
5537 if err := gensupport.DecodeResponse(target, res); err != nil {
5538 return nil, err
5539 }
5540 return ret, nil
5541 }
5542
5543
5544
5545
5546 func (c *ProjectsLocationsListCall) Pages(ctx context.Context, f func(*ListLocationsResponse) error) error {
5547 c.ctx_ = ctx
5548 defer c.PageToken(c.urlParams_.Get("pageToken"))
5549 for {
5550 x, err := c.Do()
5551 if err != nil {
5552 return err
5553 }
5554 if err := f(x); err != nil {
5555 return err
5556 }
5557 if x.NextPageToken == "" {
5558 return nil
5559 }
5560 c.PageToken(x.NextPageToken)
5561 }
5562 }
5563
5564 type ProjectsLocationsBareMetalAdminClustersCreateCall struct {
5565 s *Service
5566 parent string
5567 baremetaladmincluster *BareMetalAdminCluster
5568 urlParams_ gensupport.URLParams
5569 ctx_ context.Context
5570 header_ http.Header
5571 }
5572
5573
5574
5575
5576
5577
5578
5579
5580 func (r *ProjectsLocationsBareMetalAdminClustersService) Create(parent string, baremetaladmincluster *BareMetalAdminCluster) *ProjectsLocationsBareMetalAdminClustersCreateCall {
5581 c := &ProjectsLocationsBareMetalAdminClustersCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5582 c.parent = parent
5583 c.baremetaladmincluster = baremetaladmincluster
5584 return c
5585 }
5586
5587
5588
5589
5590
5591 func (c *ProjectsLocationsBareMetalAdminClustersCreateCall) BareMetalAdminClusterId(bareMetalAdminClusterId string) *ProjectsLocationsBareMetalAdminClustersCreateCall {
5592 c.urlParams_.Set("bareMetalAdminClusterId", bareMetalAdminClusterId)
5593 return c
5594 }
5595
5596
5597
5598 func (c *ProjectsLocationsBareMetalAdminClustersCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalAdminClustersCreateCall {
5599 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
5600 return c
5601 }
5602
5603
5604
5605
5606 func (c *ProjectsLocationsBareMetalAdminClustersCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersCreateCall {
5607 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5608 return c
5609 }
5610
5611
5612 func (c *ProjectsLocationsBareMetalAdminClustersCreateCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersCreateCall {
5613 c.ctx_ = ctx
5614 return c
5615 }
5616
5617
5618
5619 func (c *ProjectsLocationsBareMetalAdminClustersCreateCall) Header() http.Header {
5620 if c.header_ == nil {
5621 c.header_ = make(http.Header)
5622 }
5623 return c.header_
5624 }
5625
5626 func (c *ProjectsLocationsBareMetalAdminClustersCreateCall) doRequest(alt string) (*http.Response, error) {
5627 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5628 var body io.Reader = nil
5629 body, err := googleapi.WithoutDataWrapper.JSONReader(c.baremetaladmincluster)
5630 if err != nil {
5631 return nil, err
5632 }
5633 c.urlParams_.Set("alt", alt)
5634 c.urlParams_.Set("prettyPrint", "false")
5635 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalAdminClusters")
5636 urls += "?" + c.urlParams_.Encode()
5637 req, err := http.NewRequest("POST", urls, body)
5638 if err != nil {
5639 return nil, err
5640 }
5641 req.Header = reqHeaders
5642 googleapi.Expand(req.URL, map[string]string{
5643 "parent": c.parent,
5644 })
5645 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5646 }
5647
5648
5649
5650
5651
5652
5653 func (c *ProjectsLocationsBareMetalAdminClustersCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
5654 gensupport.SetOptions(c.urlParams_, opts...)
5655 res, err := c.doRequest("json")
5656 if res != nil && res.StatusCode == http.StatusNotModified {
5657 if res.Body != nil {
5658 res.Body.Close()
5659 }
5660 return nil, gensupport.WrapError(&googleapi.Error{
5661 Code: res.StatusCode,
5662 Header: res.Header,
5663 })
5664 }
5665 if err != nil {
5666 return nil, err
5667 }
5668 defer googleapi.CloseBody(res)
5669 if err := googleapi.CheckResponse(res); err != nil {
5670 return nil, gensupport.WrapError(err)
5671 }
5672 ret := &Operation{
5673 ServerResponse: googleapi.ServerResponse{
5674 Header: res.Header,
5675 HTTPStatusCode: res.StatusCode,
5676 },
5677 }
5678 target := &ret
5679 if err := gensupport.DecodeResponse(target, res); err != nil {
5680 return nil, err
5681 }
5682 return ret, nil
5683 }
5684
5685 type ProjectsLocationsBareMetalAdminClustersEnrollCall struct {
5686 s *Service
5687 parent string
5688 enrollbaremetaladminclusterrequest *EnrollBareMetalAdminClusterRequest
5689 urlParams_ gensupport.URLParams
5690 ctx_ context.Context
5691 header_ http.Header
5692 }
5693
5694
5695
5696
5697
5698
5699
5700
5701
5702 func (r *ProjectsLocationsBareMetalAdminClustersService) Enroll(parent string, enrollbaremetaladminclusterrequest *EnrollBareMetalAdminClusterRequest) *ProjectsLocationsBareMetalAdminClustersEnrollCall {
5703 c := &ProjectsLocationsBareMetalAdminClustersEnrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5704 c.parent = parent
5705 c.enrollbaremetaladminclusterrequest = enrollbaremetaladminclusterrequest
5706 return c
5707 }
5708
5709
5710
5711
5712 func (c *ProjectsLocationsBareMetalAdminClustersEnrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersEnrollCall {
5713 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5714 return c
5715 }
5716
5717
5718 func (c *ProjectsLocationsBareMetalAdminClustersEnrollCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersEnrollCall {
5719 c.ctx_ = ctx
5720 return c
5721 }
5722
5723
5724
5725 func (c *ProjectsLocationsBareMetalAdminClustersEnrollCall) Header() http.Header {
5726 if c.header_ == nil {
5727 c.header_ = make(http.Header)
5728 }
5729 return c.header_
5730 }
5731
5732 func (c *ProjectsLocationsBareMetalAdminClustersEnrollCall) doRequest(alt string) (*http.Response, error) {
5733 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5734 var body io.Reader = nil
5735 body, err := googleapi.WithoutDataWrapper.JSONReader(c.enrollbaremetaladminclusterrequest)
5736 if err != nil {
5737 return nil, err
5738 }
5739 c.urlParams_.Set("alt", alt)
5740 c.urlParams_.Set("prettyPrint", "false")
5741 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalAdminClusters:enroll")
5742 urls += "?" + c.urlParams_.Encode()
5743 req, err := http.NewRequest("POST", urls, body)
5744 if err != nil {
5745 return nil, err
5746 }
5747 req.Header = reqHeaders
5748 googleapi.Expand(req.URL, map[string]string{
5749 "parent": c.parent,
5750 })
5751 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5752 }
5753
5754
5755
5756
5757
5758
5759 func (c *ProjectsLocationsBareMetalAdminClustersEnrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
5760 gensupport.SetOptions(c.urlParams_, opts...)
5761 res, err := c.doRequest("json")
5762 if res != nil && res.StatusCode == http.StatusNotModified {
5763 if res.Body != nil {
5764 res.Body.Close()
5765 }
5766 return nil, gensupport.WrapError(&googleapi.Error{
5767 Code: res.StatusCode,
5768 Header: res.Header,
5769 })
5770 }
5771 if err != nil {
5772 return nil, err
5773 }
5774 defer googleapi.CloseBody(res)
5775 if err := googleapi.CheckResponse(res); err != nil {
5776 return nil, gensupport.WrapError(err)
5777 }
5778 ret := &Operation{
5779 ServerResponse: googleapi.ServerResponse{
5780 Header: res.Header,
5781 HTTPStatusCode: res.StatusCode,
5782 },
5783 }
5784 target := &ret
5785 if err := gensupport.DecodeResponse(target, res); err != nil {
5786 return nil, err
5787 }
5788 return ret, nil
5789 }
5790
5791 type ProjectsLocationsBareMetalAdminClustersGetCall struct {
5792 s *Service
5793 name string
5794 urlParams_ gensupport.URLParams
5795 ifNoneMatch_ string
5796 ctx_ context.Context
5797 header_ http.Header
5798 }
5799
5800
5801
5802
5803
5804
5805 func (r *ProjectsLocationsBareMetalAdminClustersService) Get(name string) *ProjectsLocationsBareMetalAdminClustersGetCall {
5806 c := &ProjectsLocationsBareMetalAdminClustersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5807 c.name = name
5808 return c
5809 }
5810
5811
5812
5813
5814
5815
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825
5826
5827
5828
5829
5830 func (c *ProjectsLocationsBareMetalAdminClustersGetCall) View(view string) *ProjectsLocationsBareMetalAdminClustersGetCall {
5831 c.urlParams_.Set("view", view)
5832 return c
5833 }
5834
5835
5836
5837
5838 func (c *ProjectsLocationsBareMetalAdminClustersGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersGetCall {
5839 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5840 return c
5841 }
5842
5843
5844
5845
5846 func (c *ProjectsLocationsBareMetalAdminClustersGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalAdminClustersGetCall {
5847 c.ifNoneMatch_ = entityTag
5848 return c
5849 }
5850
5851
5852 func (c *ProjectsLocationsBareMetalAdminClustersGetCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersGetCall {
5853 c.ctx_ = ctx
5854 return c
5855 }
5856
5857
5858
5859 func (c *ProjectsLocationsBareMetalAdminClustersGetCall) Header() http.Header {
5860 if c.header_ == nil {
5861 c.header_ = make(http.Header)
5862 }
5863 return c.header_
5864 }
5865
5866 func (c *ProjectsLocationsBareMetalAdminClustersGetCall) doRequest(alt string) (*http.Response, error) {
5867 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5868 if c.ifNoneMatch_ != "" {
5869 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5870 }
5871 var body io.Reader = nil
5872 c.urlParams_.Set("alt", alt)
5873 c.urlParams_.Set("prettyPrint", "false")
5874 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
5875 urls += "?" + c.urlParams_.Encode()
5876 req, err := http.NewRequest("GET", urls, body)
5877 if err != nil {
5878 return nil, err
5879 }
5880 req.Header = reqHeaders
5881 googleapi.Expand(req.URL, map[string]string{
5882 "name": c.name,
5883 })
5884 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5885 }
5886
5887
5888
5889
5890
5891
5892
5893 func (c *ProjectsLocationsBareMetalAdminClustersGetCall) Do(opts ...googleapi.CallOption) (*BareMetalAdminCluster, error) {
5894 gensupport.SetOptions(c.urlParams_, opts...)
5895 res, err := c.doRequest("json")
5896 if res != nil && res.StatusCode == http.StatusNotModified {
5897 if res.Body != nil {
5898 res.Body.Close()
5899 }
5900 return nil, gensupport.WrapError(&googleapi.Error{
5901 Code: res.StatusCode,
5902 Header: res.Header,
5903 })
5904 }
5905 if err != nil {
5906 return nil, err
5907 }
5908 defer googleapi.CloseBody(res)
5909 if err := googleapi.CheckResponse(res); err != nil {
5910 return nil, gensupport.WrapError(err)
5911 }
5912 ret := &BareMetalAdminCluster{
5913 ServerResponse: googleapi.ServerResponse{
5914 Header: res.Header,
5915 HTTPStatusCode: res.StatusCode,
5916 },
5917 }
5918 target := &ret
5919 if err := gensupport.DecodeResponse(target, res); err != nil {
5920 return nil, err
5921 }
5922 return ret, nil
5923 }
5924
5925 type ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall struct {
5926 s *Service
5927 resource string
5928 urlParams_ gensupport.URLParams
5929 ifNoneMatch_ string
5930 ctx_ context.Context
5931 header_ http.Header
5932 }
5933
5934
5935
5936
5937
5938
5939
5940 func (r *ProjectsLocationsBareMetalAdminClustersService) GetIamPolicy(resource string) *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall {
5941 c := &ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5942 c.resource = resource
5943 return c
5944 }
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956
5957
5958 func (c *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall {
5959 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
5960 return c
5961 }
5962
5963
5964
5965
5966 func (c *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall {
5967 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5968 return c
5969 }
5970
5971
5972
5973
5974 func (c *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall {
5975 c.ifNoneMatch_ = entityTag
5976 return c
5977 }
5978
5979
5980 func (c *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall {
5981 c.ctx_ = ctx
5982 return c
5983 }
5984
5985
5986
5987 func (c *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall) Header() http.Header {
5988 if c.header_ == nil {
5989 c.header_ = make(http.Header)
5990 }
5991 return c.header_
5992 }
5993
5994 func (c *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
5995 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5996 if c.ifNoneMatch_ != "" {
5997 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5998 }
5999 var body io.Reader = nil
6000 c.urlParams_.Set("alt", alt)
6001 c.urlParams_.Set("prettyPrint", "false")
6002 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
6003 urls += "?" + c.urlParams_.Encode()
6004 req, err := http.NewRequest("GET", urls, body)
6005 if err != nil {
6006 return nil, err
6007 }
6008 req.Header = reqHeaders
6009 googleapi.Expand(req.URL, map[string]string{
6010 "resource": c.resource,
6011 })
6012 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6013 }
6014
6015
6016
6017
6018
6019
6020 func (c *ProjectsLocationsBareMetalAdminClustersGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
6021 gensupport.SetOptions(c.urlParams_, opts...)
6022 res, err := c.doRequest("json")
6023 if res != nil && res.StatusCode == http.StatusNotModified {
6024 if res.Body != nil {
6025 res.Body.Close()
6026 }
6027 return nil, gensupport.WrapError(&googleapi.Error{
6028 Code: res.StatusCode,
6029 Header: res.Header,
6030 })
6031 }
6032 if err != nil {
6033 return nil, err
6034 }
6035 defer googleapi.CloseBody(res)
6036 if err := googleapi.CheckResponse(res); err != nil {
6037 return nil, gensupport.WrapError(err)
6038 }
6039 ret := &Policy{
6040 ServerResponse: googleapi.ServerResponse{
6041 Header: res.Header,
6042 HTTPStatusCode: res.StatusCode,
6043 },
6044 }
6045 target := &ret
6046 if err := gensupport.DecodeResponse(target, res); err != nil {
6047 return nil, err
6048 }
6049 return ret, nil
6050 }
6051
6052 type ProjectsLocationsBareMetalAdminClustersListCall struct {
6053 s *Service
6054 parent string
6055 urlParams_ gensupport.URLParams
6056 ifNoneMatch_ string
6057 ctx_ context.Context
6058 header_ http.Header
6059 }
6060
6061
6062
6063
6064
6065 func (r *ProjectsLocationsBareMetalAdminClustersService) List(parent string) *ProjectsLocationsBareMetalAdminClustersListCall {
6066 c := &ProjectsLocationsBareMetalAdminClustersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6067 c.parent = parent
6068 return c
6069 }
6070
6071
6072
6073
6074
6075 func (c *ProjectsLocationsBareMetalAdminClustersListCall) PageSize(pageSize int64) *ProjectsLocationsBareMetalAdminClustersListCall {
6076 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6077 return c
6078 }
6079
6080
6081
6082 func (c *ProjectsLocationsBareMetalAdminClustersListCall) PageToken(pageToken string) *ProjectsLocationsBareMetalAdminClustersListCall {
6083 c.urlParams_.Set("pageToken", pageToken)
6084 return c
6085 }
6086
6087
6088
6089
6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
6105
6106
6107 func (c *ProjectsLocationsBareMetalAdminClustersListCall) View(view string) *ProjectsLocationsBareMetalAdminClustersListCall {
6108 c.urlParams_.Set("view", view)
6109 return c
6110 }
6111
6112
6113
6114
6115 func (c *ProjectsLocationsBareMetalAdminClustersListCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersListCall {
6116 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6117 return c
6118 }
6119
6120
6121
6122
6123 func (c *ProjectsLocationsBareMetalAdminClustersListCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalAdminClustersListCall {
6124 c.ifNoneMatch_ = entityTag
6125 return c
6126 }
6127
6128
6129 func (c *ProjectsLocationsBareMetalAdminClustersListCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersListCall {
6130 c.ctx_ = ctx
6131 return c
6132 }
6133
6134
6135
6136 func (c *ProjectsLocationsBareMetalAdminClustersListCall) Header() http.Header {
6137 if c.header_ == nil {
6138 c.header_ = make(http.Header)
6139 }
6140 return c.header_
6141 }
6142
6143 func (c *ProjectsLocationsBareMetalAdminClustersListCall) doRequest(alt string) (*http.Response, error) {
6144 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6145 if c.ifNoneMatch_ != "" {
6146 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6147 }
6148 var body io.Reader = nil
6149 c.urlParams_.Set("alt", alt)
6150 c.urlParams_.Set("prettyPrint", "false")
6151 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalAdminClusters")
6152 urls += "?" + c.urlParams_.Encode()
6153 req, err := http.NewRequest("GET", urls, body)
6154 if err != nil {
6155 return nil, err
6156 }
6157 req.Header = reqHeaders
6158 googleapi.Expand(req.URL, map[string]string{
6159 "parent": c.parent,
6160 })
6161 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6162 }
6163
6164
6165
6166
6167
6168
6169
6170 func (c *ProjectsLocationsBareMetalAdminClustersListCall) Do(opts ...googleapi.CallOption) (*ListBareMetalAdminClustersResponse, error) {
6171 gensupport.SetOptions(c.urlParams_, opts...)
6172 res, err := c.doRequest("json")
6173 if res != nil && res.StatusCode == http.StatusNotModified {
6174 if res.Body != nil {
6175 res.Body.Close()
6176 }
6177 return nil, gensupport.WrapError(&googleapi.Error{
6178 Code: res.StatusCode,
6179 Header: res.Header,
6180 })
6181 }
6182 if err != nil {
6183 return nil, err
6184 }
6185 defer googleapi.CloseBody(res)
6186 if err := googleapi.CheckResponse(res); err != nil {
6187 return nil, gensupport.WrapError(err)
6188 }
6189 ret := &ListBareMetalAdminClustersResponse{
6190 ServerResponse: googleapi.ServerResponse{
6191 Header: res.Header,
6192 HTTPStatusCode: res.StatusCode,
6193 },
6194 }
6195 target := &ret
6196 if err := gensupport.DecodeResponse(target, res); err != nil {
6197 return nil, err
6198 }
6199 return ret, nil
6200 }
6201
6202
6203
6204
6205 func (c *ProjectsLocationsBareMetalAdminClustersListCall) Pages(ctx context.Context, f func(*ListBareMetalAdminClustersResponse) error) error {
6206 c.ctx_ = ctx
6207 defer c.PageToken(c.urlParams_.Get("pageToken"))
6208 for {
6209 x, err := c.Do()
6210 if err != nil {
6211 return err
6212 }
6213 if err := f(x); err != nil {
6214 return err
6215 }
6216 if x.NextPageToken == "" {
6217 return nil
6218 }
6219 c.PageToken(x.NextPageToken)
6220 }
6221 }
6222
6223 type ProjectsLocationsBareMetalAdminClustersPatchCall struct {
6224 s *Service
6225 name string
6226 baremetaladmincluster *BareMetalAdminCluster
6227 urlParams_ gensupport.URLParams
6228 ctx_ context.Context
6229 header_ http.Header
6230 }
6231
6232
6233
6234
6235 func (r *ProjectsLocationsBareMetalAdminClustersService) Patch(name string, baremetaladmincluster *BareMetalAdminCluster) *ProjectsLocationsBareMetalAdminClustersPatchCall {
6236 c := &ProjectsLocationsBareMetalAdminClustersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6237 c.name = name
6238 c.baremetaladmincluster = baremetaladmincluster
6239 return c
6240 }
6241
6242
6243
6244
6245
6246
6247
6248
6249 func (c *ProjectsLocationsBareMetalAdminClustersPatchCall) UpdateMask(updateMask string) *ProjectsLocationsBareMetalAdminClustersPatchCall {
6250 c.urlParams_.Set("updateMask", updateMask)
6251 return c
6252 }
6253
6254
6255
6256 func (c *ProjectsLocationsBareMetalAdminClustersPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalAdminClustersPatchCall {
6257 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
6258 return c
6259 }
6260
6261
6262
6263
6264 func (c *ProjectsLocationsBareMetalAdminClustersPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersPatchCall {
6265 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6266 return c
6267 }
6268
6269
6270 func (c *ProjectsLocationsBareMetalAdminClustersPatchCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersPatchCall {
6271 c.ctx_ = ctx
6272 return c
6273 }
6274
6275
6276
6277 func (c *ProjectsLocationsBareMetalAdminClustersPatchCall) Header() http.Header {
6278 if c.header_ == nil {
6279 c.header_ = make(http.Header)
6280 }
6281 return c.header_
6282 }
6283
6284 func (c *ProjectsLocationsBareMetalAdminClustersPatchCall) doRequest(alt string) (*http.Response, error) {
6285 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6286 var body io.Reader = nil
6287 body, err := googleapi.WithoutDataWrapper.JSONReader(c.baremetaladmincluster)
6288 if err != nil {
6289 return nil, err
6290 }
6291 c.urlParams_.Set("alt", alt)
6292 c.urlParams_.Set("prettyPrint", "false")
6293 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
6294 urls += "?" + c.urlParams_.Encode()
6295 req, err := http.NewRequest("PATCH", urls, body)
6296 if err != nil {
6297 return nil, err
6298 }
6299 req.Header = reqHeaders
6300 googleapi.Expand(req.URL, map[string]string{
6301 "name": c.name,
6302 })
6303 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6304 }
6305
6306
6307
6308
6309
6310
6311 func (c *ProjectsLocationsBareMetalAdminClustersPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
6312 gensupport.SetOptions(c.urlParams_, opts...)
6313 res, err := c.doRequest("json")
6314 if res != nil && res.StatusCode == http.StatusNotModified {
6315 if res.Body != nil {
6316 res.Body.Close()
6317 }
6318 return nil, gensupport.WrapError(&googleapi.Error{
6319 Code: res.StatusCode,
6320 Header: res.Header,
6321 })
6322 }
6323 if err != nil {
6324 return nil, err
6325 }
6326 defer googleapi.CloseBody(res)
6327 if err := googleapi.CheckResponse(res); err != nil {
6328 return nil, gensupport.WrapError(err)
6329 }
6330 ret := &Operation{
6331 ServerResponse: googleapi.ServerResponse{
6332 Header: res.Header,
6333 HTTPStatusCode: res.StatusCode,
6334 },
6335 }
6336 target := &ret
6337 if err := gensupport.DecodeResponse(target, res); err != nil {
6338 return nil, err
6339 }
6340 return ret, nil
6341 }
6342
6343 type ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall struct {
6344 s *Service
6345 parent string
6346 urlParams_ gensupport.URLParams
6347 ctx_ context.Context
6348 header_ http.Header
6349 }
6350
6351
6352
6353
6354
6355 func (r *ProjectsLocationsBareMetalAdminClustersService) QueryVersionConfig(parent string) *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall {
6356 c := &ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6357 c.parent = parent
6358 return c
6359 }
6360
6361
6362
6363
6364
6365
6366 func (c *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall) UpgradeConfigClusterName(upgradeConfigClusterName string) *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall {
6367 c.urlParams_.Set("upgradeConfig.clusterName", upgradeConfigClusterName)
6368 return c
6369 }
6370
6371
6372
6373
6374 func (c *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall {
6375 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6376 return c
6377 }
6378
6379
6380 func (c *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall {
6381 c.ctx_ = ctx
6382 return c
6383 }
6384
6385
6386
6387 func (c *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall) Header() http.Header {
6388 if c.header_ == nil {
6389 c.header_ = make(http.Header)
6390 }
6391 return c.header_
6392 }
6393
6394 func (c *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall) doRequest(alt string) (*http.Response, error) {
6395 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6396 var body io.Reader = nil
6397 c.urlParams_.Set("alt", alt)
6398 c.urlParams_.Set("prettyPrint", "false")
6399 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalAdminClusters:queryVersionConfig")
6400 urls += "?" + c.urlParams_.Encode()
6401 req, err := http.NewRequest("POST", urls, body)
6402 if err != nil {
6403 return nil, err
6404 }
6405 req.Header = reqHeaders
6406 googleapi.Expand(req.URL, map[string]string{
6407 "parent": c.parent,
6408 })
6409 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6410 }
6411
6412
6413
6414
6415
6416
6417
6418 func (c *ProjectsLocationsBareMetalAdminClustersQueryVersionConfigCall) Do(opts ...googleapi.CallOption) (*QueryBareMetalAdminVersionConfigResponse, error) {
6419 gensupport.SetOptions(c.urlParams_, opts...)
6420 res, err := c.doRequest("json")
6421 if res != nil && res.StatusCode == http.StatusNotModified {
6422 if res.Body != nil {
6423 res.Body.Close()
6424 }
6425 return nil, gensupport.WrapError(&googleapi.Error{
6426 Code: res.StatusCode,
6427 Header: res.Header,
6428 })
6429 }
6430 if err != nil {
6431 return nil, err
6432 }
6433 defer googleapi.CloseBody(res)
6434 if err := googleapi.CheckResponse(res); err != nil {
6435 return nil, gensupport.WrapError(err)
6436 }
6437 ret := &QueryBareMetalAdminVersionConfigResponse{
6438 ServerResponse: googleapi.ServerResponse{
6439 Header: res.Header,
6440 HTTPStatusCode: res.StatusCode,
6441 },
6442 }
6443 target := &ret
6444 if err := gensupport.DecodeResponse(target, res); err != nil {
6445 return nil, err
6446 }
6447 return ret, nil
6448 }
6449
6450 type ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall struct {
6451 s *Service
6452 resource string
6453 setiampolicyrequest *SetIamPolicyRequest
6454 urlParams_ gensupport.URLParams
6455 ctx_ context.Context
6456 header_ http.Header
6457 }
6458
6459
6460
6461
6462
6463
6464
6465
6466 func (r *ProjectsLocationsBareMetalAdminClustersService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall {
6467 c := &ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6468 c.resource = resource
6469 c.setiampolicyrequest = setiampolicyrequest
6470 return c
6471 }
6472
6473
6474
6475
6476 func (c *ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall {
6477 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6478 return c
6479 }
6480
6481
6482 func (c *ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall {
6483 c.ctx_ = ctx
6484 return c
6485 }
6486
6487
6488
6489 func (c *ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall) Header() http.Header {
6490 if c.header_ == nil {
6491 c.header_ = make(http.Header)
6492 }
6493 return c.header_
6494 }
6495
6496 func (c *ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
6497 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6498 var body io.Reader = nil
6499 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
6500 if err != nil {
6501 return nil, err
6502 }
6503 c.urlParams_.Set("alt", alt)
6504 c.urlParams_.Set("prettyPrint", "false")
6505 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
6506 urls += "?" + c.urlParams_.Encode()
6507 req, err := http.NewRequest("POST", urls, body)
6508 if err != nil {
6509 return nil, err
6510 }
6511 req.Header = reqHeaders
6512 googleapi.Expand(req.URL, map[string]string{
6513 "resource": c.resource,
6514 })
6515 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6516 }
6517
6518
6519
6520
6521
6522
6523 func (c *ProjectsLocationsBareMetalAdminClustersSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
6524 gensupport.SetOptions(c.urlParams_, opts...)
6525 res, err := c.doRequest("json")
6526 if res != nil && res.StatusCode == http.StatusNotModified {
6527 if res.Body != nil {
6528 res.Body.Close()
6529 }
6530 return nil, gensupport.WrapError(&googleapi.Error{
6531 Code: res.StatusCode,
6532 Header: res.Header,
6533 })
6534 }
6535 if err != nil {
6536 return nil, err
6537 }
6538 defer googleapi.CloseBody(res)
6539 if err := googleapi.CheckResponse(res); err != nil {
6540 return nil, gensupport.WrapError(err)
6541 }
6542 ret := &Policy{
6543 ServerResponse: googleapi.ServerResponse{
6544 Header: res.Header,
6545 HTTPStatusCode: res.StatusCode,
6546 },
6547 }
6548 target := &ret
6549 if err := gensupport.DecodeResponse(target, res); err != nil {
6550 return nil, err
6551 }
6552 return ret, nil
6553 }
6554
6555 type ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall struct {
6556 s *Service
6557 resource string
6558 testiampermissionsrequest *TestIamPermissionsRequest
6559 urlParams_ gensupport.URLParams
6560 ctx_ context.Context
6561 header_ http.Header
6562 }
6563
6564
6565
6566
6567
6568
6569
6570
6571
6572
6573
6574 func (r *ProjectsLocationsBareMetalAdminClustersService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall {
6575 c := &ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6576 c.resource = resource
6577 c.testiampermissionsrequest = testiampermissionsrequest
6578 return c
6579 }
6580
6581
6582
6583
6584 func (c *ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall {
6585 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6586 return c
6587 }
6588
6589
6590 func (c *ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall {
6591 c.ctx_ = ctx
6592 return c
6593 }
6594
6595
6596
6597 func (c *ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall) Header() http.Header {
6598 if c.header_ == nil {
6599 c.header_ = make(http.Header)
6600 }
6601 return c.header_
6602 }
6603
6604 func (c *ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
6605 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6606 var body io.Reader = nil
6607 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
6608 if err != nil {
6609 return nil, err
6610 }
6611 c.urlParams_.Set("alt", alt)
6612 c.urlParams_.Set("prettyPrint", "false")
6613 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
6614 urls += "?" + c.urlParams_.Encode()
6615 req, err := http.NewRequest("POST", urls, body)
6616 if err != nil {
6617 return nil, err
6618 }
6619 req.Header = reqHeaders
6620 googleapi.Expand(req.URL, map[string]string{
6621 "resource": c.resource,
6622 })
6623 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6624 }
6625
6626
6627
6628
6629
6630
6631
6632 func (c *ProjectsLocationsBareMetalAdminClustersTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, 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 := &TestIamPermissionsResponse{
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 ProjectsLocationsBareMetalAdminClustersUnenrollCall struct {
6665 s *Service
6666 name string
6667 urlParams_ gensupport.URLParams
6668 ctx_ context.Context
6669 header_ http.Header
6670 }
6671
6672
6673
6674
6675
6676
6677
6678
6679
6680 func (r *ProjectsLocationsBareMetalAdminClustersService) Unenroll(name string) *ProjectsLocationsBareMetalAdminClustersUnenrollCall {
6681 c := &ProjectsLocationsBareMetalAdminClustersUnenrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6682 c.name = name
6683 return c
6684 }
6685
6686
6687
6688
6689 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) AllowMissing(allowMissing bool) *ProjectsLocationsBareMetalAdminClustersUnenrollCall {
6690 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
6691 return c
6692 }
6693
6694
6695
6696
6697 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) Etag(etag string) *ProjectsLocationsBareMetalAdminClustersUnenrollCall {
6698 c.urlParams_.Set("etag", etag)
6699 return c
6700 }
6701
6702
6703
6704
6705
6706
6707
6708
6709 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) IgnoreErrors(ignoreErrors bool) *ProjectsLocationsBareMetalAdminClustersUnenrollCall {
6710 c.urlParams_.Set("ignoreErrors", fmt.Sprint(ignoreErrors))
6711 return c
6712 }
6713
6714
6715
6716 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalAdminClustersUnenrollCall {
6717 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
6718 return c
6719 }
6720
6721
6722
6723
6724 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersUnenrollCall {
6725 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6726 return c
6727 }
6728
6729
6730 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersUnenrollCall {
6731 c.ctx_ = ctx
6732 return c
6733 }
6734
6735
6736
6737 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) Header() http.Header {
6738 if c.header_ == nil {
6739 c.header_ = make(http.Header)
6740 }
6741 return c.header_
6742 }
6743
6744 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) doRequest(alt string) (*http.Response, error) {
6745 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6746 var body io.Reader = nil
6747 c.urlParams_.Set("alt", alt)
6748 c.urlParams_.Set("prettyPrint", "false")
6749 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:unenroll")
6750 urls += "?" + c.urlParams_.Encode()
6751 req, err := http.NewRequest("DELETE", urls, body)
6752 if err != nil {
6753 return nil, err
6754 }
6755 req.Header = reqHeaders
6756 googleapi.Expand(req.URL, map[string]string{
6757 "name": c.name,
6758 })
6759 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6760 }
6761
6762
6763
6764
6765
6766
6767 func (c *ProjectsLocationsBareMetalAdminClustersUnenrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
6768 gensupport.SetOptions(c.urlParams_, opts...)
6769 res, err := c.doRequest("json")
6770 if res != nil && res.StatusCode == http.StatusNotModified {
6771 if res.Body != nil {
6772 res.Body.Close()
6773 }
6774 return nil, gensupport.WrapError(&googleapi.Error{
6775 Code: res.StatusCode,
6776 Header: res.Header,
6777 })
6778 }
6779 if err != nil {
6780 return nil, err
6781 }
6782 defer googleapi.CloseBody(res)
6783 if err := googleapi.CheckResponse(res); err != nil {
6784 return nil, gensupport.WrapError(err)
6785 }
6786 ret := &Operation{
6787 ServerResponse: googleapi.ServerResponse{
6788 Header: res.Header,
6789 HTTPStatusCode: res.StatusCode,
6790 },
6791 }
6792 target := &ret
6793 if err := gensupport.DecodeResponse(target, res); err != nil {
6794 return nil, err
6795 }
6796 return ret, nil
6797 }
6798
6799 type ProjectsLocationsBareMetalAdminClustersOperationsGetCall struct {
6800 s *Service
6801 name string
6802 urlParams_ gensupport.URLParams
6803 ifNoneMatch_ string
6804 ctx_ context.Context
6805 header_ http.Header
6806 }
6807
6808
6809
6810
6811
6812
6813 func (r *ProjectsLocationsBareMetalAdminClustersOperationsService) Get(name string) *ProjectsLocationsBareMetalAdminClustersOperationsGetCall {
6814 c := &ProjectsLocationsBareMetalAdminClustersOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6815 c.name = name
6816 return c
6817 }
6818
6819
6820
6821
6822 func (c *ProjectsLocationsBareMetalAdminClustersOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersOperationsGetCall {
6823 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6824 return c
6825 }
6826
6827
6828
6829
6830 func (c *ProjectsLocationsBareMetalAdminClustersOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalAdminClustersOperationsGetCall {
6831 c.ifNoneMatch_ = entityTag
6832 return c
6833 }
6834
6835
6836 func (c *ProjectsLocationsBareMetalAdminClustersOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersOperationsGetCall {
6837 c.ctx_ = ctx
6838 return c
6839 }
6840
6841
6842
6843 func (c *ProjectsLocationsBareMetalAdminClustersOperationsGetCall) Header() http.Header {
6844 if c.header_ == nil {
6845 c.header_ = make(http.Header)
6846 }
6847 return c.header_
6848 }
6849
6850 func (c *ProjectsLocationsBareMetalAdminClustersOperationsGetCall) doRequest(alt string) (*http.Response, error) {
6851 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6852 if c.ifNoneMatch_ != "" {
6853 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6854 }
6855 var body io.Reader = nil
6856 c.urlParams_.Set("alt", alt)
6857 c.urlParams_.Set("prettyPrint", "false")
6858 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
6859 urls += "?" + c.urlParams_.Encode()
6860 req, err := http.NewRequest("GET", urls, body)
6861 if err != nil {
6862 return nil, err
6863 }
6864 req.Header = reqHeaders
6865 googleapi.Expand(req.URL, map[string]string{
6866 "name": c.name,
6867 })
6868 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6869 }
6870
6871
6872
6873
6874
6875
6876 func (c *ProjectsLocationsBareMetalAdminClustersOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
6877 gensupport.SetOptions(c.urlParams_, opts...)
6878 res, err := c.doRequest("json")
6879 if res != nil && res.StatusCode == http.StatusNotModified {
6880 if res.Body != nil {
6881 res.Body.Close()
6882 }
6883 return nil, gensupport.WrapError(&googleapi.Error{
6884 Code: res.StatusCode,
6885 Header: res.Header,
6886 })
6887 }
6888 if err != nil {
6889 return nil, err
6890 }
6891 defer googleapi.CloseBody(res)
6892 if err := googleapi.CheckResponse(res); err != nil {
6893 return nil, gensupport.WrapError(err)
6894 }
6895 ret := &Operation{
6896 ServerResponse: googleapi.ServerResponse{
6897 Header: res.Header,
6898 HTTPStatusCode: res.StatusCode,
6899 },
6900 }
6901 target := &ret
6902 if err := gensupport.DecodeResponse(target, res); err != nil {
6903 return nil, err
6904 }
6905 return ret, nil
6906 }
6907
6908 type ProjectsLocationsBareMetalAdminClustersOperationsListCall struct {
6909 s *Service
6910 name string
6911 urlParams_ gensupport.URLParams
6912 ifNoneMatch_ string
6913 ctx_ context.Context
6914 header_ http.Header
6915 }
6916
6917
6918
6919
6920
6921 func (r *ProjectsLocationsBareMetalAdminClustersOperationsService) List(name string) *ProjectsLocationsBareMetalAdminClustersOperationsListCall {
6922 c := &ProjectsLocationsBareMetalAdminClustersOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6923 c.name = name
6924 return c
6925 }
6926
6927
6928 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) Filter(filter string) *ProjectsLocationsBareMetalAdminClustersOperationsListCall {
6929 c.urlParams_.Set("filter", filter)
6930 return c
6931 }
6932
6933
6934
6935 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsBareMetalAdminClustersOperationsListCall {
6936 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6937 return c
6938 }
6939
6940
6941
6942 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) PageToken(pageToken string) *ProjectsLocationsBareMetalAdminClustersOperationsListCall {
6943 c.urlParams_.Set("pageToken", pageToken)
6944 return c
6945 }
6946
6947
6948
6949
6950 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalAdminClustersOperationsListCall {
6951 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6952 return c
6953 }
6954
6955
6956
6957
6958 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalAdminClustersOperationsListCall {
6959 c.ifNoneMatch_ = entityTag
6960 return c
6961 }
6962
6963
6964 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) Context(ctx context.Context) *ProjectsLocationsBareMetalAdminClustersOperationsListCall {
6965 c.ctx_ = ctx
6966 return c
6967 }
6968
6969
6970
6971 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) Header() http.Header {
6972 if c.header_ == nil {
6973 c.header_ = make(http.Header)
6974 }
6975 return c.header_
6976 }
6977
6978 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) doRequest(alt string) (*http.Response, error) {
6979 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6980 if c.ifNoneMatch_ != "" {
6981 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6982 }
6983 var body io.Reader = nil
6984 c.urlParams_.Set("alt", alt)
6985 c.urlParams_.Set("prettyPrint", "false")
6986 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
6987 urls += "?" + c.urlParams_.Encode()
6988 req, err := http.NewRequest("GET", urls, body)
6989 if err != nil {
6990 return nil, err
6991 }
6992 req.Header = reqHeaders
6993 googleapi.Expand(req.URL, map[string]string{
6994 "name": c.name,
6995 })
6996 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6997 }
6998
6999
7000
7001
7002
7003
7004
7005 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
7006 gensupport.SetOptions(c.urlParams_, opts...)
7007 res, err := c.doRequest("json")
7008 if res != nil && res.StatusCode == http.StatusNotModified {
7009 if res.Body != nil {
7010 res.Body.Close()
7011 }
7012 return nil, gensupport.WrapError(&googleapi.Error{
7013 Code: res.StatusCode,
7014 Header: res.Header,
7015 })
7016 }
7017 if err != nil {
7018 return nil, err
7019 }
7020 defer googleapi.CloseBody(res)
7021 if err := googleapi.CheckResponse(res); err != nil {
7022 return nil, gensupport.WrapError(err)
7023 }
7024 ret := &ListOperationsResponse{
7025 ServerResponse: googleapi.ServerResponse{
7026 Header: res.Header,
7027 HTTPStatusCode: res.StatusCode,
7028 },
7029 }
7030 target := &ret
7031 if err := gensupport.DecodeResponse(target, res); err != nil {
7032 return nil, err
7033 }
7034 return ret, nil
7035 }
7036
7037
7038
7039
7040 func (c *ProjectsLocationsBareMetalAdminClustersOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
7041 c.ctx_ = ctx
7042 defer c.PageToken(c.urlParams_.Get("pageToken"))
7043 for {
7044 x, err := c.Do()
7045 if err != nil {
7046 return err
7047 }
7048 if err := f(x); err != nil {
7049 return err
7050 }
7051 if x.NextPageToken == "" {
7052 return nil
7053 }
7054 c.PageToken(x.NextPageToken)
7055 }
7056 }
7057
7058 type ProjectsLocationsBareMetalClustersCreateCall struct {
7059 s *Service
7060 parent string
7061 baremetalcluster *BareMetalCluster
7062 urlParams_ gensupport.URLParams
7063 ctx_ context.Context
7064 header_ http.Header
7065 }
7066
7067
7068
7069
7070
7071 func (r *ProjectsLocationsBareMetalClustersService) Create(parent string, baremetalcluster *BareMetalCluster) *ProjectsLocationsBareMetalClustersCreateCall {
7072 c := &ProjectsLocationsBareMetalClustersCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7073 c.parent = parent
7074 c.baremetalcluster = baremetalcluster
7075 return c
7076 }
7077
7078
7079
7080
7081
7082 func (c *ProjectsLocationsBareMetalClustersCreateCall) BareMetalClusterId(bareMetalClusterId string) *ProjectsLocationsBareMetalClustersCreateCall {
7083 c.urlParams_.Set("bareMetalClusterId", bareMetalClusterId)
7084 return c
7085 }
7086
7087
7088
7089 func (c *ProjectsLocationsBareMetalClustersCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalClustersCreateCall {
7090 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
7091 return c
7092 }
7093
7094
7095
7096
7097 func (c *ProjectsLocationsBareMetalClustersCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersCreateCall {
7098 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7099 return c
7100 }
7101
7102
7103 func (c *ProjectsLocationsBareMetalClustersCreateCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersCreateCall {
7104 c.ctx_ = ctx
7105 return c
7106 }
7107
7108
7109
7110 func (c *ProjectsLocationsBareMetalClustersCreateCall) Header() http.Header {
7111 if c.header_ == nil {
7112 c.header_ = make(http.Header)
7113 }
7114 return c.header_
7115 }
7116
7117 func (c *ProjectsLocationsBareMetalClustersCreateCall) doRequest(alt string) (*http.Response, error) {
7118 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7119 var body io.Reader = nil
7120 body, err := googleapi.WithoutDataWrapper.JSONReader(c.baremetalcluster)
7121 if err != nil {
7122 return nil, err
7123 }
7124 c.urlParams_.Set("alt", alt)
7125 c.urlParams_.Set("prettyPrint", "false")
7126 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalClusters")
7127 urls += "?" + c.urlParams_.Encode()
7128 req, err := http.NewRequest("POST", urls, body)
7129 if err != nil {
7130 return nil, err
7131 }
7132 req.Header = reqHeaders
7133 googleapi.Expand(req.URL, map[string]string{
7134 "parent": c.parent,
7135 })
7136 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7137 }
7138
7139
7140
7141
7142
7143
7144 func (c *ProjectsLocationsBareMetalClustersCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
7145 gensupport.SetOptions(c.urlParams_, opts...)
7146 res, err := c.doRequest("json")
7147 if res != nil && res.StatusCode == http.StatusNotModified {
7148 if res.Body != nil {
7149 res.Body.Close()
7150 }
7151 return nil, gensupport.WrapError(&googleapi.Error{
7152 Code: res.StatusCode,
7153 Header: res.Header,
7154 })
7155 }
7156 if err != nil {
7157 return nil, err
7158 }
7159 defer googleapi.CloseBody(res)
7160 if err := googleapi.CheckResponse(res); err != nil {
7161 return nil, gensupport.WrapError(err)
7162 }
7163 ret := &Operation{
7164 ServerResponse: googleapi.ServerResponse{
7165 Header: res.Header,
7166 HTTPStatusCode: res.StatusCode,
7167 },
7168 }
7169 target := &ret
7170 if err := gensupport.DecodeResponse(target, res); err != nil {
7171 return nil, err
7172 }
7173 return ret, nil
7174 }
7175
7176 type ProjectsLocationsBareMetalClustersDeleteCall struct {
7177 s *Service
7178 name string
7179 urlParams_ gensupport.URLParams
7180 ctx_ context.Context
7181 header_ http.Header
7182 }
7183
7184
7185
7186
7187
7188
7189 func (r *ProjectsLocationsBareMetalClustersService) Delete(name string) *ProjectsLocationsBareMetalClustersDeleteCall {
7190 c := &ProjectsLocationsBareMetalClustersDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7191 c.name = name
7192 return c
7193 }
7194
7195
7196
7197
7198 func (c *ProjectsLocationsBareMetalClustersDeleteCall) AllowMissing(allowMissing bool) *ProjectsLocationsBareMetalClustersDeleteCall {
7199 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
7200 return c
7201 }
7202
7203
7204
7205
7206 func (c *ProjectsLocationsBareMetalClustersDeleteCall) Etag(etag string) *ProjectsLocationsBareMetalClustersDeleteCall {
7207 c.urlParams_.Set("etag", etag)
7208 return c
7209 }
7210
7211
7212
7213 func (c *ProjectsLocationsBareMetalClustersDeleteCall) Force(force bool) *ProjectsLocationsBareMetalClustersDeleteCall {
7214 c.urlParams_.Set("force", fmt.Sprint(force))
7215 return c
7216 }
7217
7218
7219
7220
7221
7222
7223
7224
7225 func (c *ProjectsLocationsBareMetalClustersDeleteCall) IgnoreErrors(ignoreErrors bool) *ProjectsLocationsBareMetalClustersDeleteCall {
7226 c.urlParams_.Set("ignoreErrors", fmt.Sprint(ignoreErrors))
7227 return c
7228 }
7229
7230
7231
7232 func (c *ProjectsLocationsBareMetalClustersDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalClustersDeleteCall {
7233 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
7234 return c
7235 }
7236
7237
7238
7239
7240 func (c *ProjectsLocationsBareMetalClustersDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersDeleteCall {
7241 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7242 return c
7243 }
7244
7245
7246 func (c *ProjectsLocationsBareMetalClustersDeleteCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersDeleteCall {
7247 c.ctx_ = ctx
7248 return c
7249 }
7250
7251
7252
7253 func (c *ProjectsLocationsBareMetalClustersDeleteCall) Header() http.Header {
7254 if c.header_ == nil {
7255 c.header_ = make(http.Header)
7256 }
7257 return c.header_
7258 }
7259
7260 func (c *ProjectsLocationsBareMetalClustersDeleteCall) doRequest(alt string) (*http.Response, error) {
7261 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7262 var body io.Reader = nil
7263 c.urlParams_.Set("alt", alt)
7264 c.urlParams_.Set("prettyPrint", "false")
7265 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
7266 urls += "?" + c.urlParams_.Encode()
7267 req, err := http.NewRequest("DELETE", urls, body)
7268 if err != nil {
7269 return nil, err
7270 }
7271 req.Header = reqHeaders
7272 googleapi.Expand(req.URL, map[string]string{
7273 "name": c.name,
7274 })
7275 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7276 }
7277
7278
7279
7280
7281
7282
7283 func (c *ProjectsLocationsBareMetalClustersDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, 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 := &Operation{
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 ProjectsLocationsBareMetalClustersEnrollCall struct {
7316 s *Service
7317 parent string
7318 enrollbaremetalclusterrequest *EnrollBareMetalClusterRequest
7319 urlParams_ gensupport.URLParams
7320 ctx_ context.Context
7321 header_ http.Header
7322 }
7323
7324
7325
7326
7327
7328
7329
7330
7331
7332
7333 func (r *ProjectsLocationsBareMetalClustersService) Enroll(parent string, enrollbaremetalclusterrequest *EnrollBareMetalClusterRequest) *ProjectsLocationsBareMetalClustersEnrollCall {
7334 c := &ProjectsLocationsBareMetalClustersEnrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7335 c.parent = parent
7336 c.enrollbaremetalclusterrequest = enrollbaremetalclusterrequest
7337 return c
7338 }
7339
7340
7341
7342
7343 func (c *ProjectsLocationsBareMetalClustersEnrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersEnrollCall {
7344 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7345 return c
7346 }
7347
7348
7349 func (c *ProjectsLocationsBareMetalClustersEnrollCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersEnrollCall {
7350 c.ctx_ = ctx
7351 return c
7352 }
7353
7354
7355
7356 func (c *ProjectsLocationsBareMetalClustersEnrollCall) Header() http.Header {
7357 if c.header_ == nil {
7358 c.header_ = make(http.Header)
7359 }
7360 return c.header_
7361 }
7362
7363 func (c *ProjectsLocationsBareMetalClustersEnrollCall) doRequest(alt string) (*http.Response, error) {
7364 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7365 var body io.Reader = nil
7366 body, err := googleapi.WithoutDataWrapper.JSONReader(c.enrollbaremetalclusterrequest)
7367 if err != nil {
7368 return nil, err
7369 }
7370 c.urlParams_.Set("alt", alt)
7371 c.urlParams_.Set("prettyPrint", "false")
7372 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalClusters:enroll")
7373 urls += "?" + c.urlParams_.Encode()
7374 req, err := http.NewRequest("POST", urls, body)
7375 if err != nil {
7376 return nil, err
7377 }
7378 req.Header = reqHeaders
7379 googleapi.Expand(req.URL, map[string]string{
7380 "parent": c.parent,
7381 })
7382 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7383 }
7384
7385
7386
7387
7388
7389
7390 func (c *ProjectsLocationsBareMetalClustersEnrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
7391 gensupport.SetOptions(c.urlParams_, opts...)
7392 res, err := c.doRequest("json")
7393 if res != nil && res.StatusCode == http.StatusNotModified {
7394 if res.Body != nil {
7395 res.Body.Close()
7396 }
7397 return nil, gensupport.WrapError(&googleapi.Error{
7398 Code: res.StatusCode,
7399 Header: res.Header,
7400 })
7401 }
7402 if err != nil {
7403 return nil, err
7404 }
7405 defer googleapi.CloseBody(res)
7406 if err := googleapi.CheckResponse(res); err != nil {
7407 return nil, gensupport.WrapError(err)
7408 }
7409 ret := &Operation{
7410 ServerResponse: googleapi.ServerResponse{
7411 Header: res.Header,
7412 HTTPStatusCode: res.StatusCode,
7413 },
7414 }
7415 target := &ret
7416 if err := gensupport.DecodeResponse(target, res); err != nil {
7417 return nil, err
7418 }
7419 return ret, nil
7420 }
7421
7422 type ProjectsLocationsBareMetalClustersGetCall struct {
7423 s *Service
7424 name string
7425 urlParams_ gensupport.URLParams
7426 ifNoneMatch_ string
7427 ctx_ context.Context
7428 header_ http.Header
7429 }
7430
7431
7432
7433
7434
7435
7436 func (r *ProjectsLocationsBareMetalClustersService) Get(name string) *ProjectsLocationsBareMetalClustersGetCall {
7437 c := &ProjectsLocationsBareMetalClustersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7438 c.name = name
7439 return c
7440 }
7441
7442
7443
7444
7445
7446
7447
7448
7449
7450
7451
7452
7453
7454
7455
7456
7457
7458
7459
7460
7461 func (c *ProjectsLocationsBareMetalClustersGetCall) View(view string) *ProjectsLocationsBareMetalClustersGetCall {
7462 c.urlParams_.Set("view", view)
7463 return c
7464 }
7465
7466
7467
7468
7469 func (c *ProjectsLocationsBareMetalClustersGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersGetCall {
7470 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7471 return c
7472 }
7473
7474
7475
7476
7477 func (c *ProjectsLocationsBareMetalClustersGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersGetCall {
7478 c.ifNoneMatch_ = entityTag
7479 return c
7480 }
7481
7482
7483 func (c *ProjectsLocationsBareMetalClustersGetCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersGetCall {
7484 c.ctx_ = ctx
7485 return c
7486 }
7487
7488
7489
7490 func (c *ProjectsLocationsBareMetalClustersGetCall) Header() http.Header {
7491 if c.header_ == nil {
7492 c.header_ = make(http.Header)
7493 }
7494 return c.header_
7495 }
7496
7497 func (c *ProjectsLocationsBareMetalClustersGetCall) doRequest(alt string) (*http.Response, error) {
7498 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7499 if c.ifNoneMatch_ != "" {
7500 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7501 }
7502 var body io.Reader = nil
7503 c.urlParams_.Set("alt", alt)
7504 c.urlParams_.Set("prettyPrint", "false")
7505 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
7506 urls += "?" + c.urlParams_.Encode()
7507 req, err := http.NewRequest("GET", urls, body)
7508 if err != nil {
7509 return nil, err
7510 }
7511 req.Header = reqHeaders
7512 googleapi.Expand(req.URL, map[string]string{
7513 "name": c.name,
7514 })
7515 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7516 }
7517
7518
7519
7520
7521
7522
7523
7524 func (c *ProjectsLocationsBareMetalClustersGetCall) Do(opts ...googleapi.CallOption) (*BareMetalCluster, error) {
7525 gensupport.SetOptions(c.urlParams_, opts...)
7526 res, err := c.doRequest("json")
7527 if res != nil && res.StatusCode == http.StatusNotModified {
7528 if res.Body != nil {
7529 res.Body.Close()
7530 }
7531 return nil, gensupport.WrapError(&googleapi.Error{
7532 Code: res.StatusCode,
7533 Header: res.Header,
7534 })
7535 }
7536 if err != nil {
7537 return nil, err
7538 }
7539 defer googleapi.CloseBody(res)
7540 if err := googleapi.CheckResponse(res); err != nil {
7541 return nil, gensupport.WrapError(err)
7542 }
7543 ret := &BareMetalCluster{
7544 ServerResponse: googleapi.ServerResponse{
7545 Header: res.Header,
7546 HTTPStatusCode: res.StatusCode,
7547 },
7548 }
7549 target := &ret
7550 if err := gensupport.DecodeResponse(target, res); err != nil {
7551 return nil, err
7552 }
7553 return ret, nil
7554 }
7555
7556 type ProjectsLocationsBareMetalClustersGetIamPolicyCall struct {
7557 s *Service
7558 resource string
7559 urlParams_ gensupport.URLParams
7560 ifNoneMatch_ string
7561 ctx_ context.Context
7562 header_ http.Header
7563 }
7564
7565
7566
7567
7568
7569
7570
7571 func (r *ProjectsLocationsBareMetalClustersService) GetIamPolicy(resource string) *ProjectsLocationsBareMetalClustersGetIamPolicyCall {
7572 c := &ProjectsLocationsBareMetalClustersGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7573 c.resource = resource
7574 return c
7575 }
7576
7577
7578
7579
7580
7581
7582
7583
7584
7585
7586
7587
7588
7589 func (c *ProjectsLocationsBareMetalClustersGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsBareMetalClustersGetIamPolicyCall {
7590 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
7591 return c
7592 }
7593
7594
7595
7596
7597 func (c *ProjectsLocationsBareMetalClustersGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersGetIamPolicyCall {
7598 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7599 return c
7600 }
7601
7602
7603
7604
7605 func (c *ProjectsLocationsBareMetalClustersGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersGetIamPolicyCall {
7606 c.ifNoneMatch_ = entityTag
7607 return c
7608 }
7609
7610
7611 func (c *ProjectsLocationsBareMetalClustersGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersGetIamPolicyCall {
7612 c.ctx_ = ctx
7613 return c
7614 }
7615
7616
7617
7618 func (c *ProjectsLocationsBareMetalClustersGetIamPolicyCall) Header() http.Header {
7619 if c.header_ == nil {
7620 c.header_ = make(http.Header)
7621 }
7622 return c.header_
7623 }
7624
7625 func (c *ProjectsLocationsBareMetalClustersGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
7626 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7627 if c.ifNoneMatch_ != "" {
7628 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7629 }
7630 var body io.Reader = nil
7631 c.urlParams_.Set("alt", alt)
7632 c.urlParams_.Set("prettyPrint", "false")
7633 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
7634 urls += "?" + c.urlParams_.Encode()
7635 req, err := http.NewRequest("GET", urls, body)
7636 if err != nil {
7637 return nil, err
7638 }
7639 req.Header = reqHeaders
7640 googleapi.Expand(req.URL, map[string]string{
7641 "resource": c.resource,
7642 })
7643 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7644 }
7645
7646
7647
7648
7649
7650
7651 func (c *ProjectsLocationsBareMetalClustersGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
7652 gensupport.SetOptions(c.urlParams_, opts...)
7653 res, err := c.doRequest("json")
7654 if res != nil && res.StatusCode == http.StatusNotModified {
7655 if res.Body != nil {
7656 res.Body.Close()
7657 }
7658 return nil, gensupport.WrapError(&googleapi.Error{
7659 Code: res.StatusCode,
7660 Header: res.Header,
7661 })
7662 }
7663 if err != nil {
7664 return nil, err
7665 }
7666 defer googleapi.CloseBody(res)
7667 if err := googleapi.CheckResponse(res); err != nil {
7668 return nil, gensupport.WrapError(err)
7669 }
7670 ret := &Policy{
7671 ServerResponse: googleapi.ServerResponse{
7672 Header: res.Header,
7673 HTTPStatusCode: res.StatusCode,
7674 },
7675 }
7676 target := &ret
7677 if err := gensupport.DecodeResponse(target, res); err != nil {
7678 return nil, err
7679 }
7680 return ret, nil
7681 }
7682
7683 type ProjectsLocationsBareMetalClustersListCall struct {
7684 s *Service
7685 parent string
7686 urlParams_ gensupport.URLParams
7687 ifNoneMatch_ string
7688 ctx_ context.Context
7689 header_ http.Header
7690 }
7691
7692
7693
7694
7695
7696 func (r *ProjectsLocationsBareMetalClustersService) List(parent string) *ProjectsLocationsBareMetalClustersListCall {
7697 c := &ProjectsLocationsBareMetalClustersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7698 c.parent = parent
7699 return c
7700 }
7701
7702
7703
7704
7705 func (c *ProjectsLocationsBareMetalClustersListCall) Filter(filter string) *ProjectsLocationsBareMetalClustersListCall {
7706 c.urlParams_.Set("filter", filter)
7707 return c
7708 }
7709
7710
7711
7712
7713
7714 func (c *ProjectsLocationsBareMetalClustersListCall) PageSize(pageSize int64) *ProjectsLocationsBareMetalClustersListCall {
7715 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
7716 return c
7717 }
7718
7719
7720
7721 func (c *ProjectsLocationsBareMetalClustersListCall) PageToken(pageToken string) *ProjectsLocationsBareMetalClustersListCall {
7722 c.urlParams_.Set("pageToken", pageToken)
7723 return c
7724 }
7725
7726
7727
7728
7729
7730
7731
7732
7733
7734
7735
7736
7737
7738
7739
7740
7741
7742
7743
7744
7745 func (c *ProjectsLocationsBareMetalClustersListCall) View(view string) *ProjectsLocationsBareMetalClustersListCall {
7746 c.urlParams_.Set("view", view)
7747 return c
7748 }
7749
7750
7751
7752
7753 func (c *ProjectsLocationsBareMetalClustersListCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersListCall {
7754 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7755 return c
7756 }
7757
7758
7759
7760
7761 func (c *ProjectsLocationsBareMetalClustersListCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersListCall {
7762 c.ifNoneMatch_ = entityTag
7763 return c
7764 }
7765
7766
7767 func (c *ProjectsLocationsBareMetalClustersListCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersListCall {
7768 c.ctx_ = ctx
7769 return c
7770 }
7771
7772
7773
7774 func (c *ProjectsLocationsBareMetalClustersListCall) Header() http.Header {
7775 if c.header_ == nil {
7776 c.header_ = make(http.Header)
7777 }
7778 return c.header_
7779 }
7780
7781 func (c *ProjectsLocationsBareMetalClustersListCall) doRequest(alt string) (*http.Response, error) {
7782 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7783 if c.ifNoneMatch_ != "" {
7784 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7785 }
7786 var body io.Reader = nil
7787 c.urlParams_.Set("alt", alt)
7788 c.urlParams_.Set("prettyPrint", "false")
7789 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalClusters")
7790 urls += "?" + c.urlParams_.Encode()
7791 req, err := http.NewRequest("GET", urls, body)
7792 if err != nil {
7793 return nil, err
7794 }
7795 req.Header = reqHeaders
7796 googleapi.Expand(req.URL, map[string]string{
7797 "parent": c.parent,
7798 })
7799 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7800 }
7801
7802
7803
7804
7805
7806
7807
7808 func (c *ProjectsLocationsBareMetalClustersListCall) Do(opts ...googleapi.CallOption) (*ListBareMetalClustersResponse, error) {
7809 gensupport.SetOptions(c.urlParams_, opts...)
7810 res, err := c.doRequest("json")
7811 if res != nil && res.StatusCode == http.StatusNotModified {
7812 if res.Body != nil {
7813 res.Body.Close()
7814 }
7815 return nil, gensupport.WrapError(&googleapi.Error{
7816 Code: res.StatusCode,
7817 Header: res.Header,
7818 })
7819 }
7820 if err != nil {
7821 return nil, err
7822 }
7823 defer googleapi.CloseBody(res)
7824 if err := googleapi.CheckResponse(res); err != nil {
7825 return nil, gensupport.WrapError(err)
7826 }
7827 ret := &ListBareMetalClustersResponse{
7828 ServerResponse: googleapi.ServerResponse{
7829 Header: res.Header,
7830 HTTPStatusCode: res.StatusCode,
7831 },
7832 }
7833 target := &ret
7834 if err := gensupport.DecodeResponse(target, res); err != nil {
7835 return nil, err
7836 }
7837 return ret, nil
7838 }
7839
7840
7841
7842
7843 func (c *ProjectsLocationsBareMetalClustersListCall) Pages(ctx context.Context, f func(*ListBareMetalClustersResponse) error) error {
7844 c.ctx_ = ctx
7845 defer c.PageToken(c.urlParams_.Get("pageToken"))
7846 for {
7847 x, err := c.Do()
7848 if err != nil {
7849 return err
7850 }
7851 if err := f(x); err != nil {
7852 return err
7853 }
7854 if x.NextPageToken == "" {
7855 return nil
7856 }
7857 c.PageToken(x.NextPageToken)
7858 }
7859 }
7860
7861 type ProjectsLocationsBareMetalClustersPatchCall struct {
7862 s *Service
7863 name string
7864 baremetalcluster *BareMetalCluster
7865 urlParams_ gensupport.URLParams
7866 ctx_ context.Context
7867 header_ http.Header
7868 }
7869
7870
7871
7872
7873 func (r *ProjectsLocationsBareMetalClustersService) Patch(name string, baremetalcluster *BareMetalCluster) *ProjectsLocationsBareMetalClustersPatchCall {
7874 c := &ProjectsLocationsBareMetalClustersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7875 c.name = name
7876 c.baremetalcluster = baremetalcluster
7877 return c
7878 }
7879
7880
7881
7882
7883
7884 func (c *ProjectsLocationsBareMetalClustersPatchCall) AllowMissing(allowMissing bool) *ProjectsLocationsBareMetalClustersPatchCall {
7885 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
7886 return c
7887 }
7888
7889
7890
7891
7892
7893
7894
7895
7896 func (c *ProjectsLocationsBareMetalClustersPatchCall) UpdateMask(updateMask string) *ProjectsLocationsBareMetalClustersPatchCall {
7897 c.urlParams_.Set("updateMask", updateMask)
7898 return c
7899 }
7900
7901
7902
7903 func (c *ProjectsLocationsBareMetalClustersPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalClustersPatchCall {
7904 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
7905 return c
7906 }
7907
7908
7909
7910
7911 func (c *ProjectsLocationsBareMetalClustersPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersPatchCall {
7912 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7913 return c
7914 }
7915
7916
7917 func (c *ProjectsLocationsBareMetalClustersPatchCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersPatchCall {
7918 c.ctx_ = ctx
7919 return c
7920 }
7921
7922
7923
7924 func (c *ProjectsLocationsBareMetalClustersPatchCall) Header() http.Header {
7925 if c.header_ == nil {
7926 c.header_ = make(http.Header)
7927 }
7928 return c.header_
7929 }
7930
7931 func (c *ProjectsLocationsBareMetalClustersPatchCall) doRequest(alt string) (*http.Response, error) {
7932 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7933 var body io.Reader = nil
7934 body, err := googleapi.WithoutDataWrapper.JSONReader(c.baremetalcluster)
7935 if err != nil {
7936 return nil, err
7937 }
7938 c.urlParams_.Set("alt", alt)
7939 c.urlParams_.Set("prettyPrint", "false")
7940 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
7941 urls += "?" + c.urlParams_.Encode()
7942 req, err := http.NewRequest("PATCH", urls, body)
7943 if err != nil {
7944 return nil, err
7945 }
7946 req.Header = reqHeaders
7947 googleapi.Expand(req.URL, map[string]string{
7948 "name": c.name,
7949 })
7950 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7951 }
7952
7953
7954
7955
7956
7957
7958 func (c *ProjectsLocationsBareMetalClustersPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
7959 gensupport.SetOptions(c.urlParams_, opts...)
7960 res, err := c.doRequest("json")
7961 if res != nil && res.StatusCode == http.StatusNotModified {
7962 if res.Body != nil {
7963 res.Body.Close()
7964 }
7965 return nil, gensupport.WrapError(&googleapi.Error{
7966 Code: res.StatusCode,
7967 Header: res.Header,
7968 })
7969 }
7970 if err != nil {
7971 return nil, err
7972 }
7973 defer googleapi.CloseBody(res)
7974 if err := googleapi.CheckResponse(res); err != nil {
7975 return nil, gensupport.WrapError(err)
7976 }
7977 ret := &Operation{
7978 ServerResponse: googleapi.ServerResponse{
7979 Header: res.Header,
7980 HTTPStatusCode: res.StatusCode,
7981 },
7982 }
7983 target := &ret
7984 if err := gensupport.DecodeResponse(target, res); err != nil {
7985 return nil, err
7986 }
7987 return ret, nil
7988 }
7989
7990 type ProjectsLocationsBareMetalClustersQueryVersionConfigCall struct {
7991 s *Service
7992 parent string
7993 urlParams_ gensupport.URLParams
7994 ctx_ context.Context
7995 header_ http.Header
7996 }
7997
7998
7999
8000
8001
8002 func (r *ProjectsLocationsBareMetalClustersService) QueryVersionConfig(parent string) *ProjectsLocationsBareMetalClustersQueryVersionConfigCall {
8003 c := &ProjectsLocationsBareMetalClustersQueryVersionConfigCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8004 c.parent = parent
8005 return c
8006 }
8007
8008
8009
8010
8011
8012 func (c *ProjectsLocationsBareMetalClustersQueryVersionConfigCall) CreateConfigAdminClusterMembership(createConfigAdminClusterMembership string) *ProjectsLocationsBareMetalClustersQueryVersionConfigCall {
8013 c.urlParams_.Set("createConfig.adminClusterMembership", createConfigAdminClusterMembership)
8014 return c
8015 }
8016
8017
8018
8019
8020
8021
8022 func (c *ProjectsLocationsBareMetalClustersQueryVersionConfigCall) CreateConfigAdminClusterName(createConfigAdminClusterName string) *ProjectsLocationsBareMetalClustersQueryVersionConfigCall {
8023 c.urlParams_.Set("createConfig.adminClusterName", createConfigAdminClusterName)
8024 return c
8025 }
8026
8027
8028
8029
8030
8031
8032 func (c *ProjectsLocationsBareMetalClustersQueryVersionConfigCall) UpgradeConfigClusterName(upgradeConfigClusterName string) *ProjectsLocationsBareMetalClustersQueryVersionConfigCall {
8033 c.urlParams_.Set("upgradeConfig.clusterName", upgradeConfigClusterName)
8034 return c
8035 }
8036
8037
8038
8039
8040 func (c *ProjectsLocationsBareMetalClustersQueryVersionConfigCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersQueryVersionConfigCall {
8041 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8042 return c
8043 }
8044
8045
8046 func (c *ProjectsLocationsBareMetalClustersQueryVersionConfigCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersQueryVersionConfigCall {
8047 c.ctx_ = ctx
8048 return c
8049 }
8050
8051
8052
8053 func (c *ProjectsLocationsBareMetalClustersQueryVersionConfigCall) Header() http.Header {
8054 if c.header_ == nil {
8055 c.header_ = make(http.Header)
8056 }
8057 return c.header_
8058 }
8059
8060 func (c *ProjectsLocationsBareMetalClustersQueryVersionConfigCall) doRequest(alt string) (*http.Response, error) {
8061 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8062 var body io.Reader = nil
8063 c.urlParams_.Set("alt", alt)
8064 c.urlParams_.Set("prettyPrint", "false")
8065 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalClusters:queryVersionConfig")
8066 urls += "?" + c.urlParams_.Encode()
8067 req, err := http.NewRequest("POST", urls, body)
8068 if err != nil {
8069 return nil, err
8070 }
8071 req.Header = reqHeaders
8072 googleapi.Expand(req.URL, map[string]string{
8073 "parent": c.parent,
8074 })
8075 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8076 }
8077
8078
8079
8080
8081
8082
8083
8084 func (c *ProjectsLocationsBareMetalClustersQueryVersionConfigCall) Do(opts ...googleapi.CallOption) (*QueryBareMetalVersionConfigResponse, error) {
8085 gensupport.SetOptions(c.urlParams_, opts...)
8086 res, err := c.doRequest("json")
8087 if res != nil && res.StatusCode == http.StatusNotModified {
8088 if res.Body != nil {
8089 res.Body.Close()
8090 }
8091 return nil, gensupport.WrapError(&googleapi.Error{
8092 Code: res.StatusCode,
8093 Header: res.Header,
8094 })
8095 }
8096 if err != nil {
8097 return nil, err
8098 }
8099 defer googleapi.CloseBody(res)
8100 if err := googleapi.CheckResponse(res); err != nil {
8101 return nil, gensupport.WrapError(err)
8102 }
8103 ret := &QueryBareMetalVersionConfigResponse{
8104 ServerResponse: googleapi.ServerResponse{
8105 Header: res.Header,
8106 HTTPStatusCode: res.StatusCode,
8107 },
8108 }
8109 target := &ret
8110 if err := gensupport.DecodeResponse(target, res); err != nil {
8111 return nil, err
8112 }
8113 return ret, nil
8114 }
8115
8116 type ProjectsLocationsBareMetalClustersSetIamPolicyCall struct {
8117 s *Service
8118 resource string
8119 setiampolicyrequest *SetIamPolicyRequest
8120 urlParams_ gensupport.URLParams
8121 ctx_ context.Context
8122 header_ http.Header
8123 }
8124
8125
8126
8127
8128
8129
8130
8131
8132 func (r *ProjectsLocationsBareMetalClustersService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsBareMetalClustersSetIamPolicyCall {
8133 c := &ProjectsLocationsBareMetalClustersSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8134 c.resource = resource
8135 c.setiampolicyrequest = setiampolicyrequest
8136 return c
8137 }
8138
8139
8140
8141
8142 func (c *ProjectsLocationsBareMetalClustersSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersSetIamPolicyCall {
8143 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8144 return c
8145 }
8146
8147
8148 func (c *ProjectsLocationsBareMetalClustersSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersSetIamPolicyCall {
8149 c.ctx_ = ctx
8150 return c
8151 }
8152
8153
8154
8155 func (c *ProjectsLocationsBareMetalClustersSetIamPolicyCall) Header() http.Header {
8156 if c.header_ == nil {
8157 c.header_ = make(http.Header)
8158 }
8159 return c.header_
8160 }
8161
8162 func (c *ProjectsLocationsBareMetalClustersSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
8163 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8164 var body io.Reader = nil
8165 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
8166 if err != nil {
8167 return nil, err
8168 }
8169 c.urlParams_.Set("alt", alt)
8170 c.urlParams_.Set("prettyPrint", "false")
8171 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
8172 urls += "?" + c.urlParams_.Encode()
8173 req, err := http.NewRequest("POST", urls, body)
8174 if err != nil {
8175 return nil, err
8176 }
8177 req.Header = reqHeaders
8178 googleapi.Expand(req.URL, map[string]string{
8179 "resource": c.resource,
8180 })
8181 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8182 }
8183
8184
8185
8186
8187
8188
8189 func (c *ProjectsLocationsBareMetalClustersSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
8190 gensupport.SetOptions(c.urlParams_, opts...)
8191 res, err := c.doRequest("json")
8192 if res != nil && res.StatusCode == http.StatusNotModified {
8193 if res.Body != nil {
8194 res.Body.Close()
8195 }
8196 return nil, gensupport.WrapError(&googleapi.Error{
8197 Code: res.StatusCode,
8198 Header: res.Header,
8199 })
8200 }
8201 if err != nil {
8202 return nil, err
8203 }
8204 defer googleapi.CloseBody(res)
8205 if err := googleapi.CheckResponse(res); err != nil {
8206 return nil, gensupport.WrapError(err)
8207 }
8208 ret := &Policy{
8209 ServerResponse: googleapi.ServerResponse{
8210 Header: res.Header,
8211 HTTPStatusCode: res.StatusCode,
8212 },
8213 }
8214 target := &ret
8215 if err := gensupport.DecodeResponse(target, res); err != nil {
8216 return nil, err
8217 }
8218 return ret, nil
8219 }
8220
8221 type ProjectsLocationsBareMetalClustersTestIamPermissionsCall struct {
8222 s *Service
8223 resource string
8224 testiampermissionsrequest *TestIamPermissionsRequest
8225 urlParams_ gensupport.URLParams
8226 ctx_ context.Context
8227 header_ http.Header
8228 }
8229
8230
8231
8232
8233
8234
8235
8236
8237
8238
8239
8240 func (r *ProjectsLocationsBareMetalClustersService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsBareMetalClustersTestIamPermissionsCall {
8241 c := &ProjectsLocationsBareMetalClustersTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8242 c.resource = resource
8243 c.testiampermissionsrequest = testiampermissionsrequest
8244 return c
8245 }
8246
8247
8248
8249
8250 func (c *ProjectsLocationsBareMetalClustersTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersTestIamPermissionsCall {
8251 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8252 return c
8253 }
8254
8255
8256 func (c *ProjectsLocationsBareMetalClustersTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersTestIamPermissionsCall {
8257 c.ctx_ = ctx
8258 return c
8259 }
8260
8261
8262
8263 func (c *ProjectsLocationsBareMetalClustersTestIamPermissionsCall) Header() http.Header {
8264 if c.header_ == nil {
8265 c.header_ = make(http.Header)
8266 }
8267 return c.header_
8268 }
8269
8270 func (c *ProjectsLocationsBareMetalClustersTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
8271 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8272 var body io.Reader = nil
8273 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
8274 if err != nil {
8275 return nil, err
8276 }
8277 c.urlParams_.Set("alt", alt)
8278 c.urlParams_.Set("prettyPrint", "false")
8279 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
8280 urls += "?" + c.urlParams_.Encode()
8281 req, err := http.NewRequest("POST", urls, body)
8282 if err != nil {
8283 return nil, err
8284 }
8285 req.Header = reqHeaders
8286 googleapi.Expand(req.URL, map[string]string{
8287 "resource": c.resource,
8288 })
8289 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8290 }
8291
8292
8293
8294
8295
8296
8297
8298 func (c *ProjectsLocationsBareMetalClustersTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
8299 gensupport.SetOptions(c.urlParams_, opts...)
8300 res, err := c.doRequest("json")
8301 if res != nil && res.StatusCode == http.StatusNotModified {
8302 if res.Body != nil {
8303 res.Body.Close()
8304 }
8305 return nil, gensupport.WrapError(&googleapi.Error{
8306 Code: res.StatusCode,
8307 Header: res.Header,
8308 })
8309 }
8310 if err != nil {
8311 return nil, err
8312 }
8313 defer googleapi.CloseBody(res)
8314 if err := googleapi.CheckResponse(res); err != nil {
8315 return nil, gensupport.WrapError(err)
8316 }
8317 ret := &TestIamPermissionsResponse{
8318 ServerResponse: googleapi.ServerResponse{
8319 Header: res.Header,
8320 HTTPStatusCode: res.StatusCode,
8321 },
8322 }
8323 target := &ret
8324 if err := gensupport.DecodeResponse(target, res); err != nil {
8325 return nil, err
8326 }
8327 return ret, nil
8328 }
8329
8330 type ProjectsLocationsBareMetalClustersUnenrollCall struct {
8331 s *Service
8332 name string
8333 urlParams_ gensupport.URLParams
8334 ctx_ context.Context
8335 header_ http.Header
8336 }
8337
8338
8339
8340
8341
8342
8343
8344
8345
8346
8347 func (r *ProjectsLocationsBareMetalClustersService) Unenroll(name string) *ProjectsLocationsBareMetalClustersUnenrollCall {
8348 c := &ProjectsLocationsBareMetalClustersUnenrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8349 c.name = name
8350 return c
8351 }
8352
8353
8354
8355
8356 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) AllowMissing(allowMissing bool) *ProjectsLocationsBareMetalClustersUnenrollCall {
8357 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
8358 return c
8359 }
8360
8361
8362
8363
8364 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) Etag(etag string) *ProjectsLocationsBareMetalClustersUnenrollCall {
8365 c.urlParams_.Set("etag", etag)
8366 return c
8367 }
8368
8369
8370
8371
8372 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) Force(force bool) *ProjectsLocationsBareMetalClustersUnenrollCall {
8373 c.urlParams_.Set("force", fmt.Sprint(force))
8374 return c
8375 }
8376
8377
8378
8379 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalClustersUnenrollCall {
8380 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
8381 return c
8382 }
8383
8384
8385
8386
8387 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersUnenrollCall {
8388 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8389 return c
8390 }
8391
8392
8393 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersUnenrollCall {
8394 c.ctx_ = ctx
8395 return c
8396 }
8397
8398
8399
8400 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) Header() http.Header {
8401 if c.header_ == nil {
8402 c.header_ = make(http.Header)
8403 }
8404 return c.header_
8405 }
8406
8407 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) doRequest(alt string) (*http.Response, error) {
8408 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8409 var body io.Reader = nil
8410 c.urlParams_.Set("alt", alt)
8411 c.urlParams_.Set("prettyPrint", "false")
8412 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:unenroll")
8413 urls += "?" + c.urlParams_.Encode()
8414 req, err := http.NewRequest("DELETE", urls, body)
8415 if err != nil {
8416 return nil, err
8417 }
8418 req.Header = reqHeaders
8419 googleapi.Expand(req.URL, map[string]string{
8420 "name": c.name,
8421 })
8422 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8423 }
8424
8425
8426
8427
8428
8429
8430 func (c *ProjectsLocationsBareMetalClustersUnenrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
8431 gensupport.SetOptions(c.urlParams_, opts...)
8432 res, err := c.doRequest("json")
8433 if res != nil && res.StatusCode == http.StatusNotModified {
8434 if res.Body != nil {
8435 res.Body.Close()
8436 }
8437 return nil, gensupport.WrapError(&googleapi.Error{
8438 Code: res.StatusCode,
8439 Header: res.Header,
8440 })
8441 }
8442 if err != nil {
8443 return nil, err
8444 }
8445 defer googleapi.CloseBody(res)
8446 if err := googleapi.CheckResponse(res); err != nil {
8447 return nil, gensupport.WrapError(err)
8448 }
8449 ret := &Operation{
8450 ServerResponse: googleapi.ServerResponse{
8451 Header: res.Header,
8452 HTTPStatusCode: res.StatusCode,
8453 },
8454 }
8455 target := &ret
8456 if err := gensupport.DecodeResponse(target, res); err != nil {
8457 return nil, err
8458 }
8459 return ret, nil
8460 }
8461
8462 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall struct {
8463 s *Service
8464 parent string
8465 baremetalnodepool *BareMetalNodePool
8466 urlParams_ gensupport.URLParams
8467 ctx_ context.Context
8468 header_ http.Header
8469 }
8470
8471
8472
8473
8474
8475
8476 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) Create(parent string, baremetalnodepool *BareMetalNodePool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall {
8477 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8478 c.parent = parent
8479 c.baremetalnodepool = baremetalnodepool
8480 return c
8481 }
8482
8483
8484
8485
8486
8487
8488
8489 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall) BareMetalNodePoolId(bareMetalNodePoolId string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall {
8490 c.urlParams_.Set("bareMetalNodePoolId", bareMetalNodePoolId)
8491 return c
8492 }
8493
8494
8495
8496 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall {
8497 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
8498 return c
8499 }
8500
8501
8502
8503
8504 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall {
8505 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8506 return c
8507 }
8508
8509
8510 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall {
8511 c.ctx_ = ctx
8512 return c
8513 }
8514
8515
8516
8517 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall) Header() http.Header {
8518 if c.header_ == nil {
8519 c.header_ = make(http.Header)
8520 }
8521 return c.header_
8522 }
8523
8524 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall) doRequest(alt string) (*http.Response, error) {
8525 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8526 var body io.Reader = nil
8527 body, err := googleapi.WithoutDataWrapper.JSONReader(c.baremetalnodepool)
8528 if err != nil {
8529 return nil, err
8530 }
8531 c.urlParams_.Set("alt", alt)
8532 c.urlParams_.Set("prettyPrint", "false")
8533 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalNodePools")
8534 urls += "?" + c.urlParams_.Encode()
8535 req, err := http.NewRequest("POST", urls, body)
8536 if err != nil {
8537 return nil, err
8538 }
8539 req.Header = reqHeaders
8540 googleapi.Expand(req.URL, map[string]string{
8541 "parent": c.parent,
8542 })
8543 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8544 }
8545
8546
8547
8548
8549
8550
8551 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
8552 gensupport.SetOptions(c.urlParams_, opts...)
8553 res, err := c.doRequest("json")
8554 if res != nil && res.StatusCode == http.StatusNotModified {
8555 if res.Body != nil {
8556 res.Body.Close()
8557 }
8558 return nil, gensupport.WrapError(&googleapi.Error{
8559 Code: res.StatusCode,
8560 Header: res.Header,
8561 })
8562 }
8563 if err != nil {
8564 return nil, err
8565 }
8566 defer googleapi.CloseBody(res)
8567 if err := googleapi.CheckResponse(res); err != nil {
8568 return nil, gensupport.WrapError(err)
8569 }
8570 ret := &Operation{
8571 ServerResponse: googleapi.ServerResponse{
8572 Header: res.Header,
8573 HTTPStatusCode: res.StatusCode,
8574 },
8575 }
8576 target := &ret
8577 if err := gensupport.DecodeResponse(target, res); err != nil {
8578 return nil, err
8579 }
8580 return ret, nil
8581 }
8582
8583 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall struct {
8584 s *Service
8585 name string
8586 urlParams_ gensupport.URLParams
8587 ctx_ context.Context
8588 header_ http.Header
8589 }
8590
8591
8592
8593
8594
8595
8596 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) Delete(name string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall {
8597 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8598 c.name = name
8599 return c
8600 }
8601
8602
8603
8604
8605 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) AllowMissing(allowMissing bool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall {
8606 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
8607 return c
8608 }
8609
8610
8611
8612
8613
8614 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) Etag(etag string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall {
8615 c.urlParams_.Set("etag", etag)
8616 return c
8617 }
8618
8619
8620
8621
8622
8623
8624
8625
8626 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) IgnoreErrors(ignoreErrors bool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall {
8627 c.urlParams_.Set("ignoreErrors", fmt.Sprint(ignoreErrors))
8628 return c
8629 }
8630
8631
8632
8633 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall {
8634 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
8635 return c
8636 }
8637
8638
8639
8640
8641 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall {
8642 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8643 return c
8644 }
8645
8646
8647 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall {
8648 c.ctx_ = ctx
8649 return c
8650 }
8651
8652
8653
8654 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) Header() http.Header {
8655 if c.header_ == nil {
8656 c.header_ = make(http.Header)
8657 }
8658 return c.header_
8659 }
8660
8661 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) doRequest(alt string) (*http.Response, error) {
8662 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8663 var body io.Reader = nil
8664 c.urlParams_.Set("alt", alt)
8665 c.urlParams_.Set("prettyPrint", "false")
8666 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8667 urls += "?" + c.urlParams_.Encode()
8668 req, err := http.NewRequest("DELETE", urls, body)
8669 if err != nil {
8670 return nil, err
8671 }
8672 req.Header = reqHeaders
8673 googleapi.Expand(req.URL, map[string]string{
8674 "name": c.name,
8675 })
8676 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8677 }
8678
8679
8680
8681
8682
8683
8684 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
8685 gensupport.SetOptions(c.urlParams_, opts...)
8686 res, err := c.doRequest("json")
8687 if res != nil && res.StatusCode == http.StatusNotModified {
8688 if res.Body != nil {
8689 res.Body.Close()
8690 }
8691 return nil, gensupport.WrapError(&googleapi.Error{
8692 Code: res.StatusCode,
8693 Header: res.Header,
8694 })
8695 }
8696 if err != nil {
8697 return nil, err
8698 }
8699 defer googleapi.CloseBody(res)
8700 if err := googleapi.CheckResponse(res); err != nil {
8701 return nil, gensupport.WrapError(err)
8702 }
8703 ret := &Operation{
8704 ServerResponse: googleapi.ServerResponse{
8705 Header: res.Header,
8706 HTTPStatusCode: res.StatusCode,
8707 },
8708 }
8709 target := &ret
8710 if err := gensupport.DecodeResponse(target, res); err != nil {
8711 return nil, err
8712 }
8713 return ret, nil
8714 }
8715
8716 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall struct {
8717 s *Service
8718 parent string
8719 enrollbaremetalnodepoolrequest *EnrollBareMetalNodePoolRequest
8720 urlParams_ gensupport.URLParams
8721 ctx_ context.Context
8722 header_ http.Header
8723 }
8724
8725
8726
8727
8728
8729
8730
8731
8732 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) Enroll(parent string, enrollbaremetalnodepoolrequest *EnrollBareMetalNodePoolRequest) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall {
8733 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8734 c.parent = parent
8735 c.enrollbaremetalnodepoolrequest = enrollbaremetalnodepoolrequest
8736 return c
8737 }
8738
8739
8740
8741
8742 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall {
8743 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8744 return c
8745 }
8746
8747
8748 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall {
8749 c.ctx_ = ctx
8750 return c
8751 }
8752
8753
8754
8755 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall) Header() http.Header {
8756 if c.header_ == nil {
8757 c.header_ = make(http.Header)
8758 }
8759 return c.header_
8760 }
8761
8762 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall) doRequest(alt string) (*http.Response, error) {
8763 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8764 var body io.Reader = nil
8765 body, err := googleapi.WithoutDataWrapper.JSONReader(c.enrollbaremetalnodepoolrequest)
8766 if err != nil {
8767 return nil, err
8768 }
8769 c.urlParams_.Set("alt", alt)
8770 c.urlParams_.Set("prettyPrint", "false")
8771 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalNodePools:enroll")
8772 urls += "?" + c.urlParams_.Encode()
8773 req, err := http.NewRequest("POST", urls, body)
8774 if err != nil {
8775 return nil, err
8776 }
8777 req.Header = reqHeaders
8778 googleapi.Expand(req.URL, map[string]string{
8779 "parent": c.parent,
8780 })
8781 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8782 }
8783
8784
8785
8786
8787
8788
8789 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsEnrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
8790 gensupport.SetOptions(c.urlParams_, opts...)
8791 res, err := c.doRequest("json")
8792 if res != nil && res.StatusCode == http.StatusNotModified {
8793 if res.Body != nil {
8794 res.Body.Close()
8795 }
8796 return nil, gensupport.WrapError(&googleapi.Error{
8797 Code: res.StatusCode,
8798 Header: res.Header,
8799 })
8800 }
8801 if err != nil {
8802 return nil, err
8803 }
8804 defer googleapi.CloseBody(res)
8805 if err := googleapi.CheckResponse(res); err != nil {
8806 return nil, gensupport.WrapError(err)
8807 }
8808 ret := &Operation{
8809 ServerResponse: googleapi.ServerResponse{
8810 Header: res.Header,
8811 HTTPStatusCode: res.StatusCode,
8812 },
8813 }
8814 target := &ret
8815 if err := gensupport.DecodeResponse(target, res); err != nil {
8816 return nil, err
8817 }
8818 return ret, nil
8819 }
8820
8821 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall struct {
8822 s *Service
8823 name string
8824 urlParams_ gensupport.URLParams
8825 ifNoneMatch_ string
8826 ctx_ context.Context
8827 header_ http.Header
8828 }
8829
8830
8831
8832
8833
8834
8835 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) Get(name string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall {
8836 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8837 c.name = name
8838 return c
8839 }
8840
8841
8842
8843
8844
8845
8846
8847
8848
8849
8850
8851
8852
8853
8854
8855
8856
8857
8858
8859 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall) View(view string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall {
8860 c.urlParams_.Set("view", view)
8861 return c
8862 }
8863
8864
8865
8866
8867 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall {
8868 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8869 return c
8870 }
8871
8872
8873
8874
8875 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall {
8876 c.ifNoneMatch_ = entityTag
8877 return c
8878 }
8879
8880
8881 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall {
8882 c.ctx_ = ctx
8883 return c
8884 }
8885
8886
8887
8888 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall) Header() http.Header {
8889 if c.header_ == nil {
8890 c.header_ = make(http.Header)
8891 }
8892 return c.header_
8893 }
8894
8895 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall) doRequest(alt string) (*http.Response, error) {
8896 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8897 if c.ifNoneMatch_ != "" {
8898 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8899 }
8900 var body io.Reader = nil
8901 c.urlParams_.Set("alt", alt)
8902 c.urlParams_.Set("prettyPrint", "false")
8903 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8904 urls += "?" + c.urlParams_.Encode()
8905 req, err := http.NewRequest("GET", urls, body)
8906 if err != nil {
8907 return nil, err
8908 }
8909 req.Header = reqHeaders
8910 googleapi.Expand(req.URL, map[string]string{
8911 "name": c.name,
8912 })
8913 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8914 }
8915
8916
8917
8918
8919
8920
8921
8922 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetCall) Do(opts ...googleapi.CallOption) (*BareMetalNodePool, error) {
8923 gensupport.SetOptions(c.urlParams_, opts...)
8924 res, err := c.doRequest("json")
8925 if res != nil && res.StatusCode == http.StatusNotModified {
8926 if res.Body != nil {
8927 res.Body.Close()
8928 }
8929 return nil, gensupport.WrapError(&googleapi.Error{
8930 Code: res.StatusCode,
8931 Header: res.Header,
8932 })
8933 }
8934 if err != nil {
8935 return nil, err
8936 }
8937 defer googleapi.CloseBody(res)
8938 if err := googleapi.CheckResponse(res); err != nil {
8939 return nil, gensupport.WrapError(err)
8940 }
8941 ret := &BareMetalNodePool{
8942 ServerResponse: googleapi.ServerResponse{
8943 Header: res.Header,
8944 HTTPStatusCode: res.StatusCode,
8945 },
8946 }
8947 target := &ret
8948 if err := gensupport.DecodeResponse(target, res); err != nil {
8949 return nil, err
8950 }
8951 return ret, nil
8952 }
8953
8954 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall struct {
8955 s *Service
8956 resource string
8957 urlParams_ gensupport.URLParams
8958 ifNoneMatch_ string
8959 ctx_ context.Context
8960 header_ http.Header
8961 }
8962
8963
8964
8965
8966
8967
8968
8969 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) GetIamPolicy(resource string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall {
8970 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8971 c.resource = resource
8972 return c
8973 }
8974
8975
8976
8977
8978
8979
8980
8981
8982
8983
8984
8985
8986
8987 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall {
8988 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
8989 return c
8990 }
8991
8992
8993
8994
8995 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall {
8996 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8997 return c
8998 }
8999
9000
9001
9002
9003 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall {
9004 c.ifNoneMatch_ = entityTag
9005 return c
9006 }
9007
9008
9009 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall {
9010 c.ctx_ = ctx
9011 return c
9012 }
9013
9014
9015
9016 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall) Header() http.Header {
9017 if c.header_ == nil {
9018 c.header_ = make(http.Header)
9019 }
9020 return c.header_
9021 }
9022
9023 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
9024 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9025 if c.ifNoneMatch_ != "" {
9026 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9027 }
9028 var body io.Reader = nil
9029 c.urlParams_.Set("alt", alt)
9030 c.urlParams_.Set("prettyPrint", "false")
9031 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
9032 urls += "?" + c.urlParams_.Encode()
9033 req, err := http.NewRequest("GET", urls, body)
9034 if err != nil {
9035 return nil, err
9036 }
9037 req.Header = reqHeaders
9038 googleapi.Expand(req.URL, map[string]string{
9039 "resource": c.resource,
9040 })
9041 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9042 }
9043
9044
9045
9046
9047
9048
9049 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
9050 gensupport.SetOptions(c.urlParams_, opts...)
9051 res, err := c.doRequest("json")
9052 if res != nil && res.StatusCode == http.StatusNotModified {
9053 if res.Body != nil {
9054 res.Body.Close()
9055 }
9056 return nil, gensupport.WrapError(&googleapi.Error{
9057 Code: res.StatusCode,
9058 Header: res.Header,
9059 })
9060 }
9061 if err != nil {
9062 return nil, err
9063 }
9064 defer googleapi.CloseBody(res)
9065 if err := googleapi.CheckResponse(res); err != nil {
9066 return nil, gensupport.WrapError(err)
9067 }
9068 ret := &Policy{
9069 ServerResponse: googleapi.ServerResponse{
9070 Header: res.Header,
9071 HTTPStatusCode: res.StatusCode,
9072 },
9073 }
9074 target := &ret
9075 if err := gensupport.DecodeResponse(target, res); err != nil {
9076 return nil, err
9077 }
9078 return ret, nil
9079 }
9080
9081 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall struct {
9082 s *Service
9083 parent string
9084 urlParams_ gensupport.URLParams
9085 ifNoneMatch_ string
9086 ctx_ context.Context
9087 header_ http.Header
9088 }
9089
9090
9091
9092
9093
9094
9095
9096 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) List(parent string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall {
9097 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9098 c.parent = parent
9099 return c
9100 }
9101
9102
9103
9104
9105
9106 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) PageSize(pageSize int64) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall {
9107 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9108 return c
9109 }
9110
9111
9112
9113
9114
9115 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) PageToken(pageToken string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall {
9116 c.urlParams_.Set("pageToken", pageToken)
9117 return c
9118 }
9119
9120
9121
9122
9123
9124
9125
9126
9127
9128
9129
9130
9131
9132
9133
9134
9135
9136
9137
9138
9139 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) View(view string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall {
9140 c.urlParams_.Set("view", view)
9141 return c
9142 }
9143
9144
9145
9146
9147 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall {
9148 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9149 return c
9150 }
9151
9152
9153
9154
9155 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall {
9156 c.ifNoneMatch_ = entityTag
9157 return c
9158 }
9159
9160
9161 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall {
9162 c.ctx_ = ctx
9163 return c
9164 }
9165
9166
9167
9168 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) Header() http.Header {
9169 if c.header_ == nil {
9170 c.header_ = make(http.Header)
9171 }
9172 return c.header_
9173 }
9174
9175 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) doRequest(alt string) (*http.Response, error) {
9176 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9177 if c.ifNoneMatch_ != "" {
9178 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9179 }
9180 var body io.Reader = nil
9181 c.urlParams_.Set("alt", alt)
9182 c.urlParams_.Set("prettyPrint", "false")
9183 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/bareMetalNodePools")
9184 urls += "?" + c.urlParams_.Encode()
9185 req, err := http.NewRequest("GET", urls, body)
9186 if err != nil {
9187 return nil, err
9188 }
9189 req.Header = reqHeaders
9190 googleapi.Expand(req.URL, map[string]string{
9191 "parent": c.parent,
9192 })
9193 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9194 }
9195
9196
9197
9198
9199
9200
9201
9202 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) Do(opts ...googleapi.CallOption) (*ListBareMetalNodePoolsResponse, error) {
9203 gensupport.SetOptions(c.urlParams_, opts...)
9204 res, err := c.doRequest("json")
9205 if res != nil && res.StatusCode == http.StatusNotModified {
9206 if res.Body != nil {
9207 res.Body.Close()
9208 }
9209 return nil, gensupport.WrapError(&googleapi.Error{
9210 Code: res.StatusCode,
9211 Header: res.Header,
9212 })
9213 }
9214 if err != nil {
9215 return nil, err
9216 }
9217 defer googleapi.CloseBody(res)
9218 if err := googleapi.CheckResponse(res); err != nil {
9219 return nil, gensupport.WrapError(err)
9220 }
9221 ret := &ListBareMetalNodePoolsResponse{
9222 ServerResponse: googleapi.ServerResponse{
9223 Header: res.Header,
9224 HTTPStatusCode: res.StatusCode,
9225 },
9226 }
9227 target := &ret
9228 if err := gensupport.DecodeResponse(target, res); err != nil {
9229 return nil, err
9230 }
9231 return ret, nil
9232 }
9233
9234
9235
9236
9237 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsListCall) Pages(ctx context.Context, f func(*ListBareMetalNodePoolsResponse) error) error {
9238 c.ctx_ = ctx
9239 defer c.PageToken(c.urlParams_.Get("pageToken"))
9240 for {
9241 x, err := c.Do()
9242 if err != nil {
9243 return err
9244 }
9245 if err := f(x); err != nil {
9246 return err
9247 }
9248 if x.NextPageToken == "" {
9249 return nil
9250 }
9251 c.PageToken(x.NextPageToken)
9252 }
9253 }
9254
9255 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall struct {
9256 s *Service
9257 name string
9258 baremetalnodepool *BareMetalNodePool
9259 urlParams_ gensupport.URLParams
9260 ctx_ context.Context
9261 header_ http.Header
9262 }
9263
9264
9265
9266
9267 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) Patch(name string, baremetalnodepool *BareMetalNodePool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall {
9268 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9269 c.name = name
9270 c.baremetalnodepool = baremetalnodepool
9271 return c
9272 }
9273
9274
9275
9276
9277
9278 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall) AllowMissing(allowMissing bool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall {
9279 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
9280 return c
9281 }
9282
9283
9284
9285
9286
9287
9288
9289
9290 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall {
9291 c.urlParams_.Set("updateMask", updateMask)
9292 return c
9293 }
9294
9295
9296
9297 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall {
9298 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
9299 return c
9300 }
9301
9302
9303
9304
9305 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall {
9306 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9307 return c
9308 }
9309
9310
9311 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall {
9312 c.ctx_ = ctx
9313 return c
9314 }
9315
9316
9317
9318 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall) Header() http.Header {
9319 if c.header_ == nil {
9320 c.header_ = make(http.Header)
9321 }
9322 return c.header_
9323 }
9324
9325 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall) doRequest(alt string) (*http.Response, error) {
9326 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9327 var body io.Reader = nil
9328 body, err := googleapi.WithoutDataWrapper.JSONReader(c.baremetalnodepool)
9329 if err != nil {
9330 return nil, err
9331 }
9332 c.urlParams_.Set("alt", alt)
9333 c.urlParams_.Set("prettyPrint", "false")
9334 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
9335 urls += "?" + c.urlParams_.Encode()
9336 req, err := http.NewRequest("PATCH", urls, body)
9337 if err != nil {
9338 return nil, err
9339 }
9340 req.Header = reqHeaders
9341 googleapi.Expand(req.URL, map[string]string{
9342 "name": c.name,
9343 })
9344 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9345 }
9346
9347
9348
9349
9350
9351
9352 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
9353 gensupport.SetOptions(c.urlParams_, opts...)
9354 res, err := c.doRequest("json")
9355 if res != nil && res.StatusCode == http.StatusNotModified {
9356 if res.Body != nil {
9357 res.Body.Close()
9358 }
9359 return nil, gensupport.WrapError(&googleapi.Error{
9360 Code: res.StatusCode,
9361 Header: res.Header,
9362 })
9363 }
9364 if err != nil {
9365 return nil, err
9366 }
9367 defer googleapi.CloseBody(res)
9368 if err := googleapi.CheckResponse(res); err != nil {
9369 return nil, gensupport.WrapError(err)
9370 }
9371 ret := &Operation{
9372 ServerResponse: googleapi.ServerResponse{
9373 Header: res.Header,
9374 HTTPStatusCode: res.StatusCode,
9375 },
9376 }
9377 target := &ret
9378 if err := gensupport.DecodeResponse(target, res); err != nil {
9379 return nil, err
9380 }
9381 return ret, nil
9382 }
9383
9384 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall struct {
9385 s *Service
9386 resource string
9387 setiampolicyrequest *SetIamPolicyRequest
9388 urlParams_ gensupport.URLParams
9389 ctx_ context.Context
9390 header_ http.Header
9391 }
9392
9393
9394
9395
9396
9397
9398
9399
9400 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall {
9401 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9402 c.resource = resource
9403 c.setiampolicyrequest = setiampolicyrequest
9404 return c
9405 }
9406
9407
9408
9409
9410 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall {
9411 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9412 return c
9413 }
9414
9415
9416 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall {
9417 c.ctx_ = ctx
9418 return c
9419 }
9420
9421
9422
9423 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall) Header() http.Header {
9424 if c.header_ == nil {
9425 c.header_ = make(http.Header)
9426 }
9427 return c.header_
9428 }
9429
9430 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
9431 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9432 var body io.Reader = nil
9433 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
9434 if err != nil {
9435 return nil, err
9436 }
9437 c.urlParams_.Set("alt", alt)
9438 c.urlParams_.Set("prettyPrint", "false")
9439 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
9440 urls += "?" + c.urlParams_.Encode()
9441 req, err := http.NewRequest("POST", urls, body)
9442 if err != nil {
9443 return nil, err
9444 }
9445 req.Header = reqHeaders
9446 googleapi.Expand(req.URL, map[string]string{
9447 "resource": c.resource,
9448 })
9449 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9450 }
9451
9452
9453
9454
9455
9456
9457 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
9458 gensupport.SetOptions(c.urlParams_, opts...)
9459 res, err := c.doRequest("json")
9460 if res != nil && res.StatusCode == http.StatusNotModified {
9461 if res.Body != nil {
9462 res.Body.Close()
9463 }
9464 return nil, gensupport.WrapError(&googleapi.Error{
9465 Code: res.StatusCode,
9466 Header: res.Header,
9467 })
9468 }
9469 if err != nil {
9470 return nil, err
9471 }
9472 defer googleapi.CloseBody(res)
9473 if err := googleapi.CheckResponse(res); err != nil {
9474 return nil, gensupport.WrapError(err)
9475 }
9476 ret := &Policy{
9477 ServerResponse: googleapi.ServerResponse{
9478 Header: res.Header,
9479 HTTPStatusCode: res.StatusCode,
9480 },
9481 }
9482 target := &ret
9483 if err := gensupport.DecodeResponse(target, res); err != nil {
9484 return nil, err
9485 }
9486 return ret, nil
9487 }
9488
9489 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall struct {
9490 s *Service
9491 resource string
9492 testiampermissionsrequest *TestIamPermissionsRequest
9493 urlParams_ gensupport.URLParams
9494 ctx_ context.Context
9495 header_ http.Header
9496 }
9497
9498
9499
9500
9501
9502
9503
9504
9505
9506
9507
9508 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall {
9509 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9510 c.resource = resource
9511 c.testiampermissionsrequest = testiampermissionsrequest
9512 return c
9513 }
9514
9515
9516
9517
9518 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall {
9519 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9520 return c
9521 }
9522
9523
9524 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall {
9525 c.ctx_ = ctx
9526 return c
9527 }
9528
9529
9530
9531 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall) Header() http.Header {
9532 if c.header_ == nil {
9533 c.header_ = make(http.Header)
9534 }
9535 return c.header_
9536 }
9537
9538 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
9539 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9540 var body io.Reader = nil
9541 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
9542 if err != nil {
9543 return nil, err
9544 }
9545 c.urlParams_.Set("alt", alt)
9546 c.urlParams_.Set("prettyPrint", "false")
9547 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
9548 urls += "?" + c.urlParams_.Encode()
9549 req, err := http.NewRequest("POST", urls, body)
9550 if err != nil {
9551 return nil, err
9552 }
9553 req.Header = reqHeaders
9554 googleapi.Expand(req.URL, map[string]string{
9555 "resource": c.resource,
9556 })
9557 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9558 }
9559
9560
9561
9562
9563
9564
9565
9566 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
9567 gensupport.SetOptions(c.urlParams_, opts...)
9568 res, err := c.doRequest("json")
9569 if res != nil && res.StatusCode == http.StatusNotModified {
9570 if res.Body != nil {
9571 res.Body.Close()
9572 }
9573 return nil, gensupport.WrapError(&googleapi.Error{
9574 Code: res.StatusCode,
9575 Header: res.Header,
9576 })
9577 }
9578 if err != nil {
9579 return nil, err
9580 }
9581 defer googleapi.CloseBody(res)
9582 if err := googleapi.CheckResponse(res); err != nil {
9583 return nil, gensupport.WrapError(err)
9584 }
9585 ret := &TestIamPermissionsResponse{
9586 ServerResponse: googleapi.ServerResponse{
9587 Header: res.Header,
9588 HTTPStatusCode: res.StatusCode,
9589 },
9590 }
9591 target := &ret
9592 if err := gensupport.DecodeResponse(target, res); err != nil {
9593 return nil, err
9594 }
9595 return ret, nil
9596 }
9597
9598 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall struct {
9599 s *Service
9600 name string
9601 urlParams_ gensupport.URLParams
9602 ctx_ context.Context
9603 header_ http.Header
9604 }
9605
9606
9607
9608
9609
9610
9611 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsService) Unenroll(name string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall {
9612 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9613 c.name = name
9614 return c
9615 }
9616
9617
9618
9619
9620 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall) AllowMissing(allowMissing bool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall {
9621 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
9622 return c
9623 }
9624
9625
9626
9627
9628 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall) Etag(etag string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall {
9629 c.urlParams_.Set("etag", etag)
9630 return c
9631 }
9632
9633
9634
9635 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall) ValidateOnly(validateOnly bool) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall {
9636 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
9637 return c
9638 }
9639
9640
9641
9642
9643 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall {
9644 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9645 return c
9646 }
9647
9648
9649 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall {
9650 c.ctx_ = ctx
9651 return c
9652 }
9653
9654
9655
9656 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall) Header() http.Header {
9657 if c.header_ == nil {
9658 c.header_ = make(http.Header)
9659 }
9660 return c.header_
9661 }
9662
9663 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall) doRequest(alt string) (*http.Response, error) {
9664 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9665 var body io.Reader = nil
9666 c.urlParams_.Set("alt", alt)
9667 c.urlParams_.Set("prettyPrint", "false")
9668 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:unenroll")
9669 urls += "?" + c.urlParams_.Encode()
9670 req, err := http.NewRequest("DELETE", urls, body)
9671 if err != nil {
9672 return nil, err
9673 }
9674 req.Header = reqHeaders
9675 googleapi.Expand(req.URL, map[string]string{
9676 "name": c.name,
9677 })
9678 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9679 }
9680
9681
9682
9683
9684
9685
9686 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsUnenrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
9687 gensupport.SetOptions(c.urlParams_, opts...)
9688 res, err := c.doRequest("json")
9689 if res != nil && res.StatusCode == http.StatusNotModified {
9690 if res.Body != nil {
9691 res.Body.Close()
9692 }
9693 return nil, gensupport.WrapError(&googleapi.Error{
9694 Code: res.StatusCode,
9695 Header: res.Header,
9696 })
9697 }
9698 if err != nil {
9699 return nil, err
9700 }
9701 defer googleapi.CloseBody(res)
9702 if err := googleapi.CheckResponse(res); err != nil {
9703 return nil, gensupport.WrapError(err)
9704 }
9705 ret := &Operation{
9706 ServerResponse: googleapi.ServerResponse{
9707 Header: res.Header,
9708 HTTPStatusCode: res.StatusCode,
9709 },
9710 }
9711 target := &ret
9712 if err := gensupport.DecodeResponse(target, res); err != nil {
9713 return nil, err
9714 }
9715 return ret, nil
9716 }
9717
9718 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall struct {
9719 s *Service
9720 name string
9721 urlParams_ gensupport.URLParams
9722 ifNoneMatch_ string
9723 ctx_ context.Context
9724 header_ http.Header
9725 }
9726
9727
9728
9729
9730
9731
9732 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsService) Get(name string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall {
9733 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9734 c.name = name
9735 return c
9736 }
9737
9738
9739
9740
9741 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall {
9742 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9743 return c
9744 }
9745
9746
9747
9748
9749 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall {
9750 c.ifNoneMatch_ = entityTag
9751 return c
9752 }
9753
9754
9755 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall {
9756 c.ctx_ = ctx
9757 return c
9758 }
9759
9760
9761
9762 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall) Header() http.Header {
9763 if c.header_ == nil {
9764 c.header_ = make(http.Header)
9765 }
9766 return c.header_
9767 }
9768
9769 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall) doRequest(alt string) (*http.Response, error) {
9770 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9771 if c.ifNoneMatch_ != "" {
9772 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9773 }
9774 var body io.Reader = nil
9775 c.urlParams_.Set("alt", alt)
9776 c.urlParams_.Set("prettyPrint", "false")
9777 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
9778 urls += "?" + c.urlParams_.Encode()
9779 req, err := http.NewRequest("GET", urls, body)
9780 if err != nil {
9781 return nil, err
9782 }
9783 req.Header = reqHeaders
9784 googleapi.Expand(req.URL, map[string]string{
9785 "name": c.name,
9786 })
9787 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9788 }
9789
9790
9791
9792
9793
9794
9795 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
9796 gensupport.SetOptions(c.urlParams_, opts...)
9797 res, err := c.doRequest("json")
9798 if res != nil && res.StatusCode == http.StatusNotModified {
9799 if res.Body != nil {
9800 res.Body.Close()
9801 }
9802 return nil, gensupport.WrapError(&googleapi.Error{
9803 Code: res.StatusCode,
9804 Header: res.Header,
9805 })
9806 }
9807 if err != nil {
9808 return nil, err
9809 }
9810 defer googleapi.CloseBody(res)
9811 if err := googleapi.CheckResponse(res); err != nil {
9812 return nil, gensupport.WrapError(err)
9813 }
9814 ret := &Operation{
9815 ServerResponse: googleapi.ServerResponse{
9816 Header: res.Header,
9817 HTTPStatusCode: res.StatusCode,
9818 },
9819 }
9820 target := &ret
9821 if err := gensupport.DecodeResponse(target, res); err != nil {
9822 return nil, err
9823 }
9824 return ret, nil
9825 }
9826
9827 type ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall struct {
9828 s *Service
9829 name string
9830 urlParams_ gensupport.URLParams
9831 ifNoneMatch_ string
9832 ctx_ context.Context
9833 header_ http.Header
9834 }
9835
9836
9837
9838
9839
9840 func (r *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsService) List(name string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall {
9841 c := &ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9842 c.name = name
9843 return c
9844 }
9845
9846
9847 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) Filter(filter string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall {
9848 c.urlParams_.Set("filter", filter)
9849 return c
9850 }
9851
9852
9853
9854 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall {
9855 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9856 return c
9857 }
9858
9859
9860
9861 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) PageToken(pageToken string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall {
9862 c.urlParams_.Set("pageToken", pageToken)
9863 return c
9864 }
9865
9866
9867
9868
9869 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall {
9870 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9871 return c
9872 }
9873
9874
9875
9876
9877 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall {
9878 c.ifNoneMatch_ = entityTag
9879 return c
9880 }
9881
9882
9883 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall {
9884 c.ctx_ = ctx
9885 return c
9886 }
9887
9888
9889
9890 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) Header() http.Header {
9891 if c.header_ == nil {
9892 c.header_ = make(http.Header)
9893 }
9894 return c.header_
9895 }
9896
9897 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) doRequest(alt string) (*http.Response, error) {
9898 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9899 if c.ifNoneMatch_ != "" {
9900 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9901 }
9902 var body io.Reader = nil
9903 c.urlParams_.Set("alt", alt)
9904 c.urlParams_.Set("prettyPrint", "false")
9905 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
9906 urls += "?" + c.urlParams_.Encode()
9907 req, err := http.NewRequest("GET", urls, body)
9908 if err != nil {
9909 return nil, err
9910 }
9911 req.Header = reqHeaders
9912 googleapi.Expand(req.URL, map[string]string{
9913 "name": c.name,
9914 })
9915 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9916 }
9917
9918
9919
9920
9921
9922
9923
9924 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
9925 gensupport.SetOptions(c.urlParams_, opts...)
9926 res, err := c.doRequest("json")
9927 if res != nil && res.StatusCode == http.StatusNotModified {
9928 if res.Body != nil {
9929 res.Body.Close()
9930 }
9931 return nil, gensupport.WrapError(&googleapi.Error{
9932 Code: res.StatusCode,
9933 Header: res.Header,
9934 })
9935 }
9936 if err != nil {
9937 return nil, err
9938 }
9939 defer googleapi.CloseBody(res)
9940 if err := googleapi.CheckResponse(res); err != nil {
9941 return nil, gensupport.WrapError(err)
9942 }
9943 ret := &ListOperationsResponse{
9944 ServerResponse: googleapi.ServerResponse{
9945 Header: res.Header,
9946 HTTPStatusCode: res.StatusCode,
9947 },
9948 }
9949 target := &ret
9950 if err := gensupport.DecodeResponse(target, res); err != nil {
9951 return nil, err
9952 }
9953 return ret, nil
9954 }
9955
9956
9957
9958
9959 func (c *ProjectsLocationsBareMetalClustersBareMetalNodePoolsOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
9960 c.ctx_ = ctx
9961 defer c.PageToken(c.urlParams_.Get("pageToken"))
9962 for {
9963 x, err := c.Do()
9964 if err != nil {
9965 return err
9966 }
9967 if err := f(x); err != nil {
9968 return err
9969 }
9970 if x.NextPageToken == "" {
9971 return nil
9972 }
9973 c.PageToken(x.NextPageToken)
9974 }
9975 }
9976
9977 type ProjectsLocationsBareMetalClustersOperationsGetCall struct {
9978 s *Service
9979 name string
9980 urlParams_ gensupport.URLParams
9981 ifNoneMatch_ string
9982 ctx_ context.Context
9983 header_ http.Header
9984 }
9985
9986
9987
9988
9989
9990
9991 func (r *ProjectsLocationsBareMetalClustersOperationsService) Get(name string) *ProjectsLocationsBareMetalClustersOperationsGetCall {
9992 c := &ProjectsLocationsBareMetalClustersOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9993 c.name = name
9994 return c
9995 }
9996
9997
9998
9999
10000 func (c *ProjectsLocationsBareMetalClustersOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersOperationsGetCall {
10001 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10002 return c
10003 }
10004
10005
10006
10007
10008 func (c *ProjectsLocationsBareMetalClustersOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersOperationsGetCall {
10009 c.ifNoneMatch_ = entityTag
10010 return c
10011 }
10012
10013
10014 func (c *ProjectsLocationsBareMetalClustersOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersOperationsGetCall {
10015 c.ctx_ = ctx
10016 return c
10017 }
10018
10019
10020
10021 func (c *ProjectsLocationsBareMetalClustersOperationsGetCall) Header() http.Header {
10022 if c.header_ == nil {
10023 c.header_ = make(http.Header)
10024 }
10025 return c.header_
10026 }
10027
10028 func (c *ProjectsLocationsBareMetalClustersOperationsGetCall) doRequest(alt string) (*http.Response, error) {
10029 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10030 if c.ifNoneMatch_ != "" {
10031 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10032 }
10033 var body io.Reader = nil
10034 c.urlParams_.Set("alt", alt)
10035 c.urlParams_.Set("prettyPrint", "false")
10036 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10037 urls += "?" + c.urlParams_.Encode()
10038 req, err := http.NewRequest("GET", urls, body)
10039 if err != nil {
10040 return nil, err
10041 }
10042 req.Header = reqHeaders
10043 googleapi.Expand(req.URL, map[string]string{
10044 "name": c.name,
10045 })
10046 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10047 }
10048
10049
10050
10051
10052
10053
10054 func (c *ProjectsLocationsBareMetalClustersOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
10055 gensupport.SetOptions(c.urlParams_, opts...)
10056 res, err := c.doRequest("json")
10057 if res != nil && res.StatusCode == http.StatusNotModified {
10058 if res.Body != nil {
10059 res.Body.Close()
10060 }
10061 return nil, gensupport.WrapError(&googleapi.Error{
10062 Code: res.StatusCode,
10063 Header: res.Header,
10064 })
10065 }
10066 if err != nil {
10067 return nil, err
10068 }
10069 defer googleapi.CloseBody(res)
10070 if err := googleapi.CheckResponse(res); err != nil {
10071 return nil, gensupport.WrapError(err)
10072 }
10073 ret := &Operation{
10074 ServerResponse: googleapi.ServerResponse{
10075 Header: res.Header,
10076 HTTPStatusCode: res.StatusCode,
10077 },
10078 }
10079 target := &ret
10080 if err := gensupport.DecodeResponse(target, res); err != nil {
10081 return nil, err
10082 }
10083 return ret, nil
10084 }
10085
10086 type ProjectsLocationsBareMetalClustersOperationsListCall struct {
10087 s *Service
10088 name string
10089 urlParams_ gensupport.URLParams
10090 ifNoneMatch_ string
10091 ctx_ context.Context
10092 header_ http.Header
10093 }
10094
10095
10096
10097
10098
10099 func (r *ProjectsLocationsBareMetalClustersOperationsService) List(name string) *ProjectsLocationsBareMetalClustersOperationsListCall {
10100 c := &ProjectsLocationsBareMetalClustersOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10101 c.name = name
10102 return c
10103 }
10104
10105
10106 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) Filter(filter string) *ProjectsLocationsBareMetalClustersOperationsListCall {
10107 c.urlParams_.Set("filter", filter)
10108 return c
10109 }
10110
10111
10112
10113 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsBareMetalClustersOperationsListCall {
10114 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
10115 return c
10116 }
10117
10118
10119
10120 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) PageToken(pageToken string) *ProjectsLocationsBareMetalClustersOperationsListCall {
10121 c.urlParams_.Set("pageToken", pageToken)
10122 return c
10123 }
10124
10125
10126
10127
10128 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsBareMetalClustersOperationsListCall {
10129 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10130 return c
10131 }
10132
10133
10134
10135
10136 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsBareMetalClustersOperationsListCall {
10137 c.ifNoneMatch_ = entityTag
10138 return c
10139 }
10140
10141
10142 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) Context(ctx context.Context) *ProjectsLocationsBareMetalClustersOperationsListCall {
10143 c.ctx_ = ctx
10144 return c
10145 }
10146
10147
10148
10149 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) Header() http.Header {
10150 if c.header_ == nil {
10151 c.header_ = make(http.Header)
10152 }
10153 return c.header_
10154 }
10155
10156 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) doRequest(alt string) (*http.Response, error) {
10157 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10158 if c.ifNoneMatch_ != "" {
10159 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10160 }
10161 var body io.Reader = nil
10162 c.urlParams_.Set("alt", alt)
10163 c.urlParams_.Set("prettyPrint", "false")
10164 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
10165 urls += "?" + c.urlParams_.Encode()
10166 req, err := http.NewRequest("GET", urls, body)
10167 if err != nil {
10168 return nil, err
10169 }
10170 req.Header = reqHeaders
10171 googleapi.Expand(req.URL, map[string]string{
10172 "name": c.name,
10173 })
10174 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10175 }
10176
10177
10178
10179
10180
10181
10182
10183 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
10184 gensupport.SetOptions(c.urlParams_, opts...)
10185 res, err := c.doRequest("json")
10186 if res != nil && res.StatusCode == http.StatusNotModified {
10187 if res.Body != nil {
10188 res.Body.Close()
10189 }
10190 return nil, gensupport.WrapError(&googleapi.Error{
10191 Code: res.StatusCode,
10192 Header: res.Header,
10193 })
10194 }
10195 if err != nil {
10196 return nil, err
10197 }
10198 defer googleapi.CloseBody(res)
10199 if err := googleapi.CheckResponse(res); err != nil {
10200 return nil, gensupport.WrapError(err)
10201 }
10202 ret := &ListOperationsResponse{
10203 ServerResponse: googleapi.ServerResponse{
10204 Header: res.Header,
10205 HTTPStatusCode: res.StatusCode,
10206 },
10207 }
10208 target := &ret
10209 if err := gensupport.DecodeResponse(target, res); err != nil {
10210 return nil, err
10211 }
10212 return ret, nil
10213 }
10214
10215
10216
10217
10218 func (c *ProjectsLocationsBareMetalClustersOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
10219 c.ctx_ = ctx
10220 defer c.PageToken(c.urlParams_.Get("pageToken"))
10221 for {
10222 x, err := c.Do()
10223 if err != nil {
10224 return err
10225 }
10226 if err := f(x); err != nil {
10227 return err
10228 }
10229 if x.NextPageToken == "" {
10230 return nil
10231 }
10232 c.PageToken(x.NextPageToken)
10233 }
10234 }
10235
10236 type ProjectsLocationsOperationsCancelCall struct {
10237 s *Service
10238 name string
10239 canceloperationrequest *CancelOperationRequest
10240 urlParams_ gensupport.URLParams
10241 ctx_ context.Context
10242 header_ http.Header
10243 }
10244
10245
10246
10247
10248
10249
10250
10251
10252
10253
10254
10255
10256 func (r *ProjectsLocationsOperationsService) Cancel(name string, canceloperationrequest *CancelOperationRequest) *ProjectsLocationsOperationsCancelCall {
10257 c := &ProjectsLocationsOperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10258 c.name = name
10259 c.canceloperationrequest = canceloperationrequest
10260 return c
10261 }
10262
10263
10264
10265
10266 func (c *ProjectsLocationsOperationsCancelCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsCancelCall {
10267 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10268 return c
10269 }
10270
10271
10272 func (c *ProjectsLocationsOperationsCancelCall) Context(ctx context.Context) *ProjectsLocationsOperationsCancelCall {
10273 c.ctx_ = ctx
10274 return c
10275 }
10276
10277
10278
10279 func (c *ProjectsLocationsOperationsCancelCall) Header() http.Header {
10280 if c.header_ == nil {
10281 c.header_ = make(http.Header)
10282 }
10283 return c.header_
10284 }
10285
10286 func (c *ProjectsLocationsOperationsCancelCall) doRequest(alt string) (*http.Response, error) {
10287 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10288 var body io.Reader = nil
10289 body, err := googleapi.WithoutDataWrapper.JSONReader(c.canceloperationrequest)
10290 if err != nil {
10291 return nil, err
10292 }
10293 c.urlParams_.Set("alt", alt)
10294 c.urlParams_.Set("prettyPrint", "false")
10295 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:cancel")
10296 urls += "?" + c.urlParams_.Encode()
10297 req, err := http.NewRequest("POST", urls, body)
10298 if err != nil {
10299 return nil, err
10300 }
10301 req.Header = reqHeaders
10302 googleapi.Expand(req.URL, map[string]string{
10303 "name": c.name,
10304 })
10305 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10306 }
10307
10308
10309
10310
10311
10312
10313 func (c *ProjectsLocationsOperationsCancelCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
10314 gensupport.SetOptions(c.urlParams_, opts...)
10315 res, err := c.doRequest("json")
10316 if res != nil && res.StatusCode == http.StatusNotModified {
10317 if res.Body != nil {
10318 res.Body.Close()
10319 }
10320 return nil, gensupport.WrapError(&googleapi.Error{
10321 Code: res.StatusCode,
10322 Header: res.Header,
10323 })
10324 }
10325 if err != nil {
10326 return nil, err
10327 }
10328 defer googleapi.CloseBody(res)
10329 if err := googleapi.CheckResponse(res); err != nil {
10330 return nil, gensupport.WrapError(err)
10331 }
10332 ret := &Empty{
10333 ServerResponse: googleapi.ServerResponse{
10334 Header: res.Header,
10335 HTTPStatusCode: res.StatusCode,
10336 },
10337 }
10338 target := &ret
10339 if err := gensupport.DecodeResponse(target, res); err != nil {
10340 return nil, err
10341 }
10342 return ret, nil
10343 }
10344
10345 type ProjectsLocationsOperationsDeleteCall struct {
10346 s *Service
10347 name string
10348 urlParams_ gensupport.URLParams
10349 ctx_ context.Context
10350 header_ http.Header
10351 }
10352
10353
10354
10355
10356
10357
10358
10359 func (r *ProjectsLocationsOperationsService) Delete(name string) *ProjectsLocationsOperationsDeleteCall {
10360 c := &ProjectsLocationsOperationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10361 c.name = name
10362 return c
10363 }
10364
10365
10366
10367
10368 func (c *ProjectsLocationsOperationsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsDeleteCall {
10369 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10370 return c
10371 }
10372
10373
10374 func (c *ProjectsLocationsOperationsDeleteCall) Context(ctx context.Context) *ProjectsLocationsOperationsDeleteCall {
10375 c.ctx_ = ctx
10376 return c
10377 }
10378
10379
10380
10381 func (c *ProjectsLocationsOperationsDeleteCall) Header() http.Header {
10382 if c.header_ == nil {
10383 c.header_ = make(http.Header)
10384 }
10385 return c.header_
10386 }
10387
10388 func (c *ProjectsLocationsOperationsDeleteCall) doRequest(alt string) (*http.Response, error) {
10389 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10390 var body io.Reader = nil
10391 c.urlParams_.Set("alt", alt)
10392 c.urlParams_.Set("prettyPrint", "false")
10393 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10394 urls += "?" + c.urlParams_.Encode()
10395 req, err := http.NewRequest("DELETE", urls, body)
10396 if err != nil {
10397 return nil, err
10398 }
10399 req.Header = reqHeaders
10400 googleapi.Expand(req.URL, map[string]string{
10401 "name": c.name,
10402 })
10403 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10404 }
10405
10406
10407
10408
10409
10410
10411 func (c *ProjectsLocationsOperationsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
10412 gensupport.SetOptions(c.urlParams_, opts...)
10413 res, err := c.doRequest("json")
10414 if res != nil && res.StatusCode == http.StatusNotModified {
10415 if res.Body != nil {
10416 res.Body.Close()
10417 }
10418 return nil, gensupport.WrapError(&googleapi.Error{
10419 Code: res.StatusCode,
10420 Header: res.Header,
10421 })
10422 }
10423 if err != nil {
10424 return nil, err
10425 }
10426 defer googleapi.CloseBody(res)
10427 if err := googleapi.CheckResponse(res); err != nil {
10428 return nil, gensupport.WrapError(err)
10429 }
10430 ret := &Empty{
10431 ServerResponse: googleapi.ServerResponse{
10432 Header: res.Header,
10433 HTTPStatusCode: res.StatusCode,
10434 },
10435 }
10436 target := &ret
10437 if err := gensupport.DecodeResponse(target, res); err != nil {
10438 return nil, err
10439 }
10440 return ret, nil
10441 }
10442
10443 type ProjectsLocationsOperationsGetCall struct {
10444 s *Service
10445 name string
10446 urlParams_ gensupport.URLParams
10447 ifNoneMatch_ string
10448 ctx_ context.Context
10449 header_ http.Header
10450 }
10451
10452
10453
10454
10455
10456
10457 func (r *ProjectsLocationsOperationsService) Get(name string) *ProjectsLocationsOperationsGetCall {
10458 c := &ProjectsLocationsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10459 c.name = name
10460 return c
10461 }
10462
10463
10464
10465
10466 func (c *ProjectsLocationsOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsGetCall {
10467 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10468 return c
10469 }
10470
10471
10472
10473
10474 func (c *ProjectsLocationsOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsOperationsGetCall {
10475 c.ifNoneMatch_ = entityTag
10476 return c
10477 }
10478
10479
10480 func (c *ProjectsLocationsOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsOperationsGetCall {
10481 c.ctx_ = ctx
10482 return c
10483 }
10484
10485
10486
10487 func (c *ProjectsLocationsOperationsGetCall) Header() http.Header {
10488 if c.header_ == nil {
10489 c.header_ = make(http.Header)
10490 }
10491 return c.header_
10492 }
10493
10494 func (c *ProjectsLocationsOperationsGetCall) doRequest(alt string) (*http.Response, error) {
10495 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10496 if c.ifNoneMatch_ != "" {
10497 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10498 }
10499 var body io.Reader = nil
10500 c.urlParams_.Set("alt", alt)
10501 c.urlParams_.Set("prettyPrint", "false")
10502 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10503 urls += "?" + c.urlParams_.Encode()
10504 req, err := http.NewRequest("GET", urls, body)
10505 if err != nil {
10506 return nil, err
10507 }
10508 req.Header = reqHeaders
10509 googleapi.Expand(req.URL, map[string]string{
10510 "name": c.name,
10511 })
10512 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10513 }
10514
10515
10516
10517
10518
10519
10520 func (c *ProjectsLocationsOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
10521 gensupport.SetOptions(c.urlParams_, opts...)
10522 res, err := c.doRequest("json")
10523 if res != nil && res.StatusCode == http.StatusNotModified {
10524 if res.Body != nil {
10525 res.Body.Close()
10526 }
10527 return nil, gensupport.WrapError(&googleapi.Error{
10528 Code: res.StatusCode,
10529 Header: res.Header,
10530 })
10531 }
10532 if err != nil {
10533 return nil, err
10534 }
10535 defer googleapi.CloseBody(res)
10536 if err := googleapi.CheckResponse(res); err != nil {
10537 return nil, gensupport.WrapError(err)
10538 }
10539 ret := &Operation{
10540 ServerResponse: googleapi.ServerResponse{
10541 Header: res.Header,
10542 HTTPStatusCode: res.StatusCode,
10543 },
10544 }
10545 target := &ret
10546 if err := gensupport.DecodeResponse(target, res); err != nil {
10547 return nil, err
10548 }
10549 return ret, nil
10550 }
10551
10552 type ProjectsLocationsOperationsListCall struct {
10553 s *Service
10554 name string
10555 urlParams_ gensupport.URLParams
10556 ifNoneMatch_ string
10557 ctx_ context.Context
10558 header_ http.Header
10559 }
10560
10561
10562
10563
10564
10565 func (r *ProjectsLocationsOperationsService) List(name string) *ProjectsLocationsOperationsListCall {
10566 c := &ProjectsLocationsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10567 c.name = name
10568 return c
10569 }
10570
10571
10572 func (c *ProjectsLocationsOperationsListCall) Filter(filter string) *ProjectsLocationsOperationsListCall {
10573 c.urlParams_.Set("filter", filter)
10574 return c
10575 }
10576
10577
10578
10579 func (c *ProjectsLocationsOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsOperationsListCall {
10580 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
10581 return c
10582 }
10583
10584
10585
10586 func (c *ProjectsLocationsOperationsListCall) PageToken(pageToken string) *ProjectsLocationsOperationsListCall {
10587 c.urlParams_.Set("pageToken", pageToken)
10588 return c
10589 }
10590
10591
10592
10593
10594 func (c *ProjectsLocationsOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsListCall {
10595 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10596 return c
10597 }
10598
10599
10600
10601
10602 func (c *ProjectsLocationsOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsOperationsListCall {
10603 c.ifNoneMatch_ = entityTag
10604 return c
10605 }
10606
10607
10608 func (c *ProjectsLocationsOperationsListCall) Context(ctx context.Context) *ProjectsLocationsOperationsListCall {
10609 c.ctx_ = ctx
10610 return c
10611 }
10612
10613
10614
10615 func (c *ProjectsLocationsOperationsListCall) Header() http.Header {
10616 if c.header_ == nil {
10617 c.header_ = make(http.Header)
10618 }
10619 return c.header_
10620 }
10621
10622 func (c *ProjectsLocationsOperationsListCall) doRequest(alt string) (*http.Response, error) {
10623 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10624 if c.ifNoneMatch_ != "" {
10625 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10626 }
10627 var body io.Reader = nil
10628 c.urlParams_.Set("alt", alt)
10629 c.urlParams_.Set("prettyPrint", "false")
10630 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
10631 urls += "?" + c.urlParams_.Encode()
10632 req, err := http.NewRequest("GET", urls, body)
10633 if err != nil {
10634 return nil, err
10635 }
10636 req.Header = reqHeaders
10637 googleapi.Expand(req.URL, map[string]string{
10638 "name": c.name,
10639 })
10640 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10641 }
10642
10643
10644
10645
10646
10647
10648
10649 func (c *ProjectsLocationsOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
10650 gensupport.SetOptions(c.urlParams_, opts...)
10651 res, err := c.doRequest("json")
10652 if res != nil && res.StatusCode == http.StatusNotModified {
10653 if res.Body != nil {
10654 res.Body.Close()
10655 }
10656 return nil, gensupport.WrapError(&googleapi.Error{
10657 Code: res.StatusCode,
10658 Header: res.Header,
10659 })
10660 }
10661 if err != nil {
10662 return nil, err
10663 }
10664 defer googleapi.CloseBody(res)
10665 if err := googleapi.CheckResponse(res); err != nil {
10666 return nil, gensupport.WrapError(err)
10667 }
10668 ret := &ListOperationsResponse{
10669 ServerResponse: googleapi.ServerResponse{
10670 Header: res.Header,
10671 HTTPStatusCode: res.StatusCode,
10672 },
10673 }
10674 target := &ret
10675 if err := gensupport.DecodeResponse(target, res); err != nil {
10676 return nil, err
10677 }
10678 return ret, nil
10679 }
10680
10681
10682
10683
10684 func (c *ProjectsLocationsOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
10685 c.ctx_ = ctx
10686 defer c.PageToken(c.urlParams_.Get("pageToken"))
10687 for {
10688 x, err := c.Do()
10689 if err != nil {
10690 return err
10691 }
10692 if err := f(x); err != nil {
10693 return err
10694 }
10695 if x.NextPageToken == "" {
10696 return nil
10697 }
10698 c.PageToken(x.NextPageToken)
10699 }
10700 }
10701
10702 type ProjectsLocationsVmwareAdminClustersEnrollCall struct {
10703 s *Service
10704 parent string
10705 enrollvmwareadminclusterrequest *EnrollVmwareAdminClusterRequest
10706 urlParams_ gensupport.URLParams
10707 ctx_ context.Context
10708 header_ http.Header
10709 }
10710
10711
10712
10713
10714
10715
10716
10717
10718
10719 func (r *ProjectsLocationsVmwareAdminClustersService) Enroll(parent string, enrollvmwareadminclusterrequest *EnrollVmwareAdminClusterRequest) *ProjectsLocationsVmwareAdminClustersEnrollCall {
10720 c := &ProjectsLocationsVmwareAdminClustersEnrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10721 c.parent = parent
10722 c.enrollvmwareadminclusterrequest = enrollvmwareadminclusterrequest
10723 return c
10724 }
10725
10726
10727
10728
10729 func (c *ProjectsLocationsVmwareAdminClustersEnrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersEnrollCall {
10730 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10731 return c
10732 }
10733
10734
10735 func (c *ProjectsLocationsVmwareAdminClustersEnrollCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersEnrollCall {
10736 c.ctx_ = ctx
10737 return c
10738 }
10739
10740
10741
10742 func (c *ProjectsLocationsVmwareAdminClustersEnrollCall) Header() http.Header {
10743 if c.header_ == nil {
10744 c.header_ = make(http.Header)
10745 }
10746 return c.header_
10747 }
10748
10749 func (c *ProjectsLocationsVmwareAdminClustersEnrollCall) doRequest(alt string) (*http.Response, error) {
10750 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10751 var body io.Reader = nil
10752 body, err := googleapi.WithoutDataWrapper.JSONReader(c.enrollvmwareadminclusterrequest)
10753 if err != nil {
10754 return nil, err
10755 }
10756 c.urlParams_.Set("alt", alt)
10757 c.urlParams_.Set("prettyPrint", "false")
10758 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareAdminClusters:enroll")
10759 urls += "?" + c.urlParams_.Encode()
10760 req, err := http.NewRequest("POST", urls, body)
10761 if err != nil {
10762 return nil, err
10763 }
10764 req.Header = reqHeaders
10765 googleapi.Expand(req.URL, map[string]string{
10766 "parent": c.parent,
10767 })
10768 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10769 }
10770
10771
10772
10773
10774
10775
10776 func (c *ProjectsLocationsVmwareAdminClustersEnrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
10777 gensupport.SetOptions(c.urlParams_, opts...)
10778 res, err := c.doRequest("json")
10779 if res != nil && res.StatusCode == http.StatusNotModified {
10780 if res.Body != nil {
10781 res.Body.Close()
10782 }
10783 return nil, gensupport.WrapError(&googleapi.Error{
10784 Code: res.StatusCode,
10785 Header: res.Header,
10786 })
10787 }
10788 if err != nil {
10789 return nil, err
10790 }
10791 defer googleapi.CloseBody(res)
10792 if err := googleapi.CheckResponse(res); err != nil {
10793 return nil, gensupport.WrapError(err)
10794 }
10795 ret := &Operation{
10796 ServerResponse: googleapi.ServerResponse{
10797 Header: res.Header,
10798 HTTPStatusCode: res.StatusCode,
10799 },
10800 }
10801 target := &ret
10802 if err := gensupport.DecodeResponse(target, res); err != nil {
10803 return nil, err
10804 }
10805 return ret, nil
10806 }
10807
10808 type ProjectsLocationsVmwareAdminClustersGetCall struct {
10809 s *Service
10810 name string
10811 urlParams_ gensupport.URLParams
10812 ifNoneMatch_ string
10813 ctx_ context.Context
10814 header_ http.Header
10815 }
10816
10817
10818
10819
10820
10821
10822 func (r *ProjectsLocationsVmwareAdminClustersService) Get(name string) *ProjectsLocationsVmwareAdminClustersGetCall {
10823 c := &ProjectsLocationsVmwareAdminClustersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10824 c.name = name
10825 return c
10826 }
10827
10828
10829
10830
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
10841
10842
10843
10844
10845
10846 func (c *ProjectsLocationsVmwareAdminClustersGetCall) View(view string) *ProjectsLocationsVmwareAdminClustersGetCall {
10847 c.urlParams_.Set("view", view)
10848 return c
10849 }
10850
10851
10852
10853
10854 func (c *ProjectsLocationsVmwareAdminClustersGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersGetCall {
10855 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10856 return c
10857 }
10858
10859
10860
10861
10862 func (c *ProjectsLocationsVmwareAdminClustersGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareAdminClustersGetCall {
10863 c.ifNoneMatch_ = entityTag
10864 return c
10865 }
10866
10867
10868 func (c *ProjectsLocationsVmwareAdminClustersGetCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersGetCall {
10869 c.ctx_ = ctx
10870 return c
10871 }
10872
10873
10874
10875 func (c *ProjectsLocationsVmwareAdminClustersGetCall) Header() http.Header {
10876 if c.header_ == nil {
10877 c.header_ = make(http.Header)
10878 }
10879 return c.header_
10880 }
10881
10882 func (c *ProjectsLocationsVmwareAdminClustersGetCall) doRequest(alt string) (*http.Response, error) {
10883 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10884 if c.ifNoneMatch_ != "" {
10885 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10886 }
10887 var body io.Reader = nil
10888 c.urlParams_.Set("alt", alt)
10889 c.urlParams_.Set("prettyPrint", "false")
10890 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10891 urls += "?" + c.urlParams_.Encode()
10892 req, err := http.NewRequest("GET", urls, body)
10893 if err != nil {
10894 return nil, err
10895 }
10896 req.Header = reqHeaders
10897 googleapi.Expand(req.URL, map[string]string{
10898 "name": c.name,
10899 })
10900 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10901 }
10902
10903
10904
10905
10906
10907
10908
10909 func (c *ProjectsLocationsVmwareAdminClustersGetCall) Do(opts ...googleapi.CallOption) (*VmwareAdminCluster, error) {
10910 gensupport.SetOptions(c.urlParams_, opts...)
10911 res, err := c.doRequest("json")
10912 if res != nil && res.StatusCode == http.StatusNotModified {
10913 if res.Body != nil {
10914 res.Body.Close()
10915 }
10916 return nil, gensupport.WrapError(&googleapi.Error{
10917 Code: res.StatusCode,
10918 Header: res.Header,
10919 })
10920 }
10921 if err != nil {
10922 return nil, err
10923 }
10924 defer googleapi.CloseBody(res)
10925 if err := googleapi.CheckResponse(res); err != nil {
10926 return nil, gensupport.WrapError(err)
10927 }
10928 ret := &VmwareAdminCluster{
10929 ServerResponse: googleapi.ServerResponse{
10930 Header: res.Header,
10931 HTTPStatusCode: res.StatusCode,
10932 },
10933 }
10934 target := &ret
10935 if err := gensupport.DecodeResponse(target, res); err != nil {
10936 return nil, err
10937 }
10938 return ret, nil
10939 }
10940
10941 type ProjectsLocationsVmwareAdminClustersGetIamPolicyCall struct {
10942 s *Service
10943 resource string
10944 urlParams_ gensupport.URLParams
10945 ifNoneMatch_ string
10946 ctx_ context.Context
10947 header_ http.Header
10948 }
10949
10950
10951
10952
10953
10954
10955
10956 func (r *ProjectsLocationsVmwareAdminClustersService) GetIamPolicy(resource string) *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall {
10957 c := &ProjectsLocationsVmwareAdminClustersGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10958 c.resource = resource
10959 return c
10960 }
10961
10962
10963
10964
10965
10966
10967
10968
10969
10970
10971
10972
10973
10974 func (c *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall {
10975 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
10976 return c
10977 }
10978
10979
10980
10981
10982 func (c *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall {
10983 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10984 return c
10985 }
10986
10987
10988
10989
10990 func (c *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall {
10991 c.ifNoneMatch_ = entityTag
10992 return c
10993 }
10994
10995
10996 func (c *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall {
10997 c.ctx_ = ctx
10998 return c
10999 }
11000
11001
11002
11003 func (c *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall) Header() http.Header {
11004 if c.header_ == nil {
11005 c.header_ = make(http.Header)
11006 }
11007 return c.header_
11008 }
11009
11010 func (c *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
11011 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11012 if c.ifNoneMatch_ != "" {
11013 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11014 }
11015 var body io.Reader = nil
11016 c.urlParams_.Set("alt", alt)
11017 c.urlParams_.Set("prettyPrint", "false")
11018 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
11019 urls += "?" + c.urlParams_.Encode()
11020 req, err := http.NewRequest("GET", urls, body)
11021 if err != nil {
11022 return nil, err
11023 }
11024 req.Header = reqHeaders
11025 googleapi.Expand(req.URL, map[string]string{
11026 "resource": c.resource,
11027 })
11028 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11029 }
11030
11031
11032
11033
11034
11035
11036 func (c *ProjectsLocationsVmwareAdminClustersGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
11037 gensupport.SetOptions(c.urlParams_, opts...)
11038 res, err := c.doRequest("json")
11039 if res != nil && res.StatusCode == http.StatusNotModified {
11040 if res.Body != nil {
11041 res.Body.Close()
11042 }
11043 return nil, gensupport.WrapError(&googleapi.Error{
11044 Code: res.StatusCode,
11045 Header: res.Header,
11046 })
11047 }
11048 if err != nil {
11049 return nil, err
11050 }
11051 defer googleapi.CloseBody(res)
11052 if err := googleapi.CheckResponse(res); err != nil {
11053 return nil, gensupport.WrapError(err)
11054 }
11055 ret := &Policy{
11056 ServerResponse: googleapi.ServerResponse{
11057 Header: res.Header,
11058 HTTPStatusCode: res.StatusCode,
11059 },
11060 }
11061 target := &ret
11062 if err := gensupport.DecodeResponse(target, res); err != nil {
11063 return nil, err
11064 }
11065 return ret, nil
11066 }
11067
11068 type ProjectsLocationsVmwareAdminClustersListCall struct {
11069 s *Service
11070 parent string
11071 urlParams_ gensupport.URLParams
11072 ifNoneMatch_ string
11073 ctx_ context.Context
11074 header_ http.Header
11075 }
11076
11077
11078
11079
11080
11081 func (r *ProjectsLocationsVmwareAdminClustersService) List(parent string) *ProjectsLocationsVmwareAdminClustersListCall {
11082 c := &ProjectsLocationsVmwareAdminClustersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11083 c.parent = parent
11084 return c
11085 }
11086
11087
11088
11089
11090
11091 func (c *ProjectsLocationsVmwareAdminClustersListCall) PageSize(pageSize int64) *ProjectsLocationsVmwareAdminClustersListCall {
11092 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
11093 return c
11094 }
11095
11096
11097
11098 func (c *ProjectsLocationsVmwareAdminClustersListCall) PageToken(pageToken string) *ProjectsLocationsVmwareAdminClustersListCall {
11099 c.urlParams_.Set("pageToken", pageToken)
11100 return c
11101 }
11102
11103
11104
11105
11106
11107
11108
11109
11110
11111
11112
11113
11114
11115
11116
11117
11118
11119
11120
11121
11122
11123 func (c *ProjectsLocationsVmwareAdminClustersListCall) View(view string) *ProjectsLocationsVmwareAdminClustersListCall {
11124 c.urlParams_.Set("view", view)
11125 return c
11126 }
11127
11128
11129
11130
11131 func (c *ProjectsLocationsVmwareAdminClustersListCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersListCall {
11132 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11133 return c
11134 }
11135
11136
11137
11138
11139 func (c *ProjectsLocationsVmwareAdminClustersListCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareAdminClustersListCall {
11140 c.ifNoneMatch_ = entityTag
11141 return c
11142 }
11143
11144
11145 func (c *ProjectsLocationsVmwareAdminClustersListCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersListCall {
11146 c.ctx_ = ctx
11147 return c
11148 }
11149
11150
11151
11152 func (c *ProjectsLocationsVmwareAdminClustersListCall) Header() http.Header {
11153 if c.header_ == nil {
11154 c.header_ = make(http.Header)
11155 }
11156 return c.header_
11157 }
11158
11159 func (c *ProjectsLocationsVmwareAdminClustersListCall) doRequest(alt string) (*http.Response, error) {
11160 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11161 if c.ifNoneMatch_ != "" {
11162 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11163 }
11164 var body io.Reader = nil
11165 c.urlParams_.Set("alt", alt)
11166 c.urlParams_.Set("prettyPrint", "false")
11167 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareAdminClusters")
11168 urls += "?" + c.urlParams_.Encode()
11169 req, err := http.NewRequest("GET", urls, body)
11170 if err != nil {
11171 return nil, err
11172 }
11173 req.Header = reqHeaders
11174 googleapi.Expand(req.URL, map[string]string{
11175 "parent": c.parent,
11176 })
11177 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11178 }
11179
11180
11181
11182
11183
11184
11185
11186 func (c *ProjectsLocationsVmwareAdminClustersListCall) Do(opts ...googleapi.CallOption) (*ListVmwareAdminClustersResponse, error) {
11187 gensupport.SetOptions(c.urlParams_, opts...)
11188 res, err := c.doRequest("json")
11189 if res != nil && res.StatusCode == http.StatusNotModified {
11190 if res.Body != nil {
11191 res.Body.Close()
11192 }
11193 return nil, gensupport.WrapError(&googleapi.Error{
11194 Code: res.StatusCode,
11195 Header: res.Header,
11196 })
11197 }
11198 if err != nil {
11199 return nil, err
11200 }
11201 defer googleapi.CloseBody(res)
11202 if err := googleapi.CheckResponse(res); err != nil {
11203 return nil, gensupport.WrapError(err)
11204 }
11205 ret := &ListVmwareAdminClustersResponse{
11206 ServerResponse: googleapi.ServerResponse{
11207 Header: res.Header,
11208 HTTPStatusCode: res.StatusCode,
11209 },
11210 }
11211 target := &ret
11212 if err := gensupport.DecodeResponse(target, res); err != nil {
11213 return nil, err
11214 }
11215 return ret, nil
11216 }
11217
11218
11219
11220
11221 func (c *ProjectsLocationsVmwareAdminClustersListCall) Pages(ctx context.Context, f func(*ListVmwareAdminClustersResponse) error) error {
11222 c.ctx_ = ctx
11223 defer c.PageToken(c.urlParams_.Get("pageToken"))
11224 for {
11225 x, err := c.Do()
11226 if err != nil {
11227 return err
11228 }
11229 if err := f(x); err != nil {
11230 return err
11231 }
11232 if x.NextPageToken == "" {
11233 return nil
11234 }
11235 c.PageToken(x.NextPageToken)
11236 }
11237 }
11238
11239 type ProjectsLocationsVmwareAdminClustersPatchCall struct {
11240 s *Service
11241 name string
11242 vmwareadmincluster *VmwareAdminCluster
11243 urlParams_ gensupport.URLParams
11244 ctx_ context.Context
11245 header_ http.Header
11246 }
11247
11248
11249
11250
11251 func (r *ProjectsLocationsVmwareAdminClustersService) Patch(name string, vmwareadmincluster *VmwareAdminCluster) *ProjectsLocationsVmwareAdminClustersPatchCall {
11252 c := &ProjectsLocationsVmwareAdminClustersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11253 c.name = name
11254 c.vmwareadmincluster = vmwareadmincluster
11255 return c
11256 }
11257
11258
11259
11260
11261
11262
11263
11264
11265 func (c *ProjectsLocationsVmwareAdminClustersPatchCall) UpdateMask(updateMask string) *ProjectsLocationsVmwareAdminClustersPatchCall {
11266 c.urlParams_.Set("updateMask", updateMask)
11267 return c
11268 }
11269
11270
11271
11272 func (c *ProjectsLocationsVmwareAdminClustersPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareAdminClustersPatchCall {
11273 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
11274 return c
11275 }
11276
11277
11278
11279
11280 func (c *ProjectsLocationsVmwareAdminClustersPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersPatchCall {
11281 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11282 return c
11283 }
11284
11285
11286 func (c *ProjectsLocationsVmwareAdminClustersPatchCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersPatchCall {
11287 c.ctx_ = ctx
11288 return c
11289 }
11290
11291
11292
11293 func (c *ProjectsLocationsVmwareAdminClustersPatchCall) Header() http.Header {
11294 if c.header_ == nil {
11295 c.header_ = make(http.Header)
11296 }
11297 return c.header_
11298 }
11299
11300 func (c *ProjectsLocationsVmwareAdminClustersPatchCall) doRequest(alt string) (*http.Response, error) {
11301 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11302 var body io.Reader = nil
11303 body, err := googleapi.WithoutDataWrapper.JSONReader(c.vmwareadmincluster)
11304 if err != nil {
11305 return nil, err
11306 }
11307 c.urlParams_.Set("alt", alt)
11308 c.urlParams_.Set("prettyPrint", "false")
11309 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
11310 urls += "?" + c.urlParams_.Encode()
11311 req, err := http.NewRequest("PATCH", urls, body)
11312 if err != nil {
11313 return nil, err
11314 }
11315 req.Header = reqHeaders
11316 googleapi.Expand(req.URL, map[string]string{
11317 "name": c.name,
11318 })
11319 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11320 }
11321
11322
11323
11324
11325
11326
11327 func (c *ProjectsLocationsVmwareAdminClustersPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
11328 gensupport.SetOptions(c.urlParams_, opts...)
11329 res, err := c.doRequest("json")
11330 if res != nil && res.StatusCode == http.StatusNotModified {
11331 if res.Body != nil {
11332 res.Body.Close()
11333 }
11334 return nil, gensupport.WrapError(&googleapi.Error{
11335 Code: res.StatusCode,
11336 Header: res.Header,
11337 })
11338 }
11339 if err != nil {
11340 return nil, err
11341 }
11342 defer googleapi.CloseBody(res)
11343 if err := googleapi.CheckResponse(res); err != nil {
11344 return nil, gensupport.WrapError(err)
11345 }
11346 ret := &Operation{
11347 ServerResponse: googleapi.ServerResponse{
11348 Header: res.Header,
11349 HTTPStatusCode: res.StatusCode,
11350 },
11351 }
11352 target := &ret
11353 if err := gensupport.DecodeResponse(target, res); err != nil {
11354 return nil, err
11355 }
11356 return ret, nil
11357 }
11358
11359 type ProjectsLocationsVmwareAdminClustersSetIamPolicyCall struct {
11360 s *Service
11361 resource string
11362 setiampolicyrequest *SetIamPolicyRequest
11363 urlParams_ gensupport.URLParams
11364 ctx_ context.Context
11365 header_ http.Header
11366 }
11367
11368
11369
11370
11371
11372
11373
11374
11375 func (r *ProjectsLocationsVmwareAdminClustersService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsVmwareAdminClustersSetIamPolicyCall {
11376 c := &ProjectsLocationsVmwareAdminClustersSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11377 c.resource = resource
11378 c.setiampolicyrequest = setiampolicyrequest
11379 return c
11380 }
11381
11382
11383
11384
11385 func (c *ProjectsLocationsVmwareAdminClustersSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersSetIamPolicyCall {
11386 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11387 return c
11388 }
11389
11390
11391 func (c *ProjectsLocationsVmwareAdminClustersSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersSetIamPolicyCall {
11392 c.ctx_ = ctx
11393 return c
11394 }
11395
11396
11397
11398 func (c *ProjectsLocationsVmwareAdminClustersSetIamPolicyCall) Header() http.Header {
11399 if c.header_ == nil {
11400 c.header_ = make(http.Header)
11401 }
11402 return c.header_
11403 }
11404
11405 func (c *ProjectsLocationsVmwareAdminClustersSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
11406 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11407 var body io.Reader = nil
11408 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
11409 if err != nil {
11410 return nil, err
11411 }
11412 c.urlParams_.Set("alt", alt)
11413 c.urlParams_.Set("prettyPrint", "false")
11414 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
11415 urls += "?" + c.urlParams_.Encode()
11416 req, err := http.NewRequest("POST", urls, body)
11417 if err != nil {
11418 return nil, err
11419 }
11420 req.Header = reqHeaders
11421 googleapi.Expand(req.URL, map[string]string{
11422 "resource": c.resource,
11423 })
11424 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11425 }
11426
11427
11428
11429
11430
11431
11432 func (c *ProjectsLocationsVmwareAdminClustersSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
11433 gensupport.SetOptions(c.urlParams_, opts...)
11434 res, err := c.doRequest("json")
11435 if res != nil && res.StatusCode == http.StatusNotModified {
11436 if res.Body != nil {
11437 res.Body.Close()
11438 }
11439 return nil, gensupport.WrapError(&googleapi.Error{
11440 Code: res.StatusCode,
11441 Header: res.Header,
11442 })
11443 }
11444 if err != nil {
11445 return nil, err
11446 }
11447 defer googleapi.CloseBody(res)
11448 if err := googleapi.CheckResponse(res); err != nil {
11449 return nil, gensupport.WrapError(err)
11450 }
11451 ret := &Policy{
11452 ServerResponse: googleapi.ServerResponse{
11453 Header: res.Header,
11454 HTTPStatusCode: res.StatusCode,
11455 },
11456 }
11457 target := &ret
11458 if err := gensupport.DecodeResponse(target, res); err != nil {
11459 return nil, err
11460 }
11461 return ret, nil
11462 }
11463
11464 type ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall struct {
11465 s *Service
11466 resource string
11467 testiampermissionsrequest *TestIamPermissionsRequest
11468 urlParams_ gensupport.URLParams
11469 ctx_ context.Context
11470 header_ http.Header
11471 }
11472
11473
11474
11475
11476
11477
11478
11479
11480
11481
11482
11483 func (r *ProjectsLocationsVmwareAdminClustersService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall {
11484 c := &ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11485 c.resource = resource
11486 c.testiampermissionsrequest = testiampermissionsrequest
11487 return c
11488 }
11489
11490
11491
11492
11493 func (c *ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall {
11494 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11495 return c
11496 }
11497
11498
11499 func (c *ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall {
11500 c.ctx_ = ctx
11501 return c
11502 }
11503
11504
11505
11506 func (c *ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall) Header() http.Header {
11507 if c.header_ == nil {
11508 c.header_ = make(http.Header)
11509 }
11510 return c.header_
11511 }
11512
11513 func (c *ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
11514 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11515 var body io.Reader = nil
11516 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
11517 if err != nil {
11518 return nil, err
11519 }
11520 c.urlParams_.Set("alt", alt)
11521 c.urlParams_.Set("prettyPrint", "false")
11522 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
11523 urls += "?" + c.urlParams_.Encode()
11524 req, err := http.NewRequest("POST", urls, body)
11525 if err != nil {
11526 return nil, err
11527 }
11528 req.Header = reqHeaders
11529 googleapi.Expand(req.URL, map[string]string{
11530 "resource": c.resource,
11531 })
11532 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11533 }
11534
11535
11536
11537
11538
11539
11540
11541 func (c *ProjectsLocationsVmwareAdminClustersTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
11542 gensupport.SetOptions(c.urlParams_, opts...)
11543 res, err := c.doRequest("json")
11544 if res != nil && res.StatusCode == http.StatusNotModified {
11545 if res.Body != nil {
11546 res.Body.Close()
11547 }
11548 return nil, gensupport.WrapError(&googleapi.Error{
11549 Code: res.StatusCode,
11550 Header: res.Header,
11551 })
11552 }
11553 if err != nil {
11554 return nil, err
11555 }
11556 defer googleapi.CloseBody(res)
11557 if err := googleapi.CheckResponse(res); err != nil {
11558 return nil, gensupport.WrapError(err)
11559 }
11560 ret := &TestIamPermissionsResponse{
11561 ServerResponse: googleapi.ServerResponse{
11562 Header: res.Header,
11563 HTTPStatusCode: res.StatusCode,
11564 },
11565 }
11566 target := &ret
11567 if err := gensupport.DecodeResponse(target, res); err != nil {
11568 return nil, err
11569 }
11570 return ret, nil
11571 }
11572
11573 type ProjectsLocationsVmwareAdminClustersUnenrollCall struct {
11574 s *Service
11575 name string
11576 urlParams_ gensupport.URLParams
11577 ctx_ context.Context
11578 header_ http.Header
11579 }
11580
11581
11582
11583
11584
11585
11586
11587
11588
11589 func (r *ProjectsLocationsVmwareAdminClustersService) Unenroll(name string) *ProjectsLocationsVmwareAdminClustersUnenrollCall {
11590 c := &ProjectsLocationsVmwareAdminClustersUnenrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11591 c.name = name
11592 return c
11593 }
11594
11595
11596
11597
11598 func (c *ProjectsLocationsVmwareAdminClustersUnenrollCall) AllowMissing(allowMissing bool) *ProjectsLocationsVmwareAdminClustersUnenrollCall {
11599 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
11600 return c
11601 }
11602
11603
11604
11605
11606 func (c *ProjectsLocationsVmwareAdminClustersUnenrollCall) Etag(etag string) *ProjectsLocationsVmwareAdminClustersUnenrollCall {
11607 c.urlParams_.Set("etag", etag)
11608 return c
11609 }
11610
11611
11612
11613 func (c *ProjectsLocationsVmwareAdminClustersUnenrollCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareAdminClustersUnenrollCall {
11614 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
11615 return c
11616 }
11617
11618
11619
11620
11621 func (c *ProjectsLocationsVmwareAdminClustersUnenrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersUnenrollCall {
11622 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11623 return c
11624 }
11625
11626
11627 func (c *ProjectsLocationsVmwareAdminClustersUnenrollCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersUnenrollCall {
11628 c.ctx_ = ctx
11629 return c
11630 }
11631
11632
11633
11634 func (c *ProjectsLocationsVmwareAdminClustersUnenrollCall) Header() http.Header {
11635 if c.header_ == nil {
11636 c.header_ = make(http.Header)
11637 }
11638 return c.header_
11639 }
11640
11641 func (c *ProjectsLocationsVmwareAdminClustersUnenrollCall) doRequest(alt string) (*http.Response, error) {
11642 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11643 var body io.Reader = nil
11644 c.urlParams_.Set("alt", alt)
11645 c.urlParams_.Set("prettyPrint", "false")
11646 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:unenroll")
11647 urls += "?" + c.urlParams_.Encode()
11648 req, err := http.NewRequest("DELETE", urls, body)
11649 if err != nil {
11650 return nil, err
11651 }
11652 req.Header = reqHeaders
11653 googleapi.Expand(req.URL, map[string]string{
11654 "name": c.name,
11655 })
11656 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11657 }
11658
11659
11660
11661
11662
11663
11664 func (c *ProjectsLocationsVmwareAdminClustersUnenrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
11665 gensupport.SetOptions(c.urlParams_, opts...)
11666 res, err := c.doRequest("json")
11667 if res != nil && res.StatusCode == http.StatusNotModified {
11668 if res.Body != nil {
11669 res.Body.Close()
11670 }
11671 return nil, gensupport.WrapError(&googleapi.Error{
11672 Code: res.StatusCode,
11673 Header: res.Header,
11674 })
11675 }
11676 if err != nil {
11677 return nil, err
11678 }
11679 defer googleapi.CloseBody(res)
11680 if err := googleapi.CheckResponse(res); err != nil {
11681 return nil, gensupport.WrapError(err)
11682 }
11683 ret := &Operation{
11684 ServerResponse: googleapi.ServerResponse{
11685 Header: res.Header,
11686 HTTPStatusCode: res.StatusCode,
11687 },
11688 }
11689 target := &ret
11690 if err := gensupport.DecodeResponse(target, res); err != nil {
11691 return nil, err
11692 }
11693 return ret, nil
11694 }
11695
11696 type ProjectsLocationsVmwareAdminClustersOperationsGetCall struct {
11697 s *Service
11698 name string
11699 urlParams_ gensupport.URLParams
11700 ifNoneMatch_ string
11701 ctx_ context.Context
11702 header_ http.Header
11703 }
11704
11705
11706
11707
11708
11709
11710 func (r *ProjectsLocationsVmwareAdminClustersOperationsService) Get(name string) *ProjectsLocationsVmwareAdminClustersOperationsGetCall {
11711 c := &ProjectsLocationsVmwareAdminClustersOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11712 c.name = name
11713 return c
11714 }
11715
11716
11717
11718
11719 func (c *ProjectsLocationsVmwareAdminClustersOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersOperationsGetCall {
11720 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11721 return c
11722 }
11723
11724
11725
11726
11727 func (c *ProjectsLocationsVmwareAdminClustersOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareAdminClustersOperationsGetCall {
11728 c.ifNoneMatch_ = entityTag
11729 return c
11730 }
11731
11732
11733 func (c *ProjectsLocationsVmwareAdminClustersOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersOperationsGetCall {
11734 c.ctx_ = ctx
11735 return c
11736 }
11737
11738
11739
11740 func (c *ProjectsLocationsVmwareAdminClustersOperationsGetCall) Header() http.Header {
11741 if c.header_ == nil {
11742 c.header_ = make(http.Header)
11743 }
11744 return c.header_
11745 }
11746
11747 func (c *ProjectsLocationsVmwareAdminClustersOperationsGetCall) doRequest(alt string) (*http.Response, error) {
11748 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11749 if c.ifNoneMatch_ != "" {
11750 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11751 }
11752 var body io.Reader = nil
11753 c.urlParams_.Set("alt", alt)
11754 c.urlParams_.Set("prettyPrint", "false")
11755 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
11756 urls += "?" + c.urlParams_.Encode()
11757 req, err := http.NewRequest("GET", urls, body)
11758 if err != nil {
11759 return nil, err
11760 }
11761 req.Header = reqHeaders
11762 googleapi.Expand(req.URL, map[string]string{
11763 "name": c.name,
11764 })
11765 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11766 }
11767
11768
11769
11770
11771
11772
11773 func (c *ProjectsLocationsVmwareAdminClustersOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
11774 gensupport.SetOptions(c.urlParams_, opts...)
11775 res, err := c.doRequest("json")
11776 if res != nil && res.StatusCode == http.StatusNotModified {
11777 if res.Body != nil {
11778 res.Body.Close()
11779 }
11780 return nil, gensupport.WrapError(&googleapi.Error{
11781 Code: res.StatusCode,
11782 Header: res.Header,
11783 })
11784 }
11785 if err != nil {
11786 return nil, err
11787 }
11788 defer googleapi.CloseBody(res)
11789 if err := googleapi.CheckResponse(res); err != nil {
11790 return nil, gensupport.WrapError(err)
11791 }
11792 ret := &Operation{
11793 ServerResponse: googleapi.ServerResponse{
11794 Header: res.Header,
11795 HTTPStatusCode: res.StatusCode,
11796 },
11797 }
11798 target := &ret
11799 if err := gensupport.DecodeResponse(target, res); err != nil {
11800 return nil, err
11801 }
11802 return ret, nil
11803 }
11804
11805 type ProjectsLocationsVmwareAdminClustersOperationsListCall struct {
11806 s *Service
11807 name string
11808 urlParams_ gensupport.URLParams
11809 ifNoneMatch_ string
11810 ctx_ context.Context
11811 header_ http.Header
11812 }
11813
11814
11815
11816
11817
11818 func (r *ProjectsLocationsVmwareAdminClustersOperationsService) List(name string) *ProjectsLocationsVmwareAdminClustersOperationsListCall {
11819 c := &ProjectsLocationsVmwareAdminClustersOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11820 c.name = name
11821 return c
11822 }
11823
11824
11825 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) Filter(filter string) *ProjectsLocationsVmwareAdminClustersOperationsListCall {
11826 c.urlParams_.Set("filter", filter)
11827 return c
11828 }
11829
11830
11831
11832 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsVmwareAdminClustersOperationsListCall {
11833 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
11834 return c
11835 }
11836
11837
11838
11839 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) PageToken(pageToken string) *ProjectsLocationsVmwareAdminClustersOperationsListCall {
11840 c.urlParams_.Set("pageToken", pageToken)
11841 return c
11842 }
11843
11844
11845
11846
11847 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareAdminClustersOperationsListCall {
11848 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11849 return c
11850 }
11851
11852
11853
11854
11855 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareAdminClustersOperationsListCall {
11856 c.ifNoneMatch_ = entityTag
11857 return c
11858 }
11859
11860
11861 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) Context(ctx context.Context) *ProjectsLocationsVmwareAdminClustersOperationsListCall {
11862 c.ctx_ = ctx
11863 return c
11864 }
11865
11866
11867
11868 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) Header() http.Header {
11869 if c.header_ == nil {
11870 c.header_ = make(http.Header)
11871 }
11872 return c.header_
11873 }
11874
11875 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) doRequest(alt string) (*http.Response, error) {
11876 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11877 if c.ifNoneMatch_ != "" {
11878 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11879 }
11880 var body io.Reader = nil
11881 c.urlParams_.Set("alt", alt)
11882 c.urlParams_.Set("prettyPrint", "false")
11883 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
11884 urls += "?" + c.urlParams_.Encode()
11885 req, err := http.NewRequest("GET", urls, body)
11886 if err != nil {
11887 return nil, err
11888 }
11889 req.Header = reqHeaders
11890 googleapi.Expand(req.URL, map[string]string{
11891 "name": c.name,
11892 })
11893 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11894 }
11895
11896
11897
11898
11899
11900
11901
11902 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
11903 gensupport.SetOptions(c.urlParams_, opts...)
11904 res, err := c.doRequest("json")
11905 if res != nil && res.StatusCode == http.StatusNotModified {
11906 if res.Body != nil {
11907 res.Body.Close()
11908 }
11909 return nil, gensupport.WrapError(&googleapi.Error{
11910 Code: res.StatusCode,
11911 Header: res.Header,
11912 })
11913 }
11914 if err != nil {
11915 return nil, err
11916 }
11917 defer googleapi.CloseBody(res)
11918 if err := googleapi.CheckResponse(res); err != nil {
11919 return nil, gensupport.WrapError(err)
11920 }
11921 ret := &ListOperationsResponse{
11922 ServerResponse: googleapi.ServerResponse{
11923 Header: res.Header,
11924 HTTPStatusCode: res.StatusCode,
11925 },
11926 }
11927 target := &ret
11928 if err := gensupport.DecodeResponse(target, res); err != nil {
11929 return nil, err
11930 }
11931 return ret, nil
11932 }
11933
11934
11935
11936
11937 func (c *ProjectsLocationsVmwareAdminClustersOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
11938 c.ctx_ = ctx
11939 defer c.PageToken(c.urlParams_.Get("pageToken"))
11940 for {
11941 x, err := c.Do()
11942 if err != nil {
11943 return err
11944 }
11945 if err := f(x); err != nil {
11946 return err
11947 }
11948 if x.NextPageToken == "" {
11949 return nil
11950 }
11951 c.PageToken(x.NextPageToken)
11952 }
11953 }
11954
11955 type ProjectsLocationsVmwareClustersCreateCall struct {
11956 s *Service
11957 parent string
11958 vmwarecluster *VmwareCluster
11959 urlParams_ gensupport.URLParams
11960 ctx_ context.Context
11961 header_ http.Header
11962 }
11963
11964
11965
11966
11967
11968 func (r *ProjectsLocationsVmwareClustersService) Create(parent string, vmwarecluster *VmwareCluster) *ProjectsLocationsVmwareClustersCreateCall {
11969 c := &ProjectsLocationsVmwareClustersCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11970 c.parent = parent
11971 c.vmwarecluster = vmwarecluster
11972 return c
11973 }
11974
11975
11976
11977 func (c *ProjectsLocationsVmwareClustersCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareClustersCreateCall {
11978 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
11979 return c
11980 }
11981
11982
11983
11984
11985
11986 func (c *ProjectsLocationsVmwareClustersCreateCall) VmwareClusterId(vmwareClusterId string) *ProjectsLocationsVmwareClustersCreateCall {
11987 c.urlParams_.Set("vmwareClusterId", vmwareClusterId)
11988 return c
11989 }
11990
11991
11992
11993
11994 func (c *ProjectsLocationsVmwareClustersCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersCreateCall {
11995 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11996 return c
11997 }
11998
11999
12000 func (c *ProjectsLocationsVmwareClustersCreateCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersCreateCall {
12001 c.ctx_ = ctx
12002 return c
12003 }
12004
12005
12006
12007 func (c *ProjectsLocationsVmwareClustersCreateCall) Header() http.Header {
12008 if c.header_ == nil {
12009 c.header_ = make(http.Header)
12010 }
12011 return c.header_
12012 }
12013
12014 func (c *ProjectsLocationsVmwareClustersCreateCall) doRequest(alt string) (*http.Response, error) {
12015 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12016 var body io.Reader = nil
12017 body, err := googleapi.WithoutDataWrapper.JSONReader(c.vmwarecluster)
12018 if err != nil {
12019 return nil, err
12020 }
12021 c.urlParams_.Set("alt", alt)
12022 c.urlParams_.Set("prettyPrint", "false")
12023 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareClusters")
12024 urls += "?" + c.urlParams_.Encode()
12025 req, err := http.NewRequest("POST", urls, body)
12026 if err != nil {
12027 return nil, err
12028 }
12029 req.Header = reqHeaders
12030 googleapi.Expand(req.URL, map[string]string{
12031 "parent": c.parent,
12032 })
12033 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12034 }
12035
12036
12037
12038
12039
12040
12041 func (c *ProjectsLocationsVmwareClustersCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
12042 gensupport.SetOptions(c.urlParams_, opts...)
12043 res, err := c.doRequest("json")
12044 if res != nil && res.StatusCode == http.StatusNotModified {
12045 if res.Body != nil {
12046 res.Body.Close()
12047 }
12048 return nil, gensupport.WrapError(&googleapi.Error{
12049 Code: res.StatusCode,
12050 Header: res.Header,
12051 })
12052 }
12053 if err != nil {
12054 return nil, err
12055 }
12056 defer googleapi.CloseBody(res)
12057 if err := googleapi.CheckResponse(res); err != nil {
12058 return nil, gensupport.WrapError(err)
12059 }
12060 ret := &Operation{
12061 ServerResponse: googleapi.ServerResponse{
12062 Header: res.Header,
12063 HTTPStatusCode: res.StatusCode,
12064 },
12065 }
12066 target := &ret
12067 if err := gensupport.DecodeResponse(target, res); err != nil {
12068 return nil, err
12069 }
12070 return ret, nil
12071 }
12072
12073 type ProjectsLocationsVmwareClustersDeleteCall struct {
12074 s *Service
12075 name string
12076 urlParams_ gensupport.URLParams
12077 ctx_ context.Context
12078 header_ http.Header
12079 }
12080
12081
12082
12083
12084
12085 func (r *ProjectsLocationsVmwareClustersService) Delete(name string) *ProjectsLocationsVmwareClustersDeleteCall {
12086 c := &ProjectsLocationsVmwareClustersDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12087 c.name = name
12088 return c
12089 }
12090
12091
12092
12093
12094 func (c *ProjectsLocationsVmwareClustersDeleteCall) AllowMissing(allowMissing bool) *ProjectsLocationsVmwareClustersDeleteCall {
12095 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
12096 return c
12097 }
12098
12099
12100
12101
12102 func (c *ProjectsLocationsVmwareClustersDeleteCall) Etag(etag string) *ProjectsLocationsVmwareClustersDeleteCall {
12103 c.urlParams_.Set("etag", etag)
12104 return c
12105 }
12106
12107
12108
12109 func (c *ProjectsLocationsVmwareClustersDeleteCall) Force(force bool) *ProjectsLocationsVmwareClustersDeleteCall {
12110 c.urlParams_.Set("force", fmt.Sprint(force))
12111 return c
12112 }
12113
12114
12115
12116
12117
12118
12119
12120
12121 func (c *ProjectsLocationsVmwareClustersDeleteCall) IgnoreErrors(ignoreErrors bool) *ProjectsLocationsVmwareClustersDeleteCall {
12122 c.urlParams_.Set("ignoreErrors", fmt.Sprint(ignoreErrors))
12123 return c
12124 }
12125
12126
12127
12128 func (c *ProjectsLocationsVmwareClustersDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareClustersDeleteCall {
12129 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
12130 return c
12131 }
12132
12133
12134
12135
12136 func (c *ProjectsLocationsVmwareClustersDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersDeleteCall {
12137 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12138 return c
12139 }
12140
12141
12142 func (c *ProjectsLocationsVmwareClustersDeleteCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersDeleteCall {
12143 c.ctx_ = ctx
12144 return c
12145 }
12146
12147
12148
12149 func (c *ProjectsLocationsVmwareClustersDeleteCall) Header() http.Header {
12150 if c.header_ == nil {
12151 c.header_ = make(http.Header)
12152 }
12153 return c.header_
12154 }
12155
12156 func (c *ProjectsLocationsVmwareClustersDeleteCall) doRequest(alt string) (*http.Response, error) {
12157 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12158 var body io.Reader = nil
12159 c.urlParams_.Set("alt", alt)
12160 c.urlParams_.Set("prettyPrint", "false")
12161 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
12162 urls += "?" + c.urlParams_.Encode()
12163 req, err := http.NewRequest("DELETE", urls, body)
12164 if err != nil {
12165 return nil, err
12166 }
12167 req.Header = reqHeaders
12168 googleapi.Expand(req.URL, map[string]string{
12169 "name": c.name,
12170 })
12171 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12172 }
12173
12174
12175
12176
12177
12178
12179 func (c *ProjectsLocationsVmwareClustersDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
12180 gensupport.SetOptions(c.urlParams_, opts...)
12181 res, err := c.doRequest("json")
12182 if res != nil && res.StatusCode == http.StatusNotModified {
12183 if res.Body != nil {
12184 res.Body.Close()
12185 }
12186 return nil, gensupport.WrapError(&googleapi.Error{
12187 Code: res.StatusCode,
12188 Header: res.Header,
12189 })
12190 }
12191 if err != nil {
12192 return nil, err
12193 }
12194 defer googleapi.CloseBody(res)
12195 if err := googleapi.CheckResponse(res); err != nil {
12196 return nil, gensupport.WrapError(err)
12197 }
12198 ret := &Operation{
12199 ServerResponse: googleapi.ServerResponse{
12200 Header: res.Header,
12201 HTTPStatusCode: res.StatusCode,
12202 },
12203 }
12204 target := &ret
12205 if err := gensupport.DecodeResponse(target, res); err != nil {
12206 return nil, err
12207 }
12208 return ret, nil
12209 }
12210
12211 type ProjectsLocationsVmwareClustersEnrollCall struct {
12212 s *Service
12213 parent string
12214 enrollvmwareclusterrequest *EnrollVmwareClusterRequest
12215 urlParams_ gensupport.URLParams
12216 ctx_ context.Context
12217 header_ http.Header
12218 }
12219
12220
12221
12222
12223
12224
12225
12226
12227
12228
12229 func (r *ProjectsLocationsVmwareClustersService) Enroll(parent string, enrollvmwareclusterrequest *EnrollVmwareClusterRequest) *ProjectsLocationsVmwareClustersEnrollCall {
12230 c := &ProjectsLocationsVmwareClustersEnrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12231 c.parent = parent
12232 c.enrollvmwareclusterrequest = enrollvmwareclusterrequest
12233 return c
12234 }
12235
12236
12237
12238
12239 func (c *ProjectsLocationsVmwareClustersEnrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersEnrollCall {
12240 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12241 return c
12242 }
12243
12244
12245 func (c *ProjectsLocationsVmwareClustersEnrollCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersEnrollCall {
12246 c.ctx_ = ctx
12247 return c
12248 }
12249
12250
12251
12252 func (c *ProjectsLocationsVmwareClustersEnrollCall) Header() http.Header {
12253 if c.header_ == nil {
12254 c.header_ = make(http.Header)
12255 }
12256 return c.header_
12257 }
12258
12259 func (c *ProjectsLocationsVmwareClustersEnrollCall) doRequest(alt string) (*http.Response, error) {
12260 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12261 var body io.Reader = nil
12262 body, err := googleapi.WithoutDataWrapper.JSONReader(c.enrollvmwareclusterrequest)
12263 if err != nil {
12264 return nil, err
12265 }
12266 c.urlParams_.Set("alt", alt)
12267 c.urlParams_.Set("prettyPrint", "false")
12268 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareClusters:enroll")
12269 urls += "?" + c.urlParams_.Encode()
12270 req, err := http.NewRequest("POST", urls, body)
12271 if err != nil {
12272 return nil, err
12273 }
12274 req.Header = reqHeaders
12275 googleapi.Expand(req.URL, map[string]string{
12276 "parent": c.parent,
12277 })
12278 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12279 }
12280
12281
12282
12283
12284
12285
12286 func (c *ProjectsLocationsVmwareClustersEnrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
12287 gensupport.SetOptions(c.urlParams_, opts...)
12288 res, err := c.doRequest("json")
12289 if res != nil && res.StatusCode == http.StatusNotModified {
12290 if res.Body != nil {
12291 res.Body.Close()
12292 }
12293 return nil, gensupport.WrapError(&googleapi.Error{
12294 Code: res.StatusCode,
12295 Header: res.Header,
12296 })
12297 }
12298 if err != nil {
12299 return nil, err
12300 }
12301 defer googleapi.CloseBody(res)
12302 if err := googleapi.CheckResponse(res); err != nil {
12303 return nil, gensupport.WrapError(err)
12304 }
12305 ret := &Operation{
12306 ServerResponse: googleapi.ServerResponse{
12307 Header: res.Header,
12308 HTTPStatusCode: res.StatusCode,
12309 },
12310 }
12311 target := &ret
12312 if err := gensupport.DecodeResponse(target, res); err != nil {
12313 return nil, err
12314 }
12315 return ret, nil
12316 }
12317
12318 type ProjectsLocationsVmwareClustersGetCall struct {
12319 s *Service
12320 name string
12321 urlParams_ gensupport.URLParams
12322 ifNoneMatch_ string
12323 ctx_ context.Context
12324 header_ http.Header
12325 }
12326
12327
12328
12329
12330
12331 func (r *ProjectsLocationsVmwareClustersService) Get(name string) *ProjectsLocationsVmwareClustersGetCall {
12332 c := &ProjectsLocationsVmwareClustersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12333 c.name = name
12334 return c
12335 }
12336
12337
12338
12339
12340
12341
12342
12343
12344
12345
12346
12347
12348
12349
12350
12351
12352
12353
12354
12355
12356 func (c *ProjectsLocationsVmwareClustersGetCall) View(view string) *ProjectsLocationsVmwareClustersGetCall {
12357 c.urlParams_.Set("view", view)
12358 return c
12359 }
12360
12361
12362
12363
12364 func (c *ProjectsLocationsVmwareClustersGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersGetCall {
12365 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12366 return c
12367 }
12368
12369
12370
12371
12372 func (c *ProjectsLocationsVmwareClustersGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersGetCall {
12373 c.ifNoneMatch_ = entityTag
12374 return c
12375 }
12376
12377
12378 func (c *ProjectsLocationsVmwareClustersGetCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersGetCall {
12379 c.ctx_ = ctx
12380 return c
12381 }
12382
12383
12384
12385 func (c *ProjectsLocationsVmwareClustersGetCall) Header() http.Header {
12386 if c.header_ == nil {
12387 c.header_ = make(http.Header)
12388 }
12389 return c.header_
12390 }
12391
12392 func (c *ProjectsLocationsVmwareClustersGetCall) doRequest(alt string) (*http.Response, error) {
12393 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12394 if c.ifNoneMatch_ != "" {
12395 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12396 }
12397 var body io.Reader = nil
12398 c.urlParams_.Set("alt", alt)
12399 c.urlParams_.Set("prettyPrint", "false")
12400 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
12401 urls += "?" + c.urlParams_.Encode()
12402 req, err := http.NewRequest("GET", urls, body)
12403 if err != nil {
12404 return nil, err
12405 }
12406 req.Header = reqHeaders
12407 googleapi.Expand(req.URL, map[string]string{
12408 "name": c.name,
12409 })
12410 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12411 }
12412
12413
12414
12415
12416
12417
12418 func (c *ProjectsLocationsVmwareClustersGetCall) Do(opts ...googleapi.CallOption) (*VmwareCluster, error) {
12419 gensupport.SetOptions(c.urlParams_, opts...)
12420 res, err := c.doRequest("json")
12421 if res != nil && res.StatusCode == http.StatusNotModified {
12422 if res.Body != nil {
12423 res.Body.Close()
12424 }
12425 return nil, gensupport.WrapError(&googleapi.Error{
12426 Code: res.StatusCode,
12427 Header: res.Header,
12428 })
12429 }
12430 if err != nil {
12431 return nil, err
12432 }
12433 defer googleapi.CloseBody(res)
12434 if err := googleapi.CheckResponse(res); err != nil {
12435 return nil, gensupport.WrapError(err)
12436 }
12437 ret := &VmwareCluster{
12438 ServerResponse: googleapi.ServerResponse{
12439 Header: res.Header,
12440 HTTPStatusCode: res.StatusCode,
12441 },
12442 }
12443 target := &ret
12444 if err := gensupport.DecodeResponse(target, res); err != nil {
12445 return nil, err
12446 }
12447 return ret, nil
12448 }
12449
12450 type ProjectsLocationsVmwareClustersGetIamPolicyCall struct {
12451 s *Service
12452 resource string
12453 urlParams_ gensupport.URLParams
12454 ifNoneMatch_ string
12455 ctx_ context.Context
12456 header_ http.Header
12457 }
12458
12459
12460
12461
12462
12463
12464
12465 func (r *ProjectsLocationsVmwareClustersService) GetIamPolicy(resource string) *ProjectsLocationsVmwareClustersGetIamPolicyCall {
12466 c := &ProjectsLocationsVmwareClustersGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12467 c.resource = resource
12468 return c
12469 }
12470
12471
12472
12473
12474
12475
12476
12477
12478
12479
12480
12481
12482
12483 func (c *ProjectsLocationsVmwareClustersGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsVmwareClustersGetIamPolicyCall {
12484 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
12485 return c
12486 }
12487
12488
12489
12490
12491 func (c *ProjectsLocationsVmwareClustersGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersGetIamPolicyCall {
12492 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12493 return c
12494 }
12495
12496
12497
12498
12499 func (c *ProjectsLocationsVmwareClustersGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersGetIamPolicyCall {
12500 c.ifNoneMatch_ = entityTag
12501 return c
12502 }
12503
12504
12505 func (c *ProjectsLocationsVmwareClustersGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersGetIamPolicyCall {
12506 c.ctx_ = ctx
12507 return c
12508 }
12509
12510
12511
12512 func (c *ProjectsLocationsVmwareClustersGetIamPolicyCall) Header() http.Header {
12513 if c.header_ == nil {
12514 c.header_ = make(http.Header)
12515 }
12516 return c.header_
12517 }
12518
12519 func (c *ProjectsLocationsVmwareClustersGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12520 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12521 if c.ifNoneMatch_ != "" {
12522 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12523 }
12524 var body io.Reader = nil
12525 c.urlParams_.Set("alt", alt)
12526 c.urlParams_.Set("prettyPrint", "false")
12527 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
12528 urls += "?" + c.urlParams_.Encode()
12529 req, err := http.NewRequest("GET", urls, body)
12530 if err != nil {
12531 return nil, err
12532 }
12533 req.Header = reqHeaders
12534 googleapi.Expand(req.URL, map[string]string{
12535 "resource": c.resource,
12536 })
12537 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12538 }
12539
12540
12541
12542
12543
12544
12545 func (c *ProjectsLocationsVmwareClustersGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
12546 gensupport.SetOptions(c.urlParams_, opts...)
12547 res, err := c.doRequest("json")
12548 if res != nil && res.StatusCode == http.StatusNotModified {
12549 if res.Body != nil {
12550 res.Body.Close()
12551 }
12552 return nil, gensupport.WrapError(&googleapi.Error{
12553 Code: res.StatusCode,
12554 Header: res.Header,
12555 })
12556 }
12557 if err != nil {
12558 return nil, err
12559 }
12560 defer googleapi.CloseBody(res)
12561 if err := googleapi.CheckResponse(res); err != nil {
12562 return nil, gensupport.WrapError(err)
12563 }
12564 ret := &Policy{
12565 ServerResponse: googleapi.ServerResponse{
12566 Header: res.Header,
12567 HTTPStatusCode: res.StatusCode,
12568 },
12569 }
12570 target := &ret
12571 if err := gensupport.DecodeResponse(target, res); err != nil {
12572 return nil, err
12573 }
12574 return ret, nil
12575 }
12576
12577 type ProjectsLocationsVmwareClustersListCall struct {
12578 s *Service
12579 parent string
12580 urlParams_ gensupport.URLParams
12581 ifNoneMatch_ string
12582 ctx_ context.Context
12583 header_ http.Header
12584 }
12585
12586
12587
12588
12589
12590 func (r *ProjectsLocationsVmwareClustersService) List(parent string) *ProjectsLocationsVmwareClustersListCall {
12591 c := &ProjectsLocationsVmwareClustersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12592 c.parent = parent
12593 return c
12594 }
12595
12596
12597
12598
12599 func (c *ProjectsLocationsVmwareClustersListCall) Filter(filter string) *ProjectsLocationsVmwareClustersListCall {
12600 c.urlParams_.Set("filter", filter)
12601 return c
12602 }
12603
12604
12605
12606
12607
12608 func (c *ProjectsLocationsVmwareClustersListCall) PageSize(pageSize int64) *ProjectsLocationsVmwareClustersListCall {
12609 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
12610 return c
12611 }
12612
12613
12614
12615 func (c *ProjectsLocationsVmwareClustersListCall) PageToken(pageToken string) *ProjectsLocationsVmwareClustersListCall {
12616 c.urlParams_.Set("pageToken", pageToken)
12617 return c
12618 }
12619
12620
12621
12622
12623
12624
12625
12626
12627
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639 func (c *ProjectsLocationsVmwareClustersListCall) View(view string) *ProjectsLocationsVmwareClustersListCall {
12640 c.urlParams_.Set("view", view)
12641 return c
12642 }
12643
12644
12645
12646
12647 func (c *ProjectsLocationsVmwareClustersListCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersListCall {
12648 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12649 return c
12650 }
12651
12652
12653
12654
12655 func (c *ProjectsLocationsVmwareClustersListCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersListCall {
12656 c.ifNoneMatch_ = entityTag
12657 return c
12658 }
12659
12660
12661 func (c *ProjectsLocationsVmwareClustersListCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersListCall {
12662 c.ctx_ = ctx
12663 return c
12664 }
12665
12666
12667
12668 func (c *ProjectsLocationsVmwareClustersListCall) Header() http.Header {
12669 if c.header_ == nil {
12670 c.header_ = make(http.Header)
12671 }
12672 return c.header_
12673 }
12674
12675 func (c *ProjectsLocationsVmwareClustersListCall) doRequest(alt string) (*http.Response, error) {
12676 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12677 if c.ifNoneMatch_ != "" {
12678 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12679 }
12680 var body io.Reader = nil
12681 c.urlParams_.Set("alt", alt)
12682 c.urlParams_.Set("prettyPrint", "false")
12683 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareClusters")
12684 urls += "?" + c.urlParams_.Encode()
12685 req, err := http.NewRequest("GET", urls, body)
12686 if err != nil {
12687 return nil, err
12688 }
12689 req.Header = reqHeaders
12690 googleapi.Expand(req.URL, map[string]string{
12691 "parent": c.parent,
12692 })
12693 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12694 }
12695
12696
12697
12698
12699
12700
12701
12702 func (c *ProjectsLocationsVmwareClustersListCall) Do(opts ...googleapi.CallOption) (*ListVmwareClustersResponse, error) {
12703 gensupport.SetOptions(c.urlParams_, opts...)
12704 res, err := c.doRequest("json")
12705 if res != nil && res.StatusCode == http.StatusNotModified {
12706 if res.Body != nil {
12707 res.Body.Close()
12708 }
12709 return nil, gensupport.WrapError(&googleapi.Error{
12710 Code: res.StatusCode,
12711 Header: res.Header,
12712 })
12713 }
12714 if err != nil {
12715 return nil, err
12716 }
12717 defer googleapi.CloseBody(res)
12718 if err := googleapi.CheckResponse(res); err != nil {
12719 return nil, gensupport.WrapError(err)
12720 }
12721 ret := &ListVmwareClustersResponse{
12722 ServerResponse: googleapi.ServerResponse{
12723 Header: res.Header,
12724 HTTPStatusCode: res.StatusCode,
12725 },
12726 }
12727 target := &ret
12728 if err := gensupport.DecodeResponse(target, res); err != nil {
12729 return nil, err
12730 }
12731 return ret, nil
12732 }
12733
12734
12735
12736
12737 func (c *ProjectsLocationsVmwareClustersListCall) Pages(ctx context.Context, f func(*ListVmwareClustersResponse) error) error {
12738 c.ctx_ = ctx
12739 defer c.PageToken(c.urlParams_.Get("pageToken"))
12740 for {
12741 x, err := c.Do()
12742 if err != nil {
12743 return err
12744 }
12745 if err := f(x); err != nil {
12746 return err
12747 }
12748 if x.NextPageToken == "" {
12749 return nil
12750 }
12751 c.PageToken(x.NextPageToken)
12752 }
12753 }
12754
12755 type ProjectsLocationsVmwareClustersPatchCall struct {
12756 s *Service
12757 name string
12758 vmwarecluster *VmwareCluster
12759 urlParams_ gensupport.URLParams
12760 ctx_ context.Context
12761 header_ http.Header
12762 }
12763
12764
12765
12766
12767 func (r *ProjectsLocationsVmwareClustersService) Patch(name string, vmwarecluster *VmwareCluster) *ProjectsLocationsVmwareClustersPatchCall {
12768 c := &ProjectsLocationsVmwareClustersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12769 c.name = name
12770 c.vmwarecluster = vmwarecluster
12771 return c
12772 }
12773
12774
12775
12776
12777
12778
12779
12780
12781 func (c *ProjectsLocationsVmwareClustersPatchCall) UpdateMask(updateMask string) *ProjectsLocationsVmwareClustersPatchCall {
12782 c.urlParams_.Set("updateMask", updateMask)
12783 return c
12784 }
12785
12786
12787
12788 func (c *ProjectsLocationsVmwareClustersPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareClustersPatchCall {
12789 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
12790 return c
12791 }
12792
12793
12794
12795
12796 func (c *ProjectsLocationsVmwareClustersPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersPatchCall {
12797 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12798 return c
12799 }
12800
12801
12802 func (c *ProjectsLocationsVmwareClustersPatchCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersPatchCall {
12803 c.ctx_ = ctx
12804 return c
12805 }
12806
12807
12808
12809 func (c *ProjectsLocationsVmwareClustersPatchCall) Header() http.Header {
12810 if c.header_ == nil {
12811 c.header_ = make(http.Header)
12812 }
12813 return c.header_
12814 }
12815
12816 func (c *ProjectsLocationsVmwareClustersPatchCall) doRequest(alt string) (*http.Response, error) {
12817 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12818 var body io.Reader = nil
12819 body, err := googleapi.WithoutDataWrapper.JSONReader(c.vmwarecluster)
12820 if err != nil {
12821 return nil, err
12822 }
12823 c.urlParams_.Set("alt", alt)
12824 c.urlParams_.Set("prettyPrint", "false")
12825 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
12826 urls += "?" + c.urlParams_.Encode()
12827 req, err := http.NewRequest("PATCH", urls, body)
12828 if err != nil {
12829 return nil, err
12830 }
12831 req.Header = reqHeaders
12832 googleapi.Expand(req.URL, map[string]string{
12833 "name": c.name,
12834 })
12835 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12836 }
12837
12838
12839
12840
12841
12842
12843 func (c *ProjectsLocationsVmwareClustersPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
12844 gensupport.SetOptions(c.urlParams_, opts...)
12845 res, err := c.doRequest("json")
12846 if res != nil && res.StatusCode == http.StatusNotModified {
12847 if res.Body != nil {
12848 res.Body.Close()
12849 }
12850 return nil, gensupport.WrapError(&googleapi.Error{
12851 Code: res.StatusCode,
12852 Header: res.Header,
12853 })
12854 }
12855 if err != nil {
12856 return nil, err
12857 }
12858 defer googleapi.CloseBody(res)
12859 if err := googleapi.CheckResponse(res); err != nil {
12860 return nil, gensupport.WrapError(err)
12861 }
12862 ret := &Operation{
12863 ServerResponse: googleapi.ServerResponse{
12864 Header: res.Header,
12865 HTTPStatusCode: res.StatusCode,
12866 },
12867 }
12868 target := &ret
12869 if err := gensupport.DecodeResponse(target, res); err != nil {
12870 return nil, err
12871 }
12872 return ret, nil
12873 }
12874
12875 type ProjectsLocationsVmwareClustersQueryVersionConfigCall struct {
12876 s *Service
12877 parent string
12878 urlParams_ gensupport.URLParams
12879 ctx_ context.Context
12880 header_ http.Header
12881 }
12882
12883
12884
12885
12886
12887 func (r *ProjectsLocationsVmwareClustersService) QueryVersionConfig(parent string) *ProjectsLocationsVmwareClustersQueryVersionConfigCall {
12888 c := &ProjectsLocationsVmwareClustersQueryVersionConfigCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12889 c.parent = parent
12890 return c
12891 }
12892
12893
12894
12895
12896
12897 func (c *ProjectsLocationsVmwareClustersQueryVersionConfigCall) CreateConfigAdminClusterMembership(createConfigAdminClusterMembership string) *ProjectsLocationsVmwareClustersQueryVersionConfigCall {
12898 c.urlParams_.Set("createConfig.adminClusterMembership", createConfigAdminClusterMembership)
12899 return c
12900 }
12901
12902
12903
12904
12905
12906
12907 func (c *ProjectsLocationsVmwareClustersQueryVersionConfigCall) CreateConfigAdminClusterName(createConfigAdminClusterName string) *ProjectsLocationsVmwareClustersQueryVersionConfigCall {
12908 c.urlParams_.Set("createConfig.adminClusterName", createConfigAdminClusterName)
12909 return c
12910 }
12911
12912
12913
12914
12915
12916 func (c *ProjectsLocationsVmwareClustersQueryVersionConfigCall) UpgradeConfigClusterName(upgradeConfigClusterName string) *ProjectsLocationsVmwareClustersQueryVersionConfigCall {
12917 c.urlParams_.Set("upgradeConfig.clusterName", upgradeConfigClusterName)
12918 return c
12919 }
12920
12921
12922
12923
12924 func (c *ProjectsLocationsVmwareClustersQueryVersionConfigCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersQueryVersionConfigCall {
12925 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12926 return c
12927 }
12928
12929
12930 func (c *ProjectsLocationsVmwareClustersQueryVersionConfigCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersQueryVersionConfigCall {
12931 c.ctx_ = ctx
12932 return c
12933 }
12934
12935
12936
12937 func (c *ProjectsLocationsVmwareClustersQueryVersionConfigCall) Header() http.Header {
12938 if c.header_ == nil {
12939 c.header_ = make(http.Header)
12940 }
12941 return c.header_
12942 }
12943
12944 func (c *ProjectsLocationsVmwareClustersQueryVersionConfigCall) doRequest(alt string) (*http.Response, error) {
12945 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12946 var body io.Reader = nil
12947 c.urlParams_.Set("alt", alt)
12948 c.urlParams_.Set("prettyPrint", "false")
12949 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareClusters:queryVersionConfig")
12950 urls += "?" + c.urlParams_.Encode()
12951 req, err := http.NewRequest("POST", urls, body)
12952 if err != nil {
12953 return nil, err
12954 }
12955 req.Header = reqHeaders
12956 googleapi.Expand(req.URL, map[string]string{
12957 "parent": c.parent,
12958 })
12959 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12960 }
12961
12962
12963
12964
12965
12966
12967
12968 func (c *ProjectsLocationsVmwareClustersQueryVersionConfigCall) Do(opts ...googleapi.CallOption) (*QueryVmwareVersionConfigResponse, error) {
12969 gensupport.SetOptions(c.urlParams_, opts...)
12970 res, err := c.doRequest("json")
12971 if res != nil && res.StatusCode == http.StatusNotModified {
12972 if res.Body != nil {
12973 res.Body.Close()
12974 }
12975 return nil, gensupport.WrapError(&googleapi.Error{
12976 Code: res.StatusCode,
12977 Header: res.Header,
12978 })
12979 }
12980 if err != nil {
12981 return nil, err
12982 }
12983 defer googleapi.CloseBody(res)
12984 if err := googleapi.CheckResponse(res); err != nil {
12985 return nil, gensupport.WrapError(err)
12986 }
12987 ret := &QueryVmwareVersionConfigResponse{
12988 ServerResponse: googleapi.ServerResponse{
12989 Header: res.Header,
12990 HTTPStatusCode: res.StatusCode,
12991 },
12992 }
12993 target := &ret
12994 if err := gensupport.DecodeResponse(target, res); err != nil {
12995 return nil, err
12996 }
12997 return ret, nil
12998 }
12999
13000 type ProjectsLocationsVmwareClustersSetIamPolicyCall struct {
13001 s *Service
13002 resource string
13003 setiampolicyrequest *SetIamPolicyRequest
13004 urlParams_ gensupport.URLParams
13005 ctx_ context.Context
13006 header_ http.Header
13007 }
13008
13009
13010
13011
13012
13013
13014
13015
13016 func (r *ProjectsLocationsVmwareClustersService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsVmwareClustersSetIamPolicyCall {
13017 c := &ProjectsLocationsVmwareClustersSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13018 c.resource = resource
13019 c.setiampolicyrequest = setiampolicyrequest
13020 return c
13021 }
13022
13023
13024
13025
13026 func (c *ProjectsLocationsVmwareClustersSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersSetIamPolicyCall {
13027 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13028 return c
13029 }
13030
13031
13032 func (c *ProjectsLocationsVmwareClustersSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersSetIamPolicyCall {
13033 c.ctx_ = ctx
13034 return c
13035 }
13036
13037
13038
13039 func (c *ProjectsLocationsVmwareClustersSetIamPolicyCall) Header() http.Header {
13040 if c.header_ == nil {
13041 c.header_ = make(http.Header)
13042 }
13043 return c.header_
13044 }
13045
13046 func (c *ProjectsLocationsVmwareClustersSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
13047 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13048 var body io.Reader = nil
13049 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
13050 if err != nil {
13051 return nil, err
13052 }
13053 c.urlParams_.Set("alt", alt)
13054 c.urlParams_.Set("prettyPrint", "false")
13055 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
13056 urls += "?" + c.urlParams_.Encode()
13057 req, err := http.NewRequest("POST", urls, body)
13058 if err != nil {
13059 return nil, err
13060 }
13061 req.Header = reqHeaders
13062 googleapi.Expand(req.URL, map[string]string{
13063 "resource": c.resource,
13064 })
13065 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13066 }
13067
13068
13069
13070
13071
13072
13073 func (c *ProjectsLocationsVmwareClustersSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
13074 gensupport.SetOptions(c.urlParams_, opts...)
13075 res, err := c.doRequest("json")
13076 if res != nil && res.StatusCode == http.StatusNotModified {
13077 if res.Body != nil {
13078 res.Body.Close()
13079 }
13080 return nil, gensupport.WrapError(&googleapi.Error{
13081 Code: res.StatusCode,
13082 Header: res.Header,
13083 })
13084 }
13085 if err != nil {
13086 return nil, err
13087 }
13088 defer googleapi.CloseBody(res)
13089 if err := googleapi.CheckResponse(res); err != nil {
13090 return nil, gensupport.WrapError(err)
13091 }
13092 ret := &Policy{
13093 ServerResponse: googleapi.ServerResponse{
13094 Header: res.Header,
13095 HTTPStatusCode: res.StatusCode,
13096 },
13097 }
13098 target := &ret
13099 if err := gensupport.DecodeResponse(target, res); err != nil {
13100 return nil, err
13101 }
13102 return ret, nil
13103 }
13104
13105 type ProjectsLocationsVmwareClustersTestIamPermissionsCall struct {
13106 s *Service
13107 resource string
13108 testiampermissionsrequest *TestIamPermissionsRequest
13109 urlParams_ gensupport.URLParams
13110 ctx_ context.Context
13111 header_ http.Header
13112 }
13113
13114
13115
13116
13117
13118
13119
13120
13121
13122
13123
13124 func (r *ProjectsLocationsVmwareClustersService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsVmwareClustersTestIamPermissionsCall {
13125 c := &ProjectsLocationsVmwareClustersTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13126 c.resource = resource
13127 c.testiampermissionsrequest = testiampermissionsrequest
13128 return c
13129 }
13130
13131
13132
13133
13134 func (c *ProjectsLocationsVmwareClustersTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersTestIamPermissionsCall {
13135 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13136 return c
13137 }
13138
13139
13140 func (c *ProjectsLocationsVmwareClustersTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersTestIamPermissionsCall {
13141 c.ctx_ = ctx
13142 return c
13143 }
13144
13145
13146
13147 func (c *ProjectsLocationsVmwareClustersTestIamPermissionsCall) Header() http.Header {
13148 if c.header_ == nil {
13149 c.header_ = make(http.Header)
13150 }
13151 return c.header_
13152 }
13153
13154 func (c *ProjectsLocationsVmwareClustersTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
13155 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13156 var body io.Reader = nil
13157 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
13158 if err != nil {
13159 return nil, err
13160 }
13161 c.urlParams_.Set("alt", alt)
13162 c.urlParams_.Set("prettyPrint", "false")
13163 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
13164 urls += "?" + c.urlParams_.Encode()
13165 req, err := http.NewRequest("POST", urls, body)
13166 if err != nil {
13167 return nil, err
13168 }
13169 req.Header = reqHeaders
13170 googleapi.Expand(req.URL, map[string]string{
13171 "resource": c.resource,
13172 })
13173 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13174 }
13175
13176
13177
13178
13179
13180
13181
13182 func (c *ProjectsLocationsVmwareClustersTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
13183 gensupport.SetOptions(c.urlParams_, opts...)
13184 res, err := c.doRequest("json")
13185 if res != nil && res.StatusCode == http.StatusNotModified {
13186 if res.Body != nil {
13187 res.Body.Close()
13188 }
13189 return nil, gensupport.WrapError(&googleapi.Error{
13190 Code: res.StatusCode,
13191 Header: res.Header,
13192 })
13193 }
13194 if err != nil {
13195 return nil, err
13196 }
13197 defer googleapi.CloseBody(res)
13198 if err := googleapi.CheckResponse(res); err != nil {
13199 return nil, gensupport.WrapError(err)
13200 }
13201 ret := &TestIamPermissionsResponse{
13202 ServerResponse: googleapi.ServerResponse{
13203 Header: res.Header,
13204 HTTPStatusCode: res.StatusCode,
13205 },
13206 }
13207 target := &ret
13208 if err := gensupport.DecodeResponse(target, res); err != nil {
13209 return nil, err
13210 }
13211 return ret, nil
13212 }
13213
13214 type ProjectsLocationsVmwareClustersUnenrollCall struct {
13215 s *Service
13216 name string
13217 urlParams_ gensupport.URLParams
13218 ctx_ context.Context
13219 header_ http.Header
13220 }
13221
13222
13223
13224
13225
13226
13227
13228
13229
13230 func (r *ProjectsLocationsVmwareClustersService) Unenroll(name string) *ProjectsLocationsVmwareClustersUnenrollCall {
13231 c := &ProjectsLocationsVmwareClustersUnenrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13232 c.name = name
13233 return c
13234 }
13235
13236
13237
13238
13239 func (c *ProjectsLocationsVmwareClustersUnenrollCall) AllowMissing(allowMissing bool) *ProjectsLocationsVmwareClustersUnenrollCall {
13240 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
13241 return c
13242 }
13243
13244
13245
13246
13247 func (c *ProjectsLocationsVmwareClustersUnenrollCall) Etag(etag string) *ProjectsLocationsVmwareClustersUnenrollCall {
13248 c.urlParams_.Set("etag", etag)
13249 return c
13250 }
13251
13252
13253
13254
13255 func (c *ProjectsLocationsVmwareClustersUnenrollCall) Force(force bool) *ProjectsLocationsVmwareClustersUnenrollCall {
13256 c.urlParams_.Set("force", fmt.Sprint(force))
13257 return c
13258 }
13259
13260
13261
13262 func (c *ProjectsLocationsVmwareClustersUnenrollCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareClustersUnenrollCall {
13263 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
13264 return c
13265 }
13266
13267
13268
13269
13270 func (c *ProjectsLocationsVmwareClustersUnenrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersUnenrollCall {
13271 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13272 return c
13273 }
13274
13275
13276 func (c *ProjectsLocationsVmwareClustersUnenrollCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersUnenrollCall {
13277 c.ctx_ = ctx
13278 return c
13279 }
13280
13281
13282
13283 func (c *ProjectsLocationsVmwareClustersUnenrollCall) Header() http.Header {
13284 if c.header_ == nil {
13285 c.header_ = make(http.Header)
13286 }
13287 return c.header_
13288 }
13289
13290 func (c *ProjectsLocationsVmwareClustersUnenrollCall) doRequest(alt string) (*http.Response, error) {
13291 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13292 var body io.Reader = nil
13293 c.urlParams_.Set("alt", alt)
13294 c.urlParams_.Set("prettyPrint", "false")
13295 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:unenroll")
13296 urls += "?" + c.urlParams_.Encode()
13297 req, err := http.NewRequest("DELETE", urls, body)
13298 if err != nil {
13299 return nil, err
13300 }
13301 req.Header = reqHeaders
13302 googleapi.Expand(req.URL, map[string]string{
13303 "name": c.name,
13304 })
13305 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13306 }
13307
13308
13309
13310
13311
13312
13313 func (c *ProjectsLocationsVmwareClustersUnenrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
13314 gensupport.SetOptions(c.urlParams_, opts...)
13315 res, err := c.doRequest("json")
13316 if res != nil && res.StatusCode == http.StatusNotModified {
13317 if res.Body != nil {
13318 res.Body.Close()
13319 }
13320 return nil, gensupport.WrapError(&googleapi.Error{
13321 Code: res.StatusCode,
13322 Header: res.Header,
13323 })
13324 }
13325 if err != nil {
13326 return nil, err
13327 }
13328 defer googleapi.CloseBody(res)
13329 if err := googleapi.CheckResponse(res); err != nil {
13330 return nil, gensupport.WrapError(err)
13331 }
13332 ret := &Operation{
13333 ServerResponse: googleapi.ServerResponse{
13334 Header: res.Header,
13335 HTTPStatusCode: res.StatusCode,
13336 },
13337 }
13338 target := &ret
13339 if err := gensupport.DecodeResponse(target, res); err != nil {
13340 return nil, err
13341 }
13342 return ret, nil
13343 }
13344
13345 type ProjectsLocationsVmwareClustersOperationsGetCall struct {
13346 s *Service
13347 name string
13348 urlParams_ gensupport.URLParams
13349 ifNoneMatch_ string
13350 ctx_ context.Context
13351 header_ http.Header
13352 }
13353
13354
13355
13356
13357
13358
13359 func (r *ProjectsLocationsVmwareClustersOperationsService) Get(name string) *ProjectsLocationsVmwareClustersOperationsGetCall {
13360 c := &ProjectsLocationsVmwareClustersOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13361 c.name = name
13362 return c
13363 }
13364
13365
13366
13367
13368 func (c *ProjectsLocationsVmwareClustersOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersOperationsGetCall {
13369 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13370 return c
13371 }
13372
13373
13374
13375
13376 func (c *ProjectsLocationsVmwareClustersOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersOperationsGetCall {
13377 c.ifNoneMatch_ = entityTag
13378 return c
13379 }
13380
13381
13382 func (c *ProjectsLocationsVmwareClustersOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersOperationsGetCall {
13383 c.ctx_ = ctx
13384 return c
13385 }
13386
13387
13388
13389 func (c *ProjectsLocationsVmwareClustersOperationsGetCall) Header() http.Header {
13390 if c.header_ == nil {
13391 c.header_ = make(http.Header)
13392 }
13393 return c.header_
13394 }
13395
13396 func (c *ProjectsLocationsVmwareClustersOperationsGetCall) doRequest(alt string) (*http.Response, error) {
13397 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13398 if c.ifNoneMatch_ != "" {
13399 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13400 }
13401 var body io.Reader = nil
13402 c.urlParams_.Set("alt", alt)
13403 c.urlParams_.Set("prettyPrint", "false")
13404 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
13405 urls += "?" + c.urlParams_.Encode()
13406 req, err := http.NewRequest("GET", urls, body)
13407 if err != nil {
13408 return nil, err
13409 }
13410 req.Header = reqHeaders
13411 googleapi.Expand(req.URL, map[string]string{
13412 "name": c.name,
13413 })
13414 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13415 }
13416
13417
13418
13419
13420
13421
13422 func (c *ProjectsLocationsVmwareClustersOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
13423 gensupport.SetOptions(c.urlParams_, opts...)
13424 res, err := c.doRequest("json")
13425 if res != nil && res.StatusCode == http.StatusNotModified {
13426 if res.Body != nil {
13427 res.Body.Close()
13428 }
13429 return nil, gensupport.WrapError(&googleapi.Error{
13430 Code: res.StatusCode,
13431 Header: res.Header,
13432 })
13433 }
13434 if err != nil {
13435 return nil, err
13436 }
13437 defer googleapi.CloseBody(res)
13438 if err := googleapi.CheckResponse(res); err != nil {
13439 return nil, gensupport.WrapError(err)
13440 }
13441 ret := &Operation{
13442 ServerResponse: googleapi.ServerResponse{
13443 Header: res.Header,
13444 HTTPStatusCode: res.StatusCode,
13445 },
13446 }
13447 target := &ret
13448 if err := gensupport.DecodeResponse(target, res); err != nil {
13449 return nil, err
13450 }
13451 return ret, nil
13452 }
13453
13454 type ProjectsLocationsVmwareClustersOperationsListCall struct {
13455 s *Service
13456 name string
13457 urlParams_ gensupport.URLParams
13458 ifNoneMatch_ string
13459 ctx_ context.Context
13460 header_ http.Header
13461 }
13462
13463
13464
13465
13466
13467 func (r *ProjectsLocationsVmwareClustersOperationsService) List(name string) *ProjectsLocationsVmwareClustersOperationsListCall {
13468 c := &ProjectsLocationsVmwareClustersOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13469 c.name = name
13470 return c
13471 }
13472
13473
13474 func (c *ProjectsLocationsVmwareClustersOperationsListCall) Filter(filter string) *ProjectsLocationsVmwareClustersOperationsListCall {
13475 c.urlParams_.Set("filter", filter)
13476 return c
13477 }
13478
13479
13480
13481 func (c *ProjectsLocationsVmwareClustersOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsVmwareClustersOperationsListCall {
13482 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
13483 return c
13484 }
13485
13486
13487
13488 func (c *ProjectsLocationsVmwareClustersOperationsListCall) PageToken(pageToken string) *ProjectsLocationsVmwareClustersOperationsListCall {
13489 c.urlParams_.Set("pageToken", pageToken)
13490 return c
13491 }
13492
13493
13494
13495
13496 func (c *ProjectsLocationsVmwareClustersOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersOperationsListCall {
13497 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13498 return c
13499 }
13500
13501
13502
13503
13504 func (c *ProjectsLocationsVmwareClustersOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersOperationsListCall {
13505 c.ifNoneMatch_ = entityTag
13506 return c
13507 }
13508
13509
13510 func (c *ProjectsLocationsVmwareClustersOperationsListCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersOperationsListCall {
13511 c.ctx_ = ctx
13512 return c
13513 }
13514
13515
13516
13517 func (c *ProjectsLocationsVmwareClustersOperationsListCall) Header() http.Header {
13518 if c.header_ == nil {
13519 c.header_ = make(http.Header)
13520 }
13521 return c.header_
13522 }
13523
13524 func (c *ProjectsLocationsVmwareClustersOperationsListCall) doRequest(alt string) (*http.Response, error) {
13525 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13526 if c.ifNoneMatch_ != "" {
13527 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13528 }
13529 var body io.Reader = nil
13530 c.urlParams_.Set("alt", alt)
13531 c.urlParams_.Set("prettyPrint", "false")
13532 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
13533 urls += "?" + c.urlParams_.Encode()
13534 req, err := http.NewRequest("GET", urls, body)
13535 if err != nil {
13536 return nil, err
13537 }
13538 req.Header = reqHeaders
13539 googleapi.Expand(req.URL, map[string]string{
13540 "name": c.name,
13541 })
13542 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13543 }
13544
13545
13546
13547
13548
13549
13550
13551 func (c *ProjectsLocationsVmwareClustersOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
13552 gensupport.SetOptions(c.urlParams_, opts...)
13553 res, err := c.doRequest("json")
13554 if res != nil && res.StatusCode == http.StatusNotModified {
13555 if res.Body != nil {
13556 res.Body.Close()
13557 }
13558 return nil, gensupport.WrapError(&googleapi.Error{
13559 Code: res.StatusCode,
13560 Header: res.Header,
13561 })
13562 }
13563 if err != nil {
13564 return nil, err
13565 }
13566 defer googleapi.CloseBody(res)
13567 if err := googleapi.CheckResponse(res); err != nil {
13568 return nil, gensupport.WrapError(err)
13569 }
13570 ret := &ListOperationsResponse{
13571 ServerResponse: googleapi.ServerResponse{
13572 Header: res.Header,
13573 HTTPStatusCode: res.StatusCode,
13574 },
13575 }
13576 target := &ret
13577 if err := gensupport.DecodeResponse(target, res); err != nil {
13578 return nil, err
13579 }
13580 return ret, nil
13581 }
13582
13583
13584
13585
13586 func (c *ProjectsLocationsVmwareClustersOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
13587 c.ctx_ = ctx
13588 defer c.PageToken(c.urlParams_.Get("pageToken"))
13589 for {
13590 x, err := c.Do()
13591 if err != nil {
13592 return err
13593 }
13594 if err := f(x); err != nil {
13595 return err
13596 }
13597 if x.NextPageToken == "" {
13598 return nil
13599 }
13600 c.PageToken(x.NextPageToken)
13601 }
13602 }
13603
13604 type ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall struct {
13605 s *Service
13606 parent string
13607 vmwarenodepool *VmwareNodePool
13608 urlParams_ gensupport.URLParams
13609 ctx_ context.Context
13610 header_ http.Header
13611 }
13612
13613
13614
13615
13616
13617
13618 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) Create(parent string, vmwarenodepool *VmwareNodePool) *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall {
13619 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13620 c.parent = parent
13621 c.vmwarenodepool = vmwarenodepool
13622 return c
13623 }
13624
13625
13626
13627 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall {
13628 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
13629 return c
13630 }
13631
13632
13633
13634
13635
13636
13637
13638 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall) VmwareNodePoolId(vmwareNodePoolId string) *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall {
13639 c.urlParams_.Set("vmwareNodePoolId", vmwareNodePoolId)
13640 return c
13641 }
13642
13643
13644
13645
13646 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall {
13647 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13648 return c
13649 }
13650
13651
13652 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall {
13653 c.ctx_ = ctx
13654 return c
13655 }
13656
13657
13658
13659 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall) Header() http.Header {
13660 if c.header_ == nil {
13661 c.header_ = make(http.Header)
13662 }
13663 return c.header_
13664 }
13665
13666 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall) doRequest(alt string) (*http.Response, error) {
13667 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13668 var body io.Reader = nil
13669 body, err := googleapi.WithoutDataWrapper.JSONReader(c.vmwarenodepool)
13670 if err != nil {
13671 return nil, err
13672 }
13673 c.urlParams_.Set("alt", alt)
13674 c.urlParams_.Set("prettyPrint", "false")
13675 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareNodePools")
13676 urls += "?" + c.urlParams_.Encode()
13677 req, err := http.NewRequest("POST", urls, body)
13678 if err != nil {
13679 return nil, err
13680 }
13681 req.Header = reqHeaders
13682 googleapi.Expand(req.URL, map[string]string{
13683 "parent": c.parent,
13684 })
13685 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13686 }
13687
13688
13689
13690
13691
13692
13693 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
13694 gensupport.SetOptions(c.urlParams_, opts...)
13695 res, err := c.doRequest("json")
13696 if res != nil && res.StatusCode == http.StatusNotModified {
13697 if res.Body != nil {
13698 res.Body.Close()
13699 }
13700 return nil, gensupport.WrapError(&googleapi.Error{
13701 Code: res.StatusCode,
13702 Header: res.Header,
13703 })
13704 }
13705 if err != nil {
13706 return nil, err
13707 }
13708 defer googleapi.CloseBody(res)
13709 if err := googleapi.CheckResponse(res); err != nil {
13710 return nil, gensupport.WrapError(err)
13711 }
13712 ret := &Operation{
13713 ServerResponse: googleapi.ServerResponse{
13714 Header: res.Header,
13715 HTTPStatusCode: res.StatusCode,
13716 },
13717 }
13718 target := &ret
13719 if err := gensupport.DecodeResponse(target, res); err != nil {
13720 return nil, err
13721 }
13722 return ret, nil
13723 }
13724
13725 type ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall struct {
13726 s *Service
13727 name string
13728 urlParams_ gensupport.URLParams
13729 ctx_ context.Context
13730 header_ http.Header
13731 }
13732
13733
13734
13735
13736
13737
13738 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) Delete(name string) *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall {
13739 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13740 c.name = name
13741 return c
13742 }
13743
13744
13745
13746
13747 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) AllowMissing(allowMissing bool) *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall {
13748 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
13749 return c
13750 }
13751
13752
13753
13754
13755
13756 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) Etag(etag string) *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall {
13757 c.urlParams_.Set("etag", etag)
13758 return c
13759 }
13760
13761
13762
13763
13764
13765
13766
13767
13768 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) IgnoreErrors(ignoreErrors bool) *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall {
13769 c.urlParams_.Set("ignoreErrors", fmt.Sprint(ignoreErrors))
13770 return c
13771 }
13772
13773
13774
13775 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall {
13776 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
13777 return c
13778 }
13779
13780
13781
13782
13783 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall {
13784 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13785 return c
13786 }
13787
13788
13789 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall {
13790 c.ctx_ = ctx
13791 return c
13792 }
13793
13794
13795
13796 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) Header() http.Header {
13797 if c.header_ == nil {
13798 c.header_ = make(http.Header)
13799 }
13800 return c.header_
13801 }
13802
13803 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) doRequest(alt string) (*http.Response, error) {
13804 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13805 var body io.Reader = nil
13806 c.urlParams_.Set("alt", alt)
13807 c.urlParams_.Set("prettyPrint", "false")
13808 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
13809 urls += "?" + c.urlParams_.Encode()
13810 req, err := http.NewRequest("DELETE", urls, body)
13811 if err != nil {
13812 return nil, err
13813 }
13814 req.Header = reqHeaders
13815 googleapi.Expand(req.URL, map[string]string{
13816 "name": c.name,
13817 })
13818 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13819 }
13820
13821
13822
13823
13824
13825
13826 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
13827 gensupport.SetOptions(c.urlParams_, opts...)
13828 res, err := c.doRequest("json")
13829 if res != nil && res.StatusCode == http.StatusNotModified {
13830 if res.Body != nil {
13831 res.Body.Close()
13832 }
13833 return nil, gensupport.WrapError(&googleapi.Error{
13834 Code: res.StatusCode,
13835 Header: res.Header,
13836 })
13837 }
13838 if err != nil {
13839 return nil, err
13840 }
13841 defer googleapi.CloseBody(res)
13842 if err := googleapi.CheckResponse(res); err != nil {
13843 return nil, gensupport.WrapError(err)
13844 }
13845 ret := &Operation{
13846 ServerResponse: googleapi.ServerResponse{
13847 Header: res.Header,
13848 HTTPStatusCode: res.StatusCode,
13849 },
13850 }
13851 target := &ret
13852 if err := gensupport.DecodeResponse(target, res); err != nil {
13853 return nil, err
13854 }
13855 return ret, nil
13856 }
13857
13858 type ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall struct {
13859 s *Service
13860 parent string
13861 enrollvmwarenodepoolrequest *EnrollVmwareNodePoolRequest
13862 urlParams_ gensupport.URLParams
13863 ctx_ context.Context
13864 header_ http.Header
13865 }
13866
13867
13868
13869
13870 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) Enroll(parent string, enrollvmwarenodepoolrequest *EnrollVmwareNodePoolRequest) *ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall {
13871 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13872 c.parent = parent
13873 c.enrollvmwarenodepoolrequest = enrollvmwarenodepoolrequest
13874 return c
13875 }
13876
13877
13878
13879
13880 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall {
13881 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13882 return c
13883 }
13884
13885
13886 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall {
13887 c.ctx_ = ctx
13888 return c
13889 }
13890
13891
13892
13893 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall) Header() http.Header {
13894 if c.header_ == nil {
13895 c.header_ = make(http.Header)
13896 }
13897 return c.header_
13898 }
13899
13900 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall) doRequest(alt string) (*http.Response, error) {
13901 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13902 var body io.Reader = nil
13903 body, err := googleapi.WithoutDataWrapper.JSONReader(c.enrollvmwarenodepoolrequest)
13904 if err != nil {
13905 return nil, err
13906 }
13907 c.urlParams_.Set("alt", alt)
13908 c.urlParams_.Set("prettyPrint", "false")
13909 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareNodePools:enroll")
13910 urls += "?" + c.urlParams_.Encode()
13911 req, err := http.NewRequest("POST", urls, body)
13912 if err != nil {
13913 return nil, err
13914 }
13915 req.Header = reqHeaders
13916 googleapi.Expand(req.URL, map[string]string{
13917 "parent": c.parent,
13918 })
13919 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13920 }
13921
13922
13923
13924
13925
13926
13927 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsEnrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
13928 gensupport.SetOptions(c.urlParams_, opts...)
13929 res, err := c.doRequest("json")
13930 if res != nil && res.StatusCode == http.StatusNotModified {
13931 if res.Body != nil {
13932 res.Body.Close()
13933 }
13934 return nil, gensupport.WrapError(&googleapi.Error{
13935 Code: res.StatusCode,
13936 Header: res.Header,
13937 })
13938 }
13939 if err != nil {
13940 return nil, err
13941 }
13942 defer googleapi.CloseBody(res)
13943 if err := googleapi.CheckResponse(res); err != nil {
13944 return nil, gensupport.WrapError(err)
13945 }
13946 ret := &Operation{
13947 ServerResponse: googleapi.ServerResponse{
13948 Header: res.Header,
13949 HTTPStatusCode: res.StatusCode,
13950 },
13951 }
13952 target := &ret
13953 if err := gensupport.DecodeResponse(target, res); err != nil {
13954 return nil, err
13955 }
13956 return ret, nil
13957 }
13958
13959 type ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall struct {
13960 s *Service
13961 name string
13962 urlParams_ gensupport.URLParams
13963 ifNoneMatch_ string
13964 ctx_ context.Context
13965 header_ http.Header
13966 }
13967
13968
13969
13970
13971
13972
13973 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) Get(name string) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall {
13974 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13975 c.name = name
13976 return c
13977 }
13978
13979
13980
13981
13982
13983
13984
13985
13986
13987
13988
13989
13990
13991
13992
13993
13994
13995
13996
13997 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall) View(view string) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall {
13998 c.urlParams_.Set("view", view)
13999 return c
14000 }
14001
14002
14003
14004
14005 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall {
14006 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14007 return c
14008 }
14009
14010
14011
14012
14013 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall {
14014 c.ifNoneMatch_ = entityTag
14015 return c
14016 }
14017
14018
14019 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall {
14020 c.ctx_ = ctx
14021 return c
14022 }
14023
14024
14025
14026 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall) Header() http.Header {
14027 if c.header_ == nil {
14028 c.header_ = make(http.Header)
14029 }
14030 return c.header_
14031 }
14032
14033 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall) doRequest(alt string) (*http.Response, error) {
14034 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14035 if c.ifNoneMatch_ != "" {
14036 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14037 }
14038 var body io.Reader = nil
14039 c.urlParams_.Set("alt", alt)
14040 c.urlParams_.Set("prettyPrint", "false")
14041 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
14042 urls += "?" + c.urlParams_.Encode()
14043 req, err := http.NewRequest("GET", urls, body)
14044 if err != nil {
14045 return nil, err
14046 }
14047 req.Header = reqHeaders
14048 googleapi.Expand(req.URL, map[string]string{
14049 "name": c.name,
14050 })
14051 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14052 }
14053
14054
14055
14056
14057
14058
14059 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetCall) Do(opts ...googleapi.CallOption) (*VmwareNodePool, error) {
14060 gensupport.SetOptions(c.urlParams_, opts...)
14061 res, err := c.doRequest("json")
14062 if res != nil && res.StatusCode == http.StatusNotModified {
14063 if res.Body != nil {
14064 res.Body.Close()
14065 }
14066 return nil, gensupport.WrapError(&googleapi.Error{
14067 Code: res.StatusCode,
14068 Header: res.Header,
14069 })
14070 }
14071 if err != nil {
14072 return nil, err
14073 }
14074 defer googleapi.CloseBody(res)
14075 if err := googleapi.CheckResponse(res); err != nil {
14076 return nil, gensupport.WrapError(err)
14077 }
14078 ret := &VmwareNodePool{
14079 ServerResponse: googleapi.ServerResponse{
14080 Header: res.Header,
14081 HTTPStatusCode: res.StatusCode,
14082 },
14083 }
14084 target := &ret
14085 if err := gensupport.DecodeResponse(target, res); err != nil {
14086 return nil, err
14087 }
14088 return ret, nil
14089 }
14090
14091 type ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall struct {
14092 s *Service
14093 resource string
14094 urlParams_ gensupport.URLParams
14095 ifNoneMatch_ string
14096 ctx_ context.Context
14097 header_ http.Header
14098 }
14099
14100
14101
14102
14103
14104
14105
14106 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) GetIamPolicy(resource string) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall {
14107 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14108 c.resource = resource
14109 return c
14110 }
14111
14112
14113
14114
14115
14116
14117
14118
14119
14120
14121
14122
14123
14124 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall {
14125 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
14126 return c
14127 }
14128
14129
14130
14131
14132 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall {
14133 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14134 return c
14135 }
14136
14137
14138
14139
14140 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall {
14141 c.ifNoneMatch_ = entityTag
14142 return c
14143 }
14144
14145
14146 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall {
14147 c.ctx_ = ctx
14148 return c
14149 }
14150
14151
14152
14153 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall) Header() http.Header {
14154 if c.header_ == nil {
14155 c.header_ = make(http.Header)
14156 }
14157 return c.header_
14158 }
14159
14160 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
14161 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14162 if c.ifNoneMatch_ != "" {
14163 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14164 }
14165 var body io.Reader = nil
14166 c.urlParams_.Set("alt", alt)
14167 c.urlParams_.Set("prettyPrint", "false")
14168 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
14169 urls += "?" + c.urlParams_.Encode()
14170 req, err := http.NewRequest("GET", urls, body)
14171 if err != nil {
14172 return nil, err
14173 }
14174 req.Header = reqHeaders
14175 googleapi.Expand(req.URL, map[string]string{
14176 "resource": c.resource,
14177 })
14178 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14179 }
14180
14181
14182
14183
14184
14185
14186 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
14187 gensupport.SetOptions(c.urlParams_, opts...)
14188 res, err := c.doRequest("json")
14189 if res != nil && res.StatusCode == http.StatusNotModified {
14190 if res.Body != nil {
14191 res.Body.Close()
14192 }
14193 return nil, gensupport.WrapError(&googleapi.Error{
14194 Code: res.StatusCode,
14195 Header: res.Header,
14196 })
14197 }
14198 if err != nil {
14199 return nil, err
14200 }
14201 defer googleapi.CloseBody(res)
14202 if err := googleapi.CheckResponse(res); err != nil {
14203 return nil, gensupport.WrapError(err)
14204 }
14205 ret := &Policy{
14206 ServerResponse: googleapi.ServerResponse{
14207 Header: res.Header,
14208 HTTPStatusCode: res.StatusCode,
14209 },
14210 }
14211 target := &ret
14212 if err := gensupport.DecodeResponse(target, res); err != nil {
14213 return nil, err
14214 }
14215 return ret, nil
14216 }
14217
14218 type ProjectsLocationsVmwareClustersVmwareNodePoolsListCall struct {
14219 s *Service
14220 parent string
14221 urlParams_ gensupport.URLParams
14222 ifNoneMatch_ string
14223 ctx_ context.Context
14224 header_ http.Header
14225 }
14226
14227
14228
14229
14230
14231
14232 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) List(parent string) *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall {
14233 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14234 c.parent = parent
14235 return c
14236 }
14237
14238
14239
14240
14241
14242 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) PageSize(pageSize int64) *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall {
14243 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
14244 return c
14245 }
14246
14247
14248
14249
14250
14251 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) PageToken(pageToken string) *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall {
14252 c.urlParams_.Set("pageToken", pageToken)
14253 return c
14254 }
14255
14256
14257
14258
14259
14260
14261
14262
14263
14264
14265
14266
14267
14268
14269
14270
14271
14272
14273
14274 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) View(view string) *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall {
14275 c.urlParams_.Set("view", view)
14276 return c
14277 }
14278
14279
14280
14281
14282 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall {
14283 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14284 return c
14285 }
14286
14287
14288
14289
14290 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall {
14291 c.ifNoneMatch_ = entityTag
14292 return c
14293 }
14294
14295
14296 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall {
14297 c.ctx_ = ctx
14298 return c
14299 }
14300
14301
14302
14303 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) Header() http.Header {
14304 if c.header_ == nil {
14305 c.header_ = make(http.Header)
14306 }
14307 return c.header_
14308 }
14309
14310 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) doRequest(alt string) (*http.Response, error) {
14311 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14312 if c.ifNoneMatch_ != "" {
14313 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14314 }
14315 var body io.Reader = nil
14316 c.urlParams_.Set("alt", alt)
14317 c.urlParams_.Set("prettyPrint", "false")
14318 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/vmwareNodePools")
14319 urls += "?" + c.urlParams_.Encode()
14320 req, err := http.NewRequest("GET", urls, body)
14321 if err != nil {
14322 return nil, err
14323 }
14324 req.Header = reqHeaders
14325 googleapi.Expand(req.URL, map[string]string{
14326 "parent": c.parent,
14327 })
14328 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14329 }
14330
14331
14332
14333
14334
14335
14336
14337 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) Do(opts ...googleapi.CallOption) (*ListVmwareNodePoolsResponse, error) {
14338 gensupport.SetOptions(c.urlParams_, opts...)
14339 res, err := c.doRequest("json")
14340 if res != nil && res.StatusCode == http.StatusNotModified {
14341 if res.Body != nil {
14342 res.Body.Close()
14343 }
14344 return nil, gensupport.WrapError(&googleapi.Error{
14345 Code: res.StatusCode,
14346 Header: res.Header,
14347 })
14348 }
14349 if err != nil {
14350 return nil, err
14351 }
14352 defer googleapi.CloseBody(res)
14353 if err := googleapi.CheckResponse(res); err != nil {
14354 return nil, gensupport.WrapError(err)
14355 }
14356 ret := &ListVmwareNodePoolsResponse{
14357 ServerResponse: googleapi.ServerResponse{
14358 Header: res.Header,
14359 HTTPStatusCode: res.StatusCode,
14360 },
14361 }
14362 target := &ret
14363 if err := gensupport.DecodeResponse(target, res); err != nil {
14364 return nil, err
14365 }
14366 return ret, nil
14367 }
14368
14369
14370
14371
14372 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsListCall) Pages(ctx context.Context, f func(*ListVmwareNodePoolsResponse) error) error {
14373 c.ctx_ = ctx
14374 defer c.PageToken(c.urlParams_.Get("pageToken"))
14375 for {
14376 x, err := c.Do()
14377 if err != nil {
14378 return err
14379 }
14380 if err := f(x); err != nil {
14381 return err
14382 }
14383 if x.NextPageToken == "" {
14384 return nil
14385 }
14386 c.PageToken(x.NextPageToken)
14387 }
14388 }
14389
14390 type ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall struct {
14391 s *Service
14392 name string
14393 vmwarenodepool *VmwareNodePool
14394 urlParams_ gensupport.URLParams
14395 ctx_ context.Context
14396 header_ http.Header
14397 }
14398
14399
14400
14401
14402 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) Patch(name string, vmwarenodepool *VmwareNodePool) *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall {
14403 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14404 c.name = name
14405 c.vmwarenodepool = vmwarenodepool
14406 return c
14407 }
14408
14409
14410
14411
14412
14413
14414
14415
14416 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall {
14417 c.urlParams_.Set("updateMask", updateMask)
14418 return c
14419 }
14420
14421
14422
14423 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall {
14424 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
14425 return c
14426 }
14427
14428
14429
14430
14431 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall {
14432 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14433 return c
14434 }
14435
14436
14437 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall {
14438 c.ctx_ = ctx
14439 return c
14440 }
14441
14442
14443
14444 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall) Header() http.Header {
14445 if c.header_ == nil {
14446 c.header_ = make(http.Header)
14447 }
14448 return c.header_
14449 }
14450
14451 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall) doRequest(alt string) (*http.Response, error) {
14452 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14453 var body io.Reader = nil
14454 body, err := googleapi.WithoutDataWrapper.JSONReader(c.vmwarenodepool)
14455 if err != nil {
14456 return nil, err
14457 }
14458 c.urlParams_.Set("alt", alt)
14459 c.urlParams_.Set("prettyPrint", "false")
14460 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
14461 urls += "?" + c.urlParams_.Encode()
14462 req, err := http.NewRequest("PATCH", urls, body)
14463 if err != nil {
14464 return nil, err
14465 }
14466 req.Header = reqHeaders
14467 googleapi.Expand(req.URL, map[string]string{
14468 "name": c.name,
14469 })
14470 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14471 }
14472
14473
14474
14475
14476
14477
14478 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
14479 gensupport.SetOptions(c.urlParams_, opts...)
14480 res, err := c.doRequest("json")
14481 if res != nil && res.StatusCode == http.StatusNotModified {
14482 if res.Body != nil {
14483 res.Body.Close()
14484 }
14485 return nil, gensupport.WrapError(&googleapi.Error{
14486 Code: res.StatusCode,
14487 Header: res.Header,
14488 })
14489 }
14490 if err != nil {
14491 return nil, err
14492 }
14493 defer googleapi.CloseBody(res)
14494 if err := googleapi.CheckResponse(res); err != nil {
14495 return nil, gensupport.WrapError(err)
14496 }
14497 ret := &Operation{
14498 ServerResponse: googleapi.ServerResponse{
14499 Header: res.Header,
14500 HTTPStatusCode: res.StatusCode,
14501 },
14502 }
14503 target := &ret
14504 if err := gensupport.DecodeResponse(target, res); err != nil {
14505 return nil, err
14506 }
14507 return ret, nil
14508 }
14509
14510 type ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall struct {
14511 s *Service
14512 resource string
14513 setiampolicyrequest *SetIamPolicyRequest
14514 urlParams_ gensupport.URLParams
14515 ctx_ context.Context
14516 header_ http.Header
14517 }
14518
14519
14520
14521
14522
14523
14524
14525
14526 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall {
14527 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14528 c.resource = resource
14529 c.setiampolicyrequest = setiampolicyrequest
14530 return c
14531 }
14532
14533
14534
14535
14536 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall {
14537 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14538 return c
14539 }
14540
14541
14542 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall {
14543 c.ctx_ = ctx
14544 return c
14545 }
14546
14547
14548
14549 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall) Header() http.Header {
14550 if c.header_ == nil {
14551 c.header_ = make(http.Header)
14552 }
14553 return c.header_
14554 }
14555
14556 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
14557 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14558 var body io.Reader = nil
14559 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
14560 if err != nil {
14561 return nil, err
14562 }
14563 c.urlParams_.Set("alt", alt)
14564 c.urlParams_.Set("prettyPrint", "false")
14565 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
14566 urls += "?" + c.urlParams_.Encode()
14567 req, err := http.NewRequest("POST", urls, body)
14568 if err != nil {
14569 return nil, err
14570 }
14571 req.Header = reqHeaders
14572 googleapi.Expand(req.URL, map[string]string{
14573 "resource": c.resource,
14574 })
14575 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14576 }
14577
14578
14579
14580
14581
14582
14583 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
14584 gensupport.SetOptions(c.urlParams_, opts...)
14585 res, err := c.doRequest("json")
14586 if res != nil && res.StatusCode == http.StatusNotModified {
14587 if res.Body != nil {
14588 res.Body.Close()
14589 }
14590 return nil, gensupport.WrapError(&googleapi.Error{
14591 Code: res.StatusCode,
14592 Header: res.Header,
14593 })
14594 }
14595 if err != nil {
14596 return nil, err
14597 }
14598 defer googleapi.CloseBody(res)
14599 if err := googleapi.CheckResponse(res); err != nil {
14600 return nil, gensupport.WrapError(err)
14601 }
14602 ret := &Policy{
14603 ServerResponse: googleapi.ServerResponse{
14604 Header: res.Header,
14605 HTTPStatusCode: res.StatusCode,
14606 },
14607 }
14608 target := &ret
14609 if err := gensupport.DecodeResponse(target, res); err != nil {
14610 return nil, err
14611 }
14612 return ret, nil
14613 }
14614
14615 type ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall struct {
14616 s *Service
14617 resource string
14618 testiampermissionsrequest *TestIamPermissionsRequest
14619 urlParams_ gensupport.URLParams
14620 ctx_ context.Context
14621 header_ http.Header
14622 }
14623
14624
14625
14626
14627
14628
14629
14630
14631
14632
14633
14634 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall {
14635 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14636 c.resource = resource
14637 c.testiampermissionsrequest = testiampermissionsrequest
14638 return c
14639 }
14640
14641
14642
14643
14644 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall {
14645 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14646 return c
14647 }
14648
14649
14650 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall {
14651 c.ctx_ = ctx
14652 return c
14653 }
14654
14655
14656
14657 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall) Header() http.Header {
14658 if c.header_ == nil {
14659 c.header_ = make(http.Header)
14660 }
14661 return c.header_
14662 }
14663
14664 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
14665 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14666 var body io.Reader = nil
14667 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
14668 if err != nil {
14669 return nil, err
14670 }
14671 c.urlParams_.Set("alt", alt)
14672 c.urlParams_.Set("prettyPrint", "false")
14673 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
14674 urls += "?" + c.urlParams_.Encode()
14675 req, err := http.NewRequest("POST", urls, body)
14676 if err != nil {
14677 return nil, err
14678 }
14679 req.Header = reqHeaders
14680 googleapi.Expand(req.URL, map[string]string{
14681 "resource": c.resource,
14682 })
14683 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14684 }
14685
14686
14687
14688
14689
14690
14691
14692 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
14693 gensupport.SetOptions(c.urlParams_, opts...)
14694 res, err := c.doRequest("json")
14695 if res != nil && res.StatusCode == http.StatusNotModified {
14696 if res.Body != nil {
14697 res.Body.Close()
14698 }
14699 return nil, gensupport.WrapError(&googleapi.Error{
14700 Code: res.StatusCode,
14701 Header: res.Header,
14702 })
14703 }
14704 if err != nil {
14705 return nil, err
14706 }
14707 defer googleapi.CloseBody(res)
14708 if err := googleapi.CheckResponse(res); err != nil {
14709 return nil, gensupport.WrapError(err)
14710 }
14711 ret := &TestIamPermissionsResponse{
14712 ServerResponse: googleapi.ServerResponse{
14713 Header: res.Header,
14714 HTTPStatusCode: res.StatusCode,
14715 },
14716 }
14717 target := &ret
14718 if err := gensupport.DecodeResponse(target, res); err != nil {
14719 return nil, err
14720 }
14721 return ret, nil
14722 }
14723
14724 type ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall struct {
14725 s *Service
14726 name string
14727 urlParams_ gensupport.URLParams
14728 ctx_ context.Context
14729 header_ http.Header
14730 }
14731
14732
14733
14734
14735
14736
14737 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsService) Unenroll(name string) *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall {
14738 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14739 c.name = name
14740 return c
14741 }
14742
14743
14744
14745
14746 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall) AllowMissing(allowMissing bool) *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall {
14747 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
14748 return c
14749 }
14750
14751
14752
14753
14754 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall) Etag(etag string) *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall {
14755 c.urlParams_.Set("etag", etag)
14756 return c
14757 }
14758
14759
14760
14761 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall) ValidateOnly(validateOnly bool) *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall {
14762 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
14763 return c
14764 }
14765
14766
14767
14768
14769 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall {
14770 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14771 return c
14772 }
14773
14774
14775 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall {
14776 c.ctx_ = ctx
14777 return c
14778 }
14779
14780
14781
14782 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall) Header() http.Header {
14783 if c.header_ == nil {
14784 c.header_ = make(http.Header)
14785 }
14786 return c.header_
14787 }
14788
14789 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall) doRequest(alt string) (*http.Response, error) {
14790 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14791 var body io.Reader = nil
14792 c.urlParams_.Set("alt", alt)
14793 c.urlParams_.Set("prettyPrint", "false")
14794 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:unenroll")
14795 urls += "?" + c.urlParams_.Encode()
14796 req, err := http.NewRequest("DELETE", urls, body)
14797 if err != nil {
14798 return nil, err
14799 }
14800 req.Header = reqHeaders
14801 googleapi.Expand(req.URL, map[string]string{
14802 "name": c.name,
14803 })
14804 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14805 }
14806
14807
14808
14809
14810
14811
14812 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsUnenrollCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
14813 gensupport.SetOptions(c.urlParams_, opts...)
14814 res, err := c.doRequest("json")
14815 if res != nil && res.StatusCode == http.StatusNotModified {
14816 if res.Body != nil {
14817 res.Body.Close()
14818 }
14819 return nil, gensupport.WrapError(&googleapi.Error{
14820 Code: res.StatusCode,
14821 Header: res.Header,
14822 })
14823 }
14824 if err != nil {
14825 return nil, err
14826 }
14827 defer googleapi.CloseBody(res)
14828 if err := googleapi.CheckResponse(res); err != nil {
14829 return nil, gensupport.WrapError(err)
14830 }
14831 ret := &Operation{
14832 ServerResponse: googleapi.ServerResponse{
14833 Header: res.Header,
14834 HTTPStatusCode: res.StatusCode,
14835 },
14836 }
14837 target := &ret
14838 if err := gensupport.DecodeResponse(target, res); err != nil {
14839 return nil, err
14840 }
14841 return ret, nil
14842 }
14843
14844 type ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall struct {
14845 s *Service
14846 name string
14847 urlParams_ gensupport.URLParams
14848 ifNoneMatch_ string
14849 ctx_ context.Context
14850 header_ http.Header
14851 }
14852
14853
14854
14855
14856
14857
14858 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsService) Get(name string) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall {
14859 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14860 c.name = name
14861 return c
14862 }
14863
14864
14865
14866
14867 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall {
14868 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14869 return c
14870 }
14871
14872
14873
14874
14875 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall {
14876 c.ifNoneMatch_ = entityTag
14877 return c
14878 }
14879
14880
14881 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall {
14882 c.ctx_ = ctx
14883 return c
14884 }
14885
14886
14887
14888 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall) Header() http.Header {
14889 if c.header_ == nil {
14890 c.header_ = make(http.Header)
14891 }
14892 return c.header_
14893 }
14894
14895 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall) doRequest(alt string) (*http.Response, error) {
14896 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14897 if c.ifNoneMatch_ != "" {
14898 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14899 }
14900 var body io.Reader = nil
14901 c.urlParams_.Set("alt", alt)
14902 c.urlParams_.Set("prettyPrint", "false")
14903 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
14904 urls += "?" + c.urlParams_.Encode()
14905 req, err := http.NewRequest("GET", urls, body)
14906 if err != nil {
14907 return nil, err
14908 }
14909 req.Header = reqHeaders
14910 googleapi.Expand(req.URL, map[string]string{
14911 "name": c.name,
14912 })
14913 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14914 }
14915
14916
14917
14918
14919
14920
14921 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
14922 gensupport.SetOptions(c.urlParams_, opts...)
14923 res, err := c.doRequest("json")
14924 if res != nil && res.StatusCode == http.StatusNotModified {
14925 if res.Body != nil {
14926 res.Body.Close()
14927 }
14928 return nil, gensupport.WrapError(&googleapi.Error{
14929 Code: res.StatusCode,
14930 Header: res.Header,
14931 })
14932 }
14933 if err != nil {
14934 return nil, err
14935 }
14936 defer googleapi.CloseBody(res)
14937 if err := googleapi.CheckResponse(res); err != nil {
14938 return nil, gensupport.WrapError(err)
14939 }
14940 ret := &Operation{
14941 ServerResponse: googleapi.ServerResponse{
14942 Header: res.Header,
14943 HTTPStatusCode: res.StatusCode,
14944 },
14945 }
14946 target := &ret
14947 if err := gensupport.DecodeResponse(target, res); err != nil {
14948 return nil, err
14949 }
14950 return ret, nil
14951 }
14952
14953 type ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall struct {
14954 s *Service
14955 name string
14956 urlParams_ gensupport.URLParams
14957 ifNoneMatch_ string
14958 ctx_ context.Context
14959 header_ http.Header
14960 }
14961
14962
14963
14964
14965
14966 func (r *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsService) List(name string) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall {
14967 c := &ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14968 c.name = name
14969 return c
14970 }
14971
14972
14973 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) Filter(filter string) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall {
14974 c.urlParams_.Set("filter", filter)
14975 return c
14976 }
14977
14978
14979
14980 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall {
14981 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
14982 return c
14983 }
14984
14985
14986
14987 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) PageToken(pageToken string) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall {
14988 c.urlParams_.Set("pageToken", pageToken)
14989 return c
14990 }
14991
14992
14993
14994
14995 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall {
14996 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14997 return c
14998 }
14999
15000
15001
15002
15003 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall {
15004 c.ifNoneMatch_ = entityTag
15005 return c
15006 }
15007
15008
15009 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) Context(ctx context.Context) *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall {
15010 c.ctx_ = ctx
15011 return c
15012 }
15013
15014
15015
15016 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) Header() http.Header {
15017 if c.header_ == nil {
15018 c.header_ = make(http.Header)
15019 }
15020 return c.header_
15021 }
15022
15023 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) doRequest(alt string) (*http.Response, error) {
15024 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15025 if c.ifNoneMatch_ != "" {
15026 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15027 }
15028 var body io.Reader = nil
15029 c.urlParams_.Set("alt", alt)
15030 c.urlParams_.Set("prettyPrint", "false")
15031 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
15032 urls += "?" + c.urlParams_.Encode()
15033 req, err := http.NewRequest("GET", urls, body)
15034 if err != nil {
15035 return nil, err
15036 }
15037 req.Header = reqHeaders
15038 googleapi.Expand(req.URL, map[string]string{
15039 "name": c.name,
15040 })
15041 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15042 }
15043
15044
15045
15046
15047
15048
15049
15050 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
15051 gensupport.SetOptions(c.urlParams_, opts...)
15052 res, err := c.doRequest("json")
15053 if res != nil && res.StatusCode == http.StatusNotModified {
15054 if res.Body != nil {
15055 res.Body.Close()
15056 }
15057 return nil, gensupport.WrapError(&googleapi.Error{
15058 Code: res.StatusCode,
15059 Header: res.Header,
15060 })
15061 }
15062 if err != nil {
15063 return nil, err
15064 }
15065 defer googleapi.CloseBody(res)
15066 if err := googleapi.CheckResponse(res); err != nil {
15067 return nil, gensupport.WrapError(err)
15068 }
15069 ret := &ListOperationsResponse{
15070 ServerResponse: googleapi.ServerResponse{
15071 Header: res.Header,
15072 HTTPStatusCode: res.StatusCode,
15073 },
15074 }
15075 target := &ret
15076 if err := gensupport.DecodeResponse(target, res); err != nil {
15077 return nil, err
15078 }
15079 return ret, nil
15080 }
15081
15082
15083
15084
15085 func (c *ProjectsLocationsVmwareClustersVmwareNodePoolsOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
15086 c.ctx_ = ctx
15087 defer c.PageToken(c.urlParams_.Get("pageToken"))
15088 for {
15089 x, err := c.Do()
15090 if err != nil {
15091 return err
15092 }
15093 if err := f(x); err != nil {
15094 return err
15095 }
15096 if x.NextPageToken == "" {
15097 return nil
15098 }
15099 c.PageToken(x.NextPageToken)
15100 }
15101 }
15102
View as plain text