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