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