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
52
53
54
55
56 package analyticsadmin
57
58 import (
59 "bytes"
60 "context"
61 "encoding/json"
62 "errors"
63 "fmt"
64 "io"
65 "net/http"
66 "net/url"
67 "strconv"
68 "strings"
69
70 googleapi "google.golang.org/api/googleapi"
71 internal "google.golang.org/api/internal"
72 gensupport "google.golang.org/api/internal/gensupport"
73 option "google.golang.org/api/option"
74 internaloption "google.golang.org/api/option/internaloption"
75 htransport "google.golang.org/api/transport/http"
76 )
77
78
79
80 var _ = bytes.NewBuffer
81 var _ = strconv.Itoa
82 var _ = fmt.Sprintf
83 var _ = json.NewDecoder
84 var _ = io.Copy
85 var _ = url.Parse
86 var _ = gensupport.MarshalJSON
87 var _ = googleapi.Version
88 var _ = errors.New
89 var _ = strings.Replace
90 var _ = context.Canceled
91 var _ = internaloption.WithDefaultEndpoint
92 var _ = internal.Version
93
94 const apiId = "analyticsadmin:v1alpha"
95 const apiName = "analyticsadmin"
96 const apiVersion = "v1alpha"
97 const basePath = "https://analyticsadmin.googleapis.com/"
98 const basePathTemplate = "https://analyticsadmin.UNIVERSE_DOMAIN/"
99 const mtlsBasePath = "https://analyticsadmin.mtls.googleapis.com/"
100
101
102 const (
103
104 AnalyticsEditScope = "https://www.googleapis.com/auth/analytics.edit"
105
106
107 AnalyticsManageUsersScope = "https://www.googleapis.com/auth/analytics.manage.users"
108
109
110 AnalyticsManageUsersReadonlyScope = "https://www.googleapis.com/auth/analytics.manage.users.readonly"
111
112
113 AnalyticsReadonlyScope = "https://www.googleapis.com/auth/analytics.readonly"
114 )
115
116
117 func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
118 scopesOption := internaloption.WithDefaultScopes(
119 "https://www.googleapis.com/auth/analytics.edit",
120 "https://www.googleapis.com/auth/analytics.manage.users",
121 "https://www.googleapis.com/auth/analytics.manage.users.readonly",
122 "https://www.googleapis.com/auth/analytics.readonly",
123 )
124
125 opts = append([]option.ClientOption{scopesOption}, opts...)
126 opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
127 opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate))
128 opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
129 opts = append(opts, internaloption.EnableNewAuthLibrary())
130 client, endpoint, err := htransport.NewClient(ctx, opts...)
131 if err != nil {
132 return nil, err
133 }
134 s, err := New(client)
135 if err != nil {
136 return nil, err
137 }
138 if endpoint != "" {
139 s.BasePath = endpoint
140 }
141 return s, nil
142 }
143
144
145
146
147
148
149 func New(client *http.Client) (*Service, error) {
150 if client == nil {
151 return nil, errors.New("client is nil")
152 }
153 s := &Service{client: client, BasePath: basePath}
154 s.AccountSummaries = NewAccountSummariesService(s)
155 s.Accounts = NewAccountsService(s)
156 s.Properties = NewPropertiesService(s)
157 return s, nil
158 }
159
160 type Service struct {
161 client *http.Client
162 BasePath string
163 UserAgent string
164
165 AccountSummaries *AccountSummariesService
166
167 Accounts *AccountsService
168
169 Properties *PropertiesService
170 }
171
172 func (s *Service) userAgent() string {
173 if s.UserAgent == "" {
174 return googleapi.UserAgent
175 }
176 return googleapi.UserAgent + " " + s.UserAgent
177 }
178
179 func NewAccountSummariesService(s *Service) *AccountSummariesService {
180 rs := &AccountSummariesService{s: s}
181 return rs
182 }
183
184 type AccountSummariesService struct {
185 s *Service
186 }
187
188 func NewAccountsService(s *Service) *AccountsService {
189 rs := &AccountsService{s: s}
190 rs.AccessBindings = NewAccountsAccessBindingsService(s)
191 return rs
192 }
193
194 type AccountsService struct {
195 s *Service
196
197 AccessBindings *AccountsAccessBindingsService
198 }
199
200 func NewAccountsAccessBindingsService(s *Service) *AccountsAccessBindingsService {
201 rs := &AccountsAccessBindingsService{s: s}
202 return rs
203 }
204
205 type AccountsAccessBindingsService struct {
206 s *Service
207 }
208
209 func NewPropertiesService(s *Service) *PropertiesService {
210 rs := &PropertiesService{s: s}
211 rs.AccessBindings = NewPropertiesAccessBindingsService(s)
212 rs.AdSenseLinks = NewPropertiesAdSenseLinksService(s)
213 rs.Audiences = NewPropertiesAudiencesService(s)
214 rs.BigQueryLinks = NewPropertiesBigQueryLinksService(s)
215 rs.CalculatedMetrics = NewPropertiesCalculatedMetricsService(s)
216 rs.ChannelGroups = NewPropertiesChannelGroupsService(s)
217 rs.ConversionEvents = NewPropertiesConversionEventsService(s)
218 rs.CustomDimensions = NewPropertiesCustomDimensionsService(s)
219 rs.CustomMetrics = NewPropertiesCustomMetricsService(s)
220 rs.DataStreams = NewPropertiesDataStreamsService(s)
221 rs.DisplayVideo360AdvertiserLinkProposals = NewPropertiesDisplayVideo360AdvertiserLinkProposalsService(s)
222 rs.DisplayVideo360AdvertiserLinks = NewPropertiesDisplayVideo360AdvertiserLinksService(s)
223 rs.ExpandedDataSets = NewPropertiesExpandedDataSetsService(s)
224 rs.FirebaseLinks = NewPropertiesFirebaseLinksService(s)
225 rs.GoogleAdsLinks = NewPropertiesGoogleAdsLinksService(s)
226 rs.KeyEvents = NewPropertiesKeyEventsService(s)
227 rs.RollupPropertySourceLinks = NewPropertiesRollupPropertySourceLinksService(s)
228 rs.SearchAds360Links = NewPropertiesSearchAds360LinksService(s)
229 rs.SubpropertyEventFilters = NewPropertiesSubpropertyEventFiltersService(s)
230 return rs
231 }
232
233 type PropertiesService struct {
234 s *Service
235
236 AccessBindings *PropertiesAccessBindingsService
237
238 AdSenseLinks *PropertiesAdSenseLinksService
239
240 Audiences *PropertiesAudiencesService
241
242 BigQueryLinks *PropertiesBigQueryLinksService
243
244 CalculatedMetrics *PropertiesCalculatedMetricsService
245
246 ChannelGroups *PropertiesChannelGroupsService
247
248 ConversionEvents *PropertiesConversionEventsService
249
250 CustomDimensions *PropertiesCustomDimensionsService
251
252 CustomMetrics *PropertiesCustomMetricsService
253
254 DataStreams *PropertiesDataStreamsService
255
256 DisplayVideo360AdvertiserLinkProposals *PropertiesDisplayVideo360AdvertiserLinkProposalsService
257
258 DisplayVideo360AdvertiserLinks *PropertiesDisplayVideo360AdvertiserLinksService
259
260 ExpandedDataSets *PropertiesExpandedDataSetsService
261
262 FirebaseLinks *PropertiesFirebaseLinksService
263
264 GoogleAdsLinks *PropertiesGoogleAdsLinksService
265
266 KeyEvents *PropertiesKeyEventsService
267
268 RollupPropertySourceLinks *PropertiesRollupPropertySourceLinksService
269
270 SearchAds360Links *PropertiesSearchAds360LinksService
271
272 SubpropertyEventFilters *PropertiesSubpropertyEventFiltersService
273 }
274
275 func NewPropertiesAccessBindingsService(s *Service) *PropertiesAccessBindingsService {
276 rs := &PropertiesAccessBindingsService{s: s}
277 return rs
278 }
279
280 type PropertiesAccessBindingsService struct {
281 s *Service
282 }
283
284 func NewPropertiesAdSenseLinksService(s *Service) *PropertiesAdSenseLinksService {
285 rs := &PropertiesAdSenseLinksService{s: s}
286 return rs
287 }
288
289 type PropertiesAdSenseLinksService struct {
290 s *Service
291 }
292
293 func NewPropertiesAudiencesService(s *Service) *PropertiesAudiencesService {
294 rs := &PropertiesAudiencesService{s: s}
295 return rs
296 }
297
298 type PropertiesAudiencesService struct {
299 s *Service
300 }
301
302 func NewPropertiesBigQueryLinksService(s *Service) *PropertiesBigQueryLinksService {
303 rs := &PropertiesBigQueryLinksService{s: s}
304 return rs
305 }
306
307 type PropertiesBigQueryLinksService struct {
308 s *Service
309 }
310
311 func NewPropertiesCalculatedMetricsService(s *Service) *PropertiesCalculatedMetricsService {
312 rs := &PropertiesCalculatedMetricsService{s: s}
313 return rs
314 }
315
316 type PropertiesCalculatedMetricsService struct {
317 s *Service
318 }
319
320 func NewPropertiesChannelGroupsService(s *Service) *PropertiesChannelGroupsService {
321 rs := &PropertiesChannelGroupsService{s: s}
322 return rs
323 }
324
325 type PropertiesChannelGroupsService struct {
326 s *Service
327 }
328
329 func NewPropertiesConversionEventsService(s *Service) *PropertiesConversionEventsService {
330 rs := &PropertiesConversionEventsService{s: s}
331 return rs
332 }
333
334 type PropertiesConversionEventsService struct {
335 s *Service
336 }
337
338 func NewPropertiesCustomDimensionsService(s *Service) *PropertiesCustomDimensionsService {
339 rs := &PropertiesCustomDimensionsService{s: s}
340 return rs
341 }
342
343 type PropertiesCustomDimensionsService struct {
344 s *Service
345 }
346
347 func NewPropertiesCustomMetricsService(s *Service) *PropertiesCustomMetricsService {
348 rs := &PropertiesCustomMetricsService{s: s}
349 return rs
350 }
351
352 type PropertiesCustomMetricsService struct {
353 s *Service
354 }
355
356 func NewPropertiesDataStreamsService(s *Service) *PropertiesDataStreamsService {
357 rs := &PropertiesDataStreamsService{s: s}
358 rs.EventCreateRules = NewPropertiesDataStreamsEventCreateRulesService(s)
359 rs.MeasurementProtocolSecrets = NewPropertiesDataStreamsMeasurementProtocolSecretsService(s)
360 rs.SKAdNetworkConversionValueSchema = NewPropertiesDataStreamsSKAdNetworkConversionValueSchemaService(s)
361 return rs
362 }
363
364 type PropertiesDataStreamsService struct {
365 s *Service
366
367 EventCreateRules *PropertiesDataStreamsEventCreateRulesService
368
369 MeasurementProtocolSecrets *PropertiesDataStreamsMeasurementProtocolSecretsService
370
371 SKAdNetworkConversionValueSchema *PropertiesDataStreamsSKAdNetworkConversionValueSchemaService
372 }
373
374 func NewPropertiesDataStreamsEventCreateRulesService(s *Service) *PropertiesDataStreamsEventCreateRulesService {
375 rs := &PropertiesDataStreamsEventCreateRulesService{s: s}
376 return rs
377 }
378
379 type PropertiesDataStreamsEventCreateRulesService struct {
380 s *Service
381 }
382
383 func NewPropertiesDataStreamsMeasurementProtocolSecretsService(s *Service) *PropertiesDataStreamsMeasurementProtocolSecretsService {
384 rs := &PropertiesDataStreamsMeasurementProtocolSecretsService{s: s}
385 return rs
386 }
387
388 type PropertiesDataStreamsMeasurementProtocolSecretsService struct {
389 s *Service
390 }
391
392 func NewPropertiesDataStreamsSKAdNetworkConversionValueSchemaService(s *Service) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaService {
393 rs := &PropertiesDataStreamsSKAdNetworkConversionValueSchemaService{s: s}
394 return rs
395 }
396
397 type PropertiesDataStreamsSKAdNetworkConversionValueSchemaService struct {
398 s *Service
399 }
400
401 func NewPropertiesDisplayVideo360AdvertiserLinkProposalsService(s *Service) *PropertiesDisplayVideo360AdvertiserLinkProposalsService {
402 rs := &PropertiesDisplayVideo360AdvertiserLinkProposalsService{s: s}
403 return rs
404 }
405
406 type PropertiesDisplayVideo360AdvertiserLinkProposalsService struct {
407 s *Service
408 }
409
410 func NewPropertiesDisplayVideo360AdvertiserLinksService(s *Service) *PropertiesDisplayVideo360AdvertiserLinksService {
411 rs := &PropertiesDisplayVideo360AdvertiserLinksService{s: s}
412 return rs
413 }
414
415 type PropertiesDisplayVideo360AdvertiserLinksService struct {
416 s *Service
417 }
418
419 func NewPropertiesExpandedDataSetsService(s *Service) *PropertiesExpandedDataSetsService {
420 rs := &PropertiesExpandedDataSetsService{s: s}
421 return rs
422 }
423
424 type PropertiesExpandedDataSetsService struct {
425 s *Service
426 }
427
428 func NewPropertiesFirebaseLinksService(s *Service) *PropertiesFirebaseLinksService {
429 rs := &PropertiesFirebaseLinksService{s: s}
430 return rs
431 }
432
433 type PropertiesFirebaseLinksService struct {
434 s *Service
435 }
436
437 func NewPropertiesGoogleAdsLinksService(s *Service) *PropertiesGoogleAdsLinksService {
438 rs := &PropertiesGoogleAdsLinksService{s: s}
439 return rs
440 }
441
442 type PropertiesGoogleAdsLinksService struct {
443 s *Service
444 }
445
446 func NewPropertiesKeyEventsService(s *Service) *PropertiesKeyEventsService {
447 rs := &PropertiesKeyEventsService{s: s}
448 return rs
449 }
450
451 type PropertiesKeyEventsService struct {
452 s *Service
453 }
454
455 func NewPropertiesRollupPropertySourceLinksService(s *Service) *PropertiesRollupPropertySourceLinksService {
456 rs := &PropertiesRollupPropertySourceLinksService{s: s}
457 return rs
458 }
459
460 type PropertiesRollupPropertySourceLinksService struct {
461 s *Service
462 }
463
464 func NewPropertiesSearchAds360LinksService(s *Service) *PropertiesSearchAds360LinksService {
465 rs := &PropertiesSearchAds360LinksService{s: s}
466 return rs
467 }
468
469 type PropertiesSearchAds360LinksService struct {
470 s *Service
471 }
472
473 func NewPropertiesSubpropertyEventFiltersService(s *Service) *PropertiesSubpropertyEventFiltersService {
474 rs := &PropertiesSubpropertyEventFiltersService{s: s}
475 return rs
476 }
477
478 type PropertiesSubpropertyEventFiltersService struct {
479 s *Service
480 }
481
482
483
484 type GoogleAnalyticsAdminV1alphaAccessBetweenFilter struct {
485
486 FromValue *GoogleAnalyticsAdminV1alphaNumericValue `json:"fromValue,omitempty"`
487
488 ToValue *GoogleAnalyticsAdminV1alphaNumericValue `json:"toValue,omitempty"`
489
490
491
492
493
494 ForceSendFields []string `json:"-"`
495
496
497
498
499 NullFields []string `json:"-"`
500 }
501
502 func (s *GoogleAnalyticsAdminV1alphaAccessBetweenFilter) MarshalJSON() ([]byte, error) {
503 type NoMethod GoogleAnalyticsAdminV1alphaAccessBetweenFilter
504 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
505 }
506
507
508
509 type GoogleAnalyticsAdminV1alphaAccessBinding struct {
510
511
512
513
514 Name string `json:"name,omitempty"`
515
516
517
518
519
520 Roles []string `json:"roles,omitempty"`
521
522
523 User string `json:"user,omitempty"`
524
525
526 googleapi.ServerResponse `json:"-"`
527
528
529
530
531
532 ForceSendFields []string `json:"-"`
533
534
535
536
537 NullFields []string `json:"-"`
538 }
539
540 func (s *GoogleAnalyticsAdminV1alphaAccessBinding) MarshalJSON() ([]byte, error) {
541 type NoMethod GoogleAnalyticsAdminV1alphaAccessBinding
542 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
543 }
544
545
546
547 type GoogleAnalyticsAdminV1alphaAccessDateRange struct {
548
549
550
551
552 EndDate string `json:"endDate,omitempty"`
553
554
555
556
557 StartDate string `json:"startDate,omitempty"`
558
559
560
561
562
563 ForceSendFields []string `json:"-"`
564
565
566
567
568 NullFields []string `json:"-"`
569 }
570
571 func (s *GoogleAnalyticsAdminV1alphaAccessDateRange) MarshalJSON() ([]byte, error) {
572 type NoMethod GoogleAnalyticsAdminV1alphaAccessDateRange
573 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
574 }
575
576
577
578
579
580 type GoogleAnalyticsAdminV1alphaAccessDimension struct {
581
582
583
584
585 DimensionName string `json:"dimensionName,omitempty"`
586
587
588
589
590
591 ForceSendFields []string `json:"-"`
592
593
594
595
596 NullFields []string `json:"-"`
597 }
598
599 func (s *GoogleAnalyticsAdminV1alphaAccessDimension) MarshalJSON() ([]byte, error) {
600 type NoMethod GoogleAnalyticsAdminV1alphaAccessDimension
601 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
602 }
603
604
605
606
607
608
609 type GoogleAnalyticsAdminV1alphaAccessDimensionHeader struct {
610
611 DimensionName string `json:"dimensionName,omitempty"`
612
613
614
615
616
617 ForceSendFields []string `json:"-"`
618
619
620
621
622 NullFields []string `json:"-"`
623 }
624
625 func (s *GoogleAnalyticsAdminV1alphaAccessDimensionHeader) MarshalJSON() ([]byte, error) {
626 type NoMethod GoogleAnalyticsAdminV1alphaAccessDimensionHeader
627 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
628 }
629
630
631 type GoogleAnalyticsAdminV1alphaAccessDimensionValue struct {
632
633
634 Value string `json:"value,omitempty"`
635
636
637
638
639
640 ForceSendFields []string `json:"-"`
641
642
643
644
645 NullFields []string `json:"-"`
646 }
647
648 func (s *GoogleAnalyticsAdminV1alphaAccessDimensionValue) MarshalJSON() ([]byte, error) {
649 type NoMethod GoogleAnalyticsAdminV1alphaAccessDimensionValue
650 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
651 }
652
653
654
655 type GoogleAnalyticsAdminV1alphaAccessFilter struct {
656
657 BetweenFilter *GoogleAnalyticsAdminV1alphaAccessBetweenFilter `json:"betweenFilter,omitempty"`
658
659 FieldName string `json:"fieldName,omitempty"`
660
661 InListFilter *GoogleAnalyticsAdminV1alphaAccessInListFilter `json:"inListFilter,omitempty"`
662
663 NumericFilter *GoogleAnalyticsAdminV1alphaAccessNumericFilter `json:"numericFilter,omitempty"`
664
665 StringFilter *GoogleAnalyticsAdminV1alphaAccessStringFilter `json:"stringFilter,omitempty"`
666
667
668
669
670
671 ForceSendFields []string `json:"-"`
672
673
674
675
676 NullFields []string `json:"-"`
677 }
678
679 func (s *GoogleAnalyticsAdminV1alphaAccessFilter) MarshalJSON() ([]byte, error) {
680 type NoMethod GoogleAnalyticsAdminV1alphaAccessFilter
681 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
682 }
683
684
685
686
687 type GoogleAnalyticsAdminV1alphaAccessFilterExpression struct {
688
689
690 AccessFilter *GoogleAnalyticsAdminV1alphaAccessFilter `json:"accessFilter,omitempty"`
691
692
693 AndGroup *GoogleAnalyticsAdminV1alphaAccessFilterExpressionList `json:"andGroup,omitempty"`
694
695 NotExpression *GoogleAnalyticsAdminV1alphaAccessFilterExpression `json:"notExpression,omitempty"`
696
697
698 OrGroup *GoogleAnalyticsAdminV1alphaAccessFilterExpressionList `json:"orGroup,omitempty"`
699
700
701
702
703
704 ForceSendFields []string `json:"-"`
705
706
707
708
709 NullFields []string `json:"-"`
710 }
711
712 func (s *GoogleAnalyticsAdminV1alphaAccessFilterExpression) MarshalJSON() ([]byte, error) {
713 type NoMethod GoogleAnalyticsAdminV1alphaAccessFilterExpression
714 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
715 }
716
717
718
719 type GoogleAnalyticsAdminV1alphaAccessFilterExpressionList struct {
720
721 Expressions []*GoogleAnalyticsAdminV1alphaAccessFilterExpression `json:"expressions,omitempty"`
722
723
724
725
726
727 ForceSendFields []string `json:"-"`
728
729
730
731
732 NullFields []string `json:"-"`
733 }
734
735 func (s *GoogleAnalyticsAdminV1alphaAccessFilterExpressionList) MarshalJSON() ([]byte, error) {
736 type NoMethod GoogleAnalyticsAdminV1alphaAccessFilterExpressionList
737 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
738 }
739
740
741
742 type GoogleAnalyticsAdminV1alphaAccessInListFilter struct {
743
744 CaseSensitive bool `json:"caseSensitive,omitempty"`
745
746 Values []string `json:"values,omitempty"`
747
748
749
750
751
752 ForceSendFields []string `json:"-"`
753
754
755
756
757 NullFields []string `json:"-"`
758 }
759
760 func (s *GoogleAnalyticsAdminV1alphaAccessInListFilter) MarshalJSON() ([]byte, error) {
761 type NoMethod GoogleAnalyticsAdminV1alphaAccessInListFilter
762 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
763 }
764
765
766
767
768 type GoogleAnalyticsAdminV1alphaAccessMetric struct {
769
770
771
772
773 MetricName string `json:"metricName,omitempty"`
774
775
776
777
778
779 ForceSendFields []string `json:"-"`
780
781
782
783
784 NullFields []string `json:"-"`
785 }
786
787 func (s *GoogleAnalyticsAdminV1alphaAccessMetric) MarshalJSON() ([]byte, error) {
788 type NoMethod GoogleAnalyticsAdminV1alphaAccessMetric
789 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
790 }
791
792
793
794
795
796
797 type GoogleAnalyticsAdminV1alphaAccessMetricHeader struct {
798
799 MetricName string `json:"metricName,omitempty"`
800
801
802
803
804
805 ForceSendFields []string `json:"-"`
806
807
808
809
810 NullFields []string `json:"-"`
811 }
812
813 func (s *GoogleAnalyticsAdminV1alphaAccessMetricHeader) MarshalJSON() ([]byte, error) {
814 type NoMethod GoogleAnalyticsAdminV1alphaAccessMetricHeader
815 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
816 }
817
818
819 type GoogleAnalyticsAdminV1alphaAccessMetricValue struct {
820
821 Value string `json:"value,omitempty"`
822
823
824
825
826
827 ForceSendFields []string `json:"-"`
828
829
830
831
832 NullFields []string `json:"-"`
833 }
834
835 func (s *GoogleAnalyticsAdminV1alphaAccessMetricValue) MarshalJSON() ([]byte, error) {
836 type NoMethod GoogleAnalyticsAdminV1alphaAccessMetricValue
837 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
838 }
839
840
841
842 type GoogleAnalyticsAdminV1alphaAccessNumericFilter struct {
843
844
845
846
847
848
849
850
851
852 Operation string `json:"operation,omitempty"`
853
854 Value *GoogleAnalyticsAdminV1alphaNumericValue `json:"value,omitempty"`
855
856
857
858
859
860 ForceSendFields []string `json:"-"`
861
862
863
864
865 NullFields []string `json:"-"`
866 }
867
868 func (s *GoogleAnalyticsAdminV1alphaAccessNumericFilter) MarshalJSON() ([]byte, error) {
869 type NoMethod GoogleAnalyticsAdminV1alphaAccessNumericFilter
870 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
871 }
872
873
874
875
876
877 type GoogleAnalyticsAdminV1alphaAccessOrderBy struct {
878
879
880 Desc bool `json:"desc,omitempty"`
881
882 Dimension *GoogleAnalyticsAdminV1alphaAccessOrderByDimensionOrderBy `json:"dimension,omitempty"`
883
884 Metric *GoogleAnalyticsAdminV1alphaAccessOrderByMetricOrderBy `json:"metric,omitempty"`
885
886
887
888
889
890 ForceSendFields []string `json:"-"`
891
892
893
894
895 NullFields []string `json:"-"`
896 }
897
898 func (s *GoogleAnalyticsAdminV1alphaAccessOrderBy) MarshalJSON() ([]byte, error) {
899 type NoMethod GoogleAnalyticsAdminV1alphaAccessOrderBy
900 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
901 }
902
903
904
905 type GoogleAnalyticsAdminV1alphaAccessOrderByDimensionOrderBy struct {
906
907 DimensionName string `json:"dimensionName,omitempty"`
908
909
910
911
912
913
914
915
916
917
918
919
920 OrderType string `json:"orderType,omitempty"`
921
922
923
924
925
926 ForceSendFields []string `json:"-"`
927
928
929
930
931 NullFields []string `json:"-"`
932 }
933
934 func (s *GoogleAnalyticsAdminV1alphaAccessOrderByDimensionOrderBy) MarshalJSON() ([]byte, error) {
935 type NoMethod GoogleAnalyticsAdminV1alphaAccessOrderByDimensionOrderBy
936 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
937 }
938
939
940
941 type GoogleAnalyticsAdminV1alphaAccessOrderByMetricOrderBy struct {
942
943 MetricName string `json:"metricName,omitempty"`
944
945
946
947
948
949 ForceSendFields []string `json:"-"`
950
951
952
953
954 NullFields []string `json:"-"`
955 }
956
957 func (s *GoogleAnalyticsAdminV1alphaAccessOrderByMetricOrderBy) MarshalJSON() ([]byte, error) {
958 type NoMethod GoogleAnalyticsAdminV1alphaAccessOrderByMetricOrderBy
959 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
960 }
961
962
963
964
965 type GoogleAnalyticsAdminV1alphaAccessQuota struct {
966
967 ConcurrentRequests *GoogleAnalyticsAdminV1alphaAccessQuotaStatus `json:"concurrentRequests,omitempty"`
968
969
970 ServerErrorsPerProjectPerHour *GoogleAnalyticsAdminV1alphaAccessQuotaStatus `json:"serverErrorsPerProjectPerHour,omitempty"`
971
972
973 TokensPerDay *GoogleAnalyticsAdminV1alphaAccessQuotaStatus `json:"tokensPerDay,omitempty"`
974
975
976
977 TokensPerHour *GoogleAnalyticsAdminV1alphaAccessQuotaStatus `json:"tokensPerHour,omitempty"`
978
979
980
981
982
983 TokensPerProjectPerHour *GoogleAnalyticsAdminV1alphaAccessQuotaStatus `json:"tokensPerProjectPerHour,omitempty"`
984
985
986
987
988
989 ForceSendFields []string `json:"-"`
990
991
992
993
994 NullFields []string `json:"-"`
995 }
996
997 func (s *GoogleAnalyticsAdminV1alphaAccessQuota) MarshalJSON() ([]byte, error) {
998 type NoMethod GoogleAnalyticsAdminV1alphaAccessQuota
999 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1000 }
1001
1002
1003
1004 type GoogleAnalyticsAdminV1alphaAccessQuotaStatus struct {
1005
1006 Consumed int64 `json:"consumed,omitempty"`
1007
1008 Remaining int64 `json:"remaining,omitempty"`
1009
1010
1011
1012
1013
1014 ForceSendFields []string `json:"-"`
1015
1016
1017
1018
1019 NullFields []string `json:"-"`
1020 }
1021
1022 func (s *GoogleAnalyticsAdminV1alphaAccessQuotaStatus) MarshalJSON() ([]byte, error) {
1023 type NoMethod GoogleAnalyticsAdminV1alphaAccessQuotaStatus
1024 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1025 }
1026
1027
1028 type GoogleAnalyticsAdminV1alphaAccessRow struct {
1029
1030
1031 DimensionValues []*GoogleAnalyticsAdminV1alphaAccessDimensionValue `json:"dimensionValues,omitempty"`
1032
1033
1034 MetricValues []*GoogleAnalyticsAdminV1alphaAccessMetricValue `json:"metricValues,omitempty"`
1035
1036
1037
1038
1039
1040 ForceSendFields []string `json:"-"`
1041
1042
1043
1044
1045 NullFields []string `json:"-"`
1046 }
1047
1048 func (s *GoogleAnalyticsAdminV1alphaAccessRow) MarshalJSON() ([]byte, error) {
1049 type NoMethod GoogleAnalyticsAdminV1alphaAccessRow
1050 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1051 }
1052
1053
1054 type GoogleAnalyticsAdminV1alphaAccessStringFilter struct {
1055
1056 CaseSensitive bool `json:"caseSensitive,omitempty"`
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069 MatchType string `json:"matchType,omitempty"`
1070
1071 Value string `json:"value,omitempty"`
1072
1073
1074
1075
1076
1077 ForceSendFields []string `json:"-"`
1078
1079
1080
1081
1082 NullFields []string `json:"-"`
1083 }
1084
1085 func (s *GoogleAnalyticsAdminV1alphaAccessStringFilter) MarshalJSON() ([]byte, error) {
1086 type NoMethod GoogleAnalyticsAdminV1alphaAccessStringFilter
1087 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1088 }
1089
1090
1091
1092 type GoogleAnalyticsAdminV1alphaAccount struct {
1093
1094 CreateTime string `json:"createTime,omitempty"`
1095
1096
1097
1098 Deleted bool `json:"deleted,omitempty"`
1099
1100 DisplayName string `json:"displayName,omitempty"`
1101
1102
1103
1104
1105 GmpOrganization string `json:"gmpOrganization,omitempty"`
1106
1107
1108 Name string `json:"name,omitempty"`
1109
1110 RegionCode string `json:"regionCode,omitempty"`
1111
1112 UpdateTime string `json:"updateTime,omitempty"`
1113
1114
1115 googleapi.ServerResponse `json:"-"`
1116
1117
1118
1119
1120
1121 ForceSendFields []string `json:"-"`
1122
1123
1124
1125
1126 NullFields []string `json:"-"`
1127 }
1128
1129 func (s *GoogleAnalyticsAdminV1alphaAccount) MarshalJSON() ([]byte, error) {
1130 type NoMethod GoogleAnalyticsAdminV1alphaAccount
1131 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1132 }
1133
1134
1135
1136 type GoogleAnalyticsAdminV1alphaAccountSummary struct {
1137
1138
1139 Account string `json:"account,omitempty"`
1140
1141
1142 DisplayName string `json:"displayName,omitempty"`
1143
1144
1145 Name string `json:"name,omitempty"`
1146
1147 PropertySummaries []*GoogleAnalyticsAdminV1alphaPropertySummary `json:"propertySummaries,omitempty"`
1148
1149
1150
1151
1152
1153 ForceSendFields []string `json:"-"`
1154
1155
1156
1157
1158 NullFields []string `json:"-"`
1159 }
1160
1161 func (s *GoogleAnalyticsAdminV1alphaAccountSummary) MarshalJSON() ([]byte, error) {
1162 type NoMethod GoogleAnalyticsAdminV1alphaAccountSummary
1163 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1164 }
1165
1166
1167
1168 type GoogleAnalyticsAdminV1alphaAcknowledgeUserDataCollectionRequest struct {
1169
1170
1171
1172
1173
1174
1175 Acknowledgement string `json:"acknowledgement,omitempty"`
1176
1177
1178
1179
1180
1181 ForceSendFields []string `json:"-"`
1182
1183
1184
1185
1186 NullFields []string `json:"-"`
1187 }
1188
1189 func (s *GoogleAnalyticsAdminV1alphaAcknowledgeUserDataCollectionRequest) MarshalJSON() ([]byte, error) {
1190 type NoMethod GoogleAnalyticsAdminV1alphaAcknowledgeUserDataCollectionRequest
1191 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1192 }
1193
1194
1195
1196 type GoogleAnalyticsAdminV1alphaAcknowledgeUserDataCollectionResponse struct {
1197
1198 googleapi.ServerResponse `json:"-"`
1199 }
1200
1201
1202
1203 type GoogleAnalyticsAdminV1alphaAdSenseLink struct {
1204
1205
1206 AdClientCode string `json:"adClientCode,omitempty"`
1207
1208
1209
1210 Name string `json:"name,omitempty"`
1211
1212
1213 googleapi.ServerResponse `json:"-"`
1214
1215
1216
1217
1218
1219 ForceSendFields []string `json:"-"`
1220
1221
1222
1223
1224 NullFields []string `json:"-"`
1225 }
1226
1227 func (s *GoogleAnalyticsAdminV1alphaAdSenseLink) MarshalJSON() ([]byte, error) {
1228 type NoMethod GoogleAnalyticsAdminV1alphaAdSenseLink
1229 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1230 }
1231
1232
1233
1234 type GoogleAnalyticsAdminV1alphaApproveDisplayVideo360AdvertiserLinkProposalRequest struct {
1235 }
1236
1237
1238
1239 type GoogleAnalyticsAdminV1alphaApproveDisplayVideo360AdvertiserLinkProposalResponse struct {
1240
1241
1242 DisplayVideo360AdvertiserLink *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink `json:"displayVideo360AdvertiserLink,omitempty"`
1243
1244
1245 googleapi.ServerResponse `json:"-"`
1246
1247
1248
1249
1250
1251 ForceSendFields []string `json:"-"`
1252
1253
1254
1255
1256 NullFields []string `json:"-"`
1257 }
1258
1259 func (s *GoogleAnalyticsAdminV1alphaApproveDisplayVideo360AdvertiserLinkProposalResponse) MarshalJSON() ([]byte, error) {
1260 type NoMethod GoogleAnalyticsAdminV1alphaApproveDisplayVideo360AdvertiserLinkProposalResponse
1261 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1262 }
1263
1264
1265
1266 type GoogleAnalyticsAdminV1alphaArchiveAudienceRequest struct {
1267 }
1268
1269
1270
1271 type GoogleAnalyticsAdminV1alphaArchiveCustomDimensionRequest struct {
1272 }
1273
1274
1275
1276 type GoogleAnalyticsAdminV1alphaArchiveCustomMetricRequest struct {
1277 }
1278
1279
1280
1281 type GoogleAnalyticsAdminV1alphaAttributionSettings struct {
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293 AcquisitionConversionEventLookbackWindow string `json:"acquisitionConversionEventLookbackWindow,omitempty"`
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309 AdsWebConversionDataExportScope string `json:"adsWebConversionDataExportScope,omitempty"`
1310
1311
1312
1313 Name string `json:"name,omitempty"`
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324 OtherConversionEventLookbackWindow string `json:"otherConversionEventLookbackWindow,omitempty"`
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345 ReportingAttributionModel string `json:"reportingAttributionModel,omitempty"`
1346
1347
1348 googleapi.ServerResponse `json:"-"`
1349
1350
1351
1352
1353
1354
1355 ForceSendFields []string `json:"-"`
1356
1357
1358
1359
1360
1361 NullFields []string `json:"-"`
1362 }
1363
1364 func (s *GoogleAnalyticsAdminV1alphaAttributionSettings) MarshalJSON() ([]byte, error) {
1365 type NoMethod GoogleAnalyticsAdminV1alphaAttributionSettings
1366 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1367 }
1368
1369
1370
1371 type GoogleAnalyticsAdminV1alphaAudience struct {
1372
1373
1374 AdsPersonalizationEnabled bool `json:"adsPersonalizationEnabled,omitempty"`
1375
1376 Description string `json:"description,omitempty"`
1377
1378 DisplayName string `json:"displayName,omitempty"`
1379
1380
1381 EventTrigger *GoogleAnalyticsAdminV1alphaAudienceEventTrigger `json:"eventTrigger,omitempty"`
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393 ExclusionDurationMode string `json:"exclusionDurationMode,omitempty"`
1394
1395
1396 FilterClauses []*GoogleAnalyticsAdminV1alphaAudienceFilterClause `json:"filterClauses,omitempty"`
1397
1398
1399 MembershipDurationDays int64 `json:"membershipDurationDays,omitempty"`
1400
1401
1402 Name string `json:"name,omitempty"`
1403
1404
1405 googleapi.ServerResponse `json:"-"`
1406
1407
1408
1409
1410
1411 ForceSendFields []string `json:"-"`
1412
1413
1414
1415
1416 NullFields []string `json:"-"`
1417 }
1418
1419 func (s *GoogleAnalyticsAdminV1alphaAudience) MarshalJSON() ([]byte, error) {
1420 type NoMethod GoogleAnalyticsAdminV1alphaAudience
1421 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1422 }
1423
1424
1425
1426 type GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilter struct {
1427
1428
1429
1430
1431
1432
1433 AtAnyPointInTime bool `json:"atAnyPointInTime,omitempty"`
1434
1435
1436 BetweenFilter *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterBetweenFilter `json:"betweenFilter,omitempty"`
1437
1438
1439
1440
1441
1442
1443 FieldName string `json:"fieldName,omitempty"`
1444
1445
1446
1447
1448
1449
1450
1451 InAnyNDayPeriod int64 `json:"inAnyNDayPeriod,omitempty"`
1452
1453
1454 InListFilter *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterInListFilter `json:"inListFilter,omitempty"`
1455
1456 NumericFilter *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericFilter `json:"numericFilter,omitempty"`
1457
1458
1459 StringFilter *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterStringFilter `json:"stringFilter,omitempty"`
1460
1461
1462
1463
1464
1465 ForceSendFields []string `json:"-"`
1466
1467
1468
1469
1470 NullFields []string `json:"-"`
1471 }
1472
1473 func (s *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilter) MarshalJSON() ([]byte, error) {
1474 type NoMethod GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilter
1475 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1476 }
1477
1478
1479
1480
1481 type GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterBetweenFilter struct {
1482
1483 FromValue *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericValue `json:"fromValue,omitempty"`
1484
1485 ToValue *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericValue `json:"toValue,omitempty"`
1486
1487
1488
1489
1490
1491 ForceSendFields []string `json:"-"`
1492
1493
1494
1495
1496 NullFields []string `json:"-"`
1497 }
1498
1499 func (s *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterBetweenFilter) MarshalJSON() ([]byte, error) {
1500 type NoMethod GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterBetweenFilter
1501 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1502 }
1503
1504
1505
1506 type GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterInListFilter struct {
1507
1508
1509 CaseSensitive bool `json:"caseSensitive,omitempty"`
1510
1511
1512 Values []string `json:"values,omitempty"`
1513
1514
1515
1516
1517
1518 ForceSendFields []string `json:"-"`
1519
1520
1521
1522
1523 NullFields []string `json:"-"`
1524 }
1525
1526 func (s *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterInListFilter) MarshalJSON() ([]byte, error) {
1527 type NoMethod GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterInListFilter
1528 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1529 }
1530
1531
1532
1533 type GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericFilter struct {
1534
1535
1536
1537
1538
1539
1540
1541 Operation string `json:"operation,omitempty"`
1542
1543 Value *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericValue `json:"value,omitempty"`
1544
1545
1546
1547
1548
1549 ForceSendFields []string `json:"-"`
1550
1551
1552
1553
1554 NullFields []string `json:"-"`
1555 }
1556
1557 func (s *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericFilter) MarshalJSON() ([]byte, error) {
1558 type NoMethod GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericFilter
1559 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1560 }
1561
1562
1563
1564 type GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericValue struct {
1565
1566 DoubleValue float64 `json:"doubleValue,omitempty"`
1567
1568 Int64Value int64 `json:"int64Value,omitempty,string"`
1569
1570
1571
1572
1573
1574 ForceSendFields []string `json:"-"`
1575
1576
1577
1578
1579 NullFields []string `json:"-"`
1580 }
1581
1582 func (s *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericValue) MarshalJSON() ([]byte, error) {
1583 type NoMethod GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericValue
1584 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1585 }
1586
1587 func (s *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericValue) UnmarshalJSON(data []byte) error {
1588 type NoMethod GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterNumericValue
1589 var s1 struct {
1590 DoubleValue gensupport.JSONFloat64 `json:"doubleValue"`
1591 *NoMethod
1592 }
1593 s1.NoMethod = (*NoMethod)(s)
1594 if err := json.Unmarshal(data, &s1); err != nil {
1595 return err
1596 }
1597 s.DoubleValue = float64(s1.DoubleValue)
1598 return nil
1599 }
1600
1601
1602
1603 type GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterStringFilter struct {
1604
1605
1606 CaseSensitive bool `json:"caseSensitive,omitempty"`
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616 MatchType string `json:"matchType,omitempty"`
1617
1618 Value string `json:"value,omitempty"`
1619
1620
1621
1622
1623
1624 ForceSendFields []string `json:"-"`
1625
1626
1627
1628
1629 NullFields []string `json:"-"`
1630 }
1631
1632 func (s *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterStringFilter) MarshalJSON() ([]byte, error) {
1633 type NoMethod GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilterStringFilter
1634 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1635 }
1636
1637
1638
1639
1640
1641 type GoogleAnalyticsAdminV1alphaAudienceEventFilter struct {
1642
1643 EventName string `json:"eventName,omitempty"`
1644
1645
1646
1647
1648
1649
1650
1651
1652 EventParameterFilterExpression *GoogleAnalyticsAdminV1alphaAudienceFilterExpression `json:"eventParameterFilterExpression,omitempty"`
1653
1654
1655
1656
1657
1658 ForceSendFields []string `json:"-"`
1659
1660
1661
1662
1663 NullFields []string `json:"-"`
1664 }
1665
1666 func (s *GoogleAnalyticsAdminV1alphaAudienceEventFilter) MarshalJSON() ([]byte, error) {
1667 type NoMethod GoogleAnalyticsAdminV1alphaAudienceEventFilter
1668 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1669 }
1670
1671
1672
1673 type GoogleAnalyticsAdminV1alphaAudienceEventTrigger struct {
1674
1675 EventName string `json:"eventName,omitempty"`
1676
1677
1678
1679
1680
1681
1682
1683
1684 LogCondition string `json:"logCondition,omitempty"`
1685
1686
1687
1688
1689
1690 ForceSendFields []string `json:"-"`
1691
1692
1693
1694
1695 NullFields []string `json:"-"`
1696 }
1697
1698 func (s *GoogleAnalyticsAdminV1alphaAudienceEventTrigger) MarshalJSON() ([]byte, error) {
1699 type NoMethod GoogleAnalyticsAdminV1alphaAudienceEventTrigger
1700 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1701 }
1702
1703
1704
1705
1706
1707
1708 type GoogleAnalyticsAdminV1alphaAudienceFilterClause struct {
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718 ClauseType string `json:"clauseType,omitempty"`
1719
1720
1721 SequenceFilter *GoogleAnalyticsAdminV1alphaAudienceSequenceFilter `json:"sequenceFilter,omitempty"`
1722
1723
1724 SimpleFilter *GoogleAnalyticsAdminV1alphaAudienceSimpleFilter `json:"simpleFilter,omitempty"`
1725
1726
1727
1728
1729
1730 ForceSendFields []string `json:"-"`
1731
1732
1733
1734
1735 NullFields []string `json:"-"`
1736 }
1737
1738 func (s *GoogleAnalyticsAdminV1alphaAudienceFilterClause) MarshalJSON() ([]byte, error) {
1739 type NoMethod GoogleAnalyticsAdminV1alphaAudienceFilterClause
1740 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1741 }
1742
1743
1744
1745 type GoogleAnalyticsAdminV1alphaAudienceFilterExpression struct {
1746
1747
1748
1749 AndGroup *GoogleAnalyticsAdminV1alphaAudienceFilterExpressionList `json:"andGroup,omitempty"`
1750
1751
1752 DimensionOrMetricFilter *GoogleAnalyticsAdminV1alphaAudienceDimensionOrMetricFilter `json:"dimensionOrMetricFilter,omitempty"`
1753
1754
1755 EventFilter *GoogleAnalyticsAdminV1alphaAudienceEventFilter `json:"eventFilter,omitempty"`
1756
1757
1758
1759 NotExpression *GoogleAnalyticsAdminV1alphaAudienceFilterExpression `json:"notExpression,omitempty"`
1760
1761
1762 OrGroup *GoogleAnalyticsAdminV1alphaAudienceFilterExpressionList `json:"orGroup,omitempty"`
1763
1764
1765
1766
1767
1768 ForceSendFields []string `json:"-"`
1769
1770
1771
1772
1773 NullFields []string `json:"-"`
1774 }
1775
1776 func (s *GoogleAnalyticsAdminV1alphaAudienceFilterExpression) MarshalJSON() ([]byte, error) {
1777 type NoMethod GoogleAnalyticsAdminV1alphaAudienceFilterExpression
1778 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1779 }
1780
1781
1782
1783 type GoogleAnalyticsAdminV1alphaAudienceFilterExpressionList struct {
1784
1785 FilterExpressions []*GoogleAnalyticsAdminV1alphaAudienceFilterExpression `json:"filterExpressions,omitempty"`
1786
1787
1788
1789
1790
1791 ForceSendFields []string `json:"-"`
1792
1793
1794
1795
1796 NullFields []string `json:"-"`
1797 }
1798
1799 func (s *GoogleAnalyticsAdminV1alphaAudienceFilterExpressionList) MarshalJSON() ([]byte, error) {
1800 type NoMethod GoogleAnalyticsAdminV1alphaAudienceFilterExpressionList
1801 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1802 }
1803
1804
1805
1806 type GoogleAnalyticsAdminV1alphaAudienceSequenceFilter struct {
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817 Scope string `json:"scope,omitempty"`
1818
1819
1820 SequenceMaximumDuration string `json:"sequenceMaximumDuration,omitempty"`
1821
1822
1823 SequenceSteps []*GoogleAnalyticsAdminV1alphaAudienceSequenceFilterAudienceSequenceStep `json:"sequenceSteps,omitempty"`
1824
1825
1826
1827
1828
1829 ForceSendFields []string `json:"-"`
1830
1831
1832
1833
1834 NullFields []string `json:"-"`
1835 }
1836
1837 func (s *GoogleAnalyticsAdminV1alphaAudienceSequenceFilter) MarshalJSON() ([]byte, error) {
1838 type NoMethod GoogleAnalyticsAdminV1alphaAudienceSequenceFilter
1839 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1840 }
1841
1842
1843
1844
1845 type GoogleAnalyticsAdminV1alphaAudienceSequenceFilterAudienceSequenceStep struct {
1846
1847
1848
1849
1850 ConstraintDuration string `json:"constraintDuration,omitempty"`
1851
1852
1853 FilterExpression *GoogleAnalyticsAdminV1alphaAudienceFilterExpression `json:"filterExpression,omitempty"`
1854
1855
1856
1857
1858
1859 ImmediatelyFollows bool `json:"immediatelyFollows,omitempty"`
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870 Scope string `json:"scope,omitempty"`
1871
1872
1873
1874
1875
1876 ForceSendFields []string `json:"-"`
1877
1878
1879
1880
1881 NullFields []string `json:"-"`
1882 }
1883
1884 func (s *GoogleAnalyticsAdminV1alphaAudienceSequenceFilterAudienceSequenceStep) MarshalJSON() ([]byte, error) {
1885 type NoMethod GoogleAnalyticsAdminV1alphaAudienceSequenceFilterAudienceSequenceStep
1886 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1887 }
1888
1889
1890
1891 type GoogleAnalyticsAdminV1alphaAudienceSimpleFilter struct {
1892
1893
1894 FilterExpression *GoogleAnalyticsAdminV1alphaAudienceFilterExpression `json:"filterExpression,omitempty"`
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905 Scope string `json:"scope,omitempty"`
1906
1907
1908
1909
1910
1911 ForceSendFields []string `json:"-"`
1912
1913
1914
1915
1916 NullFields []string `json:"-"`
1917 }
1918
1919 func (s *GoogleAnalyticsAdminV1alphaAudienceSimpleFilter) MarshalJSON() ([]byte, error) {
1920 type NoMethod GoogleAnalyticsAdminV1alphaAudienceSimpleFilter
1921 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1922 }
1923
1924
1925
1926 type GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsRequest struct {
1927
1928
1929 Requests []*GoogleAnalyticsAdminV1alphaCreateAccessBindingRequest `json:"requests,omitempty"`
1930
1931
1932
1933
1934
1935 ForceSendFields []string `json:"-"`
1936
1937
1938
1939
1940 NullFields []string `json:"-"`
1941 }
1942
1943 func (s *GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsRequest) MarshalJSON() ([]byte, error) {
1944 type NoMethod GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsRequest
1945 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1946 }
1947
1948
1949
1950 type GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsResponse struct {
1951
1952 AccessBindings []*GoogleAnalyticsAdminV1alphaAccessBinding `json:"accessBindings,omitempty"`
1953
1954
1955 googleapi.ServerResponse `json:"-"`
1956
1957
1958
1959
1960
1961 ForceSendFields []string `json:"-"`
1962
1963
1964
1965
1966 NullFields []string `json:"-"`
1967 }
1968
1969 func (s *GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsResponse) MarshalJSON() ([]byte, error) {
1970 type NoMethod GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsResponse
1971 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1972 }
1973
1974
1975
1976 type GoogleAnalyticsAdminV1alphaBatchDeleteAccessBindingsRequest struct {
1977
1978
1979 Requests []*GoogleAnalyticsAdminV1alphaDeleteAccessBindingRequest `json:"requests,omitempty"`
1980
1981
1982
1983
1984
1985 ForceSendFields []string `json:"-"`
1986
1987
1988
1989
1990 NullFields []string `json:"-"`
1991 }
1992
1993 func (s *GoogleAnalyticsAdminV1alphaBatchDeleteAccessBindingsRequest) MarshalJSON() ([]byte, error) {
1994 type NoMethod GoogleAnalyticsAdminV1alphaBatchDeleteAccessBindingsRequest
1995 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1996 }
1997
1998
1999
2000 type GoogleAnalyticsAdminV1alphaBatchGetAccessBindingsResponse struct {
2001
2002 AccessBindings []*GoogleAnalyticsAdminV1alphaAccessBinding `json:"accessBindings,omitempty"`
2003
2004
2005 googleapi.ServerResponse `json:"-"`
2006
2007
2008
2009
2010
2011 ForceSendFields []string `json:"-"`
2012
2013
2014
2015
2016 NullFields []string `json:"-"`
2017 }
2018
2019 func (s *GoogleAnalyticsAdminV1alphaBatchGetAccessBindingsResponse) MarshalJSON() ([]byte, error) {
2020 type NoMethod GoogleAnalyticsAdminV1alphaBatchGetAccessBindingsResponse
2021 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2022 }
2023
2024
2025
2026 type GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsRequest struct {
2027
2028
2029 Requests []*GoogleAnalyticsAdminV1alphaUpdateAccessBindingRequest `json:"requests,omitempty"`
2030
2031
2032
2033
2034
2035 ForceSendFields []string `json:"-"`
2036
2037
2038
2039
2040 NullFields []string `json:"-"`
2041 }
2042
2043 func (s *GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsRequest) MarshalJSON() ([]byte, error) {
2044 type NoMethod GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsRequest
2045 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2046 }
2047
2048
2049
2050 type GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsResponse struct {
2051
2052 AccessBindings []*GoogleAnalyticsAdminV1alphaAccessBinding `json:"accessBindings,omitempty"`
2053
2054
2055 googleapi.ServerResponse `json:"-"`
2056
2057
2058
2059
2060
2061 ForceSendFields []string `json:"-"`
2062
2063
2064
2065
2066 NullFields []string `json:"-"`
2067 }
2068
2069 func (s *GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsResponse) MarshalJSON() ([]byte, error) {
2070 type NoMethod GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsResponse
2071 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2072 }
2073
2074
2075
2076 type GoogleAnalyticsAdminV1alphaBigQueryLink struct {
2077
2078 CreateTime string `json:"createTime,omitempty"`
2079
2080
2081 DailyExportEnabled bool `json:"dailyExportEnabled,omitempty"`
2082
2083 ExcludedEvents []string `json:"excludedEvents,omitempty"`
2084
2085
2086
2087 ExportStreams []string `json:"exportStreams,omitempty"`
2088
2089
2090 FreshDailyExportEnabled bool `json:"freshDailyExportEnabled,omitempty"`
2091
2092
2093 IncludeAdvertisingId bool `json:"includeAdvertisingId,omitempty"`
2094
2095
2096
2097 Name string `json:"name,omitempty"`
2098
2099
2100
2101
2102
2103 Project string `json:"project,omitempty"`
2104
2105
2106 StreamingExportEnabled bool `json:"streamingExportEnabled,omitempty"`
2107
2108
2109 googleapi.ServerResponse `json:"-"`
2110
2111
2112
2113
2114
2115 ForceSendFields []string `json:"-"`
2116
2117
2118
2119
2120 NullFields []string `json:"-"`
2121 }
2122
2123 func (s *GoogleAnalyticsAdminV1alphaBigQueryLink) MarshalJSON() ([]byte, error) {
2124 type NoMethod GoogleAnalyticsAdminV1alphaBigQueryLink
2125 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2126 }
2127
2128
2129
2130 type GoogleAnalyticsAdminV1alphaCalculatedMetric struct {
2131
2132
2133
2134
2135 CalculatedMetricId string `json:"calculatedMetricId,omitempty"`
2136
2137
2138 Description string `json:"description,omitempty"`
2139
2140
2141 DisplayName string `json:"displayName,omitempty"`
2142
2143
2144
2145
2146
2147
2148
2149 Formula string `json:"formula,omitempty"`
2150
2151
2152
2153
2154 InvalidMetricReference bool `json:"invalidMetricReference,omitempty"`
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169 MetricUnit string `json:"metricUnit,omitempty"`
2170
2171
2172 Name string `json:"name,omitempty"`
2173
2174
2175
2176
2177
2178
2179
2180 RestrictedMetricType []string `json:"restrictedMetricType,omitempty"`
2181
2182
2183 googleapi.ServerResponse `json:"-"`
2184
2185
2186
2187
2188
2189 ForceSendFields []string `json:"-"`
2190
2191
2192
2193
2194 NullFields []string `json:"-"`
2195 }
2196
2197 func (s *GoogleAnalyticsAdminV1alphaCalculatedMetric) MarshalJSON() ([]byte, error) {
2198 type NoMethod GoogleAnalyticsAdminV1alphaCalculatedMetric
2199 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2200 }
2201
2202
2203
2204 type GoogleAnalyticsAdminV1alphaCancelDisplayVideo360AdvertiserLinkProposalRequest struct {
2205 }
2206
2207
2208
2209 type GoogleAnalyticsAdminV1alphaChangeHistoryChange struct {
2210
2211
2212
2213
2214
2215
2216
2217 Action string `json:"action,omitempty"`
2218
2219
2220 Resource string `json:"resource,omitempty"`
2221
2222
2223 ResourceAfterChange *GoogleAnalyticsAdminV1alphaChangeHistoryChangeChangeHistoryResource `json:"resourceAfterChange,omitempty"`
2224
2225
2226 ResourceBeforeChange *GoogleAnalyticsAdminV1alphaChangeHistoryChangeChangeHistoryResource `json:"resourceBeforeChange,omitempty"`
2227
2228
2229
2230
2231
2232 ForceSendFields []string `json:"-"`
2233
2234
2235
2236
2237 NullFields []string `json:"-"`
2238 }
2239
2240 func (s *GoogleAnalyticsAdminV1alphaChangeHistoryChange) MarshalJSON() ([]byte, error) {
2241 type NoMethod GoogleAnalyticsAdminV1alphaChangeHistoryChange
2242 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2243 }
2244
2245
2246
2247
2248 type GoogleAnalyticsAdminV1alphaChangeHistoryChangeChangeHistoryResource struct {
2249
2250 Account *GoogleAnalyticsAdminV1alphaAccount `json:"account,omitempty"`
2251
2252 AdsenseLink *GoogleAnalyticsAdminV1alphaAdSenseLink `json:"adsenseLink,omitempty"`
2253
2254
2255 AttributionSettings *GoogleAnalyticsAdminV1alphaAttributionSettings `json:"attributionSettings,omitempty"`
2256
2257 Audience *GoogleAnalyticsAdminV1alphaAudience `json:"audience,omitempty"`
2258
2259 BigqueryLink *GoogleAnalyticsAdminV1alphaBigQueryLink `json:"bigqueryLink,omitempty"`
2260
2261
2262 CalculatedMetric *GoogleAnalyticsAdminV1alphaCalculatedMetric `json:"calculatedMetric,omitempty"`
2263
2264 ChannelGroup *GoogleAnalyticsAdminV1alphaChannelGroup `json:"channelGroup,omitempty"`
2265
2266 ConversionEvent *GoogleAnalyticsAdminV1alphaConversionEvent `json:"conversionEvent,omitempty"`
2267
2268 CustomDimension *GoogleAnalyticsAdminV1alphaCustomDimension `json:"customDimension,omitempty"`
2269
2270 CustomMetric *GoogleAnalyticsAdminV1alphaCustomMetric `json:"customMetric,omitempty"`
2271
2272
2273 DataRedactionSettings *GoogleAnalyticsAdminV1alphaDataRedactionSettings `json:"dataRedactionSettings,omitempty"`
2274
2275
2276 DataRetentionSettings *GoogleAnalyticsAdminV1alphaDataRetentionSettings `json:"dataRetentionSettings,omitempty"`
2277
2278 DataStream *GoogleAnalyticsAdminV1alphaDataStream `json:"dataStream,omitempty"`
2279
2280
2281 DisplayVideo360AdvertiserLink *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink `json:"displayVideo360AdvertiserLink,omitempty"`
2282
2283
2284 DisplayVideo360AdvertiserLinkProposal *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal `json:"displayVideo360AdvertiserLinkProposal,omitempty"`
2285
2286
2287 EnhancedMeasurementSettings *GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings `json:"enhancedMeasurementSettings,omitempty"`
2288
2289
2290 EventCreateRule *GoogleAnalyticsAdminV1alphaEventCreateRule `json:"eventCreateRule,omitempty"`
2291
2292
2293 ExpandedDataSet *GoogleAnalyticsAdminV1alphaExpandedDataSet `json:"expandedDataSet,omitempty"`
2294
2295 FirebaseLink *GoogleAnalyticsAdminV1alphaFirebaseLink `json:"firebaseLink,omitempty"`
2296
2297 GoogleAdsLink *GoogleAnalyticsAdminV1alphaGoogleAdsLink `json:"googleAdsLink,omitempty"`
2298
2299
2300 GoogleSignalsSettings *GoogleAnalyticsAdminV1alphaGoogleSignalsSettings `json:"googleSignalsSettings,omitempty"`
2301
2302
2303 MeasurementProtocolSecret *GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret `json:"measurementProtocolSecret,omitempty"`
2304
2305 Property *GoogleAnalyticsAdminV1alphaProperty `json:"property,omitempty"`
2306
2307
2308 SearchAds360Link *GoogleAnalyticsAdminV1alphaSearchAds360Link `json:"searchAds360Link,omitempty"`
2309
2310
2311 SkadnetworkConversionValueSchema *GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema `json:"skadnetworkConversionValueSchema,omitempty"`
2312
2313
2314
2315
2316
2317 ForceSendFields []string `json:"-"`
2318
2319
2320
2321
2322 NullFields []string `json:"-"`
2323 }
2324
2325 func (s *GoogleAnalyticsAdminV1alphaChangeHistoryChangeChangeHistoryResource) MarshalJSON() ([]byte, error) {
2326 type NoMethod GoogleAnalyticsAdminV1alphaChangeHistoryChangeChangeHistoryResource
2327 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2328 }
2329
2330
2331
2332
2333
2334 type GoogleAnalyticsAdminV1alphaChangeHistoryEvent struct {
2335
2336
2337
2338
2339
2340
2341
2342 ActorType string `json:"actorType,omitempty"`
2343
2344 ChangeTime string `json:"changeTime,omitempty"`
2345
2346
2347 Changes []*GoogleAnalyticsAdminV1alphaChangeHistoryChange `json:"changes,omitempty"`
2348
2349
2350 ChangesFiltered bool `json:"changesFiltered,omitempty"`
2351
2352
2353 Id string `json:"id,omitempty"`
2354
2355
2356
2357 UserActorEmail string `json:"userActorEmail,omitempty"`
2358
2359
2360
2361
2362
2363 ForceSendFields []string `json:"-"`
2364
2365
2366
2367
2368 NullFields []string `json:"-"`
2369 }
2370
2371 func (s *GoogleAnalyticsAdminV1alphaChangeHistoryEvent) MarshalJSON() ([]byte, error) {
2372 type NoMethod GoogleAnalyticsAdminV1alphaChangeHistoryEvent
2373 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2374 }
2375
2376
2377
2378 type GoogleAnalyticsAdminV1alphaChannelGroup struct {
2379
2380
2381 Description string `json:"description,omitempty"`
2382
2383
2384 DisplayName string `json:"displayName,omitempty"`
2385
2386
2387 GroupingRule []*GoogleAnalyticsAdminV1alphaGroupingRule `json:"groupingRule,omitempty"`
2388
2389
2390 Name string `json:"name,omitempty"`
2391
2392
2393
2394
2395
2396 Primary bool `json:"primary,omitempty"`
2397
2398
2399
2400 SystemDefined bool `json:"systemDefined,omitempty"`
2401
2402
2403 googleapi.ServerResponse `json:"-"`
2404
2405
2406
2407
2408
2409 ForceSendFields []string `json:"-"`
2410
2411
2412
2413
2414 NullFields []string `json:"-"`
2415 }
2416
2417 func (s *GoogleAnalyticsAdminV1alphaChannelGroup) MarshalJSON() ([]byte, error) {
2418 type NoMethod GoogleAnalyticsAdminV1alphaChannelGroup
2419 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2420 }
2421
2422
2423
2424 type GoogleAnalyticsAdminV1alphaChannelGroupFilter struct {
2425
2426 FieldName string `json:"fieldName,omitempty"`
2427
2428
2429 InListFilter *GoogleAnalyticsAdminV1alphaChannelGroupFilterInListFilter `json:"inListFilter,omitempty"`
2430
2431
2432 StringFilter *GoogleAnalyticsAdminV1alphaChannelGroupFilterStringFilter `json:"stringFilter,omitempty"`
2433
2434
2435
2436
2437
2438 ForceSendFields []string `json:"-"`
2439
2440
2441
2442
2443 NullFields []string `json:"-"`
2444 }
2445
2446 func (s *GoogleAnalyticsAdminV1alphaChannelGroupFilter) MarshalJSON() ([]byte, error) {
2447 type NoMethod GoogleAnalyticsAdminV1alphaChannelGroupFilter
2448 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2449 }
2450
2451
2452
2453 type GoogleAnalyticsAdminV1alphaChannelGroupFilterExpression struct {
2454
2455
2456
2457 AndGroup *GoogleAnalyticsAdminV1alphaChannelGroupFilterExpressionList `json:"andGroup,omitempty"`
2458
2459
2460 Filter *GoogleAnalyticsAdminV1alphaChannelGroupFilter `json:"filter,omitempty"`
2461
2462
2463
2464 NotExpression *GoogleAnalyticsAdminV1alphaChannelGroupFilterExpression `json:"notExpression,omitempty"`
2465
2466
2467 OrGroup *GoogleAnalyticsAdminV1alphaChannelGroupFilterExpressionList `json:"orGroup,omitempty"`
2468
2469
2470
2471
2472
2473 ForceSendFields []string `json:"-"`
2474
2475
2476
2477
2478 NullFields []string `json:"-"`
2479 }
2480
2481 func (s *GoogleAnalyticsAdminV1alphaChannelGroupFilterExpression) MarshalJSON() ([]byte, error) {
2482 type NoMethod GoogleAnalyticsAdminV1alphaChannelGroupFilterExpression
2483 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2484 }
2485
2486
2487
2488 type GoogleAnalyticsAdminV1alphaChannelGroupFilterExpressionList struct {
2489
2490 FilterExpressions []*GoogleAnalyticsAdminV1alphaChannelGroupFilterExpression `json:"filterExpressions,omitempty"`
2491
2492
2493
2494
2495
2496 ForceSendFields []string `json:"-"`
2497
2498
2499
2500
2501 NullFields []string `json:"-"`
2502 }
2503
2504 func (s *GoogleAnalyticsAdminV1alphaChannelGroupFilterExpressionList) MarshalJSON() ([]byte, error) {
2505 type NoMethod GoogleAnalyticsAdminV1alphaChannelGroupFilterExpressionList
2506 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2507 }
2508
2509
2510
2511
2512 type GoogleAnalyticsAdminV1alphaChannelGroupFilterInListFilter struct {
2513
2514
2515 Values []string `json:"values,omitempty"`
2516
2517
2518
2519
2520
2521 ForceSendFields []string `json:"-"`
2522
2523
2524
2525
2526 NullFields []string `json:"-"`
2527 }
2528
2529 func (s *GoogleAnalyticsAdminV1alphaChannelGroupFilterInListFilter) MarshalJSON() ([]byte, error) {
2530 type NoMethod GoogleAnalyticsAdminV1alphaChannelGroupFilterInListFilter
2531 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2532 }
2533
2534
2535
2536 type GoogleAnalyticsAdminV1alphaChannelGroupFilterStringFilter struct {
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547 MatchType string `json:"matchType,omitempty"`
2548
2549 Value string `json:"value,omitempty"`
2550
2551
2552
2553
2554
2555 ForceSendFields []string `json:"-"`
2556
2557
2558
2559
2560 NullFields []string `json:"-"`
2561 }
2562
2563 func (s *GoogleAnalyticsAdminV1alphaChannelGroupFilterStringFilter) MarshalJSON() ([]byte, error) {
2564 type NoMethod GoogleAnalyticsAdminV1alphaChannelGroupFilterStringFilter
2565 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2566 }
2567
2568
2569
2570 type GoogleAnalyticsAdminV1alphaConnectedSiteTag struct {
2571
2572
2573 DisplayName string `json:"displayName,omitempty"`
2574
2575
2576 TagId string `json:"tagId,omitempty"`
2577
2578
2579
2580
2581
2582 ForceSendFields []string `json:"-"`
2583
2584
2585
2586
2587 NullFields []string `json:"-"`
2588 }
2589
2590 func (s *GoogleAnalyticsAdminV1alphaConnectedSiteTag) MarshalJSON() ([]byte, error) {
2591 type NoMethod GoogleAnalyticsAdminV1alphaConnectedSiteTag
2592 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2593 }
2594
2595
2596
2597 type GoogleAnalyticsAdminV1alphaConversionEvent struct {
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607 CountingMethod string `json:"countingMethod,omitempty"`
2608
2609
2610 CreateTime string `json:"createTime,omitempty"`
2611
2612
2613
2614
2615
2616
2617 Custom bool `json:"custom,omitempty"`
2618
2619
2620 DefaultConversionValue *GoogleAnalyticsAdminV1alphaConversionEventDefaultConversionValue `json:"defaultConversionValue,omitempty"`
2621
2622
2623 Deletable bool `json:"deletable,omitempty"`
2624
2625
2626 EventName string `json:"eventName,omitempty"`
2627
2628
2629 Name string `json:"name,omitempty"`
2630
2631
2632 googleapi.ServerResponse `json:"-"`
2633
2634
2635
2636
2637
2638 ForceSendFields []string `json:"-"`
2639
2640
2641
2642
2643 NullFields []string `json:"-"`
2644 }
2645
2646 func (s *GoogleAnalyticsAdminV1alphaConversionEvent) MarshalJSON() ([]byte, error) {
2647 type NoMethod GoogleAnalyticsAdminV1alphaConversionEvent
2648 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2649 }
2650
2651
2652
2653
2654 type GoogleAnalyticsAdminV1alphaConversionEventDefaultConversionValue struct {
2655
2656
2657
2658
2659 CurrencyCode string `json:"currencyCode,omitempty"`
2660
2661
2662 Value float64 `json:"value,omitempty"`
2663
2664
2665
2666
2667
2668 ForceSendFields []string `json:"-"`
2669
2670
2671
2672
2673 NullFields []string `json:"-"`
2674 }
2675
2676 func (s *GoogleAnalyticsAdminV1alphaConversionEventDefaultConversionValue) MarshalJSON() ([]byte, error) {
2677 type NoMethod GoogleAnalyticsAdminV1alphaConversionEventDefaultConversionValue
2678 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2679 }
2680
2681 func (s *GoogleAnalyticsAdminV1alphaConversionEventDefaultConversionValue) UnmarshalJSON(data []byte) error {
2682 type NoMethod GoogleAnalyticsAdminV1alphaConversionEventDefaultConversionValue
2683 var s1 struct {
2684 Value gensupport.JSONFloat64 `json:"value"`
2685 *NoMethod
2686 }
2687 s1.NoMethod = (*NoMethod)(s)
2688 if err := json.Unmarshal(data, &s1); err != nil {
2689 return err
2690 }
2691 s.Value = float64(s1.Value)
2692 return nil
2693 }
2694
2695
2696
2697 type GoogleAnalyticsAdminV1alphaConversionValues struct {
2698
2699
2700
2701
2702
2703
2704
2705
2706 CoarseValue string `json:"coarseValue,omitempty"`
2707
2708
2709 DisplayName string `json:"displayName,omitempty"`
2710
2711
2712
2713
2714 EventMappings []*GoogleAnalyticsAdminV1alphaEventMapping `json:"eventMappings,omitempty"`
2715
2716
2717
2718
2719
2720
2721 FineValue int64 `json:"fineValue,omitempty"`
2722
2723
2724 LockEnabled bool `json:"lockEnabled,omitempty"`
2725
2726
2727
2728
2729
2730 ForceSendFields []string `json:"-"`
2731
2732
2733
2734
2735 NullFields []string `json:"-"`
2736 }
2737
2738 func (s *GoogleAnalyticsAdminV1alphaConversionValues) MarshalJSON() ([]byte, error) {
2739 type NoMethod GoogleAnalyticsAdminV1alphaConversionValues
2740 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2741 }
2742
2743
2744
2745 type GoogleAnalyticsAdminV1alphaCreateAccessBindingRequest struct {
2746
2747 AccessBinding *GoogleAnalyticsAdminV1alphaAccessBinding `json:"accessBinding,omitempty"`
2748
2749 Parent string `json:"parent,omitempty"`
2750
2751
2752
2753
2754
2755 ForceSendFields []string `json:"-"`
2756
2757
2758
2759
2760 NullFields []string `json:"-"`
2761 }
2762
2763 func (s *GoogleAnalyticsAdminV1alphaCreateAccessBindingRequest) MarshalJSON() ([]byte, error) {
2764 type NoMethod GoogleAnalyticsAdminV1alphaCreateAccessBindingRequest
2765 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2766 }
2767
2768
2769
2770 type GoogleAnalyticsAdminV1alphaCreateConnectedSiteTagRequest struct {
2771
2772
2773 ConnectedSiteTag *GoogleAnalyticsAdminV1alphaConnectedSiteTag `json:"connectedSiteTag,omitempty"`
2774
2775
2776
2777 Property string `json:"property,omitempty"`
2778
2779
2780
2781
2782
2783 ForceSendFields []string `json:"-"`
2784
2785
2786
2787
2788 NullFields []string `json:"-"`
2789 }
2790
2791 func (s *GoogleAnalyticsAdminV1alphaCreateConnectedSiteTagRequest) MarshalJSON() ([]byte, error) {
2792 type NoMethod GoogleAnalyticsAdminV1alphaCreateConnectedSiteTagRequest
2793 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2794 }
2795
2796
2797
2798 type GoogleAnalyticsAdminV1alphaCreateConnectedSiteTagResponse struct {
2799
2800 googleapi.ServerResponse `json:"-"`
2801 }
2802
2803
2804
2805 type GoogleAnalyticsAdminV1alphaCreateRollupPropertyRequest struct {
2806
2807 RollupProperty *GoogleAnalyticsAdminV1alphaProperty `json:"rollupProperty,omitempty"`
2808
2809
2810 SourceProperties []string `json:"sourceProperties,omitempty"`
2811
2812
2813
2814
2815
2816 ForceSendFields []string `json:"-"`
2817
2818
2819
2820
2821 NullFields []string `json:"-"`
2822 }
2823
2824 func (s *GoogleAnalyticsAdminV1alphaCreateRollupPropertyRequest) MarshalJSON() ([]byte, error) {
2825 type NoMethod GoogleAnalyticsAdminV1alphaCreateRollupPropertyRequest
2826 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2827 }
2828
2829
2830
2831 type GoogleAnalyticsAdminV1alphaCreateRollupPropertyResponse struct {
2832
2833 RollupProperty *GoogleAnalyticsAdminV1alphaProperty `json:"rollupProperty,omitempty"`
2834
2835 RollupPropertySourceLinks []*GoogleAnalyticsAdminV1alphaRollupPropertySourceLink `json:"rollupPropertySourceLinks,omitempty"`
2836
2837
2838 googleapi.ServerResponse `json:"-"`
2839
2840
2841
2842
2843
2844 ForceSendFields []string `json:"-"`
2845
2846
2847
2848
2849 NullFields []string `json:"-"`
2850 }
2851
2852 func (s *GoogleAnalyticsAdminV1alphaCreateRollupPropertyResponse) MarshalJSON() ([]byte, error) {
2853 type NoMethod GoogleAnalyticsAdminV1alphaCreateRollupPropertyResponse
2854 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2855 }
2856
2857
2858
2859 type GoogleAnalyticsAdminV1alphaCreateSubpropertyRequest struct {
2860
2861
2862 Parent string `json:"parent,omitempty"`
2863
2864 Subproperty *GoogleAnalyticsAdminV1alphaProperty `json:"subproperty,omitempty"`
2865
2866
2867 SubpropertyEventFilter *GoogleAnalyticsAdminV1alphaSubpropertyEventFilter `json:"subpropertyEventFilter,omitempty"`
2868
2869
2870
2871
2872
2873 ForceSendFields []string `json:"-"`
2874
2875
2876
2877
2878 NullFields []string `json:"-"`
2879 }
2880
2881 func (s *GoogleAnalyticsAdminV1alphaCreateSubpropertyRequest) MarshalJSON() ([]byte, error) {
2882 type NoMethod GoogleAnalyticsAdminV1alphaCreateSubpropertyRequest
2883 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2884 }
2885
2886
2887
2888 type GoogleAnalyticsAdminV1alphaCreateSubpropertyResponse struct {
2889
2890 Subproperty *GoogleAnalyticsAdminV1alphaProperty `json:"subproperty,omitempty"`
2891
2892 SubpropertyEventFilter *GoogleAnalyticsAdminV1alphaSubpropertyEventFilter `json:"subpropertyEventFilter,omitempty"`
2893
2894
2895 googleapi.ServerResponse `json:"-"`
2896
2897
2898
2899
2900
2901 ForceSendFields []string `json:"-"`
2902
2903
2904
2905
2906 NullFields []string `json:"-"`
2907 }
2908
2909 func (s *GoogleAnalyticsAdminV1alphaCreateSubpropertyResponse) MarshalJSON() ([]byte, error) {
2910 type NoMethod GoogleAnalyticsAdminV1alphaCreateSubpropertyResponse
2911 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2912 }
2913
2914
2915
2916 type GoogleAnalyticsAdminV1alphaCustomDimension struct {
2917
2918
2919 Description string `json:"description,omitempty"`
2920
2921
2922
2923 DisallowAdsPersonalization bool `json:"disallowAdsPersonalization,omitempty"`
2924
2925
2926
2927
2928
2929 DisplayName string `json:"displayName,omitempty"`
2930
2931
2932 Name string `json:"name,omitempty"`
2933
2934
2935
2936
2937
2938
2939
2940
2941 ParameterName string `json:"parameterName,omitempty"`
2942
2943
2944
2945
2946
2947
2948
2949 Scope string `json:"scope,omitempty"`
2950
2951
2952 googleapi.ServerResponse `json:"-"`
2953
2954
2955
2956
2957
2958 ForceSendFields []string `json:"-"`
2959
2960
2961
2962
2963 NullFields []string `json:"-"`
2964 }
2965
2966 func (s *GoogleAnalyticsAdminV1alphaCustomDimension) MarshalJSON() ([]byte, error) {
2967 type NoMethod GoogleAnalyticsAdminV1alphaCustomDimension
2968 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2969 }
2970
2971
2972 type GoogleAnalyticsAdminV1alphaCustomMetric struct {
2973
2974
2975 Description string `json:"description,omitempty"`
2976
2977
2978
2979
2980
2981 DisplayName string `json:"displayName,omitempty"`
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996 MeasurementUnit string `json:"measurementUnit,omitempty"`
2997
2998
2999 Name string `json:"name,omitempty"`
3000
3001
3002
3003
3004 ParameterName string `json:"parameterName,omitempty"`
3005
3006
3007
3008
3009
3010
3011
3012
3013 RestrictedMetricType []string `json:"restrictedMetricType,omitempty"`
3014
3015
3016
3017
3018
3019 Scope string `json:"scope,omitempty"`
3020
3021
3022 googleapi.ServerResponse `json:"-"`
3023
3024
3025
3026
3027
3028 ForceSendFields []string `json:"-"`
3029
3030
3031
3032
3033 NullFields []string `json:"-"`
3034 }
3035
3036 func (s *GoogleAnalyticsAdminV1alphaCustomMetric) MarshalJSON() ([]byte, error) {
3037 type NoMethod GoogleAnalyticsAdminV1alphaCustomMetric
3038 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3039 }
3040
3041
3042
3043 type GoogleAnalyticsAdminV1alphaDataRedactionSettings struct {
3044
3045
3046 EmailRedactionEnabled bool `json:"emailRedactionEnabled,omitempty"`
3047
3048
3049
3050 Name string `json:"name,omitempty"`
3051
3052
3053
3054
3055 QueryParameterKeys []string `json:"queryParameterKeys,omitempty"`
3056
3057
3058
3059
3060
3061 QueryParameterRedactionEnabled bool `json:"queryParameterRedactionEnabled,omitempty"`
3062
3063
3064 googleapi.ServerResponse `json:"-"`
3065
3066
3067
3068
3069
3070 ForceSendFields []string `json:"-"`
3071
3072
3073
3074
3075 NullFields []string `json:"-"`
3076 }
3077
3078 func (s *GoogleAnalyticsAdminV1alphaDataRedactionSettings) MarshalJSON() ([]byte, error) {
3079 type NoMethod GoogleAnalyticsAdminV1alphaDataRedactionSettings
3080 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3081 }
3082
3083
3084
3085 type GoogleAnalyticsAdminV1alphaDataRetentionSettings struct {
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099 EventDataRetention string `json:"eventDataRetention,omitempty"`
3100
3101
3102 Name string `json:"name,omitempty"`
3103
3104
3105 ResetUserDataOnNewActivity bool `json:"resetUserDataOnNewActivity,omitempty"`
3106
3107
3108 googleapi.ServerResponse `json:"-"`
3109
3110
3111
3112
3113
3114 ForceSendFields []string `json:"-"`
3115
3116
3117
3118
3119 NullFields []string `json:"-"`
3120 }
3121
3122 func (s *GoogleAnalyticsAdminV1alphaDataRetentionSettings) MarshalJSON() ([]byte, error) {
3123 type NoMethod GoogleAnalyticsAdminV1alphaDataRetentionSettings
3124 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3125 }
3126
3127
3128
3129 type GoogleAnalyticsAdminV1alphaDataSharingSettings struct {
3130
3131
3132
3133 Name string `json:"name,omitempty"`
3134
3135
3136 SharingWithGoogleAnySalesEnabled bool `json:"sharingWithGoogleAnySalesEnabled,omitempty"`
3137
3138
3139
3140
3141 SharingWithGoogleAssignedSalesEnabled bool `json:"sharingWithGoogleAssignedSalesEnabled,omitempty"`
3142
3143
3144 SharingWithGoogleProductsEnabled bool `json:"sharingWithGoogleProductsEnabled,omitempty"`
3145
3146
3147 SharingWithGoogleSupportEnabled bool `json:"sharingWithGoogleSupportEnabled,omitempty"`
3148
3149
3150 SharingWithOthersEnabled bool `json:"sharingWithOthersEnabled,omitempty"`
3151
3152
3153 googleapi.ServerResponse `json:"-"`
3154
3155
3156
3157
3158
3159 ForceSendFields []string `json:"-"`
3160
3161
3162
3163
3164 NullFields []string `json:"-"`
3165 }
3166
3167 func (s *GoogleAnalyticsAdminV1alphaDataSharingSettings) MarshalJSON() ([]byte, error) {
3168 type NoMethod GoogleAnalyticsAdminV1alphaDataSharingSettings
3169 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3170 }
3171
3172
3173
3174 type GoogleAnalyticsAdminV1alphaDataStream struct {
3175
3176
3177 AndroidAppStreamData *GoogleAnalyticsAdminV1alphaDataStreamAndroidAppStreamData `json:"androidAppStreamData,omitempty"`
3178
3179 CreateTime string `json:"createTime,omitempty"`
3180
3181
3182
3183 DisplayName string `json:"displayName,omitempty"`
3184
3185
3186 IosAppStreamData *GoogleAnalyticsAdminV1alphaDataStreamIosAppStreamData `json:"iosAppStreamData,omitempty"`
3187
3188
3189
3190 Name string `json:"name,omitempty"`
3191
3192
3193
3194
3195
3196
3197
3198 Type string `json:"type,omitempty"`
3199
3200 UpdateTime string `json:"updateTime,omitempty"`
3201
3202
3203 WebStreamData *GoogleAnalyticsAdminV1alphaDataStreamWebStreamData `json:"webStreamData,omitempty"`
3204
3205
3206 googleapi.ServerResponse `json:"-"`
3207
3208
3209
3210
3211
3212 ForceSendFields []string `json:"-"`
3213
3214
3215
3216
3217 NullFields []string `json:"-"`
3218 }
3219
3220 func (s *GoogleAnalyticsAdminV1alphaDataStream) MarshalJSON() ([]byte, error) {
3221 type NoMethod GoogleAnalyticsAdminV1alphaDataStream
3222 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3223 }
3224
3225
3226
3227 type GoogleAnalyticsAdminV1alphaDataStreamAndroidAppStreamData struct {
3228
3229
3230 FirebaseAppId string `json:"firebaseAppId,omitempty"`
3231
3232
3233 PackageName string `json:"packageName,omitempty"`
3234
3235
3236
3237
3238
3239 ForceSendFields []string `json:"-"`
3240
3241
3242
3243
3244 NullFields []string `json:"-"`
3245 }
3246
3247 func (s *GoogleAnalyticsAdminV1alphaDataStreamAndroidAppStreamData) MarshalJSON() ([]byte, error) {
3248 type NoMethod GoogleAnalyticsAdminV1alphaDataStreamAndroidAppStreamData
3249 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3250 }
3251
3252
3253
3254 type GoogleAnalyticsAdminV1alphaDataStreamIosAppStreamData struct {
3255
3256
3257 BundleId string `json:"bundleId,omitempty"`
3258
3259
3260 FirebaseAppId string `json:"firebaseAppId,omitempty"`
3261
3262
3263
3264
3265
3266 ForceSendFields []string `json:"-"`
3267
3268
3269
3270
3271 NullFields []string `json:"-"`
3272 }
3273
3274 func (s *GoogleAnalyticsAdminV1alphaDataStreamIosAppStreamData) MarshalJSON() ([]byte, error) {
3275 type NoMethod GoogleAnalyticsAdminV1alphaDataStreamIosAppStreamData
3276 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3277 }
3278
3279
3280
3281 type GoogleAnalyticsAdminV1alphaDataStreamWebStreamData struct {
3282
3283
3284 DefaultUri string `json:"defaultUri,omitempty"`
3285
3286
3287 FirebaseAppId string `json:"firebaseAppId,omitempty"`
3288
3289
3290 MeasurementId string `json:"measurementId,omitempty"`
3291
3292
3293
3294
3295
3296 ForceSendFields []string `json:"-"`
3297
3298
3299
3300
3301 NullFields []string `json:"-"`
3302 }
3303
3304 func (s *GoogleAnalyticsAdminV1alphaDataStreamWebStreamData) MarshalJSON() ([]byte, error) {
3305 type NoMethod GoogleAnalyticsAdminV1alphaDataStreamWebStreamData
3306 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3307 }
3308
3309
3310
3311 type GoogleAnalyticsAdminV1alphaDeleteAccessBindingRequest struct {
3312
3313
3314 Name string `json:"name,omitempty"`
3315
3316
3317
3318
3319
3320 ForceSendFields []string `json:"-"`
3321
3322
3323
3324
3325 NullFields []string `json:"-"`
3326 }
3327
3328 func (s *GoogleAnalyticsAdminV1alphaDeleteAccessBindingRequest) MarshalJSON() ([]byte, error) {
3329 type NoMethod GoogleAnalyticsAdminV1alphaDeleteAccessBindingRequest
3330 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3331 }
3332
3333
3334
3335 type GoogleAnalyticsAdminV1alphaDeleteConnectedSiteTagRequest struct {
3336
3337
3338
3339 Property string `json:"property,omitempty"`
3340
3341
3342 TagId string `json:"tagId,omitempty"`
3343
3344
3345
3346
3347
3348 ForceSendFields []string `json:"-"`
3349
3350
3351
3352
3353 NullFields []string `json:"-"`
3354 }
3355
3356 func (s *GoogleAnalyticsAdminV1alphaDeleteConnectedSiteTagRequest) MarshalJSON() ([]byte, error) {
3357 type NoMethod GoogleAnalyticsAdminV1alphaDeleteConnectedSiteTagRequest
3358 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3359 }
3360
3361
3362
3363 type GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink struct {
3364
3365
3366
3367 AdsPersonalizationEnabled bool `json:"adsPersonalizationEnabled,omitempty"`
3368
3369
3370 AdvertiserDisplayName string `json:"advertiserDisplayName,omitempty"`
3371
3372 AdvertiserId string `json:"advertiserId,omitempty"`
3373
3374
3375
3376
3377 CampaignDataSharingEnabled bool `json:"campaignDataSharingEnabled,omitempty"`
3378
3379
3380
3381
3382
3383 CostDataSharingEnabled bool `json:"costDataSharingEnabled,omitempty"`
3384
3385
3386
3387
3388 Name string `json:"name,omitempty"`
3389
3390
3391 googleapi.ServerResponse `json:"-"`
3392
3393
3394
3395
3396
3397 ForceSendFields []string `json:"-"`
3398
3399
3400
3401
3402 NullFields []string `json:"-"`
3403 }
3404
3405 func (s *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink) MarshalJSON() ([]byte, error) {
3406 type NoMethod GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink
3407 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3408 }
3409
3410
3411
3412
3413
3414
3415 type GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal struct {
3416
3417
3418
3419 AdsPersonalizationEnabled bool `json:"adsPersonalizationEnabled,omitempty"`
3420
3421
3422
3423 AdvertiserDisplayName string `json:"advertiserDisplayName,omitempty"`
3424
3425 AdvertiserId string `json:"advertiserId,omitempty"`
3426
3427
3428
3429 CampaignDataSharingEnabled bool `json:"campaignDataSharingEnabled,omitempty"`
3430
3431
3432
3433
3434 CostDataSharingEnabled bool `json:"costDataSharingEnabled,omitempty"`
3435
3436
3437 LinkProposalStatusDetails *GoogleAnalyticsAdminV1alphaLinkProposalStatusDetails `json:"linkProposalStatusDetails,omitempty"`
3438
3439
3440
3441
3442 Name string `json:"name,omitempty"`
3443
3444
3445
3446
3447
3448
3449 ValidationEmail string `json:"validationEmail,omitempty"`
3450
3451
3452 googleapi.ServerResponse `json:"-"`
3453
3454
3455
3456
3457
3458 ForceSendFields []string `json:"-"`
3459
3460
3461
3462
3463 NullFields []string `json:"-"`
3464 }
3465
3466 func (s *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal) MarshalJSON() ([]byte, error) {
3467 type NoMethod GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal
3468 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3469 }
3470
3471
3472
3473
3474 type GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings struct {
3475
3476
3477
3478 FileDownloadsEnabled bool `json:"fileDownloadsEnabled,omitempty"`
3479
3480
3481 FormInteractionsEnabled bool `json:"formInteractionsEnabled,omitempty"`
3482
3483
3484
3485
3486 Name string `json:"name,omitempty"`
3487
3488
3489 OutboundClicksEnabled bool `json:"outboundClicksEnabled,omitempty"`
3490
3491
3492 PageChangesEnabled bool `json:"pageChangesEnabled,omitempty"`
3493
3494
3495 ScrollsEnabled bool `json:"scrollsEnabled,omitempty"`
3496
3497
3498 SearchQueryParameter string `json:"searchQueryParameter,omitempty"`
3499
3500
3501 SiteSearchEnabled bool `json:"siteSearchEnabled,omitempty"`
3502
3503
3504
3505
3506 StreamEnabled bool `json:"streamEnabled,omitempty"`
3507
3508
3509 UriQueryParameter string `json:"uriQueryParameter,omitempty"`
3510
3511
3512 VideoEngagementEnabled bool `json:"videoEngagementEnabled,omitempty"`
3513
3514
3515 googleapi.ServerResponse `json:"-"`
3516
3517
3518
3519
3520
3521 ForceSendFields []string `json:"-"`
3522
3523
3524
3525
3526 NullFields []string `json:"-"`
3527 }
3528
3529 func (s *GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings) MarshalJSON() ([]byte, error) {
3530 type NoMethod GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings
3531 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3532 }
3533
3534
3535
3536
3537
3538
3539
3540
3541 type GoogleAnalyticsAdminV1alphaEventCreateRule struct {
3542
3543
3544
3545 DestinationEvent string `json:"destinationEvent,omitempty"`
3546
3547
3548
3549 EventConditions []*GoogleAnalyticsAdminV1alphaMatchingCondition `json:"eventConditions,omitempty"`
3550
3551
3552
3553 Name string `json:"name,omitempty"`
3554
3555
3556 ParameterMutations []*GoogleAnalyticsAdminV1alphaParameterMutation `json:"parameterMutations,omitempty"`
3557
3558
3559
3560
3561 SourceCopyParameters bool `json:"sourceCopyParameters,omitempty"`
3562
3563
3564 googleapi.ServerResponse `json:"-"`
3565
3566
3567
3568
3569
3570 ForceSendFields []string `json:"-"`
3571
3572
3573
3574
3575 NullFields []string `json:"-"`
3576 }
3577
3578 func (s *GoogleAnalyticsAdminV1alphaEventCreateRule) MarshalJSON() ([]byte, error) {
3579 type NoMethod GoogleAnalyticsAdminV1alphaEventCreateRule
3580 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3581 }
3582
3583
3584
3585 type GoogleAnalyticsAdminV1alphaEventMapping struct {
3586
3587
3588 EventName string `json:"eventName,omitempty"`
3589
3590
3591 MaxEventCount int64 `json:"maxEventCount,omitempty,string"`
3592
3593
3594
3595 MaxEventValue float64 `json:"maxEventValue,omitempty"`
3596
3597
3598
3599
3600 MinEventCount int64 `json:"minEventCount,omitempty,string"`
3601
3602
3603
3604 MinEventValue float64 `json:"minEventValue,omitempty"`
3605
3606
3607
3608
3609
3610 ForceSendFields []string `json:"-"`
3611
3612
3613
3614
3615 NullFields []string `json:"-"`
3616 }
3617
3618 func (s *GoogleAnalyticsAdminV1alphaEventMapping) MarshalJSON() ([]byte, error) {
3619 type NoMethod GoogleAnalyticsAdminV1alphaEventMapping
3620 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3621 }
3622
3623 func (s *GoogleAnalyticsAdminV1alphaEventMapping) UnmarshalJSON(data []byte) error {
3624 type NoMethod GoogleAnalyticsAdminV1alphaEventMapping
3625 var s1 struct {
3626 MaxEventValue gensupport.JSONFloat64 `json:"maxEventValue"`
3627 MinEventValue gensupport.JSONFloat64 `json:"minEventValue"`
3628 *NoMethod
3629 }
3630 s1.NoMethod = (*NoMethod)(s)
3631 if err := json.Unmarshal(data, &s1); err != nil {
3632 return err
3633 }
3634 s.MaxEventValue = float64(s1.MaxEventValue)
3635 s.MinEventValue = float64(s1.MinEventValue)
3636 return nil
3637 }
3638
3639
3640
3641 type GoogleAnalyticsAdminV1alphaExpandedDataSet struct {
3642
3643
3644 DataCollectionStartTime string `json:"dataCollectionStartTime,omitempty"`
3645
3646 Description string `json:"description,omitempty"`
3647
3648
3649
3650
3651 DimensionFilterExpression *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpression `json:"dimensionFilterExpression,omitempty"`
3652
3653
3654
3655
3656 DimensionNames []string `json:"dimensionNames,omitempty"`
3657
3658
3659 DisplayName string `json:"displayName,omitempty"`
3660
3661
3662
3663
3664 MetricNames []string `json:"metricNames,omitempty"`
3665
3666
3667 Name string `json:"name,omitempty"`
3668
3669
3670 googleapi.ServerResponse `json:"-"`
3671
3672
3673
3674
3675
3676 ForceSendFields []string `json:"-"`
3677
3678
3679
3680
3681 NullFields []string `json:"-"`
3682 }
3683
3684 func (s *GoogleAnalyticsAdminV1alphaExpandedDataSet) MarshalJSON() ([]byte, error) {
3685 type NoMethod GoogleAnalyticsAdminV1alphaExpandedDataSet
3686 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3687 }
3688
3689
3690
3691 type GoogleAnalyticsAdminV1alphaExpandedDataSetFilter struct {
3692
3693 FieldName string `json:"fieldName,omitempty"`
3694
3695
3696 InListFilter *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterInListFilter `json:"inListFilter,omitempty"`
3697
3698
3699 StringFilter *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterStringFilter `json:"stringFilter,omitempty"`
3700
3701
3702
3703
3704
3705 ForceSendFields []string `json:"-"`
3706
3707
3708
3709
3710 NullFields []string `json:"-"`
3711 }
3712
3713 func (s *GoogleAnalyticsAdminV1alphaExpandedDataSetFilter) MarshalJSON() ([]byte, error) {
3714 type NoMethod GoogleAnalyticsAdminV1alphaExpandedDataSetFilter
3715 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3716 }
3717
3718
3719
3720 type GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpression struct {
3721
3722
3723
3724
3725 AndGroup *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpressionList `json:"andGroup,omitempty"`
3726
3727
3728 Filter *GoogleAnalyticsAdminV1alphaExpandedDataSetFilter `json:"filter,omitempty"`
3729
3730
3731
3732 NotExpression *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpression `json:"notExpression,omitempty"`
3733
3734
3735
3736
3737
3738 ForceSendFields []string `json:"-"`
3739
3740
3741
3742
3743 NullFields []string `json:"-"`
3744 }
3745
3746 func (s *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpression) MarshalJSON() ([]byte, error) {
3747 type NoMethod GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpression
3748 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3749 }
3750
3751
3752
3753 type GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpressionList struct {
3754
3755 FilterExpressions []*GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpression `json:"filterExpressions,omitempty"`
3756
3757
3758
3759
3760
3761 ForceSendFields []string `json:"-"`
3762
3763
3764
3765
3766 NullFields []string `json:"-"`
3767 }
3768
3769 func (s *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpressionList) MarshalJSON() ([]byte, error) {
3770 type NoMethod GoogleAnalyticsAdminV1alphaExpandedDataSetFilterExpressionList
3771 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3772 }
3773
3774
3775
3776 type GoogleAnalyticsAdminV1alphaExpandedDataSetFilterInListFilter struct {
3777
3778
3779 CaseSensitive bool `json:"caseSensitive,omitempty"`
3780
3781
3782 Values []string `json:"values,omitempty"`
3783
3784
3785
3786
3787
3788 ForceSendFields []string `json:"-"`
3789
3790
3791
3792
3793 NullFields []string `json:"-"`
3794 }
3795
3796 func (s *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterInListFilter) MarshalJSON() ([]byte, error) {
3797 type NoMethod GoogleAnalyticsAdminV1alphaExpandedDataSetFilterInListFilter
3798 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3799 }
3800
3801
3802
3803 type GoogleAnalyticsAdminV1alphaExpandedDataSetFilterStringFilter struct {
3804
3805
3806
3807 CaseSensitive bool `json:"caseSensitive,omitempty"`
3808
3809
3810
3811
3812
3813
3814 MatchType string `json:"matchType,omitempty"`
3815
3816 Value string `json:"value,omitempty"`
3817
3818
3819
3820
3821
3822 ForceSendFields []string `json:"-"`
3823
3824
3825
3826
3827 NullFields []string `json:"-"`
3828 }
3829
3830 func (s *GoogleAnalyticsAdminV1alphaExpandedDataSetFilterStringFilter) MarshalJSON() ([]byte, error) {
3831 type NoMethod GoogleAnalyticsAdminV1alphaExpandedDataSetFilterStringFilter
3832 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3833 }
3834
3835
3836
3837 type GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutRequest struct {
3838
3839
3840
3841
3842 Property string `json:"property,omitempty"`
3843
3844
3845
3846
3847
3848 ForceSendFields []string `json:"-"`
3849
3850
3851
3852
3853 NullFields []string `json:"-"`
3854 }
3855
3856 func (s *GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutRequest) MarshalJSON() ([]byte, error) {
3857 type NoMethod GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutRequest
3858 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3859 }
3860
3861
3862
3863
3864 type GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutResponse struct {
3865
3866 OptOut bool `json:"optOut,omitempty"`
3867
3868
3869 googleapi.ServerResponse `json:"-"`
3870
3871
3872
3873
3874
3875 ForceSendFields []string `json:"-"`
3876
3877
3878
3879
3880 NullFields []string `json:"-"`
3881 }
3882
3883 func (s *GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutResponse) MarshalJSON() ([]byte, error) {
3884 type NoMethod GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutResponse
3885 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3886 }
3887
3888
3889
3890 type GoogleAnalyticsAdminV1alphaFetchConnectedGa4PropertyResponse struct {
3891
3892
3893
3894 Property string `json:"property,omitempty"`
3895
3896
3897 googleapi.ServerResponse `json:"-"`
3898
3899
3900
3901
3902
3903 ForceSendFields []string `json:"-"`
3904
3905
3906
3907
3908 NullFields []string `json:"-"`
3909 }
3910
3911 func (s *GoogleAnalyticsAdminV1alphaFetchConnectedGa4PropertyResponse) MarshalJSON() ([]byte, error) {
3912 type NoMethod GoogleAnalyticsAdminV1alphaFetchConnectedGa4PropertyResponse
3913 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3914 }
3915
3916
3917
3918 type GoogleAnalyticsAdminV1alphaFirebaseLink struct {
3919
3920 CreateTime string `json:"createTime,omitempty"`
3921
3922 Name string `json:"name,omitempty"`
3923
3924
3925
3926
3927
3928 Project string `json:"project,omitempty"`
3929
3930
3931 googleapi.ServerResponse `json:"-"`
3932
3933
3934
3935
3936
3937 ForceSendFields []string `json:"-"`
3938
3939
3940
3941
3942 NullFields []string `json:"-"`
3943 }
3944
3945 func (s *GoogleAnalyticsAdminV1alphaFirebaseLink) MarshalJSON() ([]byte, error) {
3946 type NoMethod GoogleAnalyticsAdminV1alphaFirebaseLink
3947 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3948 }
3949
3950
3951
3952
3953 type GoogleAnalyticsAdminV1alphaGlobalSiteTag struct {
3954
3955
3956
3957 Name string `json:"name,omitempty"`
3958
3959
3960 Snippet string `json:"snippet,omitempty"`
3961
3962
3963 googleapi.ServerResponse `json:"-"`
3964
3965
3966
3967
3968
3969 ForceSendFields []string `json:"-"`
3970
3971
3972
3973
3974 NullFields []string `json:"-"`
3975 }
3976
3977 func (s *GoogleAnalyticsAdminV1alphaGlobalSiteTag) MarshalJSON() ([]byte, error) {
3978 type NoMethod GoogleAnalyticsAdminV1alphaGlobalSiteTag
3979 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3980 }
3981
3982
3983
3984 type GoogleAnalyticsAdminV1alphaGoogleAdsLink struct {
3985
3986
3987
3988
3989
3990 AdsPersonalizationEnabled bool `json:"adsPersonalizationEnabled,omitempty"`
3991
3992
3993 CanManageClients bool `json:"canManageClients,omitempty"`
3994
3995 CreateTime string `json:"createTime,omitempty"`
3996
3997
3998
3999 CreatorEmailAddress string `json:"creatorEmailAddress,omitempty"`
4000
4001 CustomerId string `json:"customerId,omitempty"`
4002
4003
4004
4005 Name string `json:"name,omitempty"`
4006
4007 UpdateTime string `json:"updateTime,omitempty"`
4008
4009
4010 googleapi.ServerResponse `json:"-"`
4011
4012
4013
4014
4015
4016 ForceSendFields []string `json:"-"`
4017
4018
4019
4020
4021 NullFields []string `json:"-"`
4022 }
4023
4024 func (s *GoogleAnalyticsAdminV1alphaGoogleAdsLink) MarshalJSON() ([]byte, error) {
4025 type NoMethod GoogleAnalyticsAdminV1alphaGoogleAdsLink
4026 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4027 }
4028
4029
4030
4031 type GoogleAnalyticsAdminV1alphaGoogleSignalsSettings struct {
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041 Consent string `json:"consent,omitempty"`
4042
4043
4044
4045 Name string `json:"name,omitempty"`
4046
4047
4048
4049
4050
4051
4052
4053
4054 State string `json:"state,omitempty"`
4055
4056
4057 googleapi.ServerResponse `json:"-"`
4058
4059
4060
4061
4062
4063 ForceSendFields []string `json:"-"`
4064
4065
4066
4067
4068 NullFields []string `json:"-"`
4069 }
4070
4071 func (s *GoogleAnalyticsAdminV1alphaGoogleSignalsSettings) MarshalJSON() ([]byte, error) {
4072 type NoMethod GoogleAnalyticsAdminV1alphaGoogleSignalsSettings
4073 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4074 }
4075
4076
4077
4078 type GoogleAnalyticsAdminV1alphaGroupingRule struct {
4079
4080 DisplayName string `json:"displayName,omitempty"`
4081
4082 Expression *GoogleAnalyticsAdminV1alphaChannelGroupFilterExpression `json:"expression,omitempty"`
4083
4084
4085
4086
4087
4088 ForceSendFields []string `json:"-"`
4089
4090
4091
4092
4093 NullFields []string `json:"-"`
4094 }
4095
4096 func (s *GoogleAnalyticsAdminV1alphaGroupingRule) MarshalJSON() ([]byte, error) {
4097 type NoMethod GoogleAnalyticsAdminV1alphaGroupingRule
4098 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4099 }
4100
4101
4102
4103 type GoogleAnalyticsAdminV1alphaKeyEvent struct {
4104
4105
4106
4107
4108
4109
4110
4111
4112 CountingMethod string `json:"countingMethod,omitempty"`
4113
4114
4115 CreateTime string `json:"createTime,omitempty"`
4116
4117
4118
4119
4120
4121
4122 Custom bool `json:"custom,omitempty"`
4123
4124 DefaultValue *GoogleAnalyticsAdminV1alphaKeyEventDefaultValue `json:"defaultValue,omitempty"`
4125
4126 Deletable bool `json:"deletable,omitempty"`
4127
4128
4129 EventName string `json:"eventName,omitempty"`
4130
4131
4132 Name string `json:"name,omitempty"`
4133
4134
4135 googleapi.ServerResponse `json:"-"`
4136
4137
4138
4139
4140
4141 ForceSendFields []string `json:"-"`
4142
4143
4144
4145
4146 NullFields []string `json:"-"`
4147 }
4148
4149 func (s *GoogleAnalyticsAdminV1alphaKeyEvent) MarshalJSON() ([]byte, error) {
4150 type NoMethod GoogleAnalyticsAdminV1alphaKeyEvent
4151 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4152 }
4153
4154
4155
4156 type GoogleAnalyticsAdminV1alphaKeyEventDefaultValue struct {
4157
4158
4159
4160
4161 CurrencyCode string `json:"currencyCode,omitempty"`
4162
4163
4164
4165 NumericValue float64 `json:"numericValue,omitempty"`
4166
4167
4168
4169
4170
4171 ForceSendFields []string `json:"-"`
4172
4173
4174
4175
4176 NullFields []string `json:"-"`
4177 }
4178
4179 func (s *GoogleAnalyticsAdminV1alphaKeyEventDefaultValue) MarshalJSON() ([]byte, error) {
4180 type NoMethod GoogleAnalyticsAdminV1alphaKeyEventDefaultValue
4181 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4182 }
4183
4184 func (s *GoogleAnalyticsAdminV1alphaKeyEventDefaultValue) UnmarshalJSON(data []byte) error {
4185 type NoMethod GoogleAnalyticsAdminV1alphaKeyEventDefaultValue
4186 var s1 struct {
4187 NumericValue gensupport.JSONFloat64 `json:"numericValue"`
4188 *NoMethod
4189 }
4190 s1.NoMethod = (*NoMethod)(s)
4191 if err := json.Unmarshal(data, &s1); err != nil {
4192 return err
4193 }
4194 s.NumericValue = float64(s1.NumericValue)
4195 return nil
4196 }
4197
4198
4199
4200 type GoogleAnalyticsAdminV1alphaLinkProposalStatusDetails struct {
4201
4202
4203
4204
4205
4206
4207
4208
4209 LinkProposalInitiatingProduct string `json:"linkProposalInitiatingProduct,omitempty"`
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229
4230
4231 LinkProposalState string `json:"linkProposalState,omitempty"`
4232
4233
4234 RequestorEmail string `json:"requestorEmail,omitempty"`
4235
4236
4237
4238
4239
4240 ForceSendFields []string `json:"-"`
4241
4242
4243
4244
4245 NullFields []string `json:"-"`
4246 }
4247
4248 func (s *GoogleAnalyticsAdminV1alphaLinkProposalStatusDetails) MarshalJSON() ([]byte, error) {
4249 type NoMethod GoogleAnalyticsAdminV1alphaLinkProposalStatusDetails
4250 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4251 }
4252
4253
4254
4255 type GoogleAnalyticsAdminV1alphaListAccessBindingsResponse struct {
4256
4257
4258 AccessBindings []*GoogleAnalyticsAdminV1alphaAccessBinding `json:"accessBindings,omitempty"`
4259
4260
4261 NextPageToken string `json:"nextPageToken,omitempty"`
4262
4263
4264 googleapi.ServerResponse `json:"-"`
4265
4266
4267
4268
4269
4270 ForceSendFields []string `json:"-"`
4271
4272
4273
4274
4275 NullFields []string `json:"-"`
4276 }
4277
4278 func (s *GoogleAnalyticsAdminV1alphaListAccessBindingsResponse) MarshalJSON() ([]byte, error) {
4279 type NoMethod GoogleAnalyticsAdminV1alphaListAccessBindingsResponse
4280 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4281 }
4282
4283
4284
4285 type GoogleAnalyticsAdminV1alphaListAccountSummariesResponse struct {
4286
4287
4288 AccountSummaries []*GoogleAnalyticsAdminV1alphaAccountSummary `json:"accountSummaries,omitempty"`
4289
4290
4291 NextPageToken string `json:"nextPageToken,omitempty"`
4292
4293
4294 googleapi.ServerResponse `json:"-"`
4295
4296
4297
4298
4299
4300 ForceSendFields []string `json:"-"`
4301
4302
4303
4304
4305 NullFields []string `json:"-"`
4306 }
4307
4308 func (s *GoogleAnalyticsAdminV1alphaListAccountSummariesResponse) MarshalJSON() ([]byte, error) {
4309 type NoMethod GoogleAnalyticsAdminV1alphaListAccountSummariesResponse
4310 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4311 }
4312
4313
4314
4315 type GoogleAnalyticsAdminV1alphaListAccountsResponse struct {
4316
4317 Accounts []*GoogleAnalyticsAdminV1alphaAccount `json:"accounts,omitempty"`
4318
4319
4320 NextPageToken string `json:"nextPageToken,omitempty"`
4321
4322
4323 googleapi.ServerResponse `json:"-"`
4324
4325
4326
4327
4328
4329 ForceSendFields []string `json:"-"`
4330
4331
4332
4333
4334 NullFields []string `json:"-"`
4335 }
4336
4337 func (s *GoogleAnalyticsAdminV1alphaListAccountsResponse) MarshalJSON() ([]byte, error) {
4338 type NoMethod GoogleAnalyticsAdminV1alphaListAccountsResponse
4339 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4340 }
4341
4342
4343
4344 type GoogleAnalyticsAdminV1alphaListAdSenseLinksResponse struct {
4345
4346 AdsenseLinks []*GoogleAnalyticsAdminV1alphaAdSenseLink `json:"adsenseLinks,omitempty"`
4347
4348
4349 NextPageToken string `json:"nextPageToken,omitempty"`
4350
4351
4352 googleapi.ServerResponse `json:"-"`
4353
4354
4355
4356
4357
4358 ForceSendFields []string `json:"-"`
4359
4360
4361
4362
4363 NullFields []string `json:"-"`
4364 }
4365
4366 func (s *GoogleAnalyticsAdminV1alphaListAdSenseLinksResponse) MarshalJSON() ([]byte, error) {
4367 type NoMethod GoogleAnalyticsAdminV1alphaListAdSenseLinksResponse
4368 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4369 }
4370
4371
4372
4373 type GoogleAnalyticsAdminV1alphaListAudiencesResponse struct {
4374
4375 Audiences []*GoogleAnalyticsAdminV1alphaAudience `json:"audiences,omitempty"`
4376
4377
4378 NextPageToken string `json:"nextPageToken,omitempty"`
4379
4380
4381 googleapi.ServerResponse `json:"-"`
4382
4383
4384
4385
4386
4387 ForceSendFields []string `json:"-"`
4388
4389
4390
4391
4392 NullFields []string `json:"-"`
4393 }
4394
4395 func (s *GoogleAnalyticsAdminV1alphaListAudiencesResponse) MarshalJSON() ([]byte, error) {
4396 type NoMethod GoogleAnalyticsAdminV1alphaListAudiencesResponse
4397 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4398 }
4399
4400
4401
4402 type GoogleAnalyticsAdminV1alphaListBigQueryLinksResponse struct {
4403
4404 BigqueryLinks []*GoogleAnalyticsAdminV1alphaBigQueryLink `json:"bigqueryLinks,omitempty"`
4405
4406
4407 NextPageToken string `json:"nextPageToken,omitempty"`
4408
4409
4410 googleapi.ServerResponse `json:"-"`
4411
4412
4413
4414
4415
4416 ForceSendFields []string `json:"-"`
4417
4418
4419
4420
4421 NullFields []string `json:"-"`
4422 }
4423
4424 func (s *GoogleAnalyticsAdminV1alphaListBigQueryLinksResponse) MarshalJSON() ([]byte, error) {
4425 type NoMethod GoogleAnalyticsAdminV1alphaListBigQueryLinksResponse
4426 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4427 }
4428
4429
4430
4431 type GoogleAnalyticsAdminV1alphaListCalculatedMetricsResponse struct {
4432
4433 CalculatedMetrics []*GoogleAnalyticsAdminV1alphaCalculatedMetric `json:"calculatedMetrics,omitempty"`
4434
4435
4436 NextPageToken string `json:"nextPageToken,omitempty"`
4437
4438
4439 googleapi.ServerResponse `json:"-"`
4440
4441
4442
4443
4444
4445 ForceSendFields []string `json:"-"`
4446
4447
4448
4449
4450 NullFields []string `json:"-"`
4451 }
4452
4453 func (s *GoogleAnalyticsAdminV1alphaListCalculatedMetricsResponse) MarshalJSON() ([]byte, error) {
4454 type NoMethod GoogleAnalyticsAdminV1alphaListCalculatedMetricsResponse
4455 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4456 }
4457
4458
4459
4460 type GoogleAnalyticsAdminV1alphaListChannelGroupsResponse struct {
4461
4462
4463 ChannelGroups []*GoogleAnalyticsAdminV1alphaChannelGroup `json:"channelGroups,omitempty"`
4464
4465
4466 NextPageToken string `json:"nextPageToken,omitempty"`
4467
4468
4469 googleapi.ServerResponse `json:"-"`
4470
4471
4472
4473
4474
4475 ForceSendFields []string `json:"-"`
4476
4477
4478
4479
4480 NullFields []string `json:"-"`
4481 }
4482
4483 func (s *GoogleAnalyticsAdminV1alphaListChannelGroupsResponse) MarshalJSON() ([]byte, error) {
4484 type NoMethod GoogleAnalyticsAdminV1alphaListChannelGroupsResponse
4485 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4486 }
4487
4488
4489
4490 type GoogleAnalyticsAdminV1alphaListConnectedSiteTagsRequest struct {
4491
4492
4493
4494 Property string `json:"property,omitempty"`
4495
4496
4497
4498
4499
4500 ForceSendFields []string `json:"-"`
4501
4502
4503
4504
4505 NullFields []string `json:"-"`
4506 }
4507
4508 func (s *GoogleAnalyticsAdminV1alphaListConnectedSiteTagsRequest) MarshalJSON() ([]byte, error) {
4509 type NoMethod GoogleAnalyticsAdminV1alphaListConnectedSiteTagsRequest
4510 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4511 }
4512
4513
4514
4515 type GoogleAnalyticsAdminV1alphaListConnectedSiteTagsResponse struct {
4516
4517
4518 ConnectedSiteTags []*GoogleAnalyticsAdminV1alphaConnectedSiteTag `json:"connectedSiteTags,omitempty"`
4519
4520
4521 googleapi.ServerResponse `json:"-"`
4522
4523
4524
4525
4526
4527 ForceSendFields []string `json:"-"`
4528
4529
4530
4531
4532 NullFields []string `json:"-"`
4533 }
4534
4535 func (s *GoogleAnalyticsAdminV1alphaListConnectedSiteTagsResponse) MarshalJSON() ([]byte, error) {
4536 type NoMethod GoogleAnalyticsAdminV1alphaListConnectedSiteTagsResponse
4537 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4538 }
4539
4540
4541
4542 type GoogleAnalyticsAdminV1alphaListConversionEventsResponse struct {
4543
4544 ConversionEvents []*GoogleAnalyticsAdminV1alphaConversionEvent `json:"conversionEvents,omitempty"`
4545
4546
4547 NextPageToken string `json:"nextPageToken,omitempty"`
4548
4549
4550 googleapi.ServerResponse `json:"-"`
4551
4552
4553
4554
4555
4556 ForceSendFields []string `json:"-"`
4557
4558
4559
4560
4561 NullFields []string `json:"-"`
4562 }
4563
4564 func (s *GoogleAnalyticsAdminV1alphaListConversionEventsResponse) MarshalJSON() ([]byte, error) {
4565 type NoMethod GoogleAnalyticsAdminV1alphaListConversionEventsResponse
4566 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4567 }
4568
4569
4570
4571 type GoogleAnalyticsAdminV1alphaListCustomDimensionsResponse struct {
4572
4573 CustomDimensions []*GoogleAnalyticsAdminV1alphaCustomDimension `json:"customDimensions,omitempty"`
4574
4575
4576 NextPageToken string `json:"nextPageToken,omitempty"`
4577
4578
4579 googleapi.ServerResponse `json:"-"`
4580
4581
4582
4583
4584
4585 ForceSendFields []string `json:"-"`
4586
4587
4588
4589
4590 NullFields []string `json:"-"`
4591 }
4592
4593 func (s *GoogleAnalyticsAdminV1alphaListCustomDimensionsResponse) MarshalJSON() ([]byte, error) {
4594 type NoMethod GoogleAnalyticsAdminV1alphaListCustomDimensionsResponse
4595 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4596 }
4597
4598
4599
4600 type GoogleAnalyticsAdminV1alphaListCustomMetricsResponse struct {
4601
4602 CustomMetrics []*GoogleAnalyticsAdminV1alphaCustomMetric `json:"customMetrics,omitempty"`
4603
4604
4605 NextPageToken string `json:"nextPageToken,omitempty"`
4606
4607
4608 googleapi.ServerResponse `json:"-"`
4609
4610
4611
4612
4613
4614 ForceSendFields []string `json:"-"`
4615
4616
4617
4618
4619 NullFields []string `json:"-"`
4620 }
4621
4622 func (s *GoogleAnalyticsAdminV1alphaListCustomMetricsResponse) MarshalJSON() ([]byte, error) {
4623 type NoMethod GoogleAnalyticsAdminV1alphaListCustomMetricsResponse
4624 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4625 }
4626
4627
4628
4629 type GoogleAnalyticsAdminV1alphaListDataStreamsResponse struct {
4630
4631 DataStreams []*GoogleAnalyticsAdminV1alphaDataStream `json:"dataStreams,omitempty"`
4632
4633
4634 NextPageToken string `json:"nextPageToken,omitempty"`
4635
4636
4637 googleapi.ServerResponse `json:"-"`
4638
4639
4640
4641
4642
4643 ForceSendFields []string `json:"-"`
4644
4645
4646
4647
4648 NullFields []string `json:"-"`
4649 }
4650
4651 func (s *GoogleAnalyticsAdminV1alphaListDataStreamsResponse) MarshalJSON() ([]byte, error) {
4652 type NoMethod GoogleAnalyticsAdminV1alphaListDataStreamsResponse
4653 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4654 }
4655
4656
4657
4658 type GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinkProposalsResponse struct {
4659
4660
4661 DisplayVideo360AdvertiserLinkProposals []*GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal `json:"displayVideo360AdvertiserLinkProposals,omitempty"`
4662
4663
4664 NextPageToken string `json:"nextPageToken,omitempty"`
4665
4666
4667 googleapi.ServerResponse `json:"-"`
4668
4669
4670
4671
4672
4673
4674 ForceSendFields []string `json:"-"`
4675
4676
4677
4678
4679
4680 NullFields []string `json:"-"`
4681 }
4682
4683 func (s *GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinkProposalsResponse) MarshalJSON() ([]byte, error) {
4684 type NoMethod GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinkProposalsResponse
4685 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4686 }
4687
4688
4689
4690 type GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinksResponse struct {
4691
4692 DisplayVideo360AdvertiserLinks []*GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink `json:"displayVideo360AdvertiserLinks,omitempty"`
4693
4694
4695 NextPageToken string `json:"nextPageToken,omitempty"`
4696
4697
4698 googleapi.ServerResponse `json:"-"`
4699
4700
4701
4702
4703
4704
4705 ForceSendFields []string `json:"-"`
4706
4707
4708
4709
4710 NullFields []string `json:"-"`
4711 }
4712
4713 func (s *GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinksResponse) MarshalJSON() ([]byte, error) {
4714 type NoMethod GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinksResponse
4715 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4716 }
4717
4718
4719
4720 type GoogleAnalyticsAdminV1alphaListEventCreateRulesResponse struct {
4721
4722
4723 EventCreateRules []*GoogleAnalyticsAdminV1alphaEventCreateRule `json:"eventCreateRules,omitempty"`
4724
4725
4726 NextPageToken string `json:"nextPageToken,omitempty"`
4727
4728
4729 googleapi.ServerResponse `json:"-"`
4730
4731
4732
4733
4734
4735 ForceSendFields []string `json:"-"`
4736
4737
4738
4739
4740 NullFields []string `json:"-"`
4741 }
4742
4743 func (s *GoogleAnalyticsAdminV1alphaListEventCreateRulesResponse) MarshalJSON() ([]byte, error) {
4744 type NoMethod GoogleAnalyticsAdminV1alphaListEventCreateRulesResponse
4745 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4746 }
4747
4748
4749
4750 type GoogleAnalyticsAdminV1alphaListExpandedDataSetsResponse struct {
4751
4752
4753 ExpandedDataSets []*GoogleAnalyticsAdminV1alphaExpandedDataSet `json:"expandedDataSets,omitempty"`
4754
4755
4756 NextPageToken string `json:"nextPageToken,omitempty"`
4757
4758
4759 googleapi.ServerResponse `json:"-"`
4760
4761
4762
4763
4764
4765 ForceSendFields []string `json:"-"`
4766
4767
4768
4769
4770 NullFields []string `json:"-"`
4771 }
4772
4773 func (s *GoogleAnalyticsAdminV1alphaListExpandedDataSetsResponse) MarshalJSON() ([]byte, error) {
4774 type NoMethod GoogleAnalyticsAdminV1alphaListExpandedDataSetsResponse
4775 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4776 }
4777
4778
4779
4780 type GoogleAnalyticsAdminV1alphaListFirebaseLinksResponse struct {
4781
4782 FirebaseLinks []*GoogleAnalyticsAdminV1alphaFirebaseLink `json:"firebaseLinks,omitempty"`
4783
4784
4785
4786
4787 NextPageToken string `json:"nextPageToken,omitempty"`
4788
4789
4790 googleapi.ServerResponse `json:"-"`
4791
4792
4793
4794
4795
4796 ForceSendFields []string `json:"-"`
4797
4798
4799
4800
4801 NullFields []string `json:"-"`
4802 }
4803
4804 func (s *GoogleAnalyticsAdminV1alphaListFirebaseLinksResponse) MarshalJSON() ([]byte, error) {
4805 type NoMethod GoogleAnalyticsAdminV1alphaListFirebaseLinksResponse
4806 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4807 }
4808
4809
4810
4811 type GoogleAnalyticsAdminV1alphaListGoogleAdsLinksResponse struct {
4812
4813 GoogleAdsLinks []*GoogleAnalyticsAdminV1alphaGoogleAdsLink `json:"googleAdsLinks,omitempty"`
4814
4815
4816 NextPageToken string `json:"nextPageToken,omitempty"`
4817
4818
4819 googleapi.ServerResponse `json:"-"`
4820
4821
4822
4823
4824
4825 ForceSendFields []string `json:"-"`
4826
4827
4828
4829
4830 NullFields []string `json:"-"`
4831 }
4832
4833 func (s *GoogleAnalyticsAdminV1alphaListGoogleAdsLinksResponse) MarshalJSON() ([]byte, error) {
4834 type NoMethod GoogleAnalyticsAdminV1alphaListGoogleAdsLinksResponse
4835 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4836 }
4837
4838
4839
4840 type GoogleAnalyticsAdminV1alphaListKeyEventsResponse struct {
4841
4842 KeyEvents []*GoogleAnalyticsAdminV1alphaKeyEvent `json:"keyEvents,omitempty"`
4843
4844
4845 NextPageToken string `json:"nextPageToken,omitempty"`
4846
4847
4848 googleapi.ServerResponse `json:"-"`
4849
4850
4851
4852
4853
4854 ForceSendFields []string `json:"-"`
4855
4856
4857
4858
4859 NullFields []string `json:"-"`
4860 }
4861
4862 func (s *GoogleAnalyticsAdminV1alphaListKeyEventsResponse) MarshalJSON() ([]byte, error) {
4863 type NoMethod GoogleAnalyticsAdminV1alphaListKeyEventsResponse
4864 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4865 }
4866
4867
4868
4869 type GoogleAnalyticsAdminV1alphaListMeasurementProtocolSecretsResponse struct {
4870
4871
4872 MeasurementProtocolSecrets []*GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret `json:"measurementProtocolSecrets,omitempty"`
4873
4874
4875 NextPageToken string `json:"nextPageToken,omitempty"`
4876
4877
4878 googleapi.ServerResponse `json:"-"`
4879
4880
4881
4882
4883
4884 ForceSendFields []string `json:"-"`
4885
4886
4887
4888
4889 NullFields []string `json:"-"`
4890 }
4891
4892 func (s *GoogleAnalyticsAdminV1alphaListMeasurementProtocolSecretsResponse) MarshalJSON() ([]byte, error) {
4893 type NoMethod GoogleAnalyticsAdminV1alphaListMeasurementProtocolSecretsResponse
4894 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4895 }
4896
4897
4898
4899 type GoogleAnalyticsAdminV1alphaListPropertiesResponse struct {
4900
4901
4902 NextPageToken string `json:"nextPageToken,omitempty"`
4903
4904
4905 Properties []*GoogleAnalyticsAdminV1alphaProperty `json:"properties,omitempty"`
4906
4907
4908 googleapi.ServerResponse `json:"-"`
4909
4910
4911
4912
4913
4914 ForceSendFields []string `json:"-"`
4915
4916
4917
4918
4919 NullFields []string `json:"-"`
4920 }
4921
4922 func (s *GoogleAnalyticsAdminV1alphaListPropertiesResponse) MarshalJSON() ([]byte, error) {
4923 type NoMethod GoogleAnalyticsAdminV1alphaListPropertiesResponse
4924 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4925 }
4926
4927
4928
4929 type GoogleAnalyticsAdminV1alphaListRollupPropertySourceLinksResponse struct {
4930
4931
4932 NextPageToken string `json:"nextPageToken,omitempty"`
4933
4934 RollupPropertySourceLinks []*GoogleAnalyticsAdminV1alphaRollupPropertySourceLink `json:"rollupPropertySourceLinks,omitempty"`
4935
4936
4937 googleapi.ServerResponse `json:"-"`
4938
4939
4940
4941
4942
4943 ForceSendFields []string `json:"-"`
4944
4945
4946
4947
4948 NullFields []string `json:"-"`
4949 }
4950
4951 func (s *GoogleAnalyticsAdminV1alphaListRollupPropertySourceLinksResponse) MarshalJSON() ([]byte, error) {
4952 type NoMethod GoogleAnalyticsAdminV1alphaListRollupPropertySourceLinksResponse
4953 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4954 }
4955
4956
4957
4958 type GoogleAnalyticsAdminV1alphaListSKAdNetworkConversionValueSchemasResponse struct {
4959
4960
4961
4962
4963
4964 NextPageToken string `json:"nextPageToken,omitempty"`
4965
4966
4967 SkadnetworkConversionValueSchemas []*GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema `json:"skadnetworkConversionValueSchemas,omitempty"`
4968
4969
4970 googleapi.ServerResponse `json:"-"`
4971
4972
4973
4974
4975
4976 ForceSendFields []string `json:"-"`
4977
4978
4979
4980
4981 NullFields []string `json:"-"`
4982 }
4983
4984 func (s *GoogleAnalyticsAdminV1alphaListSKAdNetworkConversionValueSchemasResponse) MarshalJSON() ([]byte, error) {
4985 type NoMethod GoogleAnalyticsAdminV1alphaListSKAdNetworkConversionValueSchemasResponse
4986 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4987 }
4988
4989
4990
4991 type GoogleAnalyticsAdminV1alphaListSearchAds360LinksResponse struct {
4992
4993
4994 NextPageToken string `json:"nextPageToken,omitempty"`
4995
4996 SearchAds360Links []*GoogleAnalyticsAdminV1alphaSearchAds360Link `json:"searchAds360Links,omitempty"`
4997
4998
4999 googleapi.ServerResponse `json:"-"`
5000
5001
5002
5003
5004
5005 ForceSendFields []string `json:"-"`
5006
5007
5008
5009
5010 NullFields []string `json:"-"`
5011 }
5012
5013 func (s *GoogleAnalyticsAdminV1alphaListSearchAds360LinksResponse) MarshalJSON() ([]byte, error) {
5014 type NoMethod GoogleAnalyticsAdminV1alphaListSearchAds360LinksResponse
5015 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5016 }
5017
5018
5019
5020 type GoogleAnalyticsAdminV1alphaListSubpropertyEventFiltersResponse struct {
5021
5022
5023 NextPageToken string `json:"nextPageToken,omitempty"`
5024
5025 SubpropertyEventFilters []*GoogleAnalyticsAdminV1alphaSubpropertyEventFilter `json:"subpropertyEventFilters,omitempty"`
5026
5027
5028 googleapi.ServerResponse `json:"-"`
5029
5030
5031
5032
5033
5034 ForceSendFields []string `json:"-"`
5035
5036
5037
5038
5039 NullFields []string `json:"-"`
5040 }
5041
5042 func (s *GoogleAnalyticsAdminV1alphaListSubpropertyEventFiltersResponse) MarshalJSON() ([]byte, error) {
5043 type NoMethod GoogleAnalyticsAdminV1alphaListSubpropertyEventFiltersResponse
5044 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5045 }
5046
5047
5048
5049 type GoogleAnalyticsAdminV1alphaMatchingCondition struct {
5050
5051
5052
5053
5054
5055
5056
5057
5058
5059
5060
5061
5062
5063
5064
5065
5066
5067
5068
5069 ComparisonType string `json:"comparisonType,omitempty"`
5070
5071
5072
5073
5074 Field string `json:"field,omitempty"`
5075
5076
5077
5078 Negated bool `json:"negated,omitempty"`
5079
5080
5081
5082 Value string `json:"value,omitempty"`
5083
5084
5085
5086
5087
5088 ForceSendFields []string `json:"-"`
5089
5090
5091
5092
5093 NullFields []string `json:"-"`
5094 }
5095
5096 func (s *GoogleAnalyticsAdminV1alphaMatchingCondition) MarshalJSON() ([]byte, error) {
5097 type NoMethod GoogleAnalyticsAdminV1alphaMatchingCondition
5098 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5099 }
5100
5101
5102
5103 type GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret struct {
5104
5105 DisplayName string `json:"displayName,omitempty"`
5106
5107
5108
5109
5110 Name string `json:"name,omitempty"`
5111
5112
5113
5114 SecretValue string `json:"secretValue,omitempty"`
5115
5116
5117 googleapi.ServerResponse `json:"-"`
5118
5119
5120
5121
5122
5123 ForceSendFields []string `json:"-"`
5124
5125
5126
5127
5128 NullFields []string `json:"-"`
5129 }
5130
5131 func (s *GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret) MarshalJSON() ([]byte, error) {
5132 type NoMethod GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret
5133 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5134 }
5135
5136
5137 type GoogleAnalyticsAdminV1alphaNumericValue struct {
5138
5139 DoubleValue float64 `json:"doubleValue,omitempty"`
5140
5141 Int64Value int64 `json:"int64Value,omitempty,string"`
5142
5143
5144
5145
5146
5147 ForceSendFields []string `json:"-"`
5148
5149
5150
5151
5152 NullFields []string `json:"-"`
5153 }
5154
5155 func (s *GoogleAnalyticsAdminV1alphaNumericValue) MarshalJSON() ([]byte, error) {
5156 type NoMethod GoogleAnalyticsAdminV1alphaNumericValue
5157 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5158 }
5159
5160 func (s *GoogleAnalyticsAdminV1alphaNumericValue) UnmarshalJSON(data []byte) error {
5161 type NoMethod GoogleAnalyticsAdminV1alphaNumericValue
5162 var s1 struct {
5163 DoubleValue gensupport.JSONFloat64 `json:"doubleValue"`
5164 *NoMethod
5165 }
5166 s1.NoMethod = (*NoMethod)(s)
5167 if err := json.Unmarshal(data, &s1); err != nil {
5168 return err
5169 }
5170 s.DoubleValue = float64(s1.DoubleValue)
5171 return nil
5172 }
5173
5174
5175
5176 type GoogleAnalyticsAdminV1alphaParameterMutation struct {
5177
5178
5179
5180
5181
5182 Parameter string `json:"parameter,omitempty"`
5183
5184
5185
5186
5187
5188 ParameterValue string `json:"parameterValue,omitempty"`
5189
5190
5191
5192
5193
5194 ForceSendFields []string `json:"-"`
5195
5196
5197
5198
5199 NullFields []string `json:"-"`
5200 }
5201
5202 func (s *GoogleAnalyticsAdminV1alphaParameterMutation) MarshalJSON() ([]byte, error) {
5203 type NoMethod GoogleAnalyticsAdminV1alphaParameterMutation
5204 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5205 }
5206
5207
5208
5209 type GoogleAnalyticsAdminV1alphaPostbackWindow struct {
5210
5211
5212
5213
5214
5215 ConversionValues []*GoogleAnalyticsAdminV1alphaConversionValues `json:"conversionValues,omitempty"`
5216
5217
5218
5219
5220
5221
5222 PostbackWindowSettingsEnabled bool `json:"postbackWindowSettingsEnabled,omitempty"`
5223
5224
5225
5226
5227
5228 ForceSendFields []string `json:"-"`
5229
5230
5231
5232
5233 NullFields []string `json:"-"`
5234 }
5235
5236 func (s *GoogleAnalyticsAdminV1alphaPostbackWindow) MarshalJSON() ([]byte, error) {
5237 type NoMethod GoogleAnalyticsAdminV1alphaPostbackWindow
5238 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5239 }
5240
5241
5242
5243 type GoogleAnalyticsAdminV1alphaProperty struct {
5244
5245
5246 Account string `json:"account,omitempty"`
5247
5248 CreateTime string `json:"createTime,omitempty"`
5249
5250
5251 CurrencyCode string `json:"currencyCode,omitempty"`
5252
5253
5254 DeleteTime string `json:"deleteTime,omitempty"`
5255
5256
5257 DisplayName string `json:"displayName,omitempty"`
5258
5259
5260
5261 ExpireTime string `json:"expireTime,omitempty"`
5262
5263
5264
5265
5266
5267
5268
5269
5270
5271
5272
5273
5274
5275
5276
5277
5278
5279
5280
5281
5282
5283
5284
5285
5286
5287
5288
5289
5290
5291
5292
5293 IndustryCategory string `json:"industryCategory,omitempty"`
5294
5295
5296 Name string `json:"name,omitempty"`
5297
5298
5299
5300
5301 Parent string `json:"parent,omitempty"`
5302
5303
5304
5305
5306
5307
5308
5309
5310
5311 PropertyType string `json:"propertyType,omitempty"`
5312
5313
5314
5315
5316
5317
5318
5319 ServiceLevel string `json:"serviceLevel,omitempty"`
5320
5321
5322
5323
5324
5325 TimeZone string `json:"timeZone,omitempty"`
5326
5327 UpdateTime string `json:"updateTime,omitempty"`
5328
5329
5330 googleapi.ServerResponse `json:"-"`
5331
5332
5333
5334
5335
5336 ForceSendFields []string `json:"-"`
5337
5338
5339
5340
5341 NullFields []string `json:"-"`
5342 }
5343
5344 func (s *GoogleAnalyticsAdminV1alphaProperty) MarshalJSON() ([]byte, error) {
5345 type NoMethod GoogleAnalyticsAdminV1alphaProperty
5346 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5347 }
5348
5349
5350
5351 type GoogleAnalyticsAdminV1alphaPropertySummary struct {
5352
5353
5354 DisplayName string `json:"displayName,omitempty"`
5355
5356
5357
5358
5359 Parent string `json:"parent,omitempty"`
5360
5361
5362 Property string `json:"property,omitempty"`
5363
5364
5365
5366
5367
5368
5369
5370 PropertyType string `json:"propertyType,omitempty"`
5371
5372
5373
5374
5375
5376 ForceSendFields []string `json:"-"`
5377
5378
5379
5380
5381 NullFields []string `json:"-"`
5382 }
5383
5384 func (s *GoogleAnalyticsAdminV1alphaPropertySummary) MarshalJSON() ([]byte, error) {
5385 type NoMethod GoogleAnalyticsAdminV1alphaPropertySummary
5386 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5387 }
5388
5389
5390
5391 type GoogleAnalyticsAdminV1alphaProvisionAccountTicketRequest struct {
5392
5393 Account *GoogleAnalyticsAdminV1alphaAccount `json:"account,omitempty"`
5394
5395
5396 RedirectUri string `json:"redirectUri,omitempty"`
5397
5398
5399
5400
5401
5402 ForceSendFields []string `json:"-"`
5403
5404
5405
5406
5407 NullFields []string `json:"-"`
5408 }
5409
5410 func (s *GoogleAnalyticsAdminV1alphaProvisionAccountTicketRequest) MarshalJSON() ([]byte, error) {
5411 type NoMethod GoogleAnalyticsAdminV1alphaProvisionAccountTicketRequest
5412 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5413 }
5414
5415
5416
5417 type GoogleAnalyticsAdminV1alphaProvisionAccountTicketResponse struct {
5418
5419 AccountTicketId string `json:"accountTicketId,omitempty"`
5420
5421
5422 googleapi.ServerResponse `json:"-"`
5423
5424
5425
5426
5427
5428 ForceSendFields []string `json:"-"`
5429
5430
5431
5432
5433 NullFields []string `json:"-"`
5434 }
5435
5436 func (s *GoogleAnalyticsAdminV1alphaProvisionAccountTicketResponse) MarshalJSON() ([]byte, error) {
5437 type NoMethod GoogleAnalyticsAdminV1alphaProvisionAccountTicketResponse
5438 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5439 }
5440
5441
5442
5443 type GoogleAnalyticsAdminV1alphaRollupPropertySourceLink struct {
5444
5445
5446
5447 Name string `json:"name,omitempty"`
5448
5449
5450 SourceProperty string `json:"sourceProperty,omitempty"`
5451
5452
5453 googleapi.ServerResponse `json:"-"`
5454
5455
5456
5457
5458
5459 ForceSendFields []string `json:"-"`
5460
5461
5462
5463
5464 NullFields []string `json:"-"`
5465 }
5466
5467 func (s *GoogleAnalyticsAdminV1alphaRollupPropertySourceLink) MarshalJSON() ([]byte, error) {
5468 type NoMethod GoogleAnalyticsAdminV1alphaRollupPropertySourceLink
5469 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5470 }
5471
5472
5473
5474 type GoogleAnalyticsAdminV1alphaRunAccessReportRequest struct {
5475
5476
5477
5478
5479
5480 DateRanges []*GoogleAnalyticsAdminV1alphaAccessDateRange `json:"dateRanges,omitempty"`
5481
5482
5483
5484
5485
5486
5487 DimensionFilter *GoogleAnalyticsAdminV1alphaAccessFilterExpression `json:"dimensionFilter,omitempty"`
5488
5489
5490 Dimensions []*GoogleAnalyticsAdminV1alphaAccessDimension `json:"dimensions,omitempty"`
5491
5492
5493
5494
5495 ExpandGroups bool `json:"expandGroups,omitempty"`
5496
5497
5498
5499
5500
5501 IncludeAllUsers bool `json:"includeAllUsers,omitempty"`
5502
5503
5504
5505
5506
5507
5508
5509
5510
5511 Limit int64 `json:"limit,omitempty,string"`
5512
5513
5514
5515
5516 MetricFilter *GoogleAnalyticsAdminV1alphaAccessFilterExpression `json:"metricFilter,omitempty"`
5517
5518
5519 Metrics []*GoogleAnalyticsAdminV1alphaAccessMetric `json:"metrics,omitempty"`
5520
5521
5522
5523
5524
5525 Offset int64 `json:"offset,omitempty,string"`
5526
5527 OrderBys []*GoogleAnalyticsAdminV1alphaAccessOrderBy `json:"orderBys,omitempty"`
5528
5529
5530
5531 ReturnEntityQuota bool `json:"returnEntityQuota,omitempty"`
5532
5533
5534
5535
5536
5537 TimeZone string `json:"timeZone,omitempty"`
5538
5539
5540
5541
5542
5543 ForceSendFields []string `json:"-"`
5544
5545
5546
5547
5548 NullFields []string `json:"-"`
5549 }
5550
5551 func (s *GoogleAnalyticsAdminV1alphaRunAccessReportRequest) MarshalJSON() ([]byte, error) {
5552 type NoMethod GoogleAnalyticsAdminV1alphaRunAccessReportRequest
5553 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5554 }
5555
5556
5557
5558 type GoogleAnalyticsAdminV1alphaRunAccessReportResponse struct {
5559
5560
5561
5562 DimensionHeaders []*GoogleAnalyticsAdminV1alphaAccessDimensionHeader `json:"dimensionHeaders,omitempty"`
5563
5564
5565
5566 MetricHeaders []*GoogleAnalyticsAdminV1alphaAccessMetricHeader `json:"metricHeaders,omitempty"`
5567
5568
5569 Quota *GoogleAnalyticsAdminV1alphaAccessQuota `json:"quota,omitempty"`
5570
5571
5572
5573
5574
5575
5576
5577 RowCount int64 `json:"rowCount,omitempty"`
5578
5579 Rows []*GoogleAnalyticsAdminV1alphaAccessRow `json:"rows,omitempty"`
5580
5581
5582 googleapi.ServerResponse `json:"-"`
5583
5584
5585
5586
5587
5588 ForceSendFields []string `json:"-"`
5589
5590
5591
5592
5593 NullFields []string `json:"-"`
5594 }
5595
5596 func (s *GoogleAnalyticsAdminV1alphaRunAccessReportResponse) MarshalJSON() ([]byte, error) {
5597 type NoMethod GoogleAnalyticsAdminV1alphaRunAccessReportResponse
5598 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5599 }
5600
5601
5602
5603 type GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema struct {
5604
5605
5606
5607
5608
5609 ApplyConversionValues bool `json:"applyConversionValues,omitempty"`
5610
5611
5612
5613
5614
5615 Name string `json:"name,omitempty"`
5616
5617
5618
5619
5620
5621 PostbackWindowOne *GoogleAnalyticsAdminV1alphaPostbackWindow `json:"postbackWindowOne,omitempty"`
5622
5623
5624
5625
5626
5627
5628 PostbackWindowThree *GoogleAnalyticsAdminV1alphaPostbackWindow `json:"postbackWindowThree,omitempty"`
5629
5630
5631
5632
5633
5634 PostbackWindowTwo *GoogleAnalyticsAdminV1alphaPostbackWindow `json:"postbackWindowTwo,omitempty"`
5635
5636
5637 googleapi.ServerResponse `json:"-"`
5638
5639
5640
5641
5642
5643 ForceSendFields []string `json:"-"`
5644
5645
5646
5647
5648 NullFields []string `json:"-"`
5649 }
5650
5651 func (s *GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema) MarshalJSON() ([]byte, error) {
5652 type NoMethod GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema
5653 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5654 }
5655
5656
5657
5658 type GoogleAnalyticsAdminV1alphaSearchAds360Link struct {
5659
5660
5661
5662 AdsPersonalizationEnabled bool `json:"adsPersonalizationEnabled,omitempty"`
5663
5664
5665 AdvertiserDisplayName string `json:"advertiserDisplayName,omitempty"`
5666
5667
5668 AdvertiserId string `json:"advertiserId,omitempty"`
5669
5670
5671
5672
5673 CampaignDataSharingEnabled bool `json:"campaignDataSharingEnabled,omitempty"`
5674
5675
5676
5677
5678
5679 CostDataSharingEnabled bool `json:"costDataSharingEnabled,omitempty"`
5680
5681
5682
5683 Name string `json:"name,omitempty"`
5684
5685
5686 SiteStatsSharingEnabled bool `json:"siteStatsSharingEnabled,omitempty"`
5687
5688
5689 googleapi.ServerResponse `json:"-"`
5690
5691
5692
5693
5694
5695 ForceSendFields []string `json:"-"`
5696
5697
5698
5699
5700 NullFields []string `json:"-"`
5701 }
5702
5703 func (s *GoogleAnalyticsAdminV1alphaSearchAds360Link) MarshalJSON() ([]byte, error) {
5704 type NoMethod GoogleAnalyticsAdminV1alphaSearchAds360Link
5705 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5706 }
5707
5708
5709
5710 type GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsRequest struct {
5711
5712
5713
5714
5715
5716
5717
5718
5719 Action []string `json:"action,omitempty"`
5720
5721
5722 ActorEmail []string `json:"actorEmail,omitempty"`
5723
5724
5725 EarliestChangeTime string `json:"earliestChangeTime,omitempty"`
5726
5727
5728 LatestChangeTime string `json:"latestChangeTime,omitempty"`
5729
5730
5731
5732
5733 PageSize int64 `json:"pageSize,omitempty"`
5734
5735
5736
5737
5738
5739 PageToken string `json:"pageToken,omitempty"`
5740
5741
5742
5743 Property string `json:"property,omitempty"`
5744
5745
5746
5747
5748
5749
5750
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761
5762
5763
5764
5765
5766
5767
5768
5769
5770
5771
5772
5773
5774
5775
5776
5777 ResourceType []string `json:"resourceType,omitempty"`
5778
5779
5780
5781
5782
5783 ForceSendFields []string `json:"-"`
5784
5785
5786
5787
5788 NullFields []string `json:"-"`
5789 }
5790
5791 func (s *GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsRequest) MarshalJSON() ([]byte, error) {
5792 type NoMethod GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsRequest
5793 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5794 }
5795
5796
5797
5798 type GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsResponse struct {
5799
5800 ChangeHistoryEvents []*GoogleAnalyticsAdminV1alphaChangeHistoryEvent `json:"changeHistoryEvents,omitempty"`
5801
5802
5803 NextPageToken string `json:"nextPageToken,omitempty"`
5804
5805
5806 googleapi.ServerResponse `json:"-"`
5807
5808
5809
5810
5811
5812 ForceSendFields []string `json:"-"`
5813
5814
5815
5816
5817 NullFields []string `json:"-"`
5818 }
5819
5820 func (s *GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsResponse) MarshalJSON() ([]byte, error) {
5821 type NoMethod GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsResponse
5822 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5823 }
5824
5825
5826
5827 type GoogleAnalyticsAdminV1alphaSetAutomatedGa4ConfigurationOptOutRequest struct {
5828
5829 OptOut bool `json:"optOut,omitempty"`
5830
5831
5832
5833
5834 Property string `json:"property,omitempty"`
5835
5836
5837
5838
5839
5840 ForceSendFields []string `json:"-"`
5841
5842
5843
5844
5845 NullFields []string `json:"-"`
5846 }
5847
5848 func (s *GoogleAnalyticsAdminV1alphaSetAutomatedGa4ConfigurationOptOutRequest) MarshalJSON() ([]byte, error) {
5849 type NoMethod GoogleAnalyticsAdminV1alphaSetAutomatedGa4ConfigurationOptOutRequest
5850 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5851 }
5852
5853
5854
5855
5856 type GoogleAnalyticsAdminV1alphaSetAutomatedGa4ConfigurationOptOutResponse struct {
5857
5858 googleapi.ServerResponse `json:"-"`
5859 }
5860
5861
5862
5863 type GoogleAnalyticsAdminV1alphaSubpropertyEventFilter struct {
5864
5865
5866 ApplyToProperty string `json:"applyToProperty,omitempty"`
5867
5868
5869
5870 FilterClauses []*GoogleAnalyticsAdminV1alphaSubpropertyEventFilterClause `json:"filterClauses,omitempty"`
5871
5872
5873
5874 Name string `json:"name,omitempty"`
5875
5876
5877 googleapi.ServerResponse `json:"-"`
5878
5879
5880
5881
5882
5883 ForceSendFields []string `json:"-"`
5884
5885
5886
5887
5888 NullFields []string `json:"-"`
5889 }
5890
5891 func (s *GoogleAnalyticsAdminV1alphaSubpropertyEventFilter) MarshalJSON() ([]byte, error) {
5892 type NoMethod GoogleAnalyticsAdminV1alphaSubpropertyEventFilter
5893 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5894 }
5895
5896
5897
5898
5899
5900 type GoogleAnalyticsAdminV1alphaSubpropertyEventFilterClause struct {
5901
5902
5903
5904
5905
5906
5907
5908
5909
5910 FilterClauseType string `json:"filterClauseType,omitempty"`
5911
5912
5913 FilterExpression *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpression `json:"filterExpression,omitempty"`
5914
5915
5916
5917
5918
5919 ForceSendFields []string `json:"-"`
5920
5921
5922
5923
5924 NullFields []string `json:"-"`
5925 }
5926
5927 func (s *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterClause) MarshalJSON() ([]byte, error) {
5928 type NoMethod GoogleAnalyticsAdminV1alphaSubpropertyEventFilterClause
5929 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5930 }
5931
5932
5933
5934 type GoogleAnalyticsAdminV1alphaSubpropertyEventFilterCondition struct {
5935
5936 FieldName string `json:"fieldName,omitempty"`
5937
5938 NullFilter bool `json:"nullFilter,omitempty"`
5939
5940
5941 StringFilter *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterConditionStringFilter `json:"stringFilter,omitempty"`
5942
5943
5944
5945
5946
5947 ForceSendFields []string `json:"-"`
5948
5949
5950
5951
5952 NullFields []string `json:"-"`
5953 }
5954
5955 func (s *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterCondition) MarshalJSON() ([]byte, error) {
5956 type NoMethod GoogleAnalyticsAdminV1alphaSubpropertyEventFilterCondition
5957 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5958 }
5959
5960
5961
5962 type GoogleAnalyticsAdminV1alphaSubpropertyEventFilterConditionStringFilter struct {
5963
5964
5965 CaseSensitive bool `json:"caseSensitive,omitempty"`
5966
5967
5968
5969
5970
5971
5972
5973
5974
5975
5976
5977 MatchType string `json:"matchType,omitempty"`
5978
5979 Value string `json:"value,omitempty"`
5980
5981
5982
5983
5984
5985 ForceSendFields []string `json:"-"`
5986
5987
5988
5989
5990 NullFields []string `json:"-"`
5991 }
5992
5993 func (s *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterConditionStringFilter) MarshalJSON() ([]byte, error) {
5994 type NoMethod GoogleAnalyticsAdminV1alphaSubpropertyEventFilterConditionStringFilter
5995 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5996 }
5997
5998
5999
6000 type GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpression struct {
6001
6002
6003 FilterCondition *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterCondition `json:"filterCondition,omitempty"`
6004
6005
6006
6007 NotExpression *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpression `json:"notExpression,omitempty"`
6008
6009
6010 OrGroup *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpressionList `json:"orGroup,omitempty"`
6011
6012
6013
6014
6015
6016 ForceSendFields []string `json:"-"`
6017
6018
6019
6020
6021 NullFields []string `json:"-"`
6022 }
6023
6024 func (s *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpression) MarshalJSON() ([]byte, error) {
6025 type NoMethod GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpression
6026 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6027 }
6028
6029
6030
6031 type GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpressionList struct {
6032
6033
6034 FilterExpressions []*GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpression `json:"filterExpressions,omitempty"`
6035
6036
6037
6038
6039
6040 ForceSendFields []string `json:"-"`
6041
6042
6043
6044
6045 NullFields []string `json:"-"`
6046 }
6047
6048 func (s *GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpressionList) MarshalJSON() ([]byte, error) {
6049 type NoMethod GoogleAnalyticsAdminV1alphaSubpropertyEventFilterExpressionList
6050 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6051 }
6052
6053
6054
6055 type GoogleAnalyticsAdminV1alphaUpdateAccessBindingRequest struct {
6056
6057 AccessBinding *GoogleAnalyticsAdminV1alphaAccessBinding `json:"accessBinding,omitempty"`
6058
6059
6060
6061
6062
6063 ForceSendFields []string `json:"-"`
6064
6065
6066
6067
6068 NullFields []string `json:"-"`
6069 }
6070
6071 func (s *GoogleAnalyticsAdminV1alphaUpdateAccessBindingRequest) MarshalJSON() ([]byte, error) {
6072 type NoMethod GoogleAnalyticsAdminV1alphaUpdateAccessBindingRequest
6073 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6074 }
6075
6076
6077
6078
6079
6080
6081 type GoogleProtobufEmpty struct {
6082
6083 googleapi.ServerResponse `json:"-"`
6084 }
6085
6086 type AccountSummariesListCall struct {
6087 s *Service
6088 urlParams_ gensupport.URLParams
6089 ifNoneMatch_ string
6090 ctx_ context.Context
6091 header_ http.Header
6092 }
6093
6094
6095 func (r *AccountSummariesService) List() *AccountSummariesListCall {
6096 c := &AccountSummariesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6097 return c
6098 }
6099
6100
6101
6102
6103
6104
6105 func (c *AccountSummariesListCall) PageSize(pageSize int64) *AccountSummariesListCall {
6106 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6107 return c
6108 }
6109
6110
6111
6112
6113
6114 func (c *AccountSummariesListCall) PageToken(pageToken string) *AccountSummariesListCall {
6115 c.urlParams_.Set("pageToken", pageToken)
6116 return c
6117 }
6118
6119
6120
6121
6122 func (c *AccountSummariesListCall) Fields(s ...googleapi.Field) *AccountSummariesListCall {
6123 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6124 return c
6125 }
6126
6127
6128
6129
6130 func (c *AccountSummariesListCall) IfNoneMatch(entityTag string) *AccountSummariesListCall {
6131 c.ifNoneMatch_ = entityTag
6132 return c
6133 }
6134
6135
6136 func (c *AccountSummariesListCall) Context(ctx context.Context) *AccountSummariesListCall {
6137 c.ctx_ = ctx
6138 return c
6139 }
6140
6141
6142
6143 func (c *AccountSummariesListCall) Header() http.Header {
6144 if c.header_ == nil {
6145 c.header_ = make(http.Header)
6146 }
6147 return c.header_
6148 }
6149
6150 func (c *AccountSummariesListCall) doRequest(alt string) (*http.Response, error) {
6151 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6152 if c.ifNoneMatch_ != "" {
6153 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6154 }
6155 var body io.Reader = nil
6156 c.urlParams_.Set("alt", alt)
6157 c.urlParams_.Set("prettyPrint", "false")
6158 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/accountSummaries")
6159 urls += "?" + c.urlParams_.Encode()
6160 req, err := http.NewRequest("GET", urls, body)
6161 if err != nil {
6162 return nil, err
6163 }
6164 req.Header = reqHeaders
6165 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6166 }
6167
6168
6169
6170
6171
6172
6173
6174 func (c *AccountSummariesListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListAccountSummariesResponse, error) {
6175 gensupport.SetOptions(c.urlParams_, opts...)
6176 res, err := c.doRequest("json")
6177 if res != nil && res.StatusCode == http.StatusNotModified {
6178 if res.Body != nil {
6179 res.Body.Close()
6180 }
6181 return nil, gensupport.WrapError(&googleapi.Error{
6182 Code: res.StatusCode,
6183 Header: res.Header,
6184 })
6185 }
6186 if err != nil {
6187 return nil, err
6188 }
6189 defer googleapi.CloseBody(res)
6190 if err := googleapi.CheckResponse(res); err != nil {
6191 return nil, gensupport.WrapError(err)
6192 }
6193 ret := &GoogleAnalyticsAdminV1alphaListAccountSummariesResponse{
6194 ServerResponse: googleapi.ServerResponse{
6195 Header: res.Header,
6196 HTTPStatusCode: res.StatusCode,
6197 },
6198 }
6199 target := &ret
6200 if err := gensupport.DecodeResponse(target, res); err != nil {
6201 return nil, err
6202 }
6203 return ret, nil
6204 }
6205
6206
6207
6208
6209 func (c *AccountSummariesListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListAccountSummariesResponse) error) error {
6210 c.ctx_ = ctx
6211 defer c.PageToken(c.urlParams_.Get("pageToken"))
6212 for {
6213 x, err := c.Do()
6214 if err != nil {
6215 return err
6216 }
6217 if err := f(x); err != nil {
6218 return err
6219 }
6220 if x.NextPageToken == "" {
6221 return nil
6222 }
6223 c.PageToken(x.NextPageToken)
6224 }
6225 }
6226
6227 type AccountsDeleteCall struct {
6228 s *Service
6229 name string
6230 urlParams_ gensupport.URLParams
6231 ctx_ context.Context
6232 header_ http.Header
6233 }
6234
6235
6236
6237
6238
6239
6240
6241
6242
6243
6244
6245 func (r *AccountsService) Delete(name string) *AccountsDeleteCall {
6246 c := &AccountsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6247 c.name = name
6248 return c
6249 }
6250
6251
6252
6253
6254 func (c *AccountsDeleteCall) Fields(s ...googleapi.Field) *AccountsDeleteCall {
6255 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6256 return c
6257 }
6258
6259
6260 func (c *AccountsDeleteCall) Context(ctx context.Context) *AccountsDeleteCall {
6261 c.ctx_ = ctx
6262 return c
6263 }
6264
6265
6266
6267 func (c *AccountsDeleteCall) Header() http.Header {
6268 if c.header_ == nil {
6269 c.header_ = make(http.Header)
6270 }
6271 return c.header_
6272 }
6273
6274 func (c *AccountsDeleteCall) doRequest(alt string) (*http.Response, error) {
6275 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6276 var body io.Reader = nil
6277 c.urlParams_.Set("alt", alt)
6278 c.urlParams_.Set("prettyPrint", "false")
6279 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
6280 urls += "?" + c.urlParams_.Encode()
6281 req, err := http.NewRequest("DELETE", urls, body)
6282 if err != nil {
6283 return nil, err
6284 }
6285 req.Header = reqHeaders
6286 googleapi.Expand(req.URL, map[string]string{
6287 "name": c.name,
6288 })
6289 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6290 }
6291
6292
6293
6294
6295
6296
6297
6298 func (c *AccountsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
6299 gensupport.SetOptions(c.urlParams_, opts...)
6300 res, err := c.doRequest("json")
6301 if res != nil && res.StatusCode == http.StatusNotModified {
6302 if res.Body != nil {
6303 res.Body.Close()
6304 }
6305 return nil, gensupport.WrapError(&googleapi.Error{
6306 Code: res.StatusCode,
6307 Header: res.Header,
6308 })
6309 }
6310 if err != nil {
6311 return nil, err
6312 }
6313 defer googleapi.CloseBody(res)
6314 if err := googleapi.CheckResponse(res); err != nil {
6315 return nil, gensupport.WrapError(err)
6316 }
6317 ret := &GoogleProtobufEmpty{
6318 ServerResponse: googleapi.ServerResponse{
6319 Header: res.Header,
6320 HTTPStatusCode: res.StatusCode,
6321 },
6322 }
6323 target := &ret
6324 if err := gensupport.DecodeResponse(target, res); err != nil {
6325 return nil, err
6326 }
6327 return ret, nil
6328 }
6329
6330 type AccountsGetCall struct {
6331 s *Service
6332 name string
6333 urlParams_ gensupport.URLParams
6334 ifNoneMatch_ string
6335 ctx_ context.Context
6336 header_ http.Header
6337 }
6338
6339
6340
6341
6342
6343 func (r *AccountsService) Get(name string) *AccountsGetCall {
6344 c := &AccountsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6345 c.name = name
6346 return c
6347 }
6348
6349
6350
6351
6352 func (c *AccountsGetCall) Fields(s ...googleapi.Field) *AccountsGetCall {
6353 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6354 return c
6355 }
6356
6357
6358
6359
6360 func (c *AccountsGetCall) IfNoneMatch(entityTag string) *AccountsGetCall {
6361 c.ifNoneMatch_ = entityTag
6362 return c
6363 }
6364
6365
6366 func (c *AccountsGetCall) Context(ctx context.Context) *AccountsGetCall {
6367 c.ctx_ = ctx
6368 return c
6369 }
6370
6371
6372
6373 func (c *AccountsGetCall) Header() http.Header {
6374 if c.header_ == nil {
6375 c.header_ = make(http.Header)
6376 }
6377 return c.header_
6378 }
6379
6380 func (c *AccountsGetCall) doRequest(alt string) (*http.Response, error) {
6381 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6382 if c.ifNoneMatch_ != "" {
6383 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6384 }
6385 var body io.Reader = nil
6386 c.urlParams_.Set("alt", alt)
6387 c.urlParams_.Set("prettyPrint", "false")
6388 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
6389 urls += "?" + c.urlParams_.Encode()
6390 req, err := http.NewRequest("GET", urls, body)
6391 if err != nil {
6392 return nil, err
6393 }
6394 req.Header = reqHeaders
6395 googleapi.Expand(req.URL, map[string]string{
6396 "name": c.name,
6397 })
6398 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6399 }
6400
6401
6402
6403
6404
6405
6406
6407 func (c *AccountsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAccount, error) {
6408 gensupport.SetOptions(c.urlParams_, opts...)
6409 res, err := c.doRequest("json")
6410 if res != nil && res.StatusCode == http.StatusNotModified {
6411 if res.Body != nil {
6412 res.Body.Close()
6413 }
6414 return nil, gensupport.WrapError(&googleapi.Error{
6415 Code: res.StatusCode,
6416 Header: res.Header,
6417 })
6418 }
6419 if err != nil {
6420 return nil, err
6421 }
6422 defer googleapi.CloseBody(res)
6423 if err := googleapi.CheckResponse(res); err != nil {
6424 return nil, gensupport.WrapError(err)
6425 }
6426 ret := &GoogleAnalyticsAdminV1alphaAccount{
6427 ServerResponse: googleapi.ServerResponse{
6428 Header: res.Header,
6429 HTTPStatusCode: res.StatusCode,
6430 },
6431 }
6432 target := &ret
6433 if err := gensupport.DecodeResponse(target, res); err != nil {
6434 return nil, err
6435 }
6436 return ret, nil
6437 }
6438
6439 type AccountsGetDataSharingSettingsCall struct {
6440 s *Service
6441 name string
6442 urlParams_ gensupport.URLParams
6443 ifNoneMatch_ string
6444 ctx_ context.Context
6445 header_ http.Header
6446 }
6447
6448
6449
6450
6451
6452
6453
6454 func (r *AccountsService) GetDataSharingSettings(name string) *AccountsGetDataSharingSettingsCall {
6455 c := &AccountsGetDataSharingSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6456 c.name = name
6457 return c
6458 }
6459
6460
6461
6462
6463 func (c *AccountsGetDataSharingSettingsCall) Fields(s ...googleapi.Field) *AccountsGetDataSharingSettingsCall {
6464 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6465 return c
6466 }
6467
6468
6469
6470
6471 func (c *AccountsGetDataSharingSettingsCall) IfNoneMatch(entityTag string) *AccountsGetDataSharingSettingsCall {
6472 c.ifNoneMatch_ = entityTag
6473 return c
6474 }
6475
6476
6477 func (c *AccountsGetDataSharingSettingsCall) Context(ctx context.Context) *AccountsGetDataSharingSettingsCall {
6478 c.ctx_ = ctx
6479 return c
6480 }
6481
6482
6483
6484 func (c *AccountsGetDataSharingSettingsCall) Header() http.Header {
6485 if c.header_ == nil {
6486 c.header_ = make(http.Header)
6487 }
6488 return c.header_
6489 }
6490
6491 func (c *AccountsGetDataSharingSettingsCall) doRequest(alt string) (*http.Response, error) {
6492 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6493 if c.ifNoneMatch_ != "" {
6494 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6495 }
6496 var body io.Reader = nil
6497 c.urlParams_.Set("alt", alt)
6498 c.urlParams_.Set("prettyPrint", "false")
6499 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
6500 urls += "?" + c.urlParams_.Encode()
6501 req, err := http.NewRequest("GET", urls, body)
6502 if err != nil {
6503 return nil, err
6504 }
6505 req.Header = reqHeaders
6506 googleapi.Expand(req.URL, map[string]string{
6507 "name": c.name,
6508 })
6509 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6510 }
6511
6512
6513
6514
6515
6516
6517
6518 func (c *AccountsGetDataSharingSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDataSharingSettings, error) {
6519 gensupport.SetOptions(c.urlParams_, opts...)
6520 res, err := c.doRequest("json")
6521 if res != nil && res.StatusCode == http.StatusNotModified {
6522 if res.Body != nil {
6523 res.Body.Close()
6524 }
6525 return nil, gensupport.WrapError(&googleapi.Error{
6526 Code: res.StatusCode,
6527 Header: res.Header,
6528 })
6529 }
6530 if err != nil {
6531 return nil, err
6532 }
6533 defer googleapi.CloseBody(res)
6534 if err := googleapi.CheckResponse(res); err != nil {
6535 return nil, gensupport.WrapError(err)
6536 }
6537 ret := &GoogleAnalyticsAdminV1alphaDataSharingSettings{
6538 ServerResponse: googleapi.ServerResponse{
6539 Header: res.Header,
6540 HTTPStatusCode: res.StatusCode,
6541 },
6542 }
6543 target := &ret
6544 if err := gensupport.DecodeResponse(target, res); err != nil {
6545 return nil, err
6546 }
6547 return ret, nil
6548 }
6549
6550 type AccountsListCall struct {
6551 s *Service
6552 urlParams_ gensupport.URLParams
6553 ifNoneMatch_ string
6554 ctx_ context.Context
6555 header_ http.Header
6556 }
6557
6558
6559
6560
6561
6562 func (r *AccountsService) List() *AccountsListCall {
6563 c := &AccountsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6564 return c
6565 }
6566
6567
6568
6569
6570
6571
6572 func (c *AccountsListCall) PageSize(pageSize int64) *AccountsListCall {
6573 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6574 return c
6575 }
6576
6577
6578
6579
6580
6581 func (c *AccountsListCall) PageToken(pageToken string) *AccountsListCall {
6582 c.urlParams_.Set("pageToken", pageToken)
6583 return c
6584 }
6585
6586
6587
6588
6589 func (c *AccountsListCall) ShowDeleted(showDeleted bool) *AccountsListCall {
6590 c.urlParams_.Set("showDeleted", fmt.Sprint(showDeleted))
6591 return c
6592 }
6593
6594
6595
6596
6597 func (c *AccountsListCall) Fields(s ...googleapi.Field) *AccountsListCall {
6598 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6599 return c
6600 }
6601
6602
6603
6604
6605 func (c *AccountsListCall) IfNoneMatch(entityTag string) *AccountsListCall {
6606 c.ifNoneMatch_ = entityTag
6607 return c
6608 }
6609
6610
6611 func (c *AccountsListCall) Context(ctx context.Context) *AccountsListCall {
6612 c.ctx_ = ctx
6613 return c
6614 }
6615
6616
6617
6618 func (c *AccountsListCall) Header() http.Header {
6619 if c.header_ == nil {
6620 c.header_ = make(http.Header)
6621 }
6622 return c.header_
6623 }
6624
6625 func (c *AccountsListCall) doRequest(alt string) (*http.Response, error) {
6626 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6627 if c.ifNoneMatch_ != "" {
6628 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6629 }
6630 var body io.Reader = nil
6631 c.urlParams_.Set("alt", alt)
6632 c.urlParams_.Set("prettyPrint", "false")
6633 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/accounts")
6634 urls += "?" + c.urlParams_.Encode()
6635 req, err := http.NewRequest("GET", urls, body)
6636 if err != nil {
6637 return nil, err
6638 }
6639 req.Header = reqHeaders
6640 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6641 }
6642
6643
6644
6645
6646
6647
6648
6649 func (c *AccountsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListAccountsResponse, error) {
6650 gensupport.SetOptions(c.urlParams_, opts...)
6651 res, err := c.doRequest("json")
6652 if res != nil && res.StatusCode == http.StatusNotModified {
6653 if res.Body != nil {
6654 res.Body.Close()
6655 }
6656 return nil, gensupport.WrapError(&googleapi.Error{
6657 Code: res.StatusCode,
6658 Header: res.Header,
6659 })
6660 }
6661 if err != nil {
6662 return nil, err
6663 }
6664 defer googleapi.CloseBody(res)
6665 if err := googleapi.CheckResponse(res); err != nil {
6666 return nil, gensupport.WrapError(err)
6667 }
6668 ret := &GoogleAnalyticsAdminV1alphaListAccountsResponse{
6669 ServerResponse: googleapi.ServerResponse{
6670 Header: res.Header,
6671 HTTPStatusCode: res.StatusCode,
6672 },
6673 }
6674 target := &ret
6675 if err := gensupport.DecodeResponse(target, res); err != nil {
6676 return nil, err
6677 }
6678 return ret, nil
6679 }
6680
6681
6682
6683
6684 func (c *AccountsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListAccountsResponse) error) error {
6685 c.ctx_ = ctx
6686 defer c.PageToken(c.urlParams_.Get("pageToken"))
6687 for {
6688 x, err := c.Do()
6689 if err != nil {
6690 return err
6691 }
6692 if err := f(x); err != nil {
6693 return err
6694 }
6695 if x.NextPageToken == "" {
6696 return nil
6697 }
6698 c.PageToken(x.NextPageToken)
6699 }
6700 }
6701
6702 type AccountsPatchCall struct {
6703 s *Service
6704 name string
6705 googleanalyticsadminv1alphaaccount *GoogleAnalyticsAdminV1alphaAccount
6706 urlParams_ gensupport.URLParams
6707 ctx_ context.Context
6708 header_ http.Header
6709 }
6710
6711
6712
6713
6714
6715 func (r *AccountsService) Patch(name string, googleanalyticsadminv1alphaaccount *GoogleAnalyticsAdminV1alphaAccount) *AccountsPatchCall {
6716 c := &AccountsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6717 c.name = name
6718 c.googleanalyticsadminv1alphaaccount = googleanalyticsadminv1alphaaccount
6719 return c
6720 }
6721
6722
6723
6724
6725
6726 func (c *AccountsPatchCall) UpdateMask(updateMask string) *AccountsPatchCall {
6727 c.urlParams_.Set("updateMask", updateMask)
6728 return c
6729 }
6730
6731
6732
6733
6734 func (c *AccountsPatchCall) Fields(s ...googleapi.Field) *AccountsPatchCall {
6735 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6736 return c
6737 }
6738
6739
6740 func (c *AccountsPatchCall) Context(ctx context.Context) *AccountsPatchCall {
6741 c.ctx_ = ctx
6742 return c
6743 }
6744
6745
6746
6747 func (c *AccountsPatchCall) Header() http.Header {
6748 if c.header_ == nil {
6749 c.header_ = make(http.Header)
6750 }
6751 return c.header_
6752 }
6753
6754 func (c *AccountsPatchCall) doRequest(alt string) (*http.Response, error) {
6755 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6756 var body io.Reader = nil
6757 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaaccount)
6758 if err != nil {
6759 return nil, err
6760 }
6761 c.urlParams_.Set("alt", alt)
6762 c.urlParams_.Set("prettyPrint", "false")
6763 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
6764 urls += "?" + c.urlParams_.Encode()
6765 req, err := http.NewRequest("PATCH", urls, body)
6766 if err != nil {
6767 return nil, err
6768 }
6769 req.Header = reqHeaders
6770 googleapi.Expand(req.URL, map[string]string{
6771 "name": c.name,
6772 })
6773 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6774 }
6775
6776
6777
6778
6779
6780
6781
6782 func (c *AccountsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAccount, error) {
6783 gensupport.SetOptions(c.urlParams_, opts...)
6784 res, err := c.doRequest("json")
6785 if res != nil && res.StatusCode == http.StatusNotModified {
6786 if res.Body != nil {
6787 res.Body.Close()
6788 }
6789 return nil, gensupport.WrapError(&googleapi.Error{
6790 Code: res.StatusCode,
6791 Header: res.Header,
6792 })
6793 }
6794 if err != nil {
6795 return nil, err
6796 }
6797 defer googleapi.CloseBody(res)
6798 if err := googleapi.CheckResponse(res); err != nil {
6799 return nil, gensupport.WrapError(err)
6800 }
6801 ret := &GoogleAnalyticsAdminV1alphaAccount{
6802 ServerResponse: googleapi.ServerResponse{
6803 Header: res.Header,
6804 HTTPStatusCode: res.StatusCode,
6805 },
6806 }
6807 target := &ret
6808 if err := gensupport.DecodeResponse(target, res); err != nil {
6809 return nil, err
6810 }
6811 return ret, nil
6812 }
6813
6814 type AccountsProvisionAccountTicketCall struct {
6815 s *Service
6816 googleanalyticsadminv1alphaprovisionaccountticketrequest *GoogleAnalyticsAdminV1alphaProvisionAccountTicketRequest
6817 urlParams_ gensupport.URLParams
6818 ctx_ context.Context
6819 header_ http.Header
6820 }
6821
6822
6823 func (r *AccountsService) ProvisionAccountTicket(googleanalyticsadminv1alphaprovisionaccountticketrequest *GoogleAnalyticsAdminV1alphaProvisionAccountTicketRequest) *AccountsProvisionAccountTicketCall {
6824 c := &AccountsProvisionAccountTicketCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6825 c.googleanalyticsadminv1alphaprovisionaccountticketrequest = googleanalyticsadminv1alphaprovisionaccountticketrequest
6826 return c
6827 }
6828
6829
6830
6831
6832 func (c *AccountsProvisionAccountTicketCall) Fields(s ...googleapi.Field) *AccountsProvisionAccountTicketCall {
6833 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6834 return c
6835 }
6836
6837
6838 func (c *AccountsProvisionAccountTicketCall) Context(ctx context.Context) *AccountsProvisionAccountTicketCall {
6839 c.ctx_ = ctx
6840 return c
6841 }
6842
6843
6844
6845 func (c *AccountsProvisionAccountTicketCall) Header() http.Header {
6846 if c.header_ == nil {
6847 c.header_ = make(http.Header)
6848 }
6849 return c.header_
6850 }
6851
6852 func (c *AccountsProvisionAccountTicketCall) doRequest(alt string) (*http.Response, error) {
6853 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6854 var body io.Reader = nil
6855 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaprovisionaccountticketrequest)
6856 if err != nil {
6857 return nil, err
6858 }
6859 c.urlParams_.Set("alt", alt)
6860 c.urlParams_.Set("prettyPrint", "false")
6861 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/accounts:provisionAccountTicket")
6862 urls += "?" + c.urlParams_.Encode()
6863 req, err := http.NewRequest("POST", urls, body)
6864 if err != nil {
6865 return nil, err
6866 }
6867 req.Header = reqHeaders
6868 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6869 }
6870
6871
6872
6873
6874
6875
6876
6877 func (c *AccountsProvisionAccountTicketCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaProvisionAccountTicketResponse, error) {
6878 gensupport.SetOptions(c.urlParams_, opts...)
6879 res, err := c.doRequest("json")
6880 if res != nil && res.StatusCode == http.StatusNotModified {
6881 if res.Body != nil {
6882 res.Body.Close()
6883 }
6884 return nil, gensupport.WrapError(&googleapi.Error{
6885 Code: res.StatusCode,
6886 Header: res.Header,
6887 })
6888 }
6889 if err != nil {
6890 return nil, err
6891 }
6892 defer googleapi.CloseBody(res)
6893 if err := googleapi.CheckResponse(res); err != nil {
6894 return nil, gensupport.WrapError(err)
6895 }
6896 ret := &GoogleAnalyticsAdminV1alphaProvisionAccountTicketResponse{
6897 ServerResponse: googleapi.ServerResponse{
6898 Header: res.Header,
6899 HTTPStatusCode: res.StatusCode,
6900 },
6901 }
6902 target := &ret
6903 if err := gensupport.DecodeResponse(target, res); err != nil {
6904 return nil, err
6905 }
6906 return ret, nil
6907 }
6908
6909 type AccountsRunAccessReportCall struct {
6910 s *Service
6911 entity string
6912 googleanalyticsadminv1alpharunaccessreportrequest *GoogleAnalyticsAdminV1alphaRunAccessReportRequest
6913 urlParams_ gensupport.URLParams
6914 ctx_ context.Context
6915 header_ http.Header
6916 }
6917
6918
6919
6920
6921
6922
6923
6924
6925
6926
6927
6928
6929
6930
6931
6932
6933
6934
6935
6936
6937 func (r *AccountsService) RunAccessReport(entity string, googleanalyticsadminv1alpharunaccessreportrequest *GoogleAnalyticsAdminV1alphaRunAccessReportRequest) *AccountsRunAccessReportCall {
6938 c := &AccountsRunAccessReportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6939 c.entity = entity
6940 c.googleanalyticsadminv1alpharunaccessreportrequest = googleanalyticsadminv1alpharunaccessreportrequest
6941 return c
6942 }
6943
6944
6945
6946
6947 func (c *AccountsRunAccessReportCall) Fields(s ...googleapi.Field) *AccountsRunAccessReportCall {
6948 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6949 return c
6950 }
6951
6952
6953 func (c *AccountsRunAccessReportCall) Context(ctx context.Context) *AccountsRunAccessReportCall {
6954 c.ctx_ = ctx
6955 return c
6956 }
6957
6958
6959
6960 func (c *AccountsRunAccessReportCall) Header() http.Header {
6961 if c.header_ == nil {
6962 c.header_ = make(http.Header)
6963 }
6964 return c.header_
6965 }
6966
6967 func (c *AccountsRunAccessReportCall) doRequest(alt string) (*http.Response, error) {
6968 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6969 var body io.Reader = nil
6970 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alpharunaccessreportrequest)
6971 if err != nil {
6972 return nil, err
6973 }
6974 c.urlParams_.Set("alt", alt)
6975 c.urlParams_.Set("prettyPrint", "false")
6976 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+entity}:runAccessReport")
6977 urls += "?" + c.urlParams_.Encode()
6978 req, err := http.NewRequest("POST", urls, body)
6979 if err != nil {
6980 return nil, err
6981 }
6982 req.Header = reqHeaders
6983 googleapi.Expand(req.URL, map[string]string{
6984 "entity": c.entity,
6985 })
6986 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6987 }
6988
6989
6990
6991
6992
6993
6994
6995 func (c *AccountsRunAccessReportCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaRunAccessReportResponse, error) {
6996 gensupport.SetOptions(c.urlParams_, opts...)
6997 res, err := c.doRequest("json")
6998 if res != nil && res.StatusCode == http.StatusNotModified {
6999 if res.Body != nil {
7000 res.Body.Close()
7001 }
7002 return nil, gensupport.WrapError(&googleapi.Error{
7003 Code: res.StatusCode,
7004 Header: res.Header,
7005 })
7006 }
7007 if err != nil {
7008 return nil, err
7009 }
7010 defer googleapi.CloseBody(res)
7011 if err := googleapi.CheckResponse(res); err != nil {
7012 return nil, gensupport.WrapError(err)
7013 }
7014 ret := &GoogleAnalyticsAdminV1alphaRunAccessReportResponse{
7015 ServerResponse: googleapi.ServerResponse{
7016 Header: res.Header,
7017 HTTPStatusCode: res.StatusCode,
7018 },
7019 }
7020 target := &ret
7021 if err := gensupport.DecodeResponse(target, res); err != nil {
7022 return nil, err
7023 }
7024 return ret, nil
7025 }
7026
7027 type AccountsSearchChangeHistoryEventsCall struct {
7028 s *Service
7029 account string
7030 googleanalyticsadminv1alphasearchchangehistoryeventsrequest *GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsRequest
7031 urlParams_ gensupport.URLParams
7032 ctx_ context.Context
7033 header_ http.Header
7034 }
7035
7036
7037
7038
7039
7040
7041 func (r *AccountsService) SearchChangeHistoryEvents(account string, googleanalyticsadminv1alphasearchchangehistoryeventsrequest *GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsRequest) *AccountsSearchChangeHistoryEventsCall {
7042 c := &AccountsSearchChangeHistoryEventsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7043 c.account = account
7044 c.googleanalyticsadminv1alphasearchchangehistoryeventsrequest = googleanalyticsadminv1alphasearchchangehistoryeventsrequest
7045 return c
7046 }
7047
7048
7049
7050
7051 func (c *AccountsSearchChangeHistoryEventsCall) Fields(s ...googleapi.Field) *AccountsSearchChangeHistoryEventsCall {
7052 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7053 return c
7054 }
7055
7056
7057 func (c *AccountsSearchChangeHistoryEventsCall) Context(ctx context.Context) *AccountsSearchChangeHistoryEventsCall {
7058 c.ctx_ = ctx
7059 return c
7060 }
7061
7062
7063
7064 func (c *AccountsSearchChangeHistoryEventsCall) Header() http.Header {
7065 if c.header_ == nil {
7066 c.header_ = make(http.Header)
7067 }
7068 return c.header_
7069 }
7070
7071 func (c *AccountsSearchChangeHistoryEventsCall) doRequest(alt string) (*http.Response, error) {
7072 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7073 var body io.Reader = nil
7074 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphasearchchangehistoryeventsrequest)
7075 if err != nil {
7076 return nil, err
7077 }
7078 c.urlParams_.Set("alt", alt)
7079 c.urlParams_.Set("prettyPrint", "false")
7080 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+account}:searchChangeHistoryEvents")
7081 urls += "?" + c.urlParams_.Encode()
7082 req, err := http.NewRequest("POST", urls, body)
7083 if err != nil {
7084 return nil, err
7085 }
7086 req.Header = reqHeaders
7087 googleapi.Expand(req.URL, map[string]string{
7088 "account": c.account,
7089 })
7090 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7091 }
7092
7093
7094
7095
7096
7097
7098
7099 func (c *AccountsSearchChangeHistoryEventsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsResponse, error) {
7100 gensupport.SetOptions(c.urlParams_, opts...)
7101 res, err := c.doRequest("json")
7102 if res != nil && res.StatusCode == http.StatusNotModified {
7103 if res.Body != nil {
7104 res.Body.Close()
7105 }
7106 return nil, gensupport.WrapError(&googleapi.Error{
7107 Code: res.StatusCode,
7108 Header: res.Header,
7109 })
7110 }
7111 if err != nil {
7112 return nil, err
7113 }
7114 defer googleapi.CloseBody(res)
7115 if err := googleapi.CheckResponse(res); err != nil {
7116 return nil, gensupport.WrapError(err)
7117 }
7118 ret := &GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsResponse{
7119 ServerResponse: googleapi.ServerResponse{
7120 Header: res.Header,
7121 HTTPStatusCode: res.StatusCode,
7122 },
7123 }
7124 target := &ret
7125 if err := gensupport.DecodeResponse(target, res); err != nil {
7126 return nil, err
7127 }
7128 return ret, nil
7129 }
7130
7131
7132
7133
7134 func (c *AccountsSearchChangeHistoryEventsCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaSearchChangeHistoryEventsResponse) error) error {
7135 c.ctx_ = ctx
7136 defer func(pt string) { c.googleanalyticsadminv1alphasearchchangehistoryeventsrequest.PageToken = pt }(c.googleanalyticsadminv1alphasearchchangehistoryeventsrequest.PageToken)
7137 for {
7138 x, err := c.Do()
7139 if err != nil {
7140 return err
7141 }
7142 if err := f(x); err != nil {
7143 return err
7144 }
7145 if x.NextPageToken == "" {
7146 return nil
7147 }
7148 c.googleanalyticsadminv1alphasearchchangehistoryeventsrequest.PageToken = x.NextPageToken
7149 }
7150 }
7151
7152 type AccountsAccessBindingsBatchCreateCall struct {
7153 s *Service
7154 parent string
7155 googleanalyticsadminv1alphabatchcreateaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsRequest
7156 urlParams_ gensupport.URLParams
7157 ctx_ context.Context
7158 header_ http.Header
7159 }
7160
7161
7162
7163
7164
7165
7166
7167
7168 func (r *AccountsAccessBindingsService) BatchCreate(parent string, googleanalyticsadminv1alphabatchcreateaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsRequest) *AccountsAccessBindingsBatchCreateCall {
7169 c := &AccountsAccessBindingsBatchCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7170 c.parent = parent
7171 c.googleanalyticsadminv1alphabatchcreateaccessbindingsrequest = googleanalyticsadminv1alphabatchcreateaccessbindingsrequest
7172 return c
7173 }
7174
7175
7176
7177
7178 func (c *AccountsAccessBindingsBatchCreateCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsBatchCreateCall {
7179 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7180 return c
7181 }
7182
7183
7184 func (c *AccountsAccessBindingsBatchCreateCall) Context(ctx context.Context) *AccountsAccessBindingsBatchCreateCall {
7185 c.ctx_ = ctx
7186 return c
7187 }
7188
7189
7190
7191 func (c *AccountsAccessBindingsBatchCreateCall) Header() http.Header {
7192 if c.header_ == nil {
7193 c.header_ = make(http.Header)
7194 }
7195 return c.header_
7196 }
7197
7198 func (c *AccountsAccessBindingsBatchCreateCall) doRequest(alt string) (*http.Response, error) {
7199 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7200 var body io.Reader = nil
7201 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphabatchcreateaccessbindingsrequest)
7202 if err != nil {
7203 return nil, err
7204 }
7205 c.urlParams_.Set("alt", alt)
7206 c.urlParams_.Set("prettyPrint", "false")
7207 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings:batchCreate")
7208 urls += "?" + c.urlParams_.Encode()
7209 req, err := http.NewRequest("POST", urls, body)
7210 if err != nil {
7211 return nil, err
7212 }
7213 req.Header = reqHeaders
7214 googleapi.Expand(req.URL, map[string]string{
7215 "parent": c.parent,
7216 })
7217 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7218 }
7219
7220
7221
7222
7223
7224
7225
7226 func (c *AccountsAccessBindingsBatchCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsResponse, error) {
7227 gensupport.SetOptions(c.urlParams_, opts...)
7228 res, err := c.doRequest("json")
7229 if res != nil && res.StatusCode == http.StatusNotModified {
7230 if res.Body != nil {
7231 res.Body.Close()
7232 }
7233 return nil, gensupport.WrapError(&googleapi.Error{
7234 Code: res.StatusCode,
7235 Header: res.Header,
7236 })
7237 }
7238 if err != nil {
7239 return nil, err
7240 }
7241 defer googleapi.CloseBody(res)
7242 if err := googleapi.CheckResponse(res); err != nil {
7243 return nil, gensupport.WrapError(err)
7244 }
7245 ret := &GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsResponse{
7246 ServerResponse: googleapi.ServerResponse{
7247 Header: res.Header,
7248 HTTPStatusCode: res.StatusCode,
7249 },
7250 }
7251 target := &ret
7252 if err := gensupport.DecodeResponse(target, res); err != nil {
7253 return nil, err
7254 }
7255 return ret, nil
7256 }
7257
7258 type AccountsAccessBindingsBatchDeleteCall struct {
7259 s *Service
7260 parent string
7261 googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchDeleteAccessBindingsRequest
7262 urlParams_ gensupport.URLParams
7263 ctx_ context.Context
7264 header_ http.Header
7265 }
7266
7267
7268
7269
7270
7271
7272
7273
7274 func (r *AccountsAccessBindingsService) BatchDelete(parent string, googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchDeleteAccessBindingsRequest) *AccountsAccessBindingsBatchDeleteCall {
7275 c := &AccountsAccessBindingsBatchDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7276 c.parent = parent
7277 c.googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest = googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest
7278 return c
7279 }
7280
7281
7282
7283
7284 func (c *AccountsAccessBindingsBatchDeleteCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsBatchDeleteCall {
7285 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7286 return c
7287 }
7288
7289
7290 func (c *AccountsAccessBindingsBatchDeleteCall) Context(ctx context.Context) *AccountsAccessBindingsBatchDeleteCall {
7291 c.ctx_ = ctx
7292 return c
7293 }
7294
7295
7296
7297 func (c *AccountsAccessBindingsBatchDeleteCall) Header() http.Header {
7298 if c.header_ == nil {
7299 c.header_ = make(http.Header)
7300 }
7301 return c.header_
7302 }
7303
7304 func (c *AccountsAccessBindingsBatchDeleteCall) doRequest(alt string) (*http.Response, error) {
7305 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7306 var body io.Reader = nil
7307 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest)
7308 if err != nil {
7309 return nil, err
7310 }
7311 c.urlParams_.Set("alt", alt)
7312 c.urlParams_.Set("prettyPrint", "false")
7313 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings:batchDelete")
7314 urls += "?" + c.urlParams_.Encode()
7315 req, err := http.NewRequest("POST", urls, body)
7316 if err != nil {
7317 return nil, err
7318 }
7319 req.Header = reqHeaders
7320 googleapi.Expand(req.URL, map[string]string{
7321 "parent": c.parent,
7322 })
7323 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7324 }
7325
7326
7327
7328
7329
7330
7331
7332 func (c *AccountsAccessBindingsBatchDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
7333 gensupport.SetOptions(c.urlParams_, opts...)
7334 res, err := c.doRequest("json")
7335 if res != nil && res.StatusCode == http.StatusNotModified {
7336 if res.Body != nil {
7337 res.Body.Close()
7338 }
7339 return nil, gensupport.WrapError(&googleapi.Error{
7340 Code: res.StatusCode,
7341 Header: res.Header,
7342 })
7343 }
7344 if err != nil {
7345 return nil, err
7346 }
7347 defer googleapi.CloseBody(res)
7348 if err := googleapi.CheckResponse(res); err != nil {
7349 return nil, gensupport.WrapError(err)
7350 }
7351 ret := &GoogleProtobufEmpty{
7352 ServerResponse: googleapi.ServerResponse{
7353 Header: res.Header,
7354 HTTPStatusCode: res.StatusCode,
7355 },
7356 }
7357 target := &ret
7358 if err := gensupport.DecodeResponse(target, res); err != nil {
7359 return nil, err
7360 }
7361 return ret, nil
7362 }
7363
7364 type AccountsAccessBindingsBatchGetCall struct {
7365 s *Service
7366 parent string
7367 urlParams_ gensupport.URLParams
7368 ifNoneMatch_ string
7369 ctx_ context.Context
7370 header_ http.Header
7371 }
7372
7373
7374
7375
7376
7377
7378
7379 func (r *AccountsAccessBindingsService) BatchGet(parent string) *AccountsAccessBindingsBatchGetCall {
7380 c := &AccountsAccessBindingsBatchGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7381 c.parent = parent
7382 return c
7383 }
7384
7385
7386
7387
7388
7389 func (c *AccountsAccessBindingsBatchGetCall) Names(names ...string) *AccountsAccessBindingsBatchGetCall {
7390 c.urlParams_.SetMulti("names", append([]string{}, names...))
7391 return c
7392 }
7393
7394
7395
7396
7397 func (c *AccountsAccessBindingsBatchGetCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsBatchGetCall {
7398 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7399 return c
7400 }
7401
7402
7403
7404
7405 func (c *AccountsAccessBindingsBatchGetCall) IfNoneMatch(entityTag string) *AccountsAccessBindingsBatchGetCall {
7406 c.ifNoneMatch_ = entityTag
7407 return c
7408 }
7409
7410
7411 func (c *AccountsAccessBindingsBatchGetCall) Context(ctx context.Context) *AccountsAccessBindingsBatchGetCall {
7412 c.ctx_ = ctx
7413 return c
7414 }
7415
7416
7417
7418 func (c *AccountsAccessBindingsBatchGetCall) Header() http.Header {
7419 if c.header_ == nil {
7420 c.header_ = make(http.Header)
7421 }
7422 return c.header_
7423 }
7424
7425 func (c *AccountsAccessBindingsBatchGetCall) doRequest(alt string) (*http.Response, error) {
7426 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7427 if c.ifNoneMatch_ != "" {
7428 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7429 }
7430 var body io.Reader = nil
7431 c.urlParams_.Set("alt", alt)
7432 c.urlParams_.Set("prettyPrint", "false")
7433 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings:batchGet")
7434 urls += "?" + c.urlParams_.Encode()
7435 req, err := http.NewRequest("GET", urls, body)
7436 if err != nil {
7437 return nil, err
7438 }
7439 req.Header = reqHeaders
7440 googleapi.Expand(req.URL, map[string]string{
7441 "parent": c.parent,
7442 })
7443 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7444 }
7445
7446
7447
7448
7449
7450
7451
7452 func (c *AccountsAccessBindingsBatchGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaBatchGetAccessBindingsResponse, error) {
7453 gensupport.SetOptions(c.urlParams_, opts...)
7454 res, err := c.doRequest("json")
7455 if res != nil && res.StatusCode == http.StatusNotModified {
7456 if res.Body != nil {
7457 res.Body.Close()
7458 }
7459 return nil, gensupport.WrapError(&googleapi.Error{
7460 Code: res.StatusCode,
7461 Header: res.Header,
7462 })
7463 }
7464 if err != nil {
7465 return nil, err
7466 }
7467 defer googleapi.CloseBody(res)
7468 if err := googleapi.CheckResponse(res); err != nil {
7469 return nil, gensupport.WrapError(err)
7470 }
7471 ret := &GoogleAnalyticsAdminV1alphaBatchGetAccessBindingsResponse{
7472 ServerResponse: googleapi.ServerResponse{
7473 Header: res.Header,
7474 HTTPStatusCode: res.StatusCode,
7475 },
7476 }
7477 target := &ret
7478 if err := gensupport.DecodeResponse(target, res); err != nil {
7479 return nil, err
7480 }
7481 return ret, nil
7482 }
7483
7484 type AccountsAccessBindingsBatchUpdateCall struct {
7485 s *Service
7486 parent string
7487 googleanalyticsadminv1alphabatchupdateaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsRequest
7488 urlParams_ gensupport.URLParams
7489 ctx_ context.Context
7490 header_ http.Header
7491 }
7492
7493
7494
7495
7496
7497
7498
7499 func (r *AccountsAccessBindingsService) BatchUpdate(parent string, googleanalyticsadminv1alphabatchupdateaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsRequest) *AccountsAccessBindingsBatchUpdateCall {
7500 c := &AccountsAccessBindingsBatchUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7501 c.parent = parent
7502 c.googleanalyticsadminv1alphabatchupdateaccessbindingsrequest = googleanalyticsadminv1alphabatchupdateaccessbindingsrequest
7503 return c
7504 }
7505
7506
7507
7508
7509 func (c *AccountsAccessBindingsBatchUpdateCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsBatchUpdateCall {
7510 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7511 return c
7512 }
7513
7514
7515 func (c *AccountsAccessBindingsBatchUpdateCall) Context(ctx context.Context) *AccountsAccessBindingsBatchUpdateCall {
7516 c.ctx_ = ctx
7517 return c
7518 }
7519
7520
7521
7522 func (c *AccountsAccessBindingsBatchUpdateCall) Header() http.Header {
7523 if c.header_ == nil {
7524 c.header_ = make(http.Header)
7525 }
7526 return c.header_
7527 }
7528
7529 func (c *AccountsAccessBindingsBatchUpdateCall) doRequest(alt string) (*http.Response, error) {
7530 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7531 var body io.Reader = nil
7532 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphabatchupdateaccessbindingsrequest)
7533 if err != nil {
7534 return nil, err
7535 }
7536 c.urlParams_.Set("alt", alt)
7537 c.urlParams_.Set("prettyPrint", "false")
7538 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings:batchUpdate")
7539 urls += "?" + c.urlParams_.Encode()
7540 req, err := http.NewRequest("POST", urls, body)
7541 if err != nil {
7542 return nil, err
7543 }
7544 req.Header = reqHeaders
7545 googleapi.Expand(req.URL, map[string]string{
7546 "parent": c.parent,
7547 })
7548 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7549 }
7550
7551
7552
7553
7554
7555
7556
7557 func (c *AccountsAccessBindingsBatchUpdateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsResponse, error) {
7558 gensupport.SetOptions(c.urlParams_, opts...)
7559 res, err := c.doRequest("json")
7560 if res != nil && res.StatusCode == http.StatusNotModified {
7561 if res.Body != nil {
7562 res.Body.Close()
7563 }
7564 return nil, gensupport.WrapError(&googleapi.Error{
7565 Code: res.StatusCode,
7566 Header: res.Header,
7567 })
7568 }
7569 if err != nil {
7570 return nil, err
7571 }
7572 defer googleapi.CloseBody(res)
7573 if err := googleapi.CheckResponse(res); err != nil {
7574 return nil, gensupport.WrapError(err)
7575 }
7576 ret := &GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsResponse{
7577 ServerResponse: googleapi.ServerResponse{
7578 Header: res.Header,
7579 HTTPStatusCode: res.StatusCode,
7580 },
7581 }
7582 target := &ret
7583 if err := gensupport.DecodeResponse(target, res); err != nil {
7584 return nil, err
7585 }
7586 return ret, nil
7587 }
7588
7589 type AccountsAccessBindingsCreateCall struct {
7590 s *Service
7591 parent string
7592 googleanalyticsadminv1alphaaccessbinding *GoogleAnalyticsAdminV1alphaAccessBinding
7593 urlParams_ gensupport.URLParams
7594 ctx_ context.Context
7595 header_ http.Header
7596 }
7597
7598
7599
7600
7601 func (r *AccountsAccessBindingsService) Create(parent string, googleanalyticsadminv1alphaaccessbinding *GoogleAnalyticsAdminV1alphaAccessBinding) *AccountsAccessBindingsCreateCall {
7602 c := &AccountsAccessBindingsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7603 c.parent = parent
7604 c.googleanalyticsadminv1alphaaccessbinding = googleanalyticsadminv1alphaaccessbinding
7605 return c
7606 }
7607
7608
7609
7610
7611 func (c *AccountsAccessBindingsCreateCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsCreateCall {
7612 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7613 return c
7614 }
7615
7616
7617 func (c *AccountsAccessBindingsCreateCall) Context(ctx context.Context) *AccountsAccessBindingsCreateCall {
7618 c.ctx_ = ctx
7619 return c
7620 }
7621
7622
7623
7624 func (c *AccountsAccessBindingsCreateCall) Header() http.Header {
7625 if c.header_ == nil {
7626 c.header_ = make(http.Header)
7627 }
7628 return c.header_
7629 }
7630
7631 func (c *AccountsAccessBindingsCreateCall) doRequest(alt string) (*http.Response, error) {
7632 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7633 var body io.Reader = nil
7634 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaaccessbinding)
7635 if err != nil {
7636 return nil, err
7637 }
7638 c.urlParams_.Set("alt", alt)
7639 c.urlParams_.Set("prettyPrint", "false")
7640 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings")
7641 urls += "?" + c.urlParams_.Encode()
7642 req, err := http.NewRequest("POST", urls, body)
7643 if err != nil {
7644 return nil, err
7645 }
7646 req.Header = reqHeaders
7647 googleapi.Expand(req.URL, map[string]string{
7648 "parent": c.parent,
7649 })
7650 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7651 }
7652
7653
7654
7655
7656
7657
7658
7659 func (c *AccountsAccessBindingsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAccessBinding, error) {
7660 gensupport.SetOptions(c.urlParams_, opts...)
7661 res, err := c.doRequest("json")
7662 if res != nil && res.StatusCode == http.StatusNotModified {
7663 if res.Body != nil {
7664 res.Body.Close()
7665 }
7666 return nil, gensupport.WrapError(&googleapi.Error{
7667 Code: res.StatusCode,
7668 Header: res.Header,
7669 })
7670 }
7671 if err != nil {
7672 return nil, err
7673 }
7674 defer googleapi.CloseBody(res)
7675 if err := googleapi.CheckResponse(res); err != nil {
7676 return nil, gensupport.WrapError(err)
7677 }
7678 ret := &GoogleAnalyticsAdminV1alphaAccessBinding{
7679 ServerResponse: googleapi.ServerResponse{
7680 Header: res.Header,
7681 HTTPStatusCode: res.StatusCode,
7682 },
7683 }
7684 target := &ret
7685 if err := gensupport.DecodeResponse(target, res); err != nil {
7686 return nil, err
7687 }
7688 return ret, nil
7689 }
7690
7691 type AccountsAccessBindingsDeleteCall struct {
7692 s *Service
7693 name string
7694 urlParams_ gensupport.URLParams
7695 ctx_ context.Context
7696 header_ http.Header
7697 }
7698
7699
7700
7701
7702
7703 func (r *AccountsAccessBindingsService) Delete(name string) *AccountsAccessBindingsDeleteCall {
7704 c := &AccountsAccessBindingsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7705 c.name = name
7706 return c
7707 }
7708
7709
7710
7711
7712 func (c *AccountsAccessBindingsDeleteCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsDeleteCall {
7713 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7714 return c
7715 }
7716
7717
7718 func (c *AccountsAccessBindingsDeleteCall) Context(ctx context.Context) *AccountsAccessBindingsDeleteCall {
7719 c.ctx_ = ctx
7720 return c
7721 }
7722
7723
7724
7725 func (c *AccountsAccessBindingsDeleteCall) Header() http.Header {
7726 if c.header_ == nil {
7727 c.header_ = make(http.Header)
7728 }
7729 return c.header_
7730 }
7731
7732 func (c *AccountsAccessBindingsDeleteCall) doRequest(alt string) (*http.Response, error) {
7733 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7734 var body io.Reader = nil
7735 c.urlParams_.Set("alt", alt)
7736 c.urlParams_.Set("prettyPrint", "false")
7737 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
7738 urls += "?" + c.urlParams_.Encode()
7739 req, err := http.NewRequest("DELETE", urls, body)
7740 if err != nil {
7741 return nil, err
7742 }
7743 req.Header = reqHeaders
7744 googleapi.Expand(req.URL, map[string]string{
7745 "name": c.name,
7746 })
7747 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7748 }
7749
7750
7751
7752
7753
7754
7755
7756 func (c *AccountsAccessBindingsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
7757 gensupport.SetOptions(c.urlParams_, opts...)
7758 res, err := c.doRequest("json")
7759 if res != nil && res.StatusCode == http.StatusNotModified {
7760 if res.Body != nil {
7761 res.Body.Close()
7762 }
7763 return nil, gensupport.WrapError(&googleapi.Error{
7764 Code: res.StatusCode,
7765 Header: res.Header,
7766 })
7767 }
7768 if err != nil {
7769 return nil, err
7770 }
7771 defer googleapi.CloseBody(res)
7772 if err := googleapi.CheckResponse(res); err != nil {
7773 return nil, gensupport.WrapError(err)
7774 }
7775 ret := &GoogleProtobufEmpty{
7776 ServerResponse: googleapi.ServerResponse{
7777 Header: res.Header,
7778 HTTPStatusCode: res.StatusCode,
7779 },
7780 }
7781 target := &ret
7782 if err := gensupport.DecodeResponse(target, res); err != nil {
7783 return nil, err
7784 }
7785 return ret, nil
7786 }
7787
7788 type AccountsAccessBindingsGetCall struct {
7789 s *Service
7790 name string
7791 urlParams_ gensupport.URLParams
7792 ifNoneMatch_ string
7793 ctx_ context.Context
7794 header_ http.Header
7795 }
7796
7797
7798
7799
7800
7801
7802 func (r *AccountsAccessBindingsService) Get(name string) *AccountsAccessBindingsGetCall {
7803 c := &AccountsAccessBindingsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7804 c.name = name
7805 return c
7806 }
7807
7808
7809
7810
7811 func (c *AccountsAccessBindingsGetCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsGetCall {
7812 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7813 return c
7814 }
7815
7816
7817
7818
7819 func (c *AccountsAccessBindingsGetCall) IfNoneMatch(entityTag string) *AccountsAccessBindingsGetCall {
7820 c.ifNoneMatch_ = entityTag
7821 return c
7822 }
7823
7824
7825 func (c *AccountsAccessBindingsGetCall) Context(ctx context.Context) *AccountsAccessBindingsGetCall {
7826 c.ctx_ = ctx
7827 return c
7828 }
7829
7830
7831
7832 func (c *AccountsAccessBindingsGetCall) Header() http.Header {
7833 if c.header_ == nil {
7834 c.header_ = make(http.Header)
7835 }
7836 return c.header_
7837 }
7838
7839 func (c *AccountsAccessBindingsGetCall) doRequest(alt string) (*http.Response, error) {
7840 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7841 if c.ifNoneMatch_ != "" {
7842 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7843 }
7844 var body io.Reader = nil
7845 c.urlParams_.Set("alt", alt)
7846 c.urlParams_.Set("prettyPrint", "false")
7847 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
7848 urls += "?" + c.urlParams_.Encode()
7849 req, err := http.NewRequest("GET", urls, body)
7850 if err != nil {
7851 return nil, err
7852 }
7853 req.Header = reqHeaders
7854 googleapi.Expand(req.URL, map[string]string{
7855 "name": c.name,
7856 })
7857 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7858 }
7859
7860
7861
7862
7863
7864
7865
7866 func (c *AccountsAccessBindingsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAccessBinding, error) {
7867 gensupport.SetOptions(c.urlParams_, opts...)
7868 res, err := c.doRequest("json")
7869 if res != nil && res.StatusCode == http.StatusNotModified {
7870 if res.Body != nil {
7871 res.Body.Close()
7872 }
7873 return nil, gensupport.WrapError(&googleapi.Error{
7874 Code: res.StatusCode,
7875 Header: res.Header,
7876 })
7877 }
7878 if err != nil {
7879 return nil, err
7880 }
7881 defer googleapi.CloseBody(res)
7882 if err := googleapi.CheckResponse(res); err != nil {
7883 return nil, gensupport.WrapError(err)
7884 }
7885 ret := &GoogleAnalyticsAdminV1alphaAccessBinding{
7886 ServerResponse: googleapi.ServerResponse{
7887 Header: res.Header,
7888 HTTPStatusCode: res.StatusCode,
7889 },
7890 }
7891 target := &ret
7892 if err := gensupport.DecodeResponse(target, res); err != nil {
7893 return nil, err
7894 }
7895 return ret, nil
7896 }
7897
7898 type AccountsAccessBindingsListCall struct {
7899 s *Service
7900 parent string
7901 urlParams_ gensupport.URLParams
7902 ifNoneMatch_ string
7903 ctx_ context.Context
7904 header_ http.Header
7905 }
7906
7907
7908
7909
7910 func (r *AccountsAccessBindingsService) List(parent string) *AccountsAccessBindingsListCall {
7911 c := &AccountsAccessBindingsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7912 c.parent = parent
7913 return c
7914 }
7915
7916
7917
7918
7919
7920 func (c *AccountsAccessBindingsListCall) PageSize(pageSize int64) *AccountsAccessBindingsListCall {
7921 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
7922 return c
7923 }
7924
7925
7926
7927
7928
7929 func (c *AccountsAccessBindingsListCall) PageToken(pageToken string) *AccountsAccessBindingsListCall {
7930 c.urlParams_.Set("pageToken", pageToken)
7931 return c
7932 }
7933
7934
7935
7936
7937 func (c *AccountsAccessBindingsListCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsListCall {
7938 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7939 return c
7940 }
7941
7942
7943
7944
7945 func (c *AccountsAccessBindingsListCall) IfNoneMatch(entityTag string) *AccountsAccessBindingsListCall {
7946 c.ifNoneMatch_ = entityTag
7947 return c
7948 }
7949
7950
7951 func (c *AccountsAccessBindingsListCall) Context(ctx context.Context) *AccountsAccessBindingsListCall {
7952 c.ctx_ = ctx
7953 return c
7954 }
7955
7956
7957
7958 func (c *AccountsAccessBindingsListCall) Header() http.Header {
7959 if c.header_ == nil {
7960 c.header_ = make(http.Header)
7961 }
7962 return c.header_
7963 }
7964
7965 func (c *AccountsAccessBindingsListCall) doRequest(alt string) (*http.Response, error) {
7966 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7967 if c.ifNoneMatch_ != "" {
7968 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7969 }
7970 var body io.Reader = nil
7971 c.urlParams_.Set("alt", alt)
7972 c.urlParams_.Set("prettyPrint", "false")
7973 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings")
7974 urls += "?" + c.urlParams_.Encode()
7975 req, err := http.NewRequest("GET", urls, body)
7976 if err != nil {
7977 return nil, err
7978 }
7979 req.Header = reqHeaders
7980 googleapi.Expand(req.URL, map[string]string{
7981 "parent": c.parent,
7982 })
7983 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7984 }
7985
7986
7987
7988
7989
7990
7991
7992 func (c *AccountsAccessBindingsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListAccessBindingsResponse, error) {
7993 gensupport.SetOptions(c.urlParams_, opts...)
7994 res, err := c.doRequest("json")
7995 if res != nil && res.StatusCode == http.StatusNotModified {
7996 if res.Body != nil {
7997 res.Body.Close()
7998 }
7999 return nil, gensupport.WrapError(&googleapi.Error{
8000 Code: res.StatusCode,
8001 Header: res.Header,
8002 })
8003 }
8004 if err != nil {
8005 return nil, err
8006 }
8007 defer googleapi.CloseBody(res)
8008 if err := googleapi.CheckResponse(res); err != nil {
8009 return nil, gensupport.WrapError(err)
8010 }
8011 ret := &GoogleAnalyticsAdminV1alphaListAccessBindingsResponse{
8012 ServerResponse: googleapi.ServerResponse{
8013 Header: res.Header,
8014 HTTPStatusCode: res.StatusCode,
8015 },
8016 }
8017 target := &ret
8018 if err := gensupport.DecodeResponse(target, res); err != nil {
8019 return nil, err
8020 }
8021 return ret, nil
8022 }
8023
8024
8025
8026
8027 func (c *AccountsAccessBindingsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListAccessBindingsResponse) error) error {
8028 c.ctx_ = ctx
8029 defer c.PageToken(c.urlParams_.Get("pageToken"))
8030 for {
8031 x, err := c.Do()
8032 if err != nil {
8033 return err
8034 }
8035 if err := f(x); err != nil {
8036 return err
8037 }
8038 if x.NextPageToken == "" {
8039 return nil
8040 }
8041 c.PageToken(x.NextPageToken)
8042 }
8043 }
8044
8045 type AccountsAccessBindingsPatchCall struct {
8046 s *Service
8047 name string
8048 googleanalyticsadminv1alphaaccessbinding *GoogleAnalyticsAdminV1alphaAccessBinding
8049 urlParams_ gensupport.URLParams
8050 ctx_ context.Context
8051 header_ http.Header
8052 }
8053
8054
8055
8056
8057
8058
8059
8060 func (r *AccountsAccessBindingsService) Patch(name string, googleanalyticsadminv1alphaaccessbinding *GoogleAnalyticsAdminV1alphaAccessBinding) *AccountsAccessBindingsPatchCall {
8061 c := &AccountsAccessBindingsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8062 c.name = name
8063 c.googleanalyticsadminv1alphaaccessbinding = googleanalyticsadminv1alphaaccessbinding
8064 return c
8065 }
8066
8067
8068
8069
8070 func (c *AccountsAccessBindingsPatchCall) Fields(s ...googleapi.Field) *AccountsAccessBindingsPatchCall {
8071 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8072 return c
8073 }
8074
8075
8076 func (c *AccountsAccessBindingsPatchCall) Context(ctx context.Context) *AccountsAccessBindingsPatchCall {
8077 c.ctx_ = ctx
8078 return c
8079 }
8080
8081
8082
8083 func (c *AccountsAccessBindingsPatchCall) Header() http.Header {
8084 if c.header_ == nil {
8085 c.header_ = make(http.Header)
8086 }
8087 return c.header_
8088 }
8089
8090 func (c *AccountsAccessBindingsPatchCall) doRequest(alt string) (*http.Response, error) {
8091 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8092 var body io.Reader = nil
8093 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaaccessbinding)
8094 if err != nil {
8095 return nil, err
8096 }
8097 c.urlParams_.Set("alt", alt)
8098 c.urlParams_.Set("prettyPrint", "false")
8099 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
8100 urls += "?" + c.urlParams_.Encode()
8101 req, err := http.NewRequest("PATCH", urls, body)
8102 if err != nil {
8103 return nil, err
8104 }
8105 req.Header = reqHeaders
8106 googleapi.Expand(req.URL, map[string]string{
8107 "name": c.name,
8108 })
8109 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8110 }
8111
8112
8113
8114
8115
8116
8117
8118 func (c *AccountsAccessBindingsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAccessBinding, error) {
8119 gensupport.SetOptions(c.urlParams_, opts...)
8120 res, err := c.doRequest("json")
8121 if res != nil && res.StatusCode == http.StatusNotModified {
8122 if res.Body != nil {
8123 res.Body.Close()
8124 }
8125 return nil, gensupport.WrapError(&googleapi.Error{
8126 Code: res.StatusCode,
8127 Header: res.Header,
8128 })
8129 }
8130 if err != nil {
8131 return nil, err
8132 }
8133 defer googleapi.CloseBody(res)
8134 if err := googleapi.CheckResponse(res); err != nil {
8135 return nil, gensupport.WrapError(err)
8136 }
8137 ret := &GoogleAnalyticsAdminV1alphaAccessBinding{
8138 ServerResponse: googleapi.ServerResponse{
8139 Header: res.Header,
8140 HTTPStatusCode: res.StatusCode,
8141 },
8142 }
8143 target := &ret
8144 if err := gensupport.DecodeResponse(target, res); err != nil {
8145 return nil, err
8146 }
8147 return ret, nil
8148 }
8149
8150 type PropertiesAcknowledgeUserDataCollectionCall struct {
8151 s *Service
8152 property string
8153 googleanalyticsadminv1alphaacknowledgeuserdatacollectionrequest *GoogleAnalyticsAdminV1alphaAcknowledgeUserDataCollectionRequest
8154 urlParams_ gensupport.URLParams
8155 ctx_ context.Context
8156 header_ http.Header
8157 }
8158
8159
8160
8161
8162
8163
8164
8165 func (r *PropertiesService) AcknowledgeUserDataCollection(property string, googleanalyticsadminv1alphaacknowledgeuserdatacollectionrequest *GoogleAnalyticsAdminV1alphaAcknowledgeUserDataCollectionRequest) *PropertiesAcknowledgeUserDataCollectionCall {
8166 c := &PropertiesAcknowledgeUserDataCollectionCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8167 c.property = property
8168 c.googleanalyticsadminv1alphaacknowledgeuserdatacollectionrequest = googleanalyticsadminv1alphaacknowledgeuserdatacollectionrequest
8169 return c
8170 }
8171
8172
8173
8174
8175 func (c *PropertiesAcknowledgeUserDataCollectionCall) Fields(s ...googleapi.Field) *PropertiesAcknowledgeUserDataCollectionCall {
8176 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8177 return c
8178 }
8179
8180
8181 func (c *PropertiesAcknowledgeUserDataCollectionCall) Context(ctx context.Context) *PropertiesAcknowledgeUserDataCollectionCall {
8182 c.ctx_ = ctx
8183 return c
8184 }
8185
8186
8187
8188 func (c *PropertiesAcknowledgeUserDataCollectionCall) Header() http.Header {
8189 if c.header_ == nil {
8190 c.header_ = make(http.Header)
8191 }
8192 return c.header_
8193 }
8194
8195 func (c *PropertiesAcknowledgeUserDataCollectionCall) doRequest(alt string) (*http.Response, error) {
8196 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8197 var body io.Reader = nil
8198 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaacknowledgeuserdatacollectionrequest)
8199 if err != nil {
8200 return nil, err
8201 }
8202 c.urlParams_.Set("alt", alt)
8203 c.urlParams_.Set("prettyPrint", "false")
8204 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+property}:acknowledgeUserDataCollection")
8205 urls += "?" + c.urlParams_.Encode()
8206 req, err := http.NewRequest("POST", urls, body)
8207 if err != nil {
8208 return nil, err
8209 }
8210 req.Header = reqHeaders
8211 googleapi.Expand(req.URL, map[string]string{
8212 "property": c.property,
8213 })
8214 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8215 }
8216
8217
8218
8219
8220
8221
8222
8223 func (c *PropertiesAcknowledgeUserDataCollectionCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAcknowledgeUserDataCollectionResponse, error) {
8224 gensupport.SetOptions(c.urlParams_, opts...)
8225 res, err := c.doRequest("json")
8226 if res != nil && res.StatusCode == http.StatusNotModified {
8227 if res.Body != nil {
8228 res.Body.Close()
8229 }
8230 return nil, gensupport.WrapError(&googleapi.Error{
8231 Code: res.StatusCode,
8232 Header: res.Header,
8233 })
8234 }
8235 if err != nil {
8236 return nil, err
8237 }
8238 defer googleapi.CloseBody(res)
8239 if err := googleapi.CheckResponse(res); err != nil {
8240 return nil, gensupport.WrapError(err)
8241 }
8242 ret := &GoogleAnalyticsAdminV1alphaAcknowledgeUserDataCollectionResponse{
8243 ServerResponse: googleapi.ServerResponse{
8244 Header: res.Header,
8245 HTTPStatusCode: res.StatusCode,
8246 },
8247 }
8248 target := &ret
8249 if err := gensupport.DecodeResponse(target, res); err != nil {
8250 return nil, err
8251 }
8252 return ret, nil
8253 }
8254
8255 type PropertiesCreateCall struct {
8256 s *Service
8257 googleanalyticsadminv1alphaproperty *GoogleAnalyticsAdminV1alphaProperty
8258 urlParams_ gensupport.URLParams
8259 ctx_ context.Context
8260 header_ http.Header
8261 }
8262
8263
8264
8265 func (r *PropertiesService) Create(googleanalyticsadminv1alphaproperty *GoogleAnalyticsAdminV1alphaProperty) *PropertiesCreateCall {
8266 c := &PropertiesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8267 c.googleanalyticsadminv1alphaproperty = googleanalyticsadminv1alphaproperty
8268 return c
8269 }
8270
8271
8272
8273
8274 func (c *PropertiesCreateCall) Fields(s ...googleapi.Field) *PropertiesCreateCall {
8275 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8276 return c
8277 }
8278
8279
8280 func (c *PropertiesCreateCall) Context(ctx context.Context) *PropertiesCreateCall {
8281 c.ctx_ = ctx
8282 return c
8283 }
8284
8285
8286
8287 func (c *PropertiesCreateCall) Header() http.Header {
8288 if c.header_ == nil {
8289 c.header_ = make(http.Header)
8290 }
8291 return c.header_
8292 }
8293
8294 func (c *PropertiesCreateCall) doRequest(alt string) (*http.Response, error) {
8295 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8296 var body io.Reader = nil
8297 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaproperty)
8298 if err != nil {
8299 return nil, err
8300 }
8301 c.urlParams_.Set("alt", alt)
8302 c.urlParams_.Set("prettyPrint", "false")
8303 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties")
8304 urls += "?" + c.urlParams_.Encode()
8305 req, err := http.NewRequest("POST", urls, body)
8306 if err != nil {
8307 return nil, err
8308 }
8309 req.Header = reqHeaders
8310 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8311 }
8312
8313
8314
8315
8316
8317
8318
8319 func (c *PropertiesCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaProperty, error) {
8320 gensupport.SetOptions(c.urlParams_, opts...)
8321 res, err := c.doRequest("json")
8322 if res != nil && res.StatusCode == http.StatusNotModified {
8323 if res.Body != nil {
8324 res.Body.Close()
8325 }
8326 return nil, gensupport.WrapError(&googleapi.Error{
8327 Code: res.StatusCode,
8328 Header: res.Header,
8329 })
8330 }
8331 if err != nil {
8332 return nil, err
8333 }
8334 defer googleapi.CloseBody(res)
8335 if err := googleapi.CheckResponse(res); err != nil {
8336 return nil, gensupport.WrapError(err)
8337 }
8338 ret := &GoogleAnalyticsAdminV1alphaProperty{
8339 ServerResponse: googleapi.ServerResponse{
8340 Header: res.Header,
8341 HTTPStatusCode: res.StatusCode,
8342 },
8343 }
8344 target := &ret
8345 if err := gensupport.DecodeResponse(target, res); err != nil {
8346 return nil, err
8347 }
8348 return ret, nil
8349 }
8350
8351 type PropertiesCreateConnectedSiteTagCall struct {
8352 s *Service
8353 googleanalyticsadminv1alphacreateconnectedsitetagrequest *GoogleAnalyticsAdminV1alphaCreateConnectedSiteTagRequest
8354 urlParams_ gensupport.URLParams
8355 ctx_ context.Context
8356 header_ http.Header
8357 }
8358
8359
8360
8361
8362 func (r *PropertiesService) CreateConnectedSiteTag(googleanalyticsadminv1alphacreateconnectedsitetagrequest *GoogleAnalyticsAdminV1alphaCreateConnectedSiteTagRequest) *PropertiesCreateConnectedSiteTagCall {
8363 c := &PropertiesCreateConnectedSiteTagCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8364 c.googleanalyticsadminv1alphacreateconnectedsitetagrequest = googleanalyticsadminv1alphacreateconnectedsitetagrequest
8365 return c
8366 }
8367
8368
8369
8370
8371 func (c *PropertiesCreateConnectedSiteTagCall) Fields(s ...googleapi.Field) *PropertiesCreateConnectedSiteTagCall {
8372 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8373 return c
8374 }
8375
8376
8377 func (c *PropertiesCreateConnectedSiteTagCall) Context(ctx context.Context) *PropertiesCreateConnectedSiteTagCall {
8378 c.ctx_ = ctx
8379 return c
8380 }
8381
8382
8383
8384 func (c *PropertiesCreateConnectedSiteTagCall) Header() http.Header {
8385 if c.header_ == nil {
8386 c.header_ = make(http.Header)
8387 }
8388 return c.header_
8389 }
8390
8391 func (c *PropertiesCreateConnectedSiteTagCall) doRequest(alt string) (*http.Response, error) {
8392 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8393 var body io.Reader = nil
8394 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacreateconnectedsitetagrequest)
8395 if err != nil {
8396 return nil, err
8397 }
8398 c.urlParams_.Set("alt", alt)
8399 c.urlParams_.Set("prettyPrint", "false")
8400 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties:createConnectedSiteTag")
8401 urls += "?" + c.urlParams_.Encode()
8402 req, err := http.NewRequest("POST", urls, body)
8403 if err != nil {
8404 return nil, err
8405 }
8406 req.Header = reqHeaders
8407 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8408 }
8409
8410
8411
8412
8413
8414
8415
8416 func (c *PropertiesCreateConnectedSiteTagCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCreateConnectedSiteTagResponse, error) {
8417 gensupport.SetOptions(c.urlParams_, opts...)
8418 res, err := c.doRequest("json")
8419 if res != nil && res.StatusCode == http.StatusNotModified {
8420 if res.Body != nil {
8421 res.Body.Close()
8422 }
8423 return nil, gensupport.WrapError(&googleapi.Error{
8424 Code: res.StatusCode,
8425 Header: res.Header,
8426 })
8427 }
8428 if err != nil {
8429 return nil, err
8430 }
8431 defer googleapi.CloseBody(res)
8432 if err := googleapi.CheckResponse(res); err != nil {
8433 return nil, gensupport.WrapError(err)
8434 }
8435 ret := &GoogleAnalyticsAdminV1alphaCreateConnectedSiteTagResponse{
8436 ServerResponse: googleapi.ServerResponse{
8437 Header: res.Header,
8438 HTTPStatusCode: res.StatusCode,
8439 },
8440 }
8441 target := &ret
8442 if err := gensupport.DecodeResponse(target, res); err != nil {
8443 return nil, err
8444 }
8445 return ret, nil
8446 }
8447
8448 type PropertiesCreateRollupPropertyCall struct {
8449 s *Service
8450 googleanalyticsadminv1alphacreaterolluppropertyrequest *GoogleAnalyticsAdminV1alphaCreateRollupPropertyRequest
8451 urlParams_ gensupport.URLParams
8452 ctx_ context.Context
8453 header_ http.Header
8454 }
8455
8456
8457
8458 func (r *PropertiesService) CreateRollupProperty(googleanalyticsadminv1alphacreaterolluppropertyrequest *GoogleAnalyticsAdminV1alphaCreateRollupPropertyRequest) *PropertiesCreateRollupPropertyCall {
8459 c := &PropertiesCreateRollupPropertyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8460 c.googleanalyticsadminv1alphacreaterolluppropertyrequest = googleanalyticsadminv1alphacreaterolluppropertyrequest
8461 return c
8462 }
8463
8464
8465
8466
8467 func (c *PropertiesCreateRollupPropertyCall) Fields(s ...googleapi.Field) *PropertiesCreateRollupPropertyCall {
8468 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8469 return c
8470 }
8471
8472
8473 func (c *PropertiesCreateRollupPropertyCall) Context(ctx context.Context) *PropertiesCreateRollupPropertyCall {
8474 c.ctx_ = ctx
8475 return c
8476 }
8477
8478
8479
8480 func (c *PropertiesCreateRollupPropertyCall) Header() http.Header {
8481 if c.header_ == nil {
8482 c.header_ = make(http.Header)
8483 }
8484 return c.header_
8485 }
8486
8487 func (c *PropertiesCreateRollupPropertyCall) doRequest(alt string) (*http.Response, error) {
8488 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8489 var body io.Reader = nil
8490 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacreaterolluppropertyrequest)
8491 if err != nil {
8492 return nil, err
8493 }
8494 c.urlParams_.Set("alt", alt)
8495 c.urlParams_.Set("prettyPrint", "false")
8496 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties:createRollupProperty")
8497 urls += "?" + c.urlParams_.Encode()
8498 req, err := http.NewRequest("POST", urls, body)
8499 if err != nil {
8500 return nil, err
8501 }
8502 req.Header = reqHeaders
8503 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8504 }
8505
8506
8507
8508
8509
8510
8511
8512 func (c *PropertiesCreateRollupPropertyCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCreateRollupPropertyResponse, error) {
8513 gensupport.SetOptions(c.urlParams_, opts...)
8514 res, err := c.doRequest("json")
8515 if res != nil && res.StatusCode == http.StatusNotModified {
8516 if res.Body != nil {
8517 res.Body.Close()
8518 }
8519 return nil, gensupport.WrapError(&googleapi.Error{
8520 Code: res.StatusCode,
8521 Header: res.Header,
8522 })
8523 }
8524 if err != nil {
8525 return nil, err
8526 }
8527 defer googleapi.CloseBody(res)
8528 if err := googleapi.CheckResponse(res); err != nil {
8529 return nil, gensupport.WrapError(err)
8530 }
8531 ret := &GoogleAnalyticsAdminV1alphaCreateRollupPropertyResponse{
8532 ServerResponse: googleapi.ServerResponse{
8533 Header: res.Header,
8534 HTTPStatusCode: res.StatusCode,
8535 },
8536 }
8537 target := &ret
8538 if err := gensupport.DecodeResponse(target, res); err != nil {
8539 return nil, err
8540 }
8541 return ret, nil
8542 }
8543
8544 type PropertiesCreateSubpropertyCall struct {
8545 s *Service
8546 googleanalyticsadminv1alphacreatesubpropertyrequest *GoogleAnalyticsAdminV1alphaCreateSubpropertyRequest
8547 urlParams_ gensupport.URLParams
8548 ctx_ context.Context
8549 header_ http.Header
8550 }
8551
8552
8553
8554 func (r *PropertiesService) CreateSubproperty(googleanalyticsadminv1alphacreatesubpropertyrequest *GoogleAnalyticsAdminV1alphaCreateSubpropertyRequest) *PropertiesCreateSubpropertyCall {
8555 c := &PropertiesCreateSubpropertyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8556 c.googleanalyticsadminv1alphacreatesubpropertyrequest = googleanalyticsadminv1alphacreatesubpropertyrequest
8557 return c
8558 }
8559
8560
8561
8562
8563 func (c *PropertiesCreateSubpropertyCall) Fields(s ...googleapi.Field) *PropertiesCreateSubpropertyCall {
8564 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8565 return c
8566 }
8567
8568
8569 func (c *PropertiesCreateSubpropertyCall) Context(ctx context.Context) *PropertiesCreateSubpropertyCall {
8570 c.ctx_ = ctx
8571 return c
8572 }
8573
8574
8575
8576 func (c *PropertiesCreateSubpropertyCall) Header() http.Header {
8577 if c.header_ == nil {
8578 c.header_ = make(http.Header)
8579 }
8580 return c.header_
8581 }
8582
8583 func (c *PropertiesCreateSubpropertyCall) doRequest(alt string) (*http.Response, error) {
8584 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8585 var body io.Reader = nil
8586 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacreatesubpropertyrequest)
8587 if err != nil {
8588 return nil, err
8589 }
8590 c.urlParams_.Set("alt", alt)
8591 c.urlParams_.Set("prettyPrint", "false")
8592 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties:createSubproperty")
8593 urls += "?" + c.urlParams_.Encode()
8594 req, err := http.NewRequest("POST", urls, body)
8595 if err != nil {
8596 return nil, err
8597 }
8598 req.Header = reqHeaders
8599 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8600 }
8601
8602
8603
8604
8605
8606
8607
8608 func (c *PropertiesCreateSubpropertyCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCreateSubpropertyResponse, error) {
8609 gensupport.SetOptions(c.urlParams_, opts...)
8610 res, err := c.doRequest("json")
8611 if res != nil && res.StatusCode == http.StatusNotModified {
8612 if res.Body != nil {
8613 res.Body.Close()
8614 }
8615 return nil, gensupport.WrapError(&googleapi.Error{
8616 Code: res.StatusCode,
8617 Header: res.Header,
8618 })
8619 }
8620 if err != nil {
8621 return nil, err
8622 }
8623 defer googleapi.CloseBody(res)
8624 if err := googleapi.CheckResponse(res); err != nil {
8625 return nil, gensupport.WrapError(err)
8626 }
8627 ret := &GoogleAnalyticsAdminV1alphaCreateSubpropertyResponse{
8628 ServerResponse: googleapi.ServerResponse{
8629 Header: res.Header,
8630 HTTPStatusCode: res.StatusCode,
8631 },
8632 }
8633 target := &ret
8634 if err := gensupport.DecodeResponse(target, res); err != nil {
8635 return nil, err
8636 }
8637 return ret, nil
8638 }
8639
8640 type PropertiesDeleteCall struct {
8641 s *Service
8642 name string
8643 urlParams_ gensupport.URLParams
8644 ctx_ context.Context
8645 header_ http.Header
8646 }
8647
8648
8649
8650
8651
8652
8653
8654
8655
8656
8657
8658 func (r *PropertiesService) Delete(name string) *PropertiesDeleteCall {
8659 c := &PropertiesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8660 c.name = name
8661 return c
8662 }
8663
8664
8665
8666
8667 func (c *PropertiesDeleteCall) Fields(s ...googleapi.Field) *PropertiesDeleteCall {
8668 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8669 return c
8670 }
8671
8672
8673 func (c *PropertiesDeleteCall) Context(ctx context.Context) *PropertiesDeleteCall {
8674 c.ctx_ = ctx
8675 return c
8676 }
8677
8678
8679
8680 func (c *PropertiesDeleteCall) Header() http.Header {
8681 if c.header_ == nil {
8682 c.header_ = make(http.Header)
8683 }
8684 return c.header_
8685 }
8686
8687 func (c *PropertiesDeleteCall) doRequest(alt string) (*http.Response, error) {
8688 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8689 var body io.Reader = nil
8690 c.urlParams_.Set("alt", alt)
8691 c.urlParams_.Set("prettyPrint", "false")
8692 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
8693 urls += "?" + c.urlParams_.Encode()
8694 req, err := http.NewRequest("DELETE", urls, body)
8695 if err != nil {
8696 return nil, err
8697 }
8698 req.Header = reqHeaders
8699 googleapi.Expand(req.URL, map[string]string{
8700 "name": c.name,
8701 })
8702 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8703 }
8704
8705
8706
8707
8708
8709
8710
8711 func (c *PropertiesDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaProperty, error) {
8712 gensupport.SetOptions(c.urlParams_, opts...)
8713 res, err := c.doRequest("json")
8714 if res != nil && res.StatusCode == http.StatusNotModified {
8715 if res.Body != nil {
8716 res.Body.Close()
8717 }
8718 return nil, gensupport.WrapError(&googleapi.Error{
8719 Code: res.StatusCode,
8720 Header: res.Header,
8721 })
8722 }
8723 if err != nil {
8724 return nil, err
8725 }
8726 defer googleapi.CloseBody(res)
8727 if err := googleapi.CheckResponse(res); err != nil {
8728 return nil, gensupport.WrapError(err)
8729 }
8730 ret := &GoogleAnalyticsAdminV1alphaProperty{
8731 ServerResponse: googleapi.ServerResponse{
8732 Header: res.Header,
8733 HTTPStatusCode: res.StatusCode,
8734 },
8735 }
8736 target := &ret
8737 if err := gensupport.DecodeResponse(target, res); err != nil {
8738 return nil, err
8739 }
8740 return ret, nil
8741 }
8742
8743 type PropertiesDeleteConnectedSiteTagCall struct {
8744 s *Service
8745 googleanalyticsadminv1alphadeleteconnectedsitetagrequest *GoogleAnalyticsAdminV1alphaDeleteConnectedSiteTagRequest
8746 urlParams_ gensupport.URLParams
8747 ctx_ context.Context
8748 header_ http.Header
8749 }
8750
8751
8752
8753 func (r *PropertiesService) DeleteConnectedSiteTag(googleanalyticsadminv1alphadeleteconnectedsitetagrequest *GoogleAnalyticsAdminV1alphaDeleteConnectedSiteTagRequest) *PropertiesDeleteConnectedSiteTagCall {
8754 c := &PropertiesDeleteConnectedSiteTagCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8755 c.googleanalyticsadminv1alphadeleteconnectedsitetagrequest = googleanalyticsadminv1alphadeleteconnectedsitetagrequest
8756 return c
8757 }
8758
8759
8760
8761
8762 func (c *PropertiesDeleteConnectedSiteTagCall) Fields(s ...googleapi.Field) *PropertiesDeleteConnectedSiteTagCall {
8763 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8764 return c
8765 }
8766
8767
8768 func (c *PropertiesDeleteConnectedSiteTagCall) Context(ctx context.Context) *PropertiesDeleteConnectedSiteTagCall {
8769 c.ctx_ = ctx
8770 return c
8771 }
8772
8773
8774
8775 func (c *PropertiesDeleteConnectedSiteTagCall) Header() http.Header {
8776 if c.header_ == nil {
8777 c.header_ = make(http.Header)
8778 }
8779 return c.header_
8780 }
8781
8782 func (c *PropertiesDeleteConnectedSiteTagCall) doRequest(alt string) (*http.Response, error) {
8783 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8784 var body io.Reader = nil
8785 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphadeleteconnectedsitetagrequest)
8786 if err != nil {
8787 return nil, err
8788 }
8789 c.urlParams_.Set("alt", alt)
8790 c.urlParams_.Set("prettyPrint", "false")
8791 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties:deleteConnectedSiteTag")
8792 urls += "?" + c.urlParams_.Encode()
8793 req, err := http.NewRequest("POST", urls, body)
8794 if err != nil {
8795 return nil, err
8796 }
8797 req.Header = reqHeaders
8798 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8799 }
8800
8801
8802
8803
8804
8805
8806
8807 func (c *PropertiesDeleteConnectedSiteTagCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
8808 gensupport.SetOptions(c.urlParams_, opts...)
8809 res, err := c.doRequest("json")
8810 if res != nil && res.StatusCode == http.StatusNotModified {
8811 if res.Body != nil {
8812 res.Body.Close()
8813 }
8814 return nil, gensupport.WrapError(&googleapi.Error{
8815 Code: res.StatusCode,
8816 Header: res.Header,
8817 })
8818 }
8819 if err != nil {
8820 return nil, err
8821 }
8822 defer googleapi.CloseBody(res)
8823 if err := googleapi.CheckResponse(res); err != nil {
8824 return nil, gensupport.WrapError(err)
8825 }
8826 ret := &GoogleProtobufEmpty{
8827 ServerResponse: googleapi.ServerResponse{
8828 Header: res.Header,
8829 HTTPStatusCode: res.StatusCode,
8830 },
8831 }
8832 target := &ret
8833 if err := gensupport.DecodeResponse(target, res); err != nil {
8834 return nil, err
8835 }
8836 return ret, nil
8837 }
8838
8839 type PropertiesFetchAutomatedGa4ConfigurationOptOutCall struct {
8840 s *Service
8841 googleanalyticsadminv1alphafetchautomatedga4configurationoptoutrequest *GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutRequest
8842 urlParams_ gensupport.URLParams
8843 ctx_ context.Context
8844 header_ http.Header
8845 }
8846
8847
8848
8849
8850 func (r *PropertiesService) FetchAutomatedGa4ConfigurationOptOut(googleanalyticsadminv1alphafetchautomatedga4configurationoptoutrequest *GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutRequest) *PropertiesFetchAutomatedGa4ConfigurationOptOutCall {
8851 c := &PropertiesFetchAutomatedGa4ConfigurationOptOutCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8852 c.googleanalyticsadminv1alphafetchautomatedga4configurationoptoutrequest = googleanalyticsadminv1alphafetchautomatedga4configurationoptoutrequest
8853 return c
8854 }
8855
8856
8857
8858
8859 func (c *PropertiesFetchAutomatedGa4ConfigurationOptOutCall) Fields(s ...googleapi.Field) *PropertiesFetchAutomatedGa4ConfigurationOptOutCall {
8860 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8861 return c
8862 }
8863
8864
8865 func (c *PropertiesFetchAutomatedGa4ConfigurationOptOutCall) Context(ctx context.Context) *PropertiesFetchAutomatedGa4ConfigurationOptOutCall {
8866 c.ctx_ = ctx
8867 return c
8868 }
8869
8870
8871
8872 func (c *PropertiesFetchAutomatedGa4ConfigurationOptOutCall) Header() http.Header {
8873 if c.header_ == nil {
8874 c.header_ = make(http.Header)
8875 }
8876 return c.header_
8877 }
8878
8879 func (c *PropertiesFetchAutomatedGa4ConfigurationOptOutCall) doRequest(alt string) (*http.Response, error) {
8880 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8881 var body io.Reader = nil
8882 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphafetchautomatedga4configurationoptoutrequest)
8883 if err != nil {
8884 return nil, err
8885 }
8886 c.urlParams_.Set("alt", alt)
8887 c.urlParams_.Set("prettyPrint", "false")
8888 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties:fetchAutomatedGa4ConfigurationOptOut")
8889 urls += "?" + c.urlParams_.Encode()
8890 req, err := http.NewRequest("POST", urls, body)
8891 if err != nil {
8892 return nil, err
8893 }
8894 req.Header = reqHeaders
8895 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8896 }
8897
8898
8899
8900
8901
8902
8903
8904 func (c *PropertiesFetchAutomatedGa4ConfigurationOptOutCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutResponse, error) {
8905 gensupport.SetOptions(c.urlParams_, opts...)
8906 res, err := c.doRequest("json")
8907 if res != nil && res.StatusCode == http.StatusNotModified {
8908 if res.Body != nil {
8909 res.Body.Close()
8910 }
8911 return nil, gensupport.WrapError(&googleapi.Error{
8912 Code: res.StatusCode,
8913 Header: res.Header,
8914 })
8915 }
8916 if err != nil {
8917 return nil, err
8918 }
8919 defer googleapi.CloseBody(res)
8920 if err := googleapi.CheckResponse(res); err != nil {
8921 return nil, gensupport.WrapError(err)
8922 }
8923 ret := &GoogleAnalyticsAdminV1alphaFetchAutomatedGa4ConfigurationOptOutResponse{
8924 ServerResponse: googleapi.ServerResponse{
8925 Header: res.Header,
8926 HTTPStatusCode: res.StatusCode,
8927 },
8928 }
8929 target := &ret
8930 if err := gensupport.DecodeResponse(target, res); err != nil {
8931 return nil, err
8932 }
8933 return ret, nil
8934 }
8935
8936 type PropertiesFetchConnectedGa4PropertyCall struct {
8937 s *Service
8938 urlParams_ gensupport.URLParams
8939 ifNoneMatch_ string
8940 ctx_ context.Context
8941 header_ http.Header
8942 }
8943
8944
8945
8946 func (r *PropertiesService) FetchConnectedGa4Property() *PropertiesFetchConnectedGa4PropertyCall {
8947 c := &PropertiesFetchConnectedGa4PropertyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8948 return c
8949 }
8950
8951
8952
8953
8954
8955 func (c *PropertiesFetchConnectedGa4PropertyCall) Property(property string) *PropertiesFetchConnectedGa4PropertyCall {
8956 c.urlParams_.Set("property", property)
8957 return c
8958 }
8959
8960
8961
8962
8963 func (c *PropertiesFetchConnectedGa4PropertyCall) Fields(s ...googleapi.Field) *PropertiesFetchConnectedGa4PropertyCall {
8964 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8965 return c
8966 }
8967
8968
8969
8970
8971 func (c *PropertiesFetchConnectedGa4PropertyCall) IfNoneMatch(entityTag string) *PropertiesFetchConnectedGa4PropertyCall {
8972 c.ifNoneMatch_ = entityTag
8973 return c
8974 }
8975
8976
8977 func (c *PropertiesFetchConnectedGa4PropertyCall) Context(ctx context.Context) *PropertiesFetchConnectedGa4PropertyCall {
8978 c.ctx_ = ctx
8979 return c
8980 }
8981
8982
8983
8984 func (c *PropertiesFetchConnectedGa4PropertyCall) Header() http.Header {
8985 if c.header_ == nil {
8986 c.header_ = make(http.Header)
8987 }
8988 return c.header_
8989 }
8990
8991 func (c *PropertiesFetchConnectedGa4PropertyCall) doRequest(alt string) (*http.Response, error) {
8992 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8993 if c.ifNoneMatch_ != "" {
8994 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8995 }
8996 var body io.Reader = nil
8997 c.urlParams_.Set("alt", alt)
8998 c.urlParams_.Set("prettyPrint", "false")
8999 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties:fetchConnectedGa4Property")
9000 urls += "?" + c.urlParams_.Encode()
9001 req, err := http.NewRequest("GET", urls, body)
9002 if err != nil {
9003 return nil, err
9004 }
9005 req.Header = reqHeaders
9006 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9007 }
9008
9009
9010
9011
9012
9013
9014
9015 func (c *PropertiesFetchConnectedGa4PropertyCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaFetchConnectedGa4PropertyResponse, error) {
9016 gensupport.SetOptions(c.urlParams_, opts...)
9017 res, err := c.doRequest("json")
9018 if res != nil && res.StatusCode == http.StatusNotModified {
9019 if res.Body != nil {
9020 res.Body.Close()
9021 }
9022 return nil, gensupport.WrapError(&googleapi.Error{
9023 Code: res.StatusCode,
9024 Header: res.Header,
9025 })
9026 }
9027 if err != nil {
9028 return nil, err
9029 }
9030 defer googleapi.CloseBody(res)
9031 if err := googleapi.CheckResponse(res); err != nil {
9032 return nil, gensupport.WrapError(err)
9033 }
9034 ret := &GoogleAnalyticsAdminV1alphaFetchConnectedGa4PropertyResponse{
9035 ServerResponse: googleapi.ServerResponse{
9036 Header: res.Header,
9037 HTTPStatusCode: res.StatusCode,
9038 },
9039 }
9040 target := &ret
9041 if err := gensupport.DecodeResponse(target, res); err != nil {
9042 return nil, err
9043 }
9044 return ret, nil
9045 }
9046
9047 type PropertiesGetCall struct {
9048 s *Service
9049 name string
9050 urlParams_ gensupport.URLParams
9051 ifNoneMatch_ string
9052 ctx_ context.Context
9053 header_ http.Header
9054 }
9055
9056
9057
9058
9059
9060 func (r *PropertiesService) Get(name string) *PropertiesGetCall {
9061 c := &PropertiesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9062 c.name = name
9063 return c
9064 }
9065
9066
9067
9068
9069 func (c *PropertiesGetCall) Fields(s ...googleapi.Field) *PropertiesGetCall {
9070 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9071 return c
9072 }
9073
9074
9075
9076
9077 func (c *PropertiesGetCall) IfNoneMatch(entityTag string) *PropertiesGetCall {
9078 c.ifNoneMatch_ = entityTag
9079 return c
9080 }
9081
9082
9083 func (c *PropertiesGetCall) Context(ctx context.Context) *PropertiesGetCall {
9084 c.ctx_ = ctx
9085 return c
9086 }
9087
9088
9089
9090 func (c *PropertiesGetCall) Header() http.Header {
9091 if c.header_ == nil {
9092 c.header_ = make(http.Header)
9093 }
9094 return c.header_
9095 }
9096
9097 func (c *PropertiesGetCall) doRequest(alt string) (*http.Response, error) {
9098 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9099 if c.ifNoneMatch_ != "" {
9100 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9101 }
9102 var body io.Reader = nil
9103 c.urlParams_.Set("alt", alt)
9104 c.urlParams_.Set("prettyPrint", "false")
9105 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
9106 urls += "?" + c.urlParams_.Encode()
9107 req, err := http.NewRequest("GET", urls, body)
9108 if err != nil {
9109 return nil, err
9110 }
9111 req.Header = reqHeaders
9112 googleapi.Expand(req.URL, map[string]string{
9113 "name": c.name,
9114 })
9115 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9116 }
9117
9118
9119
9120
9121
9122
9123
9124 func (c *PropertiesGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaProperty, error) {
9125 gensupport.SetOptions(c.urlParams_, opts...)
9126 res, err := c.doRequest("json")
9127 if res != nil && res.StatusCode == http.StatusNotModified {
9128 if res.Body != nil {
9129 res.Body.Close()
9130 }
9131 return nil, gensupport.WrapError(&googleapi.Error{
9132 Code: res.StatusCode,
9133 Header: res.Header,
9134 })
9135 }
9136 if err != nil {
9137 return nil, err
9138 }
9139 defer googleapi.CloseBody(res)
9140 if err := googleapi.CheckResponse(res); err != nil {
9141 return nil, gensupport.WrapError(err)
9142 }
9143 ret := &GoogleAnalyticsAdminV1alphaProperty{
9144 ServerResponse: googleapi.ServerResponse{
9145 Header: res.Header,
9146 HTTPStatusCode: res.StatusCode,
9147 },
9148 }
9149 target := &ret
9150 if err := gensupport.DecodeResponse(target, res); err != nil {
9151 return nil, err
9152 }
9153 return ret, nil
9154 }
9155
9156 type PropertiesGetAttributionSettingsCall struct {
9157 s *Service
9158 name string
9159 urlParams_ gensupport.URLParams
9160 ifNoneMatch_ string
9161 ctx_ context.Context
9162 header_ http.Header
9163 }
9164
9165
9166
9167
9168
9169 func (r *PropertiesService) GetAttributionSettings(name string) *PropertiesGetAttributionSettingsCall {
9170 c := &PropertiesGetAttributionSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9171 c.name = name
9172 return c
9173 }
9174
9175
9176
9177
9178 func (c *PropertiesGetAttributionSettingsCall) Fields(s ...googleapi.Field) *PropertiesGetAttributionSettingsCall {
9179 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9180 return c
9181 }
9182
9183
9184
9185
9186 func (c *PropertiesGetAttributionSettingsCall) IfNoneMatch(entityTag string) *PropertiesGetAttributionSettingsCall {
9187 c.ifNoneMatch_ = entityTag
9188 return c
9189 }
9190
9191
9192 func (c *PropertiesGetAttributionSettingsCall) Context(ctx context.Context) *PropertiesGetAttributionSettingsCall {
9193 c.ctx_ = ctx
9194 return c
9195 }
9196
9197
9198
9199 func (c *PropertiesGetAttributionSettingsCall) Header() http.Header {
9200 if c.header_ == nil {
9201 c.header_ = make(http.Header)
9202 }
9203 return c.header_
9204 }
9205
9206 func (c *PropertiesGetAttributionSettingsCall) doRequest(alt string) (*http.Response, error) {
9207 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9208 if c.ifNoneMatch_ != "" {
9209 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9210 }
9211 var body io.Reader = nil
9212 c.urlParams_.Set("alt", alt)
9213 c.urlParams_.Set("prettyPrint", "false")
9214 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
9215 urls += "?" + c.urlParams_.Encode()
9216 req, err := http.NewRequest("GET", urls, body)
9217 if err != nil {
9218 return nil, err
9219 }
9220 req.Header = reqHeaders
9221 googleapi.Expand(req.URL, map[string]string{
9222 "name": c.name,
9223 })
9224 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9225 }
9226
9227
9228
9229
9230
9231
9232
9233 func (c *PropertiesGetAttributionSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAttributionSettings, error) {
9234 gensupport.SetOptions(c.urlParams_, opts...)
9235 res, err := c.doRequest("json")
9236 if res != nil && res.StatusCode == http.StatusNotModified {
9237 if res.Body != nil {
9238 res.Body.Close()
9239 }
9240 return nil, gensupport.WrapError(&googleapi.Error{
9241 Code: res.StatusCode,
9242 Header: res.Header,
9243 })
9244 }
9245 if err != nil {
9246 return nil, err
9247 }
9248 defer googleapi.CloseBody(res)
9249 if err := googleapi.CheckResponse(res); err != nil {
9250 return nil, gensupport.WrapError(err)
9251 }
9252 ret := &GoogleAnalyticsAdminV1alphaAttributionSettings{
9253 ServerResponse: googleapi.ServerResponse{
9254 Header: res.Header,
9255 HTTPStatusCode: res.StatusCode,
9256 },
9257 }
9258 target := &ret
9259 if err := gensupport.DecodeResponse(target, res); err != nil {
9260 return nil, err
9261 }
9262 return ret, nil
9263 }
9264
9265 type PropertiesGetDataRetentionSettingsCall struct {
9266 s *Service
9267 name string
9268 urlParams_ gensupport.URLParams
9269 ifNoneMatch_ string
9270 ctx_ context.Context
9271 header_ http.Header
9272 }
9273
9274
9275
9276
9277
9278
9279
9280 func (r *PropertiesService) GetDataRetentionSettings(name string) *PropertiesGetDataRetentionSettingsCall {
9281 c := &PropertiesGetDataRetentionSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9282 c.name = name
9283 return c
9284 }
9285
9286
9287
9288
9289 func (c *PropertiesGetDataRetentionSettingsCall) Fields(s ...googleapi.Field) *PropertiesGetDataRetentionSettingsCall {
9290 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9291 return c
9292 }
9293
9294
9295
9296
9297 func (c *PropertiesGetDataRetentionSettingsCall) IfNoneMatch(entityTag string) *PropertiesGetDataRetentionSettingsCall {
9298 c.ifNoneMatch_ = entityTag
9299 return c
9300 }
9301
9302
9303 func (c *PropertiesGetDataRetentionSettingsCall) Context(ctx context.Context) *PropertiesGetDataRetentionSettingsCall {
9304 c.ctx_ = ctx
9305 return c
9306 }
9307
9308
9309
9310 func (c *PropertiesGetDataRetentionSettingsCall) Header() http.Header {
9311 if c.header_ == nil {
9312 c.header_ = make(http.Header)
9313 }
9314 return c.header_
9315 }
9316
9317 func (c *PropertiesGetDataRetentionSettingsCall) doRequest(alt string) (*http.Response, error) {
9318 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9319 if c.ifNoneMatch_ != "" {
9320 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9321 }
9322 var body io.Reader = nil
9323 c.urlParams_.Set("alt", alt)
9324 c.urlParams_.Set("prettyPrint", "false")
9325 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
9326 urls += "?" + c.urlParams_.Encode()
9327 req, err := http.NewRequest("GET", urls, body)
9328 if err != nil {
9329 return nil, err
9330 }
9331 req.Header = reqHeaders
9332 googleapi.Expand(req.URL, map[string]string{
9333 "name": c.name,
9334 })
9335 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9336 }
9337
9338
9339
9340
9341
9342
9343
9344 func (c *PropertiesGetDataRetentionSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDataRetentionSettings, error) {
9345 gensupport.SetOptions(c.urlParams_, opts...)
9346 res, err := c.doRequest("json")
9347 if res != nil && res.StatusCode == http.StatusNotModified {
9348 if res.Body != nil {
9349 res.Body.Close()
9350 }
9351 return nil, gensupport.WrapError(&googleapi.Error{
9352 Code: res.StatusCode,
9353 Header: res.Header,
9354 })
9355 }
9356 if err != nil {
9357 return nil, err
9358 }
9359 defer googleapi.CloseBody(res)
9360 if err := googleapi.CheckResponse(res); err != nil {
9361 return nil, gensupport.WrapError(err)
9362 }
9363 ret := &GoogleAnalyticsAdminV1alphaDataRetentionSettings{
9364 ServerResponse: googleapi.ServerResponse{
9365 Header: res.Header,
9366 HTTPStatusCode: res.StatusCode,
9367 },
9368 }
9369 target := &ret
9370 if err := gensupport.DecodeResponse(target, res); err != nil {
9371 return nil, err
9372 }
9373 return ret, nil
9374 }
9375
9376 type PropertiesGetGoogleSignalsSettingsCall struct {
9377 s *Service
9378 name string
9379 urlParams_ gensupport.URLParams
9380 ifNoneMatch_ string
9381 ctx_ context.Context
9382 header_ http.Header
9383 }
9384
9385
9386
9387
9388
9389 func (r *PropertiesService) GetGoogleSignalsSettings(name string) *PropertiesGetGoogleSignalsSettingsCall {
9390 c := &PropertiesGetGoogleSignalsSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9391 c.name = name
9392 return c
9393 }
9394
9395
9396
9397
9398 func (c *PropertiesGetGoogleSignalsSettingsCall) Fields(s ...googleapi.Field) *PropertiesGetGoogleSignalsSettingsCall {
9399 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9400 return c
9401 }
9402
9403
9404
9405
9406 func (c *PropertiesGetGoogleSignalsSettingsCall) IfNoneMatch(entityTag string) *PropertiesGetGoogleSignalsSettingsCall {
9407 c.ifNoneMatch_ = entityTag
9408 return c
9409 }
9410
9411
9412 func (c *PropertiesGetGoogleSignalsSettingsCall) Context(ctx context.Context) *PropertiesGetGoogleSignalsSettingsCall {
9413 c.ctx_ = ctx
9414 return c
9415 }
9416
9417
9418
9419 func (c *PropertiesGetGoogleSignalsSettingsCall) Header() http.Header {
9420 if c.header_ == nil {
9421 c.header_ = make(http.Header)
9422 }
9423 return c.header_
9424 }
9425
9426 func (c *PropertiesGetGoogleSignalsSettingsCall) doRequest(alt string) (*http.Response, error) {
9427 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9428 if c.ifNoneMatch_ != "" {
9429 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9430 }
9431 var body io.Reader = nil
9432 c.urlParams_.Set("alt", alt)
9433 c.urlParams_.Set("prettyPrint", "false")
9434 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
9435 urls += "?" + c.urlParams_.Encode()
9436 req, err := http.NewRequest("GET", urls, body)
9437 if err != nil {
9438 return nil, err
9439 }
9440 req.Header = reqHeaders
9441 googleapi.Expand(req.URL, map[string]string{
9442 "name": c.name,
9443 })
9444 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9445 }
9446
9447
9448
9449
9450
9451
9452
9453 func (c *PropertiesGetGoogleSignalsSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaGoogleSignalsSettings, error) {
9454 gensupport.SetOptions(c.urlParams_, opts...)
9455 res, err := c.doRequest("json")
9456 if res != nil && res.StatusCode == http.StatusNotModified {
9457 if res.Body != nil {
9458 res.Body.Close()
9459 }
9460 return nil, gensupport.WrapError(&googleapi.Error{
9461 Code: res.StatusCode,
9462 Header: res.Header,
9463 })
9464 }
9465 if err != nil {
9466 return nil, err
9467 }
9468 defer googleapi.CloseBody(res)
9469 if err := googleapi.CheckResponse(res); err != nil {
9470 return nil, gensupport.WrapError(err)
9471 }
9472 ret := &GoogleAnalyticsAdminV1alphaGoogleSignalsSettings{
9473 ServerResponse: googleapi.ServerResponse{
9474 Header: res.Header,
9475 HTTPStatusCode: res.StatusCode,
9476 },
9477 }
9478 target := &ret
9479 if err := gensupport.DecodeResponse(target, res); err != nil {
9480 return nil, err
9481 }
9482 return ret, nil
9483 }
9484
9485 type PropertiesListCall struct {
9486 s *Service
9487 urlParams_ gensupport.URLParams
9488 ifNoneMatch_ string
9489 ctx_ context.Context
9490 header_ http.Header
9491 }
9492
9493
9494
9495
9496
9497 func (r *PropertiesService) List() *PropertiesListCall {
9498 c := &PropertiesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9499 return c
9500 }
9501
9502
9503
9504
9505
9506
9507
9508
9509
9510
9511
9512
9513
9514 func (c *PropertiesListCall) Filter(filter string) *PropertiesListCall {
9515 c.urlParams_.Set("filter", filter)
9516 return c
9517 }
9518
9519
9520
9521
9522
9523
9524 func (c *PropertiesListCall) PageSize(pageSize int64) *PropertiesListCall {
9525 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9526 return c
9527 }
9528
9529
9530
9531
9532
9533 func (c *PropertiesListCall) PageToken(pageToken string) *PropertiesListCall {
9534 c.urlParams_.Set("pageToken", pageToken)
9535 return c
9536 }
9537
9538
9539
9540
9541 func (c *PropertiesListCall) ShowDeleted(showDeleted bool) *PropertiesListCall {
9542 c.urlParams_.Set("showDeleted", fmt.Sprint(showDeleted))
9543 return c
9544 }
9545
9546
9547
9548
9549 func (c *PropertiesListCall) Fields(s ...googleapi.Field) *PropertiesListCall {
9550 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9551 return c
9552 }
9553
9554
9555
9556
9557 func (c *PropertiesListCall) IfNoneMatch(entityTag string) *PropertiesListCall {
9558 c.ifNoneMatch_ = entityTag
9559 return c
9560 }
9561
9562
9563 func (c *PropertiesListCall) Context(ctx context.Context) *PropertiesListCall {
9564 c.ctx_ = ctx
9565 return c
9566 }
9567
9568
9569
9570 func (c *PropertiesListCall) Header() http.Header {
9571 if c.header_ == nil {
9572 c.header_ = make(http.Header)
9573 }
9574 return c.header_
9575 }
9576
9577 func (c *PropertiesListCall) doRequest(alt string) (*http.Response, error) {
9578 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9579 if c.ifNoneMatch_ != "" {
9580 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9581 }
9582 var body io.Reader = nil
9583 c.urlParams_.Set("alt", alt)
9584 c.urlParams_.Set("prettyPrint", "false")
9585 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties")
9586 urls += "?" + c.urlParams_.Encode()
9587 req, err := http.NewRequest("GET", urls, body)
9588 if err != nil {
9589 return nil, err
9590 }
9591 req.Header = reqHeaders
9592 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9593 }
9594
9595
9596
9597
9598
9599
9600
9601 func (c *PropertiesListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListPropertiesResponse, error) {
9602 gensupport.SetOptions(c.urlParams_, opts...)
9603 res, err := c.doRequest("json")
9604 if res != nil && res.StatusCode == http.StatusNotModified {
9605 if res.Body != nil {
9606 res.Body.Close()
9607 }
9608 return nil, gensupport.WrapError(&googleapi.Error{
9609 Code: res.StatusCode,
9610 Header: res.Header,
9611 })
9612 }
9613 if err != nil {
9614 return nil, err
9615 }
9616 defer googleapi.CloseBody(res)
9617 if err := googleapi.CheckResponse(res); err != nil {
9618 return nil, gensupport.WrapError(err)
9619 }
9620 ret := &GoogleAnalyticsAdminV1alphaListPropertiesResponse{
9621 ServerResponse: googleapi.ServerResponse{
9622 Header: res.Header,
9623 HTTPStatusCode: res.StatusCode,
9624 },
9625 }
9626 target := &ret
9627 if err := gensupport.DecodeResponse(target, res); err != nil {
9628 return nil, err
9629 }
9630 return ret, nil
9631 }
9632
9633
9634
9635
9636 func (c *PropertiesListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListPropertiesResponse) error) error {
9637 c.ctx_ = ctx
9638 defer c.PageToken(c.urlParams_.Get("pageToken"))
9639 for {
9640 x, err := c.Do()
9641 if err != nil {
9642 return err
9643 }
9644 if err := f(x); err != nil {
9645 return err
9646 }
9647 if x.NextPageToken == "" {
9648 return nil
9649 }
9650 c.PageToken(x.NextPageToken)
9651 }
9652 }
9653
9654 type PropertiesListConnectedSiteTagsCall struct {
9655 s *Service
9656 googleanalyticsadminv1alphalistconnectedsitetagsrequest *GoogleAnalyticsAdminV1alphaListConnectedSiteTagsRequest
9657 urlParams_ gensupport.URLParams
9658 ctx_ context.Context
9659 header_ http.Header
9660 }
9661
9662
9663
9664
9665 func (r *PropertiesService) ListConnectedSiteTags(googleanalyticsadminv1alphalistconnectedsitetagsrequest *GoogleAnalyticsAdminV1alphaListConnectedSiteTagsRequest) *PropertiesListConnectedSiteTagsCall {
9666 c := &PropertiesListConnectedSiteTagsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9667 c.googleanalyticsadminv1alphalistconnectedsitetagsrequest = googleanalyticsadminv1alphalistconnectedsitetagsrequest
9668 return c
9669 }
9670
9671
9672
9673
9674 func (c *PropertiesListConnectedSiteTagsCall) Fields(s ...googleapi.Field) *PropertiesListConnectedSiteTagsCall {
9675 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9676 return c
9677 }
9678
9679
9680 func (c *PropertiesListConnectedSiteTagsCall) Context(ctx context.Context) *PropertiesListConnectedSiteTagsCall {
9681 c.ctx_ = ctx
9682 return c
9683 }
9684
9685
9686
9687 func (c *PropertiesListConnectedSiteTagsCall) Header() http.Header {
9688 if c.header_ == nil {
9689 c.header_ = make(http.Header)
9690 }
9691 return c.header_
9692 }
9693
9694 func (c *PropertiesListConnectedSiteTagsCall) doRequest(alt string) (*http.Response, error) {
9695 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9696 var body io.Reader = nil
9697 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphalistconnectedsitetagsrequest)
9698 if err != nil {
9699 return nil, err
9700 }
9701 c.urlParams_.Set("alt", alt)
9702 c.urlParams_.Set("prettyPrint", "false")
9703 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties:listConnectedSiteTags")
9704 urls += "?" + c.urlParams_.Encode()
9705 req, err := http.NewRequest("POST", urls, body)
9706 if err != nil {
9707 return nil, err
9708 }
9709 req.Header = reqHeaders
9710 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9711 }
9712
9713
9714
9715
9716
9717
9718
9719 func (c *PropertiesListConnectedSiteTagsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListConnectedSiteTagsResponse, error) {
9720 gensupport.SetOptions(c.urlParams_, opts...)
9721 res, err := c.doRequest("json")
9722 if res != nil && res.StatusCode == http.StatusNotModified {
9723 if res.Body != nil {
9724 res.Body.Close()
9725 }
9726 return nil, gensupport.WrapError(&googleapi.Error{
9727 Code: res.StatusCode,
9728 Header: res.Header,
9729 })
9730 }
9731 if err != nil {
9732 return nil, err
9733 }
9734 defer googleapi.CloseBody(res)
9735 if err := googleapi.CheckResponse(res); err != nil {
9736 return nil, gensupport.WrapError(err)
9737 }
9738 ret := &GoogleAnalyticsAdminV1alphaListConnectedSiteTagsResponse{
9739 ServerResponse: googleapi.ServerResponse{
9740 Header: res.Header,
9741 HTTPStatusCode: res.StatusCode,
9742 },
9743 }
9744 target := &ret
9745 if err := gensupport.DecodeResponse(target, res); err != nil {
9746 return nil, err
9747 }
9748 return ret, nil
9749 }
9750
9751 type PropertiesPatchCall struct {
9752 s *Service
9753 name string
9754 googleanalyticsadminv1alphaproperty *GoogleAnalyticsAdminV1alphaProperty
9755 urlParams_ gensupport.URLParams
9756 ctx_ context.Context
9757 header_ http.Header
9758 }
9759
9760
9761
9762
9763
9764 func (r *PropertiesService) Patch(name string, googleanalyticsadminv1alphaproperty *GoogleAnalyticsAdminV1alphaProperty) *PropertiesPatchCall {
9765 c := &PropertiesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9766 c.name = name
9767 c.googleanalyticsadminv1alphaproperty = googleanalyticsadminv1alphaproperty
9768 return c
9769 }
9770
9771
9772
9773
9774
9775 func (c *PropertiesPatchCall) UpdateMask(updateMask string) *PropertiesPatchCall {
9776 c.urlParams_.Set("updateMask", updateMask)
9777 return c
9778 }
9779
9780
9781
9782
9783 func (c *PropertiesPatchCall) Fields(s ...googleapi.Field) *PropertiesPatchCall {
9784 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9785 return c
9786 }
9787
9788
9789 func (c *PropertiesPatchCall) Context(ctx context.Context) *PropertiesPatchCall {
9790 c.ctx_ = ctx
9791 return c
9792 }
9793
9794
9795
9796 func (c *PropertiesPatchCall) Header() http.Header {
9797 if c.header_ == nil {
9798 c.header_ = make(http.Header)
9799 }
9800 return c.header_
9801 }
9802
9803 func (c *PropertiesPatchCall) doRequest(alt string) (*http.Response, error) {
9804 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9805 var body io.Reader = nil
9806 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaproperty)
9807 if err != nil {
9808 return nil, err
9809 }
9810 c.urlParams_.Set("alt", alt)
9811 c.urlParams_.Set("prettyPrint", "false")
9812 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
9813 urls += "?" + c.urlParams_.Encode()
9814 req, err := http.NewRequest("PATCH", urls, body)
9815 if err != nil {
9816 return nil, err
9817 }
9818 req.Header = reqHeaders
9819 googleapi.Expand(req.URL, map[string]string{
9820 "name": c.name,
9821 })
9822 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9823 }
9824
9825
9826
9827
9828
9829
9830
9831 func (c *PropertiesPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaProperty, error) {
9832 gensupport.SetOptions(c.urlParams_, opts...)
9833 res, err := c.doRequest("json")
9834 if res != nil && res.StatusCode == http.StatusNotModified {
9835 if res.Body != nil {
9836 res.Body.Close()
9837 }
9838 return nil, gensupport.WrapError(&googleapi.Error{
9839 Code: res.StatusCode,
9840 Header: res.Header,
9841 })
9842 }
9843 if err != nil {
9844 return nil, err
9845 }
9846 defer googleapi.CloseBody(res)
9847 if err := googleapi.CheckResponse(res); err != nil {
9848 return nil, gensupport.WrapError(err)
9849 }
9850 ret := &GoogleAnalyticsAdminV1alphaProperty{
9851 ServerResponse: googleapi.ServerResponse{
9852 Header: res.Header,
9853 HTTPStatusCode: res.StatusCode,
9854 },
9855 }
9856 target := &ret
9857 if err := gensupport.DecodeResponse(target, res); err != nil {
9858 return nil, err
9859 }
9860 return ret, nil
9861 }
9862
9863 type PropertiesRunAccessReportCall struct {
9864 s *Service
9865 entity string
9866 googleanalyticsadminv1alpharunaccessreportrequest *GoogleAnalyticsAdminV1alphaRunAccessReportRequest
9867 urlParams_ gensupport.URLParams
9868 ctx_ context.Context
9869 header_ http.Header
9870 }
9871
9872
9873
9874
9875
9876
9877
9878
9879
9880
9881
9882
9883
9884
9885
9886
9887
9888
9889
9890
9891 func (r *PropertiesService) RunAccessReport(entity string, googleanalyticsadminv1alpharunaccessreportrequest *GoogleAnalyticsAdminV1alphaRunAccessReportRequest) *PropertiesRunAccessReportCall {
9892 c := &PropertiesRunAccessReportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9893 c.entity = entity
9894 c.googleanalyticsadminv1alpharunaccessreportrequest = googleanalyticsadminv1alpharunaccessreportrequest
9895 return c
9896 }
9897
9898
9899
9900
9901 func (c *PropertiesRunAccessReportCall) Fields(s ...googleapi.Field) *PropertiesRunAccessReportCall {
9902 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9903 return c
9904 }
9905
9906
9907 func (c *PropertiesRunAccessReportCall) Context(ctx context.Context) *PropertiesRunAccessReportCall {
9908 c.ctx_ = ctx
9909 return c
9910 }
9911
9912
9913
9914 func (c *PropertiesRunAccessReportCall) Header() http.Header {
9915 if c.header_ == nil {
9916 c.header_ = make(http.Header)
9917 }
9918 return c.header_
9919 }
9920
9921 func (c *PropertiesRunAccessReportCall) doRequest(alt string) (*http.Response, error) {
9922 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9923 var body io.Reader = nil
9924 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alpharunaccessreportrequest)
9925 if err != nil {
9926 return nil, err
9927 }
9928 c.urlParams_.Set("alt", alt)
9929 c.urlParams_.Set("prettyPrint", "false")
9930 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+entity}:runAccessReport")
9931 urls += "?" + c.urlParams_.Encode()
9932 req, err := http.NewRequest("POST", urls, body)
9933 if err != nil {
9934 return nil, err
9935 }
9936 req.Header = reqHeaders
9937 googleapi.Expand(req.URL, map[string]string{
9938 "entity": c.entity,
9939 })
9940 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9941 }
9942
9943
9944
9945
9946
9947
9948
9949 func (c *PropertiesRunAccessReportCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaRunAccessReportResponse, error) {
9950 gensupport.SetOptions(c.urlParams_, opts...)
9951 res, err := c.doRequest("json")
9952 if res != nil && res.StatusCode == http.StatusNotModified {
9953 if res.Body != nil {
9954 res.Body.Close()
9955 }
9956 return nil, gensupport.WrapError(&googleapi.Error{
9957 Code: res.StatusCode,
9958 Header: res.Header,
9959 })
9960 }
9961 if err != nil {
9962 return nil, err
9963 }
9964 defer googleapi.CloseBody(res)
9965 if err := googleapi.CheckResponse(res); err != nil {
9966 return nil, gensupport.WrapError(err)
9967 }
9968 ret := &GoogleAnalyticsAdminV1alphaRunAccessReportResponse{
9969 ServerResponse: googleapi.ServerResponse{
9970 Header: res.Header,
9971 HTTPStatusCode: res.StatusCode,
9972 },
9973 }
9974 target := &ret
9975 if err := gensupport.DecodeResponse(target, res); err != nil {
9976 return nil, err
9977 }
9978 return ret, nil
9979 }
9980
9981 type PropertiesSetAutomatedGa4ConfigurationOptOutCall struct {
9982 s *Service
9983 googleanalyticsadminv1alphasetautomatedga4configurationoptoutrequest *GoogleAnalyticsAdminV1alphaSetAutomatedGa4ConfigurationOptOutRequest
9984 urlParams_ gensupport.URLParams
9985 ctx_ context.Context
9986 header_ http.Header
9987 }
9988
9989
9990
9991
9992 func (r *PropertiesService) SetAutomatedGa4ConfigurationOptOut(googleanalyticsadminv1alphasetautomatedga4configurationoptoutrequest *GoogleAnalyticsAdminV1alphaSetAutomatedGa4ConfigurationOptOutRequest) *PropertiesSetAutomatedGa4ConfigurationOptOutCall {
9993 c := &PropertiesSetAutomatedGa4ConfigurationOptOutCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9994 c.googleanalyticsadminv1alphasetautomatedga4configurationoptoutrequest = googleanalyticsadminv1alphasetautomatedga4configurationoptoutrequest
9995 return c
9996 }
9997
9998
9999
10000
10001 func (c *PropertiesSetAutomatedGa4ConfigurationOptOutCall) Fields(s ...googleapi.Field) *PropertiesSetAutomatedGa4ConfigurationOptOutCall {
10002 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10003 return c
10004 }
10005
10006
10007 func (c *PropertiesSetAutomatedGa4ConfigurationOptOutCall) Context(ctx context.Context) *PropertiesSetAutomatedGa4ConfigurationOptOutCall {
10008 c.ctx_ = ctx
10009 return c
10010 }
10011
10012
10013
10014 func (c *PropertiesSetAutomatedGa4ConfigurationOptOutCall) Header() http.Header {
10015 if c.header_ == nil {
10016 c.header_ = make(http.Header)
10017 }
10018 return c.header_
10019 }
10020
10021 func (c *PropertiesSetAutomatedGa4ConfigurationOptOutCall) doRequest(alt string) (*http.Response, error) {
10022 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10023 var body io.Reader = nil
10024 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphasetautomatedga4configurationoptoutrequest)
10025 if err != nil {
10026 return nil, err
10027 }
10028 c.urlParams_.Set("alt", alt)
10029 c.urlParams_.Set("prettyPrint", "false")
10030 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/properties:setAutomatedGa4ConfigurationOptOut")
10031 urls += "?" + c.urlParams_.Encode()
10032 req, err := http.NewRequest("POST", urls, body)
10033 if err != nil {
10034 return nil, err
10035 }
10036 req.Header = reqHeaders
10037 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10038 }
10039
10040
10041
10042
10043
10044
10045
10046 func (c *PropertiesSetAutomatedGa4ConfigurationOptOutCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSetAutomatedGa4ConfigurationOptOutResponse, error) {
10047 gensupport.SetOptions(c.urlParams_, opts...)
10048 res, err := c.doRequest("json")
10049 if res != nil && res.StatusCode == http.StatusNotModified {
10050 if res.Body != nil {
10051 res.Body.Close()
10052 }
10053 return nil, gensupport.WrapError(&googleapi.Error{
10054 Code: res.StatusCode,
10055 Header: res.Header,
10056 })
10057 }
10058 if err != nil {
10059 return nil, err
10060 }
10061 defer googleapi.CloseBody(res)
10062 if err := googleapi.CheckResponse(res); err != nil {
10063 return nil, gensupport.WrapError(err)
10064 }
10065 ret := &GoogleAnalyticsAdminV1alphaSetAutomatedGa4ConfigurationOptOutResponse{
10066 ServerResponse: googleapi.ServerResponse{
10067 Header: res.Header,
10068 HTTPStatusCode: res.StatusCode,
10069 },
10070 }
10071 target := &ret
10072 if err := gensupport.DecodeResponse(target, res); err != nil {
10073 return nil, err
10074 }
10075 return ret, nil
10076 }
10077
10078 type PropertiesUpdateAttributionSettingsCall struct {
10079 s *Service
10080 name string
10081 googleanalyticsadminv1alphaattributionsettings *GoogleAnalyticsAdminV1alphaAttributionSettings
10082 urlParams_ gensupport.URLParams
10083 ctx_ context.Context
10084 header_ http.Header
10085 }
10086
10087
10088
10089
10090
10091
10092 func (r *PropertiesService) UpdateAttributionSettings(name string, googleanalyticsadminv1alphaattributionsettings *GoogleAnalyticsAdminV1alphaAttributionSettings) *PropertiesUpdateAttributionSettingsCall {
10093 c := &PropertiesUpdateAttributionSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10094 c.name = name
10095 c.googleanalyticsadminv1alphaattributionsettings = googleanalyticsadminv1alphaattributionsettings
10096 return c
10097 }
10098
10099
10100
10101
10102
10103 func (c *PropertiesUpdateAttributionSettingsCall) UpdateMask(updateMask string) *PropertiesUpdateAttributionSettingsCall {
10104 c.urlParams_.Set("updateMask", updateMask)
10105 return c
10106 }
10107
10108
10109
10110
10111 func (c *PropertiesUpdateAttributionSettingsCall) Fields(s ...googleapi.Field) *PropertiesUpdateAttributionSettingsCall {
10112 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10113 return c
10114 }
10115
10116
10117 func (c *PropertiesUpdateAttributionSettingsCall) Context(ctx context.Context) *PropertiesUpdateAttributionSettingsCall {
10118 c.ctx_ = ctx
10119 return c
10120 }
10121
10122
10123
10124 func (c *PropertiesUpdateAttributionSettingsCall) Header() http.Header {
10125 if c.header_ == nil {
10126 c.header_ = make(http.Header)
10127 }
10128 return c.header_
10129 }
10130
10131 func (c *PropertiesUpdateAttributionSettingsCall) doRequest(alt string) (*http.Response, error) {
10132 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10133 var body io.Reader = nil
10134 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaattributionsettings)
10135 if err != nil {
10136 return nil, err
10137 }
10138 c.urlParams_.Set("alt", alt)
10139 c.urlParams_.Set("prettyPrint", "false")
10140 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
10141 urls += "?" + c.urlParams_.Encode()
10142 req, err := http.NewRequest("PATCH", urls, body)
10143 if err != nil {
10144 return nil, err
10145 }
10146 req.Header = reqHeaders
10147 googleapi.Expand(req.URL, map[string]string{
10148 "name": c.name,
10149 })
10150 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10151 }
10152
10153
10154
10155
10156
10157
10158
10159 func (c *PropertiesUpdateAttributionSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAttributionSettings, error) {
10160 gensupport.SetOptions(c.urlParams_, opts...)
10161 res, err := c.doRequest("json")
10162 if res != nil && res.StatusCode == http.StatusNotModified {
10163 if res.Body != nil {
10164 res.Body.Close()
10165 }
10166 return nil, gensupport.WrapError(&googleapi.Error{
10167 Code: res.StatusCode,
10168 Header: res.Header,
10169 })
10170 }
10171 if err != nil {
10172 return nil, err
10173 }
10174 defer googleapi.CloseBody(res)
10175 if err := googleapi.CheckResponse(res); err != nil {
10176 return nil, gensupport.WrapError(err)
10177 }
10178 ret := &GoogleAnalyticsAdminV1alphaAttributionSettings{
10179 ServerResponse: googleapi.ServerResponse{
10180 Header: res.Header,
10181 HTTPStatusCode: res.StatusCode,
10182 },
10183 }
10184 target := &ret
10185 if err := gensupport.DecodeResponse(target, res); err != nil {
10186 return nil, err
10187 }
10188 return ret, nil
10189 }
10190
10191 type PropertiesUpdateDataRetentionSettingsCall struct {
10192 s *Service
10193 name string
10194 googleanalyticsadminv1alphadataretentionsettings *GoogleAnalyticsAdminV1alphaDataRetentionSettings
10195 urlParams_ gensupport.URLParams
10196 ctx_ context.Context
10197 header_ http.Header
10198 }
10199
10200
10201
10202
10203
10204
10205 func (r *PropertiesService) UpdateDataRetentionSettings(name string, googleanalyticsadminv1alphadataretentionsettings *GoogleAnalyticsAdminV1alphaDataRetentionSettings) *PropertiesUpdateDataRetentionSettingsCall {
10206 c := &PropertiesUpdateDataRetentionSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10207 c.name = name
10208 c.googleanalyticsadminv1alphadataretentionsettings = googleanalyticsadminv1alphadataretentionsettings
10209 return c
10210 }
10211
10212
10213
10214
10215
10216 func (c *PropertiesUpdateDataRetentionSettingsCall) UpdateMask(updateMask string) *PropertiesUpdateDataRetentionSettingsCall {
10217 c.urlParams_.Set("updateMask", updateMask)
10218 return c
10219 }
10220
10221
10222
10223
10224 func (c *PropertiesUpdateDataRetentionSettingsCall) Fields(s ...googleapi.Field) *PropertiesUpdateDataRetentionSettingsCall {
10225 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10226 return c
10227 }
10228
10229
10230 func (c *PropertiesUpdateDataRetentionSettingsCall) Context(ctx context.Context) *PropertiesUpdateDataRetentionSettingsCall {
10231 c.ctx_ = ctx
10232 return c
10233 }
10234
10235
10236
10237 func (c *PropertiesUpdateDataRetentionSettingsCall) Header() http.Header {
10238 if c.header_ == nil {
10239 c.header_ = make(http.Header)
10240 }
10241 return c.header_
10242 }
10243
10244 func (c *PropertiesUpdateDataRetentionSettingsCall) doRequest(alt string) (*http.Response, error) {
10245 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10246 var body io.Reader = nil
10247 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphadataretentionsettings)
10248 if err != nil {
10249 return nil, err
10250 }
10251 c.urlParams_.Set("alt", alt)
10252 c.urlParams_.Set("prettyPrint", "false")
10253 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
10254 urls += "?" + c.urlParams_.Encode()
10255 req, err := http.NewRequest("PATCH", urls, body)
10256 if err != nil {
10257 return nil, err
10258 }
10259 req.Header = reqHeaders
10260 googleapi.Expand(req.URL, map[string]string{
10261 "name": c.name,
10262 })
10263 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10264 }
10265
10266
10267
10268
10269
10270
10271
10272 func (c *PropertiesUpdateDataRetentionSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDataRetentionSettings, error) {
10273 gensupport.SetOptions(c.urlParams_, opts...)
10274 res, err := c.doRequest("json")
10275 if res != nil && res.StatusCode == http.StatusNotModified {
10276 if res.Body != nil {
10277 res.Body.Close()
10278 }
10279 return nil, gensupport.WrapError(&googleapi.Error{
10280 Code: res.StatusCode,
10281 Header: res.Header,
10282 })
10283 }
10284 if err != nil {
10285 return nil, err
10286 }
10287 defer googleapi.CloseBody(res)
10288 if err := googleapi.CheckResponse(res); err != nil {
10289 return nil, gensupport.WrapError(err)
10290 }
10291 ret := &GoogleAnalyticsAdminV1alphaDataRetentionSettings{
10292 ServerResponse: googleapi.ServerResponse{
10293 Header: res.Header,
10294 HTTPStatusCode: res.StatusCode,
10295 },
10296 }
10297 target := &ret
10298 if err := gensupport.DecodeResponse(target, res); err != nil {
10299 return nil, err
10300 }
10301 return ret, nil
10302 }
10303
10304 type PropertiesUpdateGoogleSignalsSettingsCall struct {
10305 s *Service
10306 name string
10307 googleanalyticsadminv1alphagooglesignalssettings *GoogleAnalyticsAdminV1alphaGoogleSignalsSettings
10308 urlParams_ gensupport.URLParams
10309 ctx_ context.Context
10310 header_ http.Header
10311 }
10312
10313
10314
10315
10316
10317
10318 func (r *PropertiesService) UpdateGoogleSignalsSettings(name string, googleanalyticsadminv1alphagooglesignalssettings *GoogleAnalyticsAdminV1alphaGoogleSignalsSettings) *PropertiesUpdateGoogleSignalsSettingsCall {
10319 c := &PropertiesUpdateGoogleSignalsSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10320 c.name = name
10321 c.googleanalyticsadminv1alphagooglesignalssettings = googleanalyticsadminv1alphagooglesignalssettings
10322 return c
10323 }
10324
10325
10326
10327
10328
10329 func (c *PropertiesUpdateGoogleSignalsSettingsCall) UpdateMask(updateMask string) *PropertiesUpdateGoogleSignalsSettingsCall {
10330 c.urlParams_.Set("updateMask", updateMask)
10331 return c
10332 }
10333
10334
10335
10336
10337 func (c *PropertiesUpdateGoogleSignalsSettingsCall) Fields(s ...googleapi.Field) *PropertiesUpdateGoogleSignalsSettingsCall {
10338 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10339 return c
10340 }
10341
10342
10343 func (c *PropertiesUpdateGoogleSignalsSettingsCall) Context(ctx context.Context) *PropertiesUpdateGoogleSignalsSettingsCall {
10344 c.ctx_ = ctx
10345 return c
10346 }
10347
10348
10349
10350 func (c *PropertiesUpdateGoogleSignalsSettingsCall) Header() http.Header {
10351 if c.header_ == nil {
10352 c.header_ = make(http.Header)
10353 }
10354 return c.header_
10355 }
10356
10357 func (c *PropertiesUpdateGoogleSignalsSettingsCall) doRequest(alt string) (*http.Response, error) {
10358 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10359 var body io.Reader = nil
10360 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphagooglesignalssettings)
10361 if err != nil {
10362 return nil, err
10363 }
10364 c.urlParams_.Set("alt", alt)
10365 c.urlParams_.Set("prettyPrint", "false")
10366 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
10367 urls += "?" + c.urlParams_.Encode()
10368 req, err := http.NewRequest("PATCH", urls, body)
10369 if err != nil {
10370 return nil, err
10371 }
10372 req.Header = reqHeaders
10373 googleapi.Expand(req.URL, map[string]string{
10374 "name": c.name,
10375 })
10376 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10377 }
10378
10379
10380
10381
10382
10383
10384
10385 func (c *PropertiesUpdateGoogleSignalsSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaGoogleSignalsSettings, error) {
10386 gensupport.SetOptions(c.urlParams_, opts...)
10387 res, err := c.doRequest("json")
10388 if res != nil && res.StatusCode == http.StatusNotModified {
10389 if res.Body != nil {
10390 res.Body.Close()
10391 }
10392 return nil, gensupport.WrapError(&googleapi.Error{
10393 Code: res.StatusCode,
10394 Header: res.Header,
10395 })
10396 }
10397 if err != nil {
10398 return nil, err
10399 }
10400 defer googleapi.CloseBody(res)
10401 if err := googleapi.CheckResponse(res); err != nil {
10402 return nil, gensupport.WrapError(err)
10403 }
10404 ret := &GoogleAnalyticsAdminV1alphaGoogleSignalsSettings{
10405 ServerResponse: googleapi.ServerResponse{
10406 Header: res.Header,
10407 HTTPStatusCode: res.StatusCode,
10408 },
10409 }
10410 target := &ret
10411 if err := gensupport.DecodeResponse(target, res); err != nil {
10412 return nil, err
10413 }
10414 return ret, nil
10415 }
10416
10417 type PropertiesAccessBindingsBatchCreateCall struct {
10418 s *Service
10419 parent string
10420 googleanalyticsadminv1alphabatchcreateaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsRequest
10421 urlParams_ gensupport.URLParams
10422 ctx_ context.Context
10423 header_ http.Header
10424 }
10425
10426
10427
10428
10429
10430
10431
10432
10433 func (r *PropertiesAccessBindingsService) BatchCreate(parent string, googleanalyticsadminv1alphabatchcreateaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsRequest) *PropertiesAccessBindingsBatchCreateCall {
10434 c := &PropertiesAccessBindingsBatchCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10435 c.parent = parent
10436 c.googleanalyticsadminv1alphabatchcreateaccessbindingsrequest = googleanalyticsadminv1alphabatchcreateaccessbindingsrequest
10437 return c
10438 }
10439
10440
10441
10442
10443 func (c *PropertiesAccessBindingsBatchCreateCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsBatchCreateCall {
10444 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10445 return c
10446 }
10447
10448
10449 func (c *PropertiesAccessBindingsBatchCreateCall) Context(ctx context.Context) *PropertiesAccessBindingsBatchCreateCall {
10450 c.ctx_ = ctx
10451 return c
10452 }
10453
10454
10455
10456 func (c *PropertiesAccessBindingsBatchCreateCall) Header() http.Header {
10457 if c.header_ == nil {
10458 c.header_ = make(http.Header)
10459 }
10460 return c.header_
10461 }
10462
10463 func (c *PropertiesAccessBindingsBatchCreateCall) doRequest(alt string) (*http.Response, error) {
10464 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10465 var body io.Reader = nil
10466 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphabatchcreateaccessbindingsrequest)
10467 if err != nil {
10468 return nil, err
10469 }
10470 c.urlParams_.Set("alt", alt)
10471 c.urlParams_.Set("prettyPrint", "false")
10472 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings:batchCreate")
10473 urls += "?" + c.urlParams_.Encode()
10474 req, err := http.NewRequest("POST", urls, body)
10475 if err != nil {
10476 return nil, err
10477 }
10478 req.Header = reqHeaders
10479 googleapi.Expand(req.URL, map[string]string{
10480 "parent": c.parent,
10481 })
10482 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10483 }
10484
10485
10486
10487
10488
10489
10490
10491 func (c *PropertiesAccessBindingsBatchCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsResponse, error) {
10492 gensupport.SetOptions(c.urlParams_, opts...)
10493 res, err := c.doRequest("json")
10494 if res != nil && res.StatusCode == http.StatusNotModified {
10495 if res.Body != nil {
10496 res.Body.Close()
10497 }
10498 return nil, gensupport.WrapError(&googleapi.Error{
10499 Code: res.StatusCode,
10500 Header: res.Header,
10501 })
10502 }
10503 if err != nil {
10504 return nil, err
10505 }
10506 defer googleapi.CloseBody(res)
10507 if err := googleapi.CheckResponse(res); err != nil {
10508 return nil, gensupport.WrapError(err)
10509 }
10510 ret := &GoogleAnalyticsAdminV1alphaBatchCreateAccessBindingsResponse{
10511 ServerResponse: googleapi.ServerResponse{
10512 Header: res.Header,
10513 HTTPStatusCode: res.StatusCode,
10514 },
10515 }
10516 target := &ret
10517 if err := gensupport.DecodeResponse(target, res); err != nil {
10518 return nil, err
10519 }
10520 return ret, nil
10521 }
10522
10523 type PropertiesAccessBindingsBatchDeleteCall struct {
10524 s *Service
10525 parent string
10526 googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchDeleteAccessBindingsRequest
10527 urlParams_ gensupport.URLParams
10528 ctx_ context.Context
10529 header_ http.Header
10530 }
10531
10532
10533
10534
10535
10536
10537
10538
10539 func (r *PropertiesAccessBindingsService) BatchDelete(parent string, googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchDeleteAccessBindingsRequest) *PropertiesAccessBindingsBatchDeleteCall {
10540 c := &PropertiesAccessBindingsBatchDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10541 c.parent = parent
10542 c.googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest = googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest
10543 return c
10544 }
10545
10546
10547
10548
10549 func (c *PropertiesAccessBindingsBatchDeleteCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsBatchDeleteCall {
10550 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10551 return c
10552 }
10553
10554
10555 func (c *PropertiesAccessBindingsBatchDeleteCall) Context(ctx context.Context) *PropertiesAccessBindingsBatchDeleteCall {
10556 c.ctx_ = ctx
10557 return c
10558 }
10559
10560
10561
10562 func (c *PropertiesAccessBindingsBatchDeleteCall) Header() http.Header {
10563 if c.header_ == nil {
10564 c.header_ = make(http.Header)
10565 }
10566 return c.header_
10567 }
10568
10569 func (c *PropertiesAccessBindingsBatchDeleteCall) doRequest(alt string) (*http.Response, error) {
10570 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10571 var body io.Reader = nil
10572 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphabatchdeleteaccessbindingsrequest)
10573 if err != nil {
10574 return nil, err
10575 }
10576 c.urlParams_.Set("alt", alt)
10577 c.urlParams_.Set("prettyPrint", "false")
10578 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings:batchDelete")
10579 urls += "?" + c.urlParams_.Encode()
10580 req, err := http.NewRequest("POST", urls, body)
10581 if err != nil {
10582 return nil, err
10583 }
10584 req.Header = reqHeaders
10585 googleapi.Expand(req.URL, map[string]string{
10586 "parent": c.parent,
10587 })
10588 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10589 }
10590
10591
10592
10593
10594
10595
10596
10597 func (c *PropertiesAccessBindingsBatchDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
10598 gensupport.SetOptions(c.urlParams_, opts...)
10599 res, err := c.doRequest("json")
10600 if res != nil && res.StatusCode == http.StatusNotModified {
10601 if res.Body != nil {
10602 res.Body.Close()
10603 }
10604 return nil, gensupport.WrapError(&googleapi.Error{
10605 Code: res.StatusCode,
10606 Header: res.Header,
10607 })
10608 }
10609 if err != nil {
10610 return nil, err
10611 }
10612 defer googleapi.CloseBody(res)
10613 if err := googleapi.CheckResponse(res); err != nil {
10614 return nil, gensupport.WrapError(err)
10615 }
10616 ret := &GoogleProtobufEmpty{
10617 ServerResponse: googleapi.ServerResponse{
10618 Header: res.Header,
10619 HTTPStatusCode: res.StatusCode,
10620 },
10621 }
10622 target := &ret
10623 if err := gensupport.DecodeResponse(target, res); err != nil {
10624 return nil, err
10625 }
10626 return ret, nil
10627 }
10628
10629 type PropertiesAccessBindingsBatchGetCall struct {
10630 s *Service
10631 parent string
10632 urlParams_ gensupport.URLParams
10633 ifNoneMatch_ string
10634 ctx_ context.Context
10635 header_ http.Header
10636 }
10637
10638
10639
10640
10641
10642
10643
10644 func (r *PropertiesAccessBindingsService) BatchGet(parent string) *PropertiesAccessBindingsBatchGetCall {
10645 c := &PropertiesAccessBindingsBatchGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10646 c.parent = parent
10647 return c
10648 }
10649
10650
10651
10652
10653
10654 func (c *PropertiesAccessBindingsBatchGetCall) Names(names ...string) *PropertiesAccessBindingsBatchGetCall {
10655 c.urlParams_.SetMulti("names", append([]string{}, names...))
10656 return c
10657 }
10658
10659
10660
10661
10662 func (c *PropertiesAccessBindingsBatchGetCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsBatchGetCall {
10663 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10664 return c
10665 }
10666
10667
10668
10669
10670 func (c *PropertiesAccessBindingsBatchGetCall) IfNoneMatch(entityTag string) *PropertiesAccessBindingsBatchGetCall {
10671 c.ifNoneMatch_ = entityTag
10672 return c
10673 }
10674
10675
10676 func (c *PropertiesAccessBindingsBatchGetCall) Context(ctx context.Context) *PropertiesAccessBindingsBatchGetCall {
10677 c.ctx_ = ctx
10678 return c
10679 }
10680
10681
10682
10683 func (c *PropertiesAccessBindingsBatchGetCall) Header() http.Header {
10684 if c.header_ == nil {
10685 c.header_ = make(http.Header)
10686 }
10687 return c.header_
10688 }
10689
10690 func (c *PropertiesAccessBindingsBatchGetCall) doRequest(alt string) (*http.Response, error) {
10691 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10692 if c.ifNoneMatch_ != "" {
10693 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10694 }
10695 var body io.Reader = nil
10696 c.urlParams_.Set("alt", alt)
10697 c.urlParams_.Set("prettyPrint", "false")
10698 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings:batchGet")
10699 urls += "?" + c.urlParams_.Encode()
10700 req, err := http.NewRequest("GET", urls, body)
10701 if err != nil {
10702 return nil, err
10703 }
10704 req.Header = reqHeaders
10705 googleapi.Expand(req.URL, map[string]string{
10706 "parent": c.parent,
10707 })
10708 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10709 }
10710
10711
10712
10713
10714
10715
10716
10717 func (c *PropertiesAccessBindingsBatchGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaBatchGetAccessBindingsResponse, error) {
10718 gensupport.SetOptions(c.urlParams_, opts...)
10719 res, err := c.doRequest("json")
10720 if res != nil && res.StatusCode == http.StatusNotModified {
10721 if res.Body != nil {
10722 res.Body.Close()
10723 }
10724 return nil, gensupport.WrapError(&googleapi.Error{
10725 Code: res.StatusCode,
10726 Header: res.Header,
10727 })
10728 }
10729 if err != nil {
10730 return nil, err
10731 }
10732 defer googleapi.CloseBody(res)
10733 if err := googleapi.CheckResponse(res); err != nil {
10734 return nil, gensupport.WrapError(err)
10735 }
10736 ret := &GoogleAnalyticsAdminV1alphaBatchGetAccessBindingsResponse{
10737 ServerResponse: googleapi.ServerResponse{
10738 Header: res.Header,
10739 HTTPStatusCode: res.StatusCode,
10740 },
10741 }
10742 target := &ret
10743 if err := gensupport.DecodeResponse(target, res); err != nil {
10744 return nil, err
10745 }
10746 return ret, nil
10747 }
10748
10749 type PropertiesAccessBindingsBatchUpdateCall struct {
10750 s *Service
10751 parent string
10752 googleanalyticsadminv1alphabatchupdateaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsRequest
10753 urlParams_ gensupport.URLParams
10754 ctx_ context.Context
10755 header_ http.Header
10756 }
10757
10758
10759
10760
10761
10762
10763
10764 func (r *PropertiesAccessBindingsService) BatchUpdate(parent string, googleanalyticsadminv1alphabatchupdateaccessbindingsrequest *GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsRequest) *PropertiesAccessBindingsBatchUpdateCall {
10765 c := &PropertiesAccessBindingsBatchUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10766 c.parent = parent
10767 c.googleanalyticsadminv1alphabatchupdateaccessbindingsrequest = googleanalyticsadminv1alphabatchupdateaccessbindingsrequest
10768 return c
10769 }
10770
10771
10772
10773
10774 func (c *PropertiesAccessBindingsBatchUpdateCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsBatchUpdateCall {
10775 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10776 return c
10777 }
10778
10779
10780 func (c *PropertiesAccessBindingsBatchUpdateCall) Context(ctx context.Context) *PropertiesAccessBindingsBatchUpdateCall {
10781 c.ctx_ = ctx
10782 return c
10783 }
10784
10785
10786
10787 func (c *PropertiesAccessBindingsBatchUpdateCall) Header() http.Header {
10788 if c.header_ == nil {
10789 c.header_ = make(http.Header)
10790 }
10791 return c.header_
10792 }
10793
10794 func (c *PropertiesAccessBindingsBatchUpdateCall) doRequest(alt string) (*http.Response, error) {
10795 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10796 var body io.Reader = nil
10797 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphabatchupdateaccessbindingsrequest)
10798 if err != nil {
10799 return nil, err
10800 }
10801 c.urlParams_.Set("alt", alt)
10802 c.urlParams_.Set("prettyPrint", "false")
10803 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings:batchUpdate")
10804 urls += "?" + c.urlParams_.Encode()
10805 req, err := http.NewRequest("POST", urls, body)
10806 if err != nil {
10807 return nil, err
10808 }
10809 req.Header = reqHeaders
10810 googleapi.Expand(req.URL, map[string]string{
10811 "parent": c.parent,
10812 })
10813 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10814 }
10815
10816
10817
10818
10819
10820
10821
10822 func (c *PropertiesAccessBindingsBatchUpdateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsResponse, error) {
10823 gensupport.SetOptions(c.urlParams_, opts...)
10824 res, err := c.doRequest("json")
10825 if res != nil && res.StatusCode == http.StatusNotModified {
10826 if res.Body != nil {
10827 res.Body.Close()
10828 }
10829 return nil, gensupport.WrapError(&googleapi.Error{
10830 Code: res.StatusCode,
10831 Header: res.Header,
10832 })
10833 }
10834 if err != nil {
10835 return nil, err
10836 }
10837 defer googleapi.CloseBody(res)
10838 if err := googleapi.CheckResponse(res); err != nil {
10839 return nil, gensupport.WrapError(err)
10840 }
10841 ret := &GoogleAnalyticsAdminV1alphaBatchUpdateAccessBindingsResponse{
10842 ServerResponse: googleapi.ServerResponse{
10843 Header: res.Header,
10844 HTTPStatusCode: res.StatusCode,
10845 },
10846 }
10847 target := &ret
10848 if err := gensupport.DecodeResponse(target, res); err != nil {
10849 return nil, err
10850 }
10851 return ret, nil
10852 }
10853
10854 type PropertiesAccessBindingsCreateCall struct {
10855 s *Service
10856 parent string
10857 googleanalyticsadminv1alphaaccessbinding *GoogleAnalyticsAdminV1alphaAccessBinding
10858 urlParams_ gensupport.URLParams
10859 ctx_ context.Context
10860 header_ http.Header
10861 }
10862
10863
10864
10865
10866 func (r *PropertiesAccessBindingsService) Create(parent string, googleanalyticsadminv1alphaaccessbinding *GoogleAnalyticsAdminV1alphaAccessBinding) *PropertiesAccessBindingsCreateCall {
10867 c := &PropertiesAccessBindingsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10868 c.parent = parent
10869 c.googleanalyticsadminv1alphaaccessbinding = googleanalyticsadminv1alphaaccessbinding
10870 return c
10871 }
10872
10873
10874
10875
10876 func (c *PropertiesAccessBindingsCreateCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsCreateCall {
10877 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10878 return c
10879 }
10880
10881
10882 func (c *PropertiesAccessBindingsCreateCall) Context(ctx context.Context) *PropertiesAccessBindingsCreateCall {
10883 c.ctx_ = ctx
10884 return c
10885 }
10886
10887
10888
10889 func (c *PropertiesAccessBindingsCreateCall) Header() http.Header {
10890 if c.header_ == nil {
10891 c.header_ = make(http.Header)
10892 }
10893 return c.header_
10894 }
10895
10896 func (c *PropertiesAccessBindingsCreateCall) doRequest(alt string) (*http.Response, error) {
10897 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10898 var body io.Reader = nil
10899 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaaccessbinding)
10900 if err != nil {
10901 return nil, err
10902 }
10903 c.urlParams_.Set("alt", alt)
10904 c.urlParams_.Set("prettyPrint", "false")
10905 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings")
10906 urls += "?" + c.urlParams_.Encode()
10907 req, err := http.NewRequest("POST", urls, body)
10908 if err != nil {
10909 return nil, err
10910 }
10911 req.Header = reqHeaders
10912 googleapi.Expand(req.URL, map[string]string{
10913 "parent": c.parent,
10914 })
10915 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10916 }
10917
10918
10919
10920
10921
10922
10923
10924 func (c *PropertiesAccessBindingsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAccessBinding, error) {
10925 gensupport.SetOptions(c.urlParams_, opts...)
10926 res, err := c.doRequest("json")
10927 if res != nil && res.StatusCode == http.StatusNotModified {
10928 if res.Body != nil {
10929 res.Body.Close()
10930 }
10931 return nil, gensupport.WrapError(&googleapi.Error{
10932 Code: res.StatusCode,
10933 Header: res.Header,
10934 })
10935 }
10936 if err != nil {
10937 return nil, err
10938 }
10939 defer googleapi.CloseBody(res)
10940 if err := googleapi.CheckResponse(res); err != nil {
10941 return nil, gensupport.WrapError(err)
10942 }
10943 ret := &GoogleAnalyticsAdminV1alphaAccessBinding{
10944 ServerResponse: googleapi.ServerResponse{
10945 Header: res.Header,
10946 HTTPStatusCode: res.StatusCode,
10947 },
10948 }
10949 target := &ret
10950 if err := gensupport.DecodeResponse(target, res); err != nil {
10951 return nil, err
10952 }
10953 return ret, nil
10954 }
10955
10956 type PropertiesAccessBindingsDeleteCall struct {
10957 s *Service
10958 name string
10959 urlParams_ gensupport.URLParams
10960 ctx_ context.Context
10961 header_ http.Header
10962 }
10963
10964
10965
10966
10967
10968 func (r *PropertiesAccessBindingsService) Delete(name string) *PropertiesAccessBindingsDeleteCall {
10969 c := &PropertiesAccessBindingsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10970 c.name = name
10971 return c
10972 }
10973
10974
10975
10976
10977 func (c *PropertiesAccessBindingsDeleteCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsDeleteCall {
10978 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10979 return c
10980 }
10981
10982
10983 func (c *PropertiesAccessBindingsDeleteCall) Context(ctx context.Context) *PropertiesAccessBindingsDeleteCall {
10984 c.ctx_ = ctx
10985 return c
10986 }
10987
10988
10989
10990 func (c *PropertiesAccessBindingsDeleteCall) Header() http.Header {
10991 if c.header_ == nil {
10992 c.header_ = make(http.Header)
10993 }
10994 return c.header_
10995 }
10996
10997 func (c *PropertiesAccessBindingsDeleteCall) doRequest(alt string) (*http.Response, error) {
10998 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10999 var body io.Reader = nil
11000 c.urlParams_.Set("alt", alt)
11001 c.urlParams_.Set("prettyPrint", "false")
11002 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
11003 urls += "?" + c.urlParams_.Encode()
11004 req, err := http.NewRequest("DELETE", urls, body)
11005 if err != nil {
11006 return nil, err
11007 }
11008 req.Header = reqHeaders
11009 googleapi.Expand(req.URL, map[string]string{
11010 "name": c.name,
11011 })
11012 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11013 }
11014
11015
11016
11017
11018
11019
11020
11021 func (c *PropertiesAccessBindingsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
11022 gensupport.SetOptions(c.urlParams_, opts...)
11023 res, err := c.doRequest("json")
11024 if res != nil && res.StatusCode == http.StatusNotModified {
11025 if res.Body != nil {
11026 res.Body.Close()
11027 }
11028 return nil, gensupport.WrapError(&googleapi.Error{
11029 Code: res.StatusCode,
11030 Header: res.Header,
11031 })
11032 }
11033 if err != nil {
11034 return nil, err
11035 }
11036 defer googleapi.CloseBody(res)
11037 if err := googleapi.CheckResponse(res); err != nil {
11038 return nil, gensupport.WrapError(err)
11039 }
11040 ret := &GoogleProtobufEmpty{
11041 ServerResponse: googleapi.ServerResponse{
11042 Header: res.Header,
11043 HTTPStatusCode: res.StatusCode,
11044 },
11045 }
11046 target := &ret
11047 if err := gensupport.DecodeResponse(target, res); err != nil {
11048 return nil, err
11049 }
11050 return ret, nil
11051 }
11052
11053 type PropertiesAccessBindingsGetCall struct {
11054 s *Service
11055 name string
11056 urlParams_ gensupport.URLParams
11057 ifNoneMatch_ string
11058 ctx_ context.Context
11059 header_ http.Header
11060 }
11061
11062
11063
11064
11065
11066
11067 func (r *PropertiesAccessBindingsService) Get(name string) *PropertiesAccessBindingsGetCall {
11068 c := &PropertiesAccessBindingsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11069 c.name = name
11070 return c
11071 }
11072
11073
11074
11075
11076 func (c *PropertiesAccessBindingsGetCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsGetCall {
11077 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11078 return c
11079 }
11080
11081
11082
11083
11084 func (c *PropertiesAccessBindingsGetCall) IfNoneMatch(entityTag string) *PropertiesAccessBindingsGetCall {
11085 c.ifNoneMatch_ = entityTag
11086 return c
11087 }
11088
11089
11090 func (c *PropertiesAccessBindingsGetCall) Context(ctx context.Context) *PropertiesAccessBindingsGetCall {
11091 c.ctx_ = ctx
11092 return c
11093 }
11094
11095
11096
11097 func (c *PropertiesAccessBindingsGetCall) Header() http.Header {
11098 if c.header_ == nil {
11099 c.header_ = make(http.Header)
11100 }
11101 return c.header_
11102 }
11103
11104 func (c *PropertiesAccessBindingsGetCall) doRequest(alt string) (*http.Response, error) {
11105 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11106 if c.ifNoneMatch_ != "" {
11107 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11108 }
11109 var body io.Reader = nil
11110 c.urlParams_.Set("alt", alt)
11111 c.urlParams_.Set("prettyPrint", "false")
11112 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
11113 urls += "?" + c.urlParams_.Encode()
11114 req, err := http.NewRequest("GET", urls, body)
11115 if err != nil {
11116 return nil, err
11117 }
11118 req.Header = reqHeaders
11119 googleapi.Expand(req.URL, map[string]string{
11120 "name": c.name,
11121 })
11122 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11123 }
11124
11125
11126
11127
11128
11129
11130
11131 func (c *PropertiesAccessBindingsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAccessBinding, error) {
11132 gensupport.SetOptions(c.urlParams_, opts...)
11133 res, err := c.doRequest("json")
11134 if res != nil && res.StatusCode == http.StatusNotModified {
11135 if res.Body != nil {
11136 res.Body.Close()
11137 }
11138 return nil, gensupport.WrapError(&googleapi.Error{
11139 Code: res.StatusCode,
11140 Header: res.Header,
11141 })
11142 }
11143 if err != nil {
11144 return nil, err
11145 }
11146 defer googleapi.CloseBody(res)
11147 if err := googleapi.CheckResponse(res); err != nil {
11148 return nil, gensupport.WrapError(err)
11149 }
11150 ret := &GoogleAnalyticsAdminV1alphaAccessBinding{
11151 ServerResponse: googleapi.ServerResponse{
11152 Header: res.Header,
11153 HTTPStatusCode: res.StatusCode,
11154 },
11155 }
11156 target := &ret
11157 if err := gensupport.DecodeResponse(target, res); err != nil {
11158 return nil, err
11159 }
11160 return ret, nil
11161 }
11162
11163 type PropertiesAccessBindingsListCall struct {
11164 s *Service
11165 parent string
11166 urlParams_ gensupport.URLParams
11167 ifNoneMatch_ string
11168 ctx_ context.Context
11169 header_ http.Header
11170 }
11171
11172
11173
11174
11175 func (r *PropertiesAccessBindingsService) List(parent string) *PropertiesAccessBindingsListCall {
11176 c := &PropertiesAccessBindingsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11177 c.parent = parent
11178 return c
11179 }
11180
11181
11182
11183
11184
11185 func (c *PropertiesAccessBindingsListCall) PageSize(pageSize int64) *PropertiesAccessBindingsListCall {
11186 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
11187 return c
11188 }
11189
11190
11191
11192
11193
11194 func (c *PropertiesAccessBindingsListCall) PageToken(pageToken string) *PropertiesAccessBindingsListCall {
11195 c.urlParams_.Set("pageToken", pageToken)
11196 return c
11197 }
11198
11199
11200
11201
11202 func (c *PropertiesAccessBindingsListCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsListCall {
11203 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11204 return c
11205 }
11206
11207
11208
11209
11210 func (c *PropertiesAccessBindingsListCall) IfNoneMatch(entityTag string) *PropertiesAccessBindingsListCall {
11211 c.ifNoneMatch_ = entityTag
11212 return c
11213 }
11214
11215
11216 func (c *PropertiesAccessBindingsListCall) Context(ctx context.Context) *PropertiesAccessBindingsListCall {
11217 c.ctx_ = ctx
11218 return c
11219 }
11220
11221
11222
11223 func (c *PropertiesAccessBindingsListCall) Header() http.Header {
11224 if c.header_ == nil {
11225 c.header_ = make(http.Header)
11226 }
11227 return c.header_
11228 }
11229
11230 func (c *PropertiesAccessBindingsListCall) doRequest(alt string) (*http.Response, error) {
11231 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11232 if c.ifNoneMatch_ != "" {
11233 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11234 }
11235 var body io.Reader = nil
11236 c.urlParams_.Set("alt", alt)
11237 c.urlParams_.Set("prettyPrint", "false")
11238 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/accessBindings")
11239 urls += "?" + c.urlParams_.Encode()
11240 req, err := http.NewRequest("GET", urls, body)
11241 if err != nil {
11242 return nil, err
11243 }
11244 req.Header = reqHeaders
11245 googleapi.Expand(req.URL, map[string]string{
11246 "parent": c.parent,
11247 })
11248 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11249 }
11250
11251
11252
11253
11254
11255
11256
11257 func (c *PropertiesAccessBindingsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListAccessBindingsResponse, error) {
11258 gensupport.SetOptions(c.urlParams_, opts...)
11259 res, err := c.doRequest("json")
11260 if res != nil && res.StatusCode == http.StatusNotModified {
11261 if res.Body != nil {
11262 res.Body.Close()
11263 }
11264 return nil, gensupport.WrapError(&googleapi.Error{
11265 Code: res.StatusCode,
11266 Header: res.Header,
11267 })
11268 }
11269 if err != nil {
11270 return nil, err
11271 }
11272 defer googleapi.CloseBody(res)
11273 if err := googleapi.CheckResponse(res); err != nil {
11274 return nil, gensupport.WrapError(err)
11275 }
11276 ret := &GoogleAnalyticsAdminV1alphaListAccessBindingsResponse{
11277 ServerResponse: googleapi.ServerResponse{
11278 Header: res.Header,
11279 HTTPStatusCode: res.StatusCode,
11280 },
11281 }
11282 target := &ret
11283 if err := gensupport.DecodeResponse(target, res); err != nil {
11284 return nil, err
11285 }
11286 return ret, nil
11287 }
11288
11289
11290
11291
11292 func (c *PropertiesAccessBindingsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListAccessBindingsResponse) error) error {
11293 c.ctx_ = ctx
11294 defer c.PageToken(c.urlParams_.Get("pageToken"))
11295 for {
11296 x, err := c.Do()
11297 if err != nil {
11298 return err
11299 }
11300 if err := f(x); err != nil {
11301 return err
11302 }
11303 if x.NextPageToken == "" {
11304 return nil
11305 }
11306 c.PageToken(x.NextPageToken)
11307 }
11308 }
11309
11310 type PropertiesAccessBindingsPatchCall struct {
11311 s *Service
11312 name string
11313 googleanalyticsadminv1alphaaccessbinding *GoogleAnalyticsAdminV1alphaAccessBinding
11314 urlParams_ gensupport.URLParams
11315 ctx_ context.Context
11316 header_ http.Header
11317 }
11318
11319
11320
11321
11322
11323
11324
11325 func (r *PropertiesAccessBindingsService) Patch(name string, googleanalyticsadminv1alphaaccessbinding *GoogleAnalyticsAdminV1alphaAccessBinding) *PropertiesAccessBindingsPatchCall {
11326 c := &PropertiesAccessBindingsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11327 c.name = name
11328 c.googleanalyticsadminv1alphaaccessbinding = googleanalyticsadminv1alphaaccessbinding
11329 return c
11330 }
11331
11332
11333
11334
11335 func (c *PropertiesAccessBindingsPatchCall) Fields(s ...googleapi.Field) *PropertiesAccessBindingsPatchCall {
11336 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11337 return c
11338 }
11339
11340
11341 func (c *PropertiesAccessBindingsPatchCall) Context(ctx context.Context) *PropertiesAccessBindingsPatchCall {
11342 c.ctx_ = ctx
11343 return c
11344 }
11345
11346
11347
11348 func (c *PropertiesAccessBindingsPatchCall) Header() http.Header {
11349 if c.header_ == nil {
11350 c.header_ = make(http.Header)
11351 }
11352 return c.header_
11353 }
11354
11355 func (c *PropertiesAccessBindingsPatchCall) doRequest(alt string) (*http.Response, error) {
11356 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11357 var body io.Reader = nil
11358 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaaccessbinding)
11359 if err != nil {
11360 return nil, err
11361 }
11362 c.urlParams_.Set("alt", alt)
11363 c.urlParams_.Set("prettyPrint", "false")
11364 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
11365 urls += "?" + c.urlParams_.Encode()
11366 req, err := http.NewRequest("PATCH", urls, body)
11367 if err != nil {
11368 return nil, err
11369 }
11370 req.Header = reqHeaders
11371 googleapi.Expand(req.URL, map[string]string{
11372 "name": c.name,
11373 })
11374 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11375 }
11376
11377
11378
11379
11380
11381
11382
11383 func (c *PropertiesAccessBindingsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAccessBinding, error) {
11384 gensupport.SetOptions(c.urlParams_, opts...)
11385 res, err := c.doRequest("json")
11386 if res != nil && res.StatusCode == http.StatusNotModified {
11387 if res.Body != nil {
11388 res.Body.Close()
11389 }
11390 return nil, gensupport.WrapError(&googleapi.Error{
11391 Code: res.StatusCode,
11392 Header: res.Header,
11393 })
11394 }
11395 if err != nil {
11396 return nil, err
11397 }
11398 defer googleapi.CloseBody(res)
11399 if err := googleapi.CheckResponse(res); err != nil {
11400 return nil, gensupport.WrapError(err)
11401 }
11402 ret := &GoogleAnalyticsAdminV1alphaAccessBinding{
11403 ServerResponse: googleapi.ServerResponse{
11404 Header: res.Header,
11405 HTTPStatusCode: res.StatusCode,
11406 },
11407 }
11408 target := &ret
11409 if err := gensupport.DecodeResponse(target, res); err != nil {
11410 return nil, err
11411 }
11412 return ret, nil
11413 }
11414
11415 type PropertiesAdSenseLinksCreateCall struct {
11416 s *Service
11417 parent string
11418 googleanalyticsadminv1alphaadsenselink *GoogleAnalyticsAdminV1alphaAdSenseLink
11419 urlParams_ gensupport.URLParams
11420 ctx_ context.Context
11421 header_ http.Header
11422 }
11423
11424
11425
11426
11427
11428 func (r *PropertiesAdSenseLinksService) Create(parent string, googleanalyticsadminv1alphaadsenselink *GoogleAnalyticsAdminV1alphaAdSenseLink) *PropertiesAdSenseLinksCreateCall {
11429 c := &PropertiesAdSenseLinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11430 c.parent = parent
11431 c.googleanalyticsadminv1alphaadsenselink = googleanalyticsadminv1alphaadsenselink
11432 return c
11433 }
11434
11435
11436
11437
11438 func (c *PropertiesAdSenseLinksCreateCall) Fields(s ...googleapi.Field) *PropertiesAdSenseLinksCreateCall {
11439 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11440 return c
11441 }
11442
11443
11444 func (c *PropertiesAdSenseLinksCreateCall) Context(ctx context.Context) *PropertiesAdSenseLinksCreateCall {
11445 c.ctx_ = ctx
11446 return c
11447 }
11448
11449
11450
11451 func (c *PropertiesAdSenseLinksCreateCall) Header() http.Header {
11452 if c.header_ == nil {
11453 c.header_ = make(http.Header)
11454 }
11455 return c.header_
11456 }
11457
11458 func (c *PropertiesAdSenseLinksCreateCall) doRequest(alt string) (*http.Response, error) {
11459 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11460 var body io.Reader = nil
11461 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaadsenselink)
11462 if err != nil {
11463 return nil, err
11464 }
11465 c.urlParams_.Set("alt", alt)
11466 c.urlParams_.Set("prettyPrint", "false")
11467 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/adSenseLinks")
11468 urls += "?" + c.urlParams_.Encode()
11469 req, err := http.NewRequest("POST", urls, body)
11470 if err != nil {
11471 return nil, err
11472 }
11473 req.Header = reqHeaders
11474 googleapi.Expand(req.URL, map[string]string{
11475 "parent": c.parent,
11476 })
11477 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11478 }
11479
11480
11481
11482
11483
11484
11485
11486 func (c *PropertiesAdSenseLinksCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAdSenseLink, error) {
11487 gensupport.SetOptions(c.urlParams_, opts...)
11488 res, err := c.doRequest("json")
11489 if res != nil && res.StatusCode == http.StatusNotModified {
11490 if res.Body != nil {
11491 res.Body.Close()
11492 }
11493 return nil, gensupport.WrapError(&googleapi.Error{
11494 Code: res.StatusCode,
11495 Header: res.Header,
11496 })
11497 }
11498 if err != nil {
11499 return nil, err
11500 }
11501 defer googleapi.CloseBody(res)
11502 if err := googleapi.CheckResponse(res); err != nil {
11503 return nil, gensupport.WrapError(err)
11504 }
11505 ret := &GoogleAnalyticsAdminV1alphaAdSenseLink{
11506 ServerResponse: googleapi.ServerResponse{
11507 Header: res.Header,
11508 HTTPStatusCode: res.StatusCode,
11509 },
11510 }
11511 target := &ret
11512 if err := gensupport.DecodeResponse(target, res); err != nil {
11513 return nil, err
11514 }
11515 return ret, nil
11516 }
11517
11518 type PropertiesAdSenseLinksDeleteCall struct {
11519 s *Service
11520 nameid string
11521 urlParams_ gensupport.URLParams
11522 ctx_ context.Context
11523 header_ http.Header
11524 }
11525
11526
11527
11528
11529
11530
11531 func (r *PropertiesAdSenseLinksService) Delete(nameid string) *PropertiesAdSenseLinksDeleteCall {
11532 c := &PropertiesAdSenseLinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11533 c.nameid = nameid
11534 return c
11535 }
11536
11537
11538
11539
11540 func (c *PropertiesAdSenseLinksDeleteCall) Fields(s ...googleapi.Field) *PropertiesAdSenseLinksDeleteCall {
11541 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11542 return c
11543 }
11544
11545
11546 func (c *PropertiesAdSenseLinksDeleteCall) Context(ctx context.Context) *PropertiesAdSenseLinksDeleteCall {
11547 c.ctx_ = ctx
11548 return c
11549 }
11550
11551
11552
11553 func (c *PropertiesAdSenseLinksDeleteCall) Header() http.Header {
11554 if c.header_ == nil {
11555 c.header_ = make(http.Header)
11556 }
11557 return c.header_
11558 }
11559
11560 func (c *PropertiesAdSenseLinksDeleteCall) doRequest(alt string) (*http.Response, error) {
11561 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11562 var body io.Reader = nil
11563 c.urlParams_.Set("alt", alt)
11564 c.urlParams_.Set("prettyPrint", "false")
11565 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
11566 urls += "?" + c.urlParams_.Encode()
11567 req, err := http.NewRequest("DELETE", urls, body)
11568 if err != nil {
11569 return nil, err
11570 }
11571 req.Header = reqHeaders
11572 googleapi.Expand(req.URL, map[string]string{
11573 "name": c.nameid,
11574 })
11575 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11576 }
11577
11578
11579
11580
11581
11582
11583
11584 func (c *PropertiesAdSenseLinksDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
11585 gensupport.SetOptions(c.urlParams_, opts...)
11586 res, err := c.doRequest("json")
11587 if res != nil && res.StatusCode == http.StatusNotModified {
11588 if res.Body != nil {
11589 res.Body.Close()
11590 }
11591 return nil, gensupport.WrapError(&googleapi.Error{
11592 Code: res.StatusCode,
11593 Header: res.Header,
11594 })
11595 }
11596 if err != nil {
11597 return nil, err
11598 }
11599 defer googleapi.CloseBody(res)
11600 if err := googleapi.CheckResponse(res); err != nil {
11601 return nil, gensupport.WrapError(err)
11602 }
11603 ret := &GoogleProtobufEmpty{
11604 ServerResponse: googleapi.ServerResponse{
11605 Header: res.Header,
11606 HTTPStatusCode: res.StatusCode,
11607 },
11608 }
11609 target := &ret
11610 if err := gensupport.DecodeResponse(target, res); err != nil {
11611 return nil, err
11612 }
11613 return ret, nil
11614 }
11615
11616 type PropertiesAdSenseLinksGetCall struct {
11617 s *Service
11618 nameid string
11619 urlParams_ gensupport.URLParams
11620 ifNoneMatch_ string
11621 ctx_ context.Context
11622 header_ http.Header
11623 }
11624
11625
11626
11627
11628
11629
11630 func (r *PropertiesAdSenseLinksService) Get(nameid string) *PropertiesAdSenseLinksGetCall {
11631 c := &PropertiesAdSenseLinksGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11632 c.nameid = nameid
11633 return c
11634 }
11635
11636
11637
11638
11639 func (c *PropertiesAdSenseLinksGetCall) Fields(s ...googleapi.Field) *PropertiesAdSenseLinksGetCall {
11640 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11641 return c
11642 }
11643
11644
11645
11646
11647 func (c *PropertiesAdSenseLinksGetCall) IfNoneMatch(entityTag string) *PropertiesAdSenseLinksGetCall {
11648 c.ifNoneMatch_ = entityTag
11649 return c
11650 }
11651
11652
11653 func (c *PropertiesAdSenseLinksGetCall) Context(ctx context.Context) *PropertiesAdSenseLinksGetCall {
11654 c.ctx_ = ctx
11655 return c
11656 }
11657
11658
11659
11660 func (c *PropertiesAdSenseLinksGetCall) Header() http.Header {
11661 if c.header_ == nil {
11662 c.header_ = make(http.Header)
11663 }
11664 return c.header_
11665 }
11666
11667 func (c *PropertiesAdSenseLinksGetCall) doRequest(alt string) (*http.Response, error) {
11668 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11669 if c.ifNoneMatch_ != "" {
11670 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11671 }
11672 var body io.Reader = nil
11673 c.urlParams_.Set("alt", alt)
11674 c.urlParams_.Set("prettyPrint", "false")
11675 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
11676 urls += "?" + c.urlParams_.Encode()
11677 req, err := http.NewRequest("GET", urls, body)
11678 if err != nil {
11679 return nil, err
11680 }
11681 req.Header = reqHeaders
11682 googleapi.Expand(req.URL, map[string]string{
11683 "name": c.nameid,
11684 })
11685 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11686 }
11687
11688
11689
11690
11691
11692
11693
11694 func (c *PropertiesAdSenseLinksGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAdSenseLink, error) {
11695 gensupport.SetOptions(c.urlParams_, opts...)
11696 res, err := c.doRequest("json")
11697 if res != nil && res.StatusCode == http.StatusNotModified {
11698 if res.Body != nil {
11699 res.Body.Close()
11700 }
11701 return nil, gensupport.WrapError(&googleapi.Error{
11702 Code: res.StatusCode,
11703 Header: res.Header,
11704 })
11705 }
11706 if err != nil {
11707 return nil, err
11708 }
11709 defer googleapi.CloseBody(res)
11710 if err := googleapi.CheckResponse(res); err != nil {
11711 return nil, gensupport.WrapError(err)
11712 }
11713 ret := &GoogleAnalyticsAdminV1alphaAdSenseLink{
11714 ServerResponse: googleapi.ServerResponse{
11715 Header: res.Header,
11716 HTTPStatusCode: res.StatusCode,
11717 },
11718 }
11719 target := &ret
11720 if err := gensupport.DecodeResponse(target, res); err != nil {
11721 return nil, err
11722 }
11723 return ret, nil
11724 }
11725
11726 type PropertiesAdSenseLinksListCall struct {
11727 s *Service
11728 parent string
11729 urlParams_ gensupport.URLParams
11730 ifNoneMatch_ string
11731 ctx_ context.Context
11732 header_ http.Header
11733 }
11734
11735
11736
11737
11738
11739 func (r *PropertiesAdSenseLinksService) List(parent string) *PropertiesAdSenseLinksListCall {
11740 c := &PropertiesAdSenseLinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11741 c.parent = parent
11742 return c
11743 }
11744
11745
11746
11747
11748 func (c *PropertiesAdSenseLinksListCall) PageSize(pageSize int64) *PropertiesAdSenseLinksListCall {
11749 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
11750 return c
11751 }
11752
11753
11754
11755
11756
11757 func (c *PropertiesAdSenseLinksListCall) PageToken(pageToken string) *PropertiesAdSenseLinksListCall {
11758 c.urlParams_.Set("pageToken", pageToken)
11759 return c
11760 }
11761
11762
11763
11764
11765 func (c *PropertiesAdSenseLinksListCall) Fields(s ...googleapi.Field) *PropertiesAdSenseLinksListCall {
11766 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11767 return c
11768 }
11769
11770
11771
11772
11773 func (c *PropertiesAdSenseLinksListCall) IfNoneMatch(entityTag string) *PropertiesAdSenseLinksListCall {
11774 c.ifNoneMatch_ = entityTag
11775 return c
11776 }
11777
11778
11779 func (c *PropertiesAdSenseLinksListCall) Context(ctx context.Context) *PropertiesAdSenseLinksListCall {
11780 c.ctx_ = ctx
11781 return c
11782 }
11783
11784
11785
11786 func (c *PropertiesAdSenseLinksListCall) Header() http.Header {
11787 if c.header_ == nil {
11788 c.header_ = make(http.Header)
11789 }
11790 return c.header_
11791 }
11792
11793 func (c *PropertiesAdSenseLinksListCall) doRequest(alt string) (*http.Response, error) {
11794 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11795 if c.ifNoneMatch_ != "" {
11796 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11797 }
11798 var body io.Reader = nil
11799 c.urlParams_.Set("alt", alt)
11800 c.urlParams_.Set("prettyPrint", "false")
11801 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/adSenseLinks")
11802 urls += "?" + c.urlParams_.Encode()
11803 req, err := http.NewRequest("GET", urls, body)
11804 if err != nil {
11805 return nil, err
11806 }
11807 req.Header = reqHeaders
11808 googleapi.Expand(req.URL, map[string]string{
11809 "parent": c.parent,
11810 })
11811 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11812 }
11813
11814
11815
11816
11817
11818
11819
11820 func (c *PropertiesAdSenseLinksListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListAdSenseLinksResponse, error) {
11821 gensupport.SetOptions(c.urlParams_, opts...)
11822 res, err := c.doRequest("json")
11823 if res != nil && res.StatusCode == http.StatusNotModified {
11824 if res.Body != nil {
11825 res.Body.Close()
11826 }
11827 return nil, gensupport.WrapError(&googleapi.Error{
11828 Code: res.StatusCode,
11829 Header: res.Header,
11830 })
11831 }
11832 if err != nil {
11833 return nil, err
11834 }
11835 defer googleapi.CloseBody(res)
11836 if err := googleapi.CheckResponse(res); err != nil {
11837 return nil, gensupport.WrapError(err)
11838 }
11839 ret := &GoogleAnalyticsAdminV1alphaListAdSenseLinksResponse{
11840 ServerResponse: googleapi.ServerResponse{
11841 Header: res.Header,
11842 HTTPStatusCode: res.StatusCode,
11843 },
11844 }
11845 target := &ret
11846 if err := gensupport.DecodeResponse(target, res); err != nil {
11847 return nil, err
11848 }
11849 return ret, nil
11850 }
11851
11852
11853
11854
11855 func (c *PropertiesAdSenseLinksListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListAdSenseLinksResponse) error) error {
11856 c.ctx_ = ctx
11857 defer c.PageToken(c.urlParams_.Get("pageToken"))
11858 for {
11859 x, err := c.Do()
11860 if err != nil {
11861 return err
11862 }
11863 if err := f(x); err != nil {
11864 return err
11865 }
11866 if x.NextPageToken == "" {
11867 return nil
11868 }
11869 c.PageToken(x.NextPageToken)
11870 }
11871 }
11872
11873 type PropertiesAudiencesArchiveCall struct {
11874 s *Service
11875 name string
11876 googleanalyticsadminv1alphaarchiveaudiencerequest *GoogleAnalyticsAdminV1alphaArchiveAudienceRequest
11877 urlParams_ gensupport.URLParams
11878 ctx_ context.Context
11879 header_ http.Header
11880 }
11881
11882
11883
11884
11885 func (r *PropertiesAudiencesService) Archive(name string, googleanalyticsadminv1alphaarchiveaudiencerequest *GoogleAnalyticsAdminV1alphaArchiveAudienceRequest) *PropertiesAudiencesArchiveCall {
11886 c := &PropertiesAudiencesArchiveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11887 c.name = name
11888 c.googleanalyticsadminv1alphaarchiveaudiencerequest = googleanalyticsadminv1alphaarchiveaudiencerequest
11889 return c
11890 }
11891
11892
11893
11894
11895 func (c *PropertiesAudiencesArchiveCall) Fields(s ...googleapi.Field) *PropertiesAudiencesArchiveCall {
11896 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11897 return c
11898 }
11899
11900
11901 func (c *PropertiesAudiencesArchiveCall) Context(ctx context.Context) *PropertiesAudiencesArchiveCall {
11902 c.ctx_ = ctx
11903 return c
11904 }
11905
11906
11907
11908 func (c *PropertiesAudiencesArchiveCall) Header() http.Header {
11909 if c.header_ == nil {
11910 c.header_ = make(http.Header)
11911 }
11912 return c.header_
11913 }
11914
11915 func (c *PropertiesAudiencesArchiveCall) doRequest(alt string) (*http.Response, error) {
11916 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11917 var body io.Reader = nil
11918 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaarchiveaudiencerequest)
11919 if err != nil {
11920 return nil, err
11921 }
11922 c.urlParams_.Set("alt", alt)
11923 c.urlParams_.Set("prettyPrint", "false")
11924 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}:archive")
11925 urls += "?" + c.urlParams_.Encode()
11926 req, err := http.NewRequest("POST", urls, body)
11927 if err != nil {
11928 return nil, err
11929 }
11930 req.Header = reqHeaders
11931 googleapi.Expand(req.URL, map[string]string{
11932 "name": c.name,
11933 })
11934 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11935 }
11936
11937
11938
11939
11940
11941
11942
11943 func (c *PropertiesAudiencesArchiveCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
11944 gensupport.SetOptions(c.urlParams_, opts...)
11945 res, err := c.doRequest("json")
11946 if res != nil && res.StatusCode == http.StatusNotModified {
11947 if res.Body != nil {
11948 res.Body.Close()
11949 }
11950 return nil, gensupport.WrapError(&googleapi.Error{
11951 Code: res.StatusCode,
11952 Header: res.Header,
11953 })
11954 }
11955 if err != nil {
11956 return nil, err
11957 }
11958 defer googleapi.CloseBody(res)
11959 if err := googleapi.CheckResponse(res); err != nil {
11960 return nil, gensupport.WrapError(err)
11961 }
11962 ret := &GoogleProtobufEmpty{
11963 ServerResponse: googleapi.ServerResponse{
11964 Header: res.Header,
11965 HTTPStatusCode: res.StatusCode,
11966 },
11967 }
11968 target := &ret
11969 if err := gensupport.DecodeResponse(target, res); err != nil {
11970 return nil, err
11971 }
11972 return ret, nil
11973 }
11974
11975 type PropertiesAudiencesCreateCall struct {
11976 s *Service
11977 parent string
11978 googleanalyticsadminv1alphaaudience *GoogleAnalyticsAdminV1alphaAudience
11979 urlParams_ gensupport.URLParams
11980 ctx_ context.Context
11981 header_ http.Header
11982 }
11983
11984
11985
11986
11987 func (r *PropertiesAudiencesService) Create(parent string, googleanalyticsadminv1alphaaudience *GoogleAnalyticsAdminV1alphaAudience) *PropertiesAudiencesCreateCall {
11988 c := &PropertiesAudiencesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11989 c.parent = parent
11990 c.googleanalyticsadminv1alphaaudience = googleanalyticsadminv1alphaaudience
11991 return c
11992 }
11993
11994
11995
11996
11997 func (c *PropertiesAudiencesCreateCall) Fields(s ...googleapi.Field) *PropertiesAudiencesCreateCall {
11998 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11999 return c
12000 }
12001
12002
12003 func (c *PropertiesAudiencesCreateCall) Context(ctx context.Context) *PropertiesAudiencesCreateCall {
12004 c.ctx_ = ctx
12005 return c
12006 }
12007
12008
12009
12010 func (c *PropertiesAudiencesCreateCall) Header() http.Header {
12011 if c.header_ == nil {
12012 c.header_ = make(http.Header)
12013 }
12014 return c.header_
12015 }
12016
12017 func (c *PropertiesAudiencesCreateCall) doRequest(alt string) (*http.Response, error) {
12018 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12019 var body io.Reader = nil
12020 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaaudience)
12021 if err != nil {
12022 return nil, err
12023 }
12024 c.urlParams_.Set("alt", alt)
12025 c.urlParams_.Set("prettyPrint", "false")
12026 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/audiences")
12027 urls += "?" + c.urlParams_.Encode()
12028 req, err := http.NewRequest("POST", urls, body)
12029 if err != nil {
12030 return nil, err
12031 }
12032 req.Header = reqHeaders
12033 googleapi.Expand(req.URL, map[string]string{
12034 "parent": c.parent,
12035 })
12036 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12037 }
12038
12039
12040
12041
12042
12043
12044
12045 func (c *PropertiesAudiencesCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAudience, error) {
12046 gensupport.SetOptions(c.urlParams_, opts...)
12047 res, err := c.doRequest("json")
12048 if res != nil && res.StatusCode == http.StatusNotModified {
12049 if res.Body != nil {
12050 res.Body.Close()
12051 }
12052 return nil, gensupport.WrapError(&googleapi.Error{
12053 Code: res.StatusCode,
12054 Header: res.Header,
12055 })
12056 }
12057 if err != nil {
12058 return nil, err
12059 }
12060 defer googleapi.CloseBody(res)
12061 if err := googleapi.CheckResponse(res); err != nil {
12062 return nil, gensupport.WrapError(err)
12063 }
12064 ret := &GoogleAnalyticsAdminV1alphaAudience{
12065 ServerResponse: googleapi.ServerResponse{
12066 Header: res.Header,
12067 HTTPStatusCode: res.StatusCode,
12068 },
12069 }
12070 target := &ret
12071 if err := gensupport.DecodeResponse(target, res); err != nil {
12072 return nil, err
12073 }
12074 return ret, nil
12075 }
12076
12077 type PropertiesAudiencesGetCall struct {
12078 s *Service
12079 name string
12080 urlParams_ gensupport.URLParams
12081 ifNoneMatch_ string
12082 ctx_ context.Context
12083 header_ http.Header
12084 }
12085
12086
12087
12088
12089
12090
12091 func (r *PropertiesAudiencesService) Get(name string) *PropertiesAudiencesGetCall {
12092 c := &PropertiesAudiencesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12093 c.name = name
12094 return c
12095 }
12096
12097
12098
12099
12100 func (c *PropertiesAudiencesGetCall) Fields(s ...googleapi.Field) *PropertiesAudiencesGetCall {
12101 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12102 return c
12103 }
12104
12105
12106
12107
12108 func (c *PropertiesAudiencesGetCall) IfNoneMatch(entityTag string) *PropertiesAudiencesGetCall {
12109 c.ifNoneMatch_ = entityTag
12110 return c
12111 }
12112
12113
12114 func (c *PropertiesAudiencesGetCall) Context(ctx context.Context) *PropertiesAudiencesGetCall {
12115 c.ctx_ = ctx
12116 return c
12117 }
12118
12119
12120
12121 func (c *PropertiesAudiencesGetCall) Header() http.Header {
12122 if c.header_ == nil {
12123 c.header_ = make(http.Header)
12124 }
12125 return c.header_
12126 }
12127
12128 func (c *PropertiesAudiencesGetCall) doRequest(alt string) (*http.Response, error) {
12129 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12130 if c.ifNoneMatch_ != "" {
12131 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12132 }
12133 var body io.Reader = nil
12134 c.urlParams_.Set("alt", alt)
12135 c.urlParams_.Set("prettyPrint", "false")
12136 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
12137 urls += "?" + c.urlParams_.Encode()
12138 req, err := http.NewRequest("GET", urls, body)
12139 if err != nil {
12140 return nil, err
12141 }
12142 req.Header = reqHeaders
12143 googleapi.Expand(req.URL, map[string]string{
12144 "name": c.name,
12145 })
12146 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12147 }
12148
12149
12150
12151
12152
12153
12154
12155 func (c *PropertiesAudiencesGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAudience, error) {
12156 gensupport.SetOptions(c.urlParams_, opts...)
12157 res, err := c.doRequest("json")
12158 if res != nil && res.StatusCode == http.StatusNotModified {
12159 if res.Body != nil {
12160 res.Body.Close()
12161 }
12162 return nil, gensupport.WrapError(&googleapi.Error{
12163 Code: res.StatusCode,
12164 Header: res.Header,
12165 })
12166 }
12167 if err != nil {
12168 return nil, err
12169 }
12170 defer googleapi.CloseBody(res)
12171 if err := googleapi.CheckResponse(res); err != nil {
12172 return nil, gensupport.WrapError(err)
12173 }
12174 ret := &GoogleAnalyticsAdminV1alphaAudience{
12175 ServerResponse: googleapi.ServerResponse{
12176 Header: res.Header,
12177 HTTPStatusCode: res.StatusCode,
12178 },
12179 }
12180 target := &ret
12181 if err := gensupport.DecodeResponse(target, res); err != nil {
12182 return nil, err
12183 }
12184 return ret, nil
12185 }
12186
12187 type PropertiesAudiencesListCall struct {
12188 s *Service
12189 parent string
12190 urlParams_ gensupport.URLParams
12191 ifNoneMatch_ string
12192 ctx_ context.Context
12193 header_ http.Header
12194 }
12195
12196
12197
12198
12199
12200 func (r *PropertiesAudiencesService) List(parent string) *PropertiesAudiencesListCall {
12201 c := &PropertiesAudiencesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12202 c.parent = parent
12203 return c
12204 }
12205
12206
12207
12208
12209 func (c *PropertiesAudiencesListCall) PageSize(pageSize int64) *PropertiesAudiencesListCall {
12210 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
12211 return c
12212 }
12213
12214
12215
12216
12217
12218 func (c *PropertiesAudiencesListCall) PageToken(pageToken string) *PropertiesAudiencesListCall {
12219 c.urlParams_.Set("pageToken", pageToken)
12220 return c
12221 }
12222
12223
12224
12225
12226 func (c *PropertiesAudiencesListCall) Fields(s ...googleapi.Field) *PropertiesAudiencesListCall {
12227 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12228 return c
12229 }
12230
12231
12232
12233
12234 func (c *PropertiesAudiencesListCall) IfNoneMatch(entityTag string) *PropertiesAudiencesListCall {
12235 c.ifNoneMatch_ = entityTag
12236 return c
12237 }
12238
12239
12240 func (c *PropertiesAudiencesListCall) Context(ctx context.Context) *PropertiesAudiencesListCall {
12241 c.ctx_ = ctx
12242 return c
12243 }
12244
12245
12246
12247 func (c *PropertiesAudiencesListCall) Header() http.Header {
12248 if c.header_ == nil {
12249 c.header_ = make(http.Header)
12250 }
12251 return c.header_
12252 }
12253
12254 func (c *PropertiesAudiencesListCall) doRequest(alt string) (*http.Response, error) {
12255 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12256 if c.ifNoneMatch_ != "" {
12257 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12258 }
12259 var body io.Reader = nil
12260 c.urlParams_.Set("alt", alt)
12261 c.urlParams_.Set("prettyPrint", "false")
12262 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/audiences")
12263 urls += "?" + c.urlParams_.Encode()
12264 req, err := http.NewRequest("GET", urls, body)
12265 if err != nil {
12266 return nil, err
12267 }
12268 req.Header = reqHeaders
12269 googleapi.Expand(req.URL, map[string]string{
12270 "parent": c.parent,
12271 })
12272 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12273 }
12274
12275
12276
12277
12278
12279
12280
12281 func (c *PropertiesAudiencesListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListAudiencesResponse, error) {
12282 gensupport.SetOptions(c.urlParams_, opts...)
12283 res, err := c.doRequest("json")
12284 if res != nil && res.StatusCode == http.StatusNotModified {
12285 if res.Body != nil {
12286 res.Body.Close()
12287 }
12288 return nil, gensupport.WrapError(&googleapi.Error{
12289 Code: res.StatusCode,
12290 Header: res.Header,
12291 })
12292 }
12293 if err != nil {
12294 return nil, err
12295 }
12296 defer googleapi.CloseBody(res)
12297 if err := googleapi.CheckResponse(res); err != nil {
12298 return nil, gensupport.WrapError(err)
12299 }
12300 ret := &GoogleAnalyticsAdminV1alphaListAudiencesResponse{
12301 ServerResponse: googleapi.ServerResponse{
12302 Header: res.Header,
12303 HTTPStatusCode: res.StatusCode,
12304 },
12305 }
12306 target := &ret
12307 if err := gensupport.DecodeResponse(target, res); err != nil {
12308 return nil, err
12309 }
12310 return ret, nil
12311 }
12312
12313
12314
12315
12316 func (c *PropertiesAudiencesListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListAudiencesResponse) error) error {
12317 c.ctx_ = ctx
12318 defer c.PageToken(c.urlParams_.Get("pageToken"))
12319 for {
12320 x, err := c.Do()
12321 if err != nil {
12322 return err
12323 }
12324 if err := f(x); err != nil {
12325 return err
12326 }
12327 if x.NextPageToken == "" {
12328 return nil
12329 }
12330 c.PageToken(x.NextPageToken)
12331 }
12332 }
12333
12334 type PropertiesAudiencesPatchCall struct {
12335 s *Service
12336 name string
12337 googleanalyticsadminv1alphaaudience *GoogleAnalyticsAdminV1alphaAudience
12338 urlParams_ gensupport.URLParams
12339 ctx_ context.Context
12340 header_ http.Header
12341 }
12342
12343
12344
12345
12346
12347 func (r *PropertiesAudiencesService) Patch(name string, googleanalyticsadminv1alphaaudience *GoogleAnalyticsAdminV1alphaAudience) *PropertiesAudiencesPatchCall {
12348 c := &PropertiesAudiencesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12349 c.name = name
12350 c.googleanalyticsadminv1alphaaudience = googleanalyticsadminv1alphaaudience
12351 return c
12352 }
12353
12354
12355
12356
12357
12358 func (c *PropertiesAudiencesPatchCall) UpdateMask(updateMask string) *PropertiesAudiencesPatchCall {
12359 c.urlParams_.Set("updateMask", updateMask)
12360 return c
12361 }
12362
12363
12364
12365
12366 func (c *PropertiesAudiencesPatchCall) Fields(s ...googleapi.Field) *PropertiesAudiencesPatchCall {
12367 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12368 return c
12369 }
12370
12371
12372 func (c *PropertiesAudiencesPatchCall) Context(ctx context.Context) *PropertiesAudiencesPatchCall {
12373 c.ctx_ = ctx
12374 return c
12375 }
12376
12377
12378
12379 func (c *PropertiesAudiencesPatchCall) Header() http.Header {
12380 if c.header_ == nil {
12381 c.header_ = make(http.Header)
12382 }
12383 return c.header_
12384 }
12385
12386 func (c *PropertiesAudiencesPatchCall) doRequest(alt string) (*http.Response, error) {
12387 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12388 var body io.Reader = nil
12389 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaaudience)
12390 if err != nil {
12391 return nil, err
12392 }
12393 c.urlParams_.Set("alt", alt)
12394 c.urlParams_.Set("prettyPrint", "false")
12395 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
12396 urls += "?" + c.urlParams_.Encode()
12397 req, err := http.NewRequest("PATCH", urls, body)
12398 if err != nil {
12399 return nil, err
12400 }
12401 req.Header = reqHeaders
12402 googleapi.Expand(req.URL, map[string]string{
12403 "name": c.name,
12404 })
12405 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12406 }
12407
12408
12409
12410
12411
12412
12413
12414 func (c *PropertiesAudiencesPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaAudience, error) {
12415 gensupport.SetOptions(c.urlParams_, opts...)
12416 res, err := c.doRequest("json")
12417 if res != nil && res.StatusCode == http.StatusNotModified {
12418 if res.Body != nil {
12419 res.Body.Close()
12420 }
12421 return nil, gensupport.WrapError(&googleapi.Error{
12422 Code: res.StatusCode,
12423 Header: res.Header,
12424 })
12425 }
12426 if err != nil {
12427 return nil, err
12428 }
12429 defer googleapi.CloseBody(res)
12430 if err := googleapi.CheckResponse(res); err != nil {
12431 return nil, gensupport.WrapError(err)
12432 }
12433 ret := &GoogleAnalyticsAdminV1alphaAudience{
12434 ServerResponse: googleapi.ServerResponse{
12435 Header: res.Header,
12436 HTTPStatusCode: res.StatusCode,
12437 },
12438 }
12439 target := &ret
12440 if err := gensupport.DecodeResponse(target, res); err != nil {
12441 return nil, err
12442 }
12443 return ret, nil
12444 }
12445
12446 type PropertiesBigQueryLinksGetCall struct {
12447 s *Service
12448 name string
12449 urlParams_ gensupport.URLParams
12450 ifNoneMatch_ string
12451 ctx_ context.Context
12452 header_ http.Header
12453 }
12454
12455
12456
12457
12458
12459
12460 func (r *PropertiesBigQueryLinksService) Get(name string) *PropertiesBigQueryLinksGetCall {
12461 c := &PropertiesBigQueryLinksGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12462 c.name = name
12463 return c
12464 }
12465
12466
12467
12468
12469 func (c *PropertiesBigQueryLinksGetCall) Fields(s ...googleapi.Field) *PropertiesBigQueryLinksGetCall {
12470 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12471 return c
12472 }
12473
12474
12475
12476
12477 func (c *PropertiesBigQueryLinksGetCall) IfNoneMatch(entityTag string) *PropertiesBigQueryLinksGetCall {
12478 c.ifNoneMatch_ = entityTag
12479 return c
12480 }
12481
12482
12483 func (c *PropertiesBigQueryLinksGetCall) Context(ctx context.Context) *PropertiesBigQueryLinksGetCall {
12484 c.ctx_ = ctx
12485 return c
12486 }
12487
12488
12489
12490 func (c *PropertiesBigQueryLinksGetCall) Header() http.Header {
12491 if c.header_ == nil {
12492 c.header_ = make(http.Header)
12493 }
12494 return c.header_
12495 }
12496
12497 func (c *PropertiesBigQueryLinksGetCall) doRequest(alt string) (*http.Response, error) {
12498 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12499 if c.ifNoneMatch_ != "" {
12500 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12501 }
12502 var body io.Reader = nil
12503 c.urlParams_.Set("alt", alt)
12504 c.urlParams_.Set("prettyPrint", "false")
12505 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
12506 urls += "?" + c.urlParams_.Encode()
12507 req, err := http.NewRequest("GET", urls, body)
12508 if err != nil {
12509 return nil, err
12510 }
12511 req.Header = reqHeaders
12512 googleapi.Expand(req.URL, map[string]string{
12513 "name": c.name,
12514 })
12515 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12516 }
12517
12518
12519
12520
12521
12522
12523
12524 func (c *PropertiesBigQueryLinksGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaBigQueryLink, error) {
12525 gensupport.SetOptions(c.urlParams_, opts...)
12526 res, err := c.doRequest("json")
12527 if res != nil && res.StatusCode == http.StatusNotModified {
12528 if res.Body != nil {
12529 res.Body.Close()
12530 }
12531 return nil, gensupport.WrapError(&googleapi.Error{
12532 Code: res.StatusCode,
12533 Header: res.Header,
12534 })
12535 }
12536 if err != nil {
12537 return nil, err
12538 }
12539 defer googleapi.CloseBody(res)
12540 if err := googleapi.CheckResponse(res); err != nil {
12541 return nil, gensupport.WrapError(err)
12542 }
12543 ret := &GoogleAnalyticsAdminV1alphaBigQueryLink{
12544 ServerResponse: googleapi.ServerResponse{
12545 Header: res.Header,
12546 HTTPStatusCode: res.StatusCode,
12547 },
12548 }
12549 target := &ret
12550 if err := gensupport.DecodeResponse(target, res); err != nil {
12551 return nil, err
12552 }
12553 return ret, nil
12554 }
12555
12556 type PropertiesBigQueryLinksListCall struct {
12557 s *Service
12558 parent string
12559 urlParams_ gensupport.URLParams
12560 ifNoneMatch_ string
12561 ctx_ context.Context
12562 header_ http.Header
12563 }
12564
12565
12566
12567
12568
12569 func (r *PropertiesBigQueryLinksService) List(parent string) *PropertiesBigQueryLinksListCall {
12570 c := &PropertiesBigQueryLinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12571 c.parent = parent
12572 return c
12573 }
12574
12575
12576
12577
12578
12579
12580 func (c *PropertiesBigQueryLinksListCall) PageSize(pageSize int64) *PropertiesBigQueryLinksListCall {
12581 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
12582 return c
12583 }
12584
12585
12586
12587
12588
12589 func (c *PropertiesBigQueryLinksListCall) PageToken(pageToken string) *PropertiesBigQueryLinksListCall {
12590 c.urlParams_.Set("pageToken", pageToken)
12591 return c
12592 }
12593
12594
12595
12596
12597 func (c *PropertiesBigQueryLinksListCall) Fields(s ...googleapi.Field) *PropertiesBigQueryLinksListCall {
12598 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12599 return c
12600 }
12601
12602
12603
12604
12605 func (c *PropertiesBigQueryLinksListCall) IfNoneMatch(entityTag string) *PropertiesBigQueryLinksListCall {
12606 c.ifNoneMatch_ = entityTag
12607 return c
12608 }
12609
12610
12611 func (c *PropertiesBigQueryLinksListCall) Context(ctx context.Context) *PropertiesBigQueryLinksListCall {
12612 c.ctx_ = ctx
12613 return c
12614 }
12615
12616
12617
12618 func (c *PropertiesBigQueryLinksListCall) Header() http.Header {
12619 if c.header_ == nil {
12620 c.header_ = make(http.Header)
12621 }
12622 return c.header_
12623 }
12624
12625 func (c *PropertiesBigQueryLinksListCall) doRequest(alt string) (*http.Response, error) {
12626 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12627 if c.ifNoneMatch_ != "" {
12628 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12629 }
12630 var body io.Reader = nil
12631 c.urlParams_.Set("alt", alt)
12632 c.urlParams_.Set("prettyPrint", "false")
12633 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/bigQueryLinks")
12634 urls += "?" + c.urlParams_.Encode()
12635 req, err := http.NewRequest("GET", urls, body)
12636 if err != nil {
12637 return nil, err
12638 }
12639 req.Header = reqHeaders
12640 googleapi.Expand(req.URL, map[string]string{
12641 "parent": c.parent,
12642 })
12643 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12644 }
12645
12646
12647
12648
12649
12650
12651
12652 func (c *PropertiesBigQueryLinksListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListBigQueryLinksResponse, error) {
12653 gensupport.SetOptions(c.urlParams_, opts...)
12654 res, err := c.doRequest("json")
12655 if res != nil && res.StatusCode == http.StatusNotModified {
12656 if res.Body != nil {
12657 res.Body.Close()
12658 }
12659 return nil, gensupport.WrapError(&googleapi.Error{
12660 Code: res.StatusCode,
12661 Header: res.Header,
12662 })
12663 }
12664 if err != nil {
12665 return nil, err
12666 }
12667 defer googleapi.CloseBody(res)
12668 if err := googleapi.CheckResponse(res); err != nil {
12669 return nil, gensupport.WrapError(err)
12670 }
12671 ret := &GoogleAnalyticsAdminV1alphaListBigQueryLinksResponse{
12672 ServerResponse: googleapi.ServerResponse{
12673 Header: res.Header,
12674 HTTPStatusCode: res.StatusCode,
12675 },
12676 }
12677 target := &ret
12678 if err := gensupport.DecodeResponse(target, res); err != nil {
12679 return nil, err
12680 }
12681 return ret, nil
12682 }
12683
12684
12685
12686
12687 func (c *PropertiesBigQueryLinksListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListBigQueryLinksResponse) error) error {
12688 c.ctx_ = ctx
12689 defer c.PageToken(c.urlParams_.Get("pageToken"))
12690 for {
12691 x, err := c.Do()
12692 if err != nil {
12693 return err
12694 }
12695 if err := f(x); err != nil {
12696 return err
12697 }
12698 if x.NextPageToken == "" {
12699 return nil
12700 }
12701 c.PageToken(x.NextPageToken)
12702 }
12703 }
12704
12705 type PropertiesCalculatedMetricsCreateCall struct {
12706 s *Service
12707 parent string
12708 googleanalyticsadminv1alphacalculatedmetric *GoogleAnalyticsAdminV1alphaCalculatedMetric
12709 urlParams_ gensupport.URLParams
12710 ctx_ context.Context
12711 header_ http.Header
12712 }
12713
12714
12715
12716
12717 func (r *PropertiesCalculatedMetricsService) Create(parent string, googleanalyticsadminv1alphacalculatedmetric *GoogleAnalyticsAdminV1alphaCalculatedMetric) *PropertiesCalculatedMetricsCreateCall {
12718 c := &PropertiesCalculatedMetricsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12719 c.parent = parent
12720 c.googleanalyticsadminv1alphacalculatedmetric = googleanalyticsadminv1alphacalculatedmetric
12721 return c
12722 }
12723
12724
12725
12726
12727
12728
12729
12730
12731
12732 func (c *PropertiesCalculatedMetricsCreateCall) CalculatedMetricId(calculatedMetricId string) *PropertiesCalculatedMetricsCreateCall {
12733 c.urlParams_.Set("calculatedMetricId", calculatedMetricId)
12734 return c
12735 }
12736
12737
12738
12739
12740 func (c *PropertiesCalculatedMetricsCreateCall) Fields(s ...googleapi.Field) *PropertiesCalculatedMetricsCreateCall {
12741 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12742 return c
12743 }
12744
12745
12746 func (c *PropertiesCalculatedMetricsCreateCall) Context(ctx context.Context) *PropertiesCalculatedMetricsCreateCall {
12747 c.ctx_ = ctx
12748 return c
12749 }
12750
12751
12752
12753 func (c *PropertiesCalculatedMetricsCreateCall) Header() http.Header {
12754 if c.header_ == nil {
12755 c.header_ = make(http.Header)
12756 }
12757 return c.header_
12758 }
12759
12760 func (c *PropertiesCalculatedMetricsCreateCall) doRequest(alt string) (*http.Response, error) {
12761 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12762 var body io.Reader = nil
12763 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacalculatedmetric)
12764 if err != nil {
12765 return nil, err
12766 }
12767 c.urlParams_.Set("alt", alt)
12768 c.urlParams_.Set("prettyPrint", "false")
12769 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/calculatedMetrics")
12770 urls += "?" + c.urlParams_.Encode()
12771 req, err := http.NewRequest("POST", urls, body)
12772 if err != nil {
12773 return nil, err
12774 }
12775 req.Header = reqHeaders
12776 googleapi.Expand(req.URL, map[string]string{
12777 "parent": c.parent,
12778 })
12779 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12780 }
12781
12782
12783
12784
12785
12786
12787
12788 func (c *PropertiesCalculatedMetricsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCalculatedMetric, error) {
12789 gensupport.SetOptions(c.urlParams_, opts...)
12790 res, err := c.doRequest("json")
12791 if res != nil && res.StatusCode == http.StatusNotModified {
12792 if res.Body != nil {
12793 res.Body.Close()
12794 }
12795 return nil, gensupport.WrapError(&googleapi.Error{
12796 Code: res.StatusCode,
12797 Header: res.Header,
12798 })
12799 }
12800 if err != nil {
12801 return nil, err
12802 }
12803 defer googleapi.CloseBody(res)
12804 if err := googleapi.CheckResponse(res); err != nil {
12805 return nil, gensupport.WrapError(err)
12806 }
12807 ret := &GoogleAnalyticsAdminV1alphaCalculatedMetric{
12808 ServerResponse: googleapi.ServerResponse{
12809 Header: res.Header,
12810 HTTPStatusCode: res.StatusCode,
12811 },
12812 }
12813 target := &ret
12814 if err := gensupport.DecodeResponse(target, res); err != nil {
12815 return nil, err
12816 }
12817 return ret, nil
12818 }
12819
12820 type PropertiesCalculatedMetricsDeleteCall struct {
12821 s *Service
12822 name string
12823 urlParams_ gensupport.URLParams
12824 ctx_ context.Context
12825 header_ http.Header
12826 }
12827
12828
12829
12830
12831
12832
12833 func (r *PropertiesCalculatedMetricsService) Delete(name string) *PropertiesCalculatedMetricsDeleteCall {
12834 c := &PropertiesCalculatedMetricsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12835 c.name = name
12836 return c
12837 }
12838
12839
12840
12841
12842 func (c *PropertiesCalculatedMetricsDeleteCall) Fields(s ...googleapi.Field) *PropertiesCalculatedMetricsDeleteCall {
12843 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12844 return c
12845 }
12846
12847
12848 func (c *PropertiesCalculatedMetricsDeleteCall) Context(ctx context.Context) *PropertiesCalculatedMetricsDeleteCall {
12849 c.ctx_ = ctx
12850 return c
12851 }
12852
12853
12854
12855 func (c *PropertiesCalculatedMetricsDeleteCall) Header() http.Header {
12856 if c.header_ == nil {
12857 c.header_ = make(http.Header)
12858 }
12859 return c.header_
12860 }
12861
12862 func (c *PropertiesCalculatedMetricsDeleteCall) doRequest(alt string) (*http.Response, error) {
12863 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12864 var body io.Reader = nil
12865 c.urlParams_.Set("alt", alt)
12866 c.urlParams_.Set("prettyPrint", "false")
12867 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
12868 urls += "?" + c.urlParams_.Encode()
12869 req, err := http.NewRequest("DELETE", urls, body)
12870 if err != nil {
12871 return nil, err
12872 }
12873 req.Header = reqHeaders
12874 googleapi.Expand(req.URL, map[string]string{
12875 "name": c.name,
12876 })
12877 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12878 }
12879
12880
12881
12882
12883
12884
12885
12886 func (c *PropertiesCalculatedMetricsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
12887 gensupport.SetOptions(c.urlParams_, opts...)
12888 res, err := c.doRequest("json")
12889 if res != nil && res.StatusCode == http.StatusNotModified {
12890 if res.Body != nil {
12891 res.Body.Close()
12892 }
12893 return nil, gensupport.WrapError(&googleapi.Error{
12894 Code: res.StatusCode,
12895 Header: res.Header,
12896 })
12897 }
12898 if err != nil {
12899 return nil, err
12900 }
12901 defer googleapi.CloseBody(res)
12902 if err := googleapi.CheckResponse(res); err != nil {
12903 return nil, gensupport.WrapError(err)
12904 }
12905 ret := &GoogleProtobufEmpty{
12906 ServerResponse: googleapi.ServerResponse{
12907 Header: res.Header,
12908 HTTPStatusCode: res.StatusCode,
12909 },
12910 }
12911 target := &ret
12912 if err := gensupport.DecodeResponse(target, res); err != nil {
12913 return nil, err
12914 }
12915 return ret, nil
12916 }
12917
12918 type PropertiesCalculatedMetricsGetCall struct {
12919 s *Service
12920 name string
12921 urlParams_ gensupport.URLParams
12922 ifNoneMatch_ string
12923 ctx_ context.Context
12924 header_ http.Header
12925 }
12926
12927
12928
12929
12930
12931
12932 func (r *PropertiesCalculatedMetricsService) Get(name string) *PropertiesCalculatedMetricsGetCall {
12933 c := &PropertiesCalculatedMetricsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12934 c.name = name
12935 return c
12936 }
12937
12938
12939
12940
12941 func (c *PropertiesCalculatedMetricsGetCall) Fields(s ...googleapi.Field) *PropertiesCalculatedMetricsGetCall {
12942 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12943 return c
12944 }
12945
12946
12947
12948
12949 func (c *PropertiesCalculatedMetricsGetCall) IfNoneMatch(entityTag string) *PropertiesCalculatedMetricsGetCall {
12950 c.ifNoneMatch_ = entityTag
12951 return c
12952 }
12953
12954
12955 func (c *PropertiesCalculatedMetricsGetCall) Context(ctx context.Context) *PropertiesCalculatedMetricsGetCall {
12956 c.ctx_ = ctx
12957 return c
12958 }
12959
12960
12961
12962 func (c *PropertiesCalculatedMetricsGetCall) Header() http.Header {
12963 if c.header_ == nil {
12964 c.header_ = make(http.Header)
12965 }
12966 return c.header_
12967 }
12968
12969 func (c *PropertiesCalculatedMetricsGetCall) doRequest(alt string) (*http.Response, error) {
12970 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12971 if c.ifNoneMatch_ != "" {
12972 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12973 }
12974 var body io.Reader = nil
12975 c.urlParams_.Set("alt", alt)
12976 c.urlParams_.Set("prettyPrint", "false")
12977 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
12978 urls += "?" + c.urlParams_.Encode()
12979 req, err := http.NewRequest("GET", urls, body)
12980 if err != nil {
12981 return nil, err
12982 }
12983 req.Header = reqHeaders
12984 googleapi.Expand(req.URL, map[string]string{
12985 "name": c.name,
12986 })
12987 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12988 }
12989
12990
12991
12992
12993
12994
12995
12996 func (c *PropertiesCalculatedMetricsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCalculatedMetric, error) {
12997 gensupport.SetOptions(c.urlParams_, opts...)
12998 res, err := c.doRequest("json")
12999 if res != nil && res.StatusCode == http.StatusNotModified {
13000 if res.Body != nil {
13001 res.Body.Close()
13002 }
13003 return nil, gensupport.WrapError(&googleapi.Error{
13004 Code: res.StatusCode,
13005 Header: res.Header,
13006 })
13007 }
13008 if err != nil {
13009 return nil, err
13010 }
13011 defer googleapi.CloseBody(res)
13012 if err := googleapi.CheckResponse(res); err != nil {
13013 return nil, gensupport.WrapError(err)
13014 }
13015 ret := &GoogleAnalyticsAdminV1alphaCalculatedMetric{
13016 ServerResponse: googleapi.ServerResponse{
13017 Header: res.Header,
13018 HTTPStatusCode: res.StatusCode,
13019 },
13020 }
13021 target := &ret
13022 if err := gensupport.DecodeResponse(target, res); err != nil {
13023 return nil, err
13024 }
13025 return ret, nil
13026 }
13027
13028 type PropertiesCalculatedMetricsListCall struct {
13029 s *Service
13030 parent string
13031 urlParams_ gensupport.URLParams
13032 ifNoneMatch_ string
13033 ctx_ context.Context
13034 header_ http.Header
13035 }
13036
13037
13038
13039
13040 func (r *PropertiesCalculatedMetricsService) List(parent string) *PropertiesCalculatedMetricsListCall {
13041 c := &PropertiesCalculatedMetricsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13042 c.parent = parent
13043 return c
13044 }
13045
13046
13047
13048
13049 func (c *PropertiesCalculatedMetricsListCall) PageSize(pageSize int64) *PropertiesCalculatedMetricsListCall {
13050 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
13051 return c
13052 }
13053
13054
13055
13056
13057
13058 func (c *PropertiesCalculatedMetricsListCall) PageToken(pageToken string) *PropertiesCalculatedMetricsListCall {
13059 c.urlParams_.Set("pageToken", pageToken)
13060 return c
13061 }
13062
13063
13064
13065
13066 func (c *PropertiesCalculatedMetricsListCall) Fields(s ...googleapi.Field) *PropertiesCalculatedMetricsListCall {
13067 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13068 return c
13069 }
13070
13071
13072
13073
13074 func (c *PropertiesCalculatedMetricsListCall) IfNoneMatch(entityTag string) *PropertiesCalculatedMetricsListCall {
13075 c.ifNoneMatch_ = entityTag
13076 return c
13077 }
13078
13079
13080 func (c *PropertiesCalculatedMetricsListCall) Context(ctx context.Context) *PropertiesCalculatedMetricsListCall {
13081 c.ctx_ = ctx
13082 return c
13083 }
13084
13085
13086
13087 func (c *PropertiesCalculatedMetricsListCall) Header() http.Header {
13088 if c.header_ == nil {
13089 c.header_ = make(http.Header)
13090 }
13091 return c.header_
13092 }
13093
13094 func (c *PropertiesCalculatedMetricsListCall) doRequest(alt string) (*http.Response, error) {
13095 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13096 if c.ifNoneMatch_ != "" {
13097 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13098 }
13099 var body io.Reader = nil
13100 c.urlParams_.Set("alt", alt)
13101 c.urlParams_.Set("prettyPrint", "false")
13102 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/calculatedMetrics")
13103 urls += "?" + c.urlParams_.Encode()
13104 req, err := http.NewRequest("GET", urls, body)
13105 if err != nil {
13106 return nil, err
13107 }
13108 req.Header = reqHeaders
13109 googleapi.Expand(req.URL, map[string]string{
13110 "parent": c.parent,
13111 })
13112 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13113 }
13114
13115
13116
13117
13118
13119
13120
13121 func (c *PropertiesCalculatedMetricsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListCalculatedMetricsResponse, error) {
13122 gensupport.SetOptions(c.urlParams_, opts...)
13123 res, err := c.doRequest("json")
13124 if res != nil && res.StatusCode == http.StatusNotModified {
13125 if res.Body != nil {
13126 res.Body.Close()
13127 }
13128 return nil, gensupport.WrapError(&googleapi.Error{
13129 Code: res.StatusCode,
13130 Header: res.Header,
13131 })
13132 }
13133 if err != nil {
13134 return nil, err
13135 }
13136 defer googleapi.CloseBody(res)
13137 if err := googleapi.CheckResponse(res); err != nil {
13138 return nil, gensupport.WrapError(err)
13139 }
13140 ret := &GoogleAnalyticsAdminV1alphaListCalculatedMetricsResponse{
13141 ServerResponse: googleapi.ServerResponse{
13142 Header: res.Header,
13143 HTTPStatusCode: res.StatusCode,
13144 },
13145 }
13146 target := &ret
13147 if err := gensupport.DecodeResponse(target, res); err != nil {
13148 return nil, err
13149 }
13150 return ret, nil
13151 }
13152
13153
13154
13155
13156 func (c *PropertiesCalculatedMetricsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListCalculatedMetricsResponse) error) error {
13157 c.ctx_ = ctx
13158 defer c.PageToken(c.urlParams_.Get("pageToken"))
13159 for {
13160 x, err := c.Do()
13161 if err != nil {
13162 return err
13163 }
13164 if err := f(x); err != nil {
13165 return err
13166 }
13167 if x.NextPageToken == "" {
13168 return nil
13169 }
13170 c.PageToken(x.NextPageToken)
13171 }
13172 }
13173
13174 type PropertiesCalculatedMetricsPatchCall struct {
13175 s *Service
13176 name string
13177 googleanalyticsadminv1alphacalculatedmetric *GoogleAnalyticsAdminV1alphaCalculatedMetric
13178 urlParams_ gensupport.URLParams
13179 ctx_ context.Context
13180 header_ http.Header
13181 }
13182
13183
13184
13185
13186
13187 func (r *PropertiesCalculatedMetricsService) Patch(name string, googleanalyticsadminv1alphacalculatedmetric *GoogleAnalyticsAdminV1alphaCalculatedMetric) *PropertiesCalculatedMetricsPatchCall {
13188 c := &PropertiesCalculatedMetricsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13189 c.name = name
13190 c.googleanalyticsadminv1alphacalculatedmetric = googleanalyticsadminv1alphacalculatedmetric
13191 return c
13192 }
13193
13194
13195
13196
13197 func (c *PropertiesCalculatedMetricsPatchCall) UpdateMask(updateMask string) *PropertiesCalculatedMetricsPatchCall {
13198 c.urlParams_.Set("updateMask", updateMask)
13199 return c
13200 }
13201
13202
13203
13204
13205 func (c *PropertiesCalculatedMetricsPatchCall) Fields(s ...googleapi.Field) *PropertiesCalculatedMetricsPatchCall {
13206 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13207 return c
13208 }
13209
13210
13211 func (c *PropertiesCalculatedMetricsPatchCall) Context(ctx context.Context) *PropertiesCalculatedMetricsPatchCall {
13212 c.ctx_ = ctx
13213 return c
13214 }
13215
13216
13217
13218 func (c *PropertiesCalculatedMetricsPatchCall) Header() http.Header {
13219 if c.header_ == nil {
13220 c.header_ = make(http.Header)
13221 }
13222 return c.header_
13223 }
13224
13225 func (c *PropertiesCalculatedMetricsPatchCall) doRequest(alt string) (*http.Response, error) {
13226 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13227 var body io.Reader = nil
13228 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacalculatedmetric)
13229 if err != nil {
13230 return nil, err
13231 }
13232 c.urlParams_.Set("alt", alt)
13233 c.urlParams_.Set("prettyPrint", "false")
13234 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
13235 urls += "?" + c.urlParams_.Encode()
13236 req, err := http.NewRequest("PATCH", urls, body)
13237 if err != nil {
13238 return nil, err
13239 }
13240 req.Header = reqHeaders
13241 googleapi.Expand(req.URL, map[string]string{
13242 "name": c.name,
13243 })
13244 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13245 }
13246
13247
13248
13249
13250
13251
13252
13253 func (c *PropertiesCalculatedMetricsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCalculatedMetric, error) {
13254 gensupport.SetOptions(c.urlParams_, opts...)
13255 res, err := c.doRequest("json")
13256 if res != nil && res.StatusCode == http.StatusNotModified {
13257 if res.Body != nil {
13258 res.Body.Close()
13259 }
13260 return nil, gensupport.WrapError(&googleapi.Error{
13261 Code: res.StatusCode,
13262 Header: res.Header,
13263 })
13264 }
13265 if err != nil {
13266 return nil, err
13267 }
13268 defer googleapi.CloseBody(res)
13269 if err := googleapi.CheckResponse(res); err != nil {
13270 return nil, gensupport.WrapError(err)
13271 }
13272 ret := &GoogleAnalyticsAdminV1alphaCalculatedMetric{
13273 ServerResponse: googleapi.ServerResponse{
13274 Header: res.Header,
13275 HTTPStatusCode: res.StatusCode,
13276 },
13277 }
13278 target := &ret
13279 if err := gensupport.DecodeResponse(target, res); err != nil {
13280 return nil, err
13281 }
13282 return ret, nil
13283 }
13284
13285 type PropertiesChannelGroupsCreateCall struct {
13286 s *Service
13287 parent string
13288 googleanalyticsadminv1alphachannelgroup *GoogleAnalyticsAdminV1alphaChannelGroup
13289 urlParams_ gensupport.URLParams
13290 ctx_ context.Context
13291 header_ http.Header
13292 }
13293
13294
13295
13296
13297
13298 func (r *PropertiesChannelGroupsService) Create(parent string, googleanalyticsadminv1alphachannelgroup *GoogleAnalyticsAdminV1alphaChannelGroup) *PropertiesChannelGroupsCreateCall {
13299 c := &PropertiesChannelGroupsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13300 c.parent = parent
13301 c.googleanalyticsadminv1alphachannelgroup = googleanalyticsadminv1alphachannelgroup
13302 return c
13303 }
13304
13305
13306
13307
13308 func (c *PropertiesChannelGroupsCreateCall) Fields(s ...googleapi.Field) *PropertiesChannelGroupsCreateCall {
13309 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13310 return c
13311 }
13312
13313
13314 func (c *PropertiesChannelGroupsCreateCall) Context(ctx context.Context) *PropertiesChannelGroupsCreateCall {
13315 c.ctx_ = ctx
13316 return c
13317 }
13318
13319
13320
13321 func (c *PropertiesChannelGroupsCreateCall) Header() http.Header {
13322 if c.header_ == nil {
13323 c.header_ = make(http.Header)
13324 }
13325 return c.header_
13326 }
13327
13328 func (c *PropertiesChannelGroupsCreateCall) doRequest(alt string) (*http.Response, error) {
13329 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13330 var body io.Reader = nil
13331 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphachannelgroup)
13332 if err != nil {
13333 return nil, err
13334 }
13335 c.urlParams_.Set("alt", alt)
13336 c.urlParams_.Set("prettyPrint", "false")
13337 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/channelGroups")
13338 urls += "?" + c.urlParams_.Encode()
13339 req, err := http.NewRequest("POST", urls, body)
13340 if err != nil {
13341 return nil, err
13342 }
13343 req.Header = reqHeaders
13344 googleapi.Expand(req.URL, map[string]string{
13345 "parent": c.parent,
13346 })
13347 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13348 }
13349
13350
13351
13352
13353
13354
13355
13356 func (c *PropertiesChannelGroupsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaChannelGroup, error) {
13357 gensupport.SetOptions(c.urlParams_, opts...)
13358 res, err := c.doRequest("json")
13359 if res != nil && res.StatusCode == http.StatusNotModified {
13360 if res.Body != nil {
13361 res.Body.Close()
13362 }
13363 return nil, gensupport.WrapError(&googleapi.Error{
13364 Code: res.StatusCode,
13365 Header: res.Header,
13366 })
13367 }
13368 if err != nil {
13369 return nil, err
13370 }
13371 defer googleapi.CloseBody(res)
13372 if err := googleapi.CheckResponse(res); err != nil {
13373 return nil, gensupport.WrapError(err)
13374 }
13375 ret := &GoogleAnalyticsAdminV1alphaChannelGroup{
13376 ServerResponse: googleapi.ServerResponse{
13377 Header: res.Header,
13378 HTTPStatusCode: res.StatusCode,
13379 },
13380 }
13381 target := &ret
13382 if err := gensupport.DecodeResponse(target, res); err != nil {
13383 return nil, err
13384 }
13385 return ret, nil
13386 }
13387
13388 type PropertiesChannelGroupsDeleteCall struct {
13389 s *Service
13390 name string
13391 urlParams_ gensupport.URLParams
13392 ctx_ context.Context
13393 header_ http.Header
13394 }
13395
13396
13397
13398
13399
13400 func (r *PropertiesChannelGroupsService) Delete(name string) *PropertiesChannelGroupsDeleteCall {
13401 c := &PropertiesChannelGroupsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13402 c.name = name
13403 return c
13404 }
13405
13406
13407
13408
13409 func (c *PropertiesChannelGroupsDeleteCall) Fields(s ...googleapi.Field) *PropertiesChannelGroupsDeleteCall {
13410 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13411 return c
13412 }
13413
13414
13415 func (c *PropertiesChannelGroupsDeleteCall) Context(ctx context.Context) *PropertiesChannelGroupsDeleteCall {
13416 c.ctx_ = ctx
13417 return c
13418 }
13419
13420
13421
13422 func (c *PropertiesChannelGroupsDeleteCall) Header() http.Header {
13423 if c.header_ == nil {
13424 c.header_ = make(http.Header)
13425 }
13426 return c.header_
13427 }
13428
13429 func (c *PropertiesChannelGroupsDeleteCall) doRequest(alt string) (*http.Response, error) {
13430 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13431 var body io.Reader = nil
13432 c.urlParams_.Set("alt", alt)
13433 c.urlParams_.Set("prettyPrint", "false")
13434 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
13435 urls += "?" + c.urlParams_.Encode()
13436 req, err := http.NewRequest("DELETE", urls, body)
13437 if err != nil {
13438 return nil, err
13439 }
13440 req.Header = reqHeaders
13441 googleapi.Expand(req.URL, map[string]string{
13442 "name": c.name,
13443 })
13444 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13445 }
13446
13447
13448
13449
13450
13451
13452
13453 func (c *PropertiesChannelGroupsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
13454 gensupport.SetOptions(c.urlParams_, opts...)
13455 res, err := c.doRequest("json")
13456 if res != nil && res.StatusCode == http.StatusNotModified {
13457 if res.Body != nil {
13458 res.Body.Close()
13459 }
13460 return nil, gensupport.WrapError(&googleapi.Error{
13461 Code: res.StatusCode,
13462 Header: res.Header,
13463 })
13464 }
13465 if err != nil {
13466 return nil, err
13467 }
13468 defer googleapi.CloseBody(res)
13469 if err := googleapi.CheckResponse(res); err != nil {
13470 return nil, gensupport.WrapError(err)
13471 }
13472 ret := &GoogleProtobufEmpty{
13473 ServerResponse: googleapi.ServerResponse{
13474 Header: res.Header,
13475 HTTPStatusCode: res.StatusCode,
13476 },
13477 }
13478 target := &ret
13479 if err := gensupport.DecodeResponse(target, res); err != nil {
13480 return nil, err
13481 }
13482 return ret, nil
13483 }
13484
13485 type PropertiesChannelGroupsGetCall struct {
13486 s *Service
13487 name string
13488 urlParams_ gensupport.URLParams
13489 ifNoneMatch_ string
13490 ctx_ context.Context
13491 header_ http.Header
13492 }
13493
13494
13495
13496
13497
13498 func (r *PropertiesChannelGroupsService) Get(name string) *PropertiesChannelGroupsGetCall {
13499 c := &PropertiesChannelGroupsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13500 c.name = name
13501 return c
13502 }
13503
13504
13505
13506
13507 func (c *PropertiesChannelGroupsGetCall) Fields(s ...googleapi.Field) *PropertiesChannelGroupsGetCall {
13508 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13509 return c
13510 }
13511
13512
13513
13514
13515 func (c *PropertiesChannelGroupsGetCall) IfNoneMatch(entityTag string) *PropertiesChannelGroupsGetCall {
13516 c.ifNoneMatch_ = entityTag
13517 return c
13518 }
13519
13520
13521 func (c *PropertiesChannelGroupsGetCall) Context(ctx context.Context) *PropertiesChannelGroupsGetCall {
13522 c.ctx_ = ctx
13523 return c
13524 }
13525
13526
13527
13528 func (c *PropertiesChannelGroupsGetCall) Header() http.Header {
13529 if c.header_ == nil {
13530 c.header_ = make(http.Header)
13531 }
13532 return c.header_
13533 }
13534
13535 func (c *PropertiesChannelGroupsGetCall) doRequest(alt string) (*http.Response, error) {
13536 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13537 if c.ifNoneMatch_ != "" {
13538 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13539 }
13540 var body io.Reader = nil
13541 c.urlParams_.Set("alt", alt)
13542 c.urlParams_.Set("prettyPrint", "false")
13543 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
13544 urls += "?" + c.urlParams_.Encode()
13545 req, err := http.NewRequest("GET", urls, body)
13546 if err != nil {
13547 return nil, err
13548 }
13549 req.Header = reqHeaders
13550 googleapi.Expand(req.URL, map[string]string{
13551 "name": c.name,
13552 })
13553 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13554 }
13555
13556
13557
13558
13559
13560
13561
13562 func (c *PropertiesChannelGroupsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaChannelGroup, error) {
13563 gensupport.SetOptions(c.urlParams_, opts...)
13564 res, err := c.doRequest("json")
13565 if res != nil && res.StatusCode == http.StatusNotModified {
13566 if res.Body != nil {
13567 res.Body.Close()
13568 }
13569 return nil, gensupport.WrapError(&googleapi.Error{
13570 Code: res.StatusCode,
13571 Header: res.Header,
13572 })
13573 }
13574 if err != nil {
13575 return nil, err
13576 }
13577 defer googleapi.CloseBody(res)
13578 if err := googleapi.CheckResponse(res); err != nil {
13579 return nil, gensupport.WrapError(err)
13580 }
13581 ret := &GoogleAnalyticsAdminV1alphaChannelGroup{
13582 ServerResponse: googleapi.ServerResponse{
13583 Header: res.Header,
13584 HTTPStatusCode: res.StatusCode,
13585 },
13586 }
13587 target := &ret
13588 if err := gensupport.DecodeResponse(target, res); err != nil {
13589 return nil, err
13590 }
13591 return ret, nil
13592 }
13593
13594 type PropertiesChannelGroupsListCall struct {
13595 s *Service
13596 parent string
13597 urlParams_ gensupport.URLParams
13598 ifNoneMatch_ string
13599 ctx_ context.Context
13600 header_ http.Header
13601 }
13602
13603
13604
13605
13606
13607 func (r *PropertiesChannelGroupsService) List(parent string) *PropertiesChannelGroupsListCall {
13608 c := &PropertiesChannelGroupsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13609 c.parent = parent
13610 return c
13611 }
13612
13613
13614
13615
13616 func (c *PropertiesChannelGroupsListCall) PageSize(pageSize int64) *PropertiesChannelGroupsListCall {
13617 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
13618 return c
13619 }
13620
13621
13622
13623
13624
13625 func (c *PropertiesChannelGroupsListCall) PageToken(pageToken string) *PropertiesChannelGroupsListCall {
13626 c.urlParams_.Set("pageToken", pageToken)
13627 return c
13628 }
13629
13630
13631
13632
13633 func (c *PropertiesChannelGroupsListCall) Fields(s ...googleapi.Field) *PropertiesChannelGroupsListCall {
13634 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13635 return c
13636 }
13637
13638
13639
13640
13641 func (c *PropertiesChannelGroupsListCall) IfNoneMatch(entityTag string) *PropertiesChannelGroupsListCall {
13642 c.ifNoneMatch_ = entityTag
13643 return c
13644 }
13645
13646
13647 func (c *PropertiesChannelGroupsListCall) Context(ctx context.Context) *PropertiesChannelGroupsListCall {
13648 c.ctx_ = ctx
13649 return c
13650 }
13651
13652
13653
13654 func (c *PropertiesChannelGroupsListCall) Header() http.Header {
13655 if c.header_ == nil {
13656 c.header_ = make(http.Header)
13657 }
13658 return c.header_
13659 }
13660
13661 func (c *PropertiesChannelGroupsListCall) doRequest(alt string) (*http.Response, error) {
13662 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13663 if c.ifNoneMatch_ != "" {
13664 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13665 }
13666 var body io.Reader = nil
13667 c.urlParams_.Set("alt", alt)
13668 c.urlParams_.Set("prettyPrint", "false")
13669 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/channelGroups")
13670 urls += "?" + c.urlParams_.Encode()
13671 req, err := http.NewRequest("GET", urls, body)
13672 if err != nil {
13673 return nil, err
13674 }
13675 req.Header = reqHeaders
13676 googleapi.Expand(req.URL, map[string]string{
13677 "parent": c.parent,
13678 })
13679 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13680 }
13681
13682
13683
13684
13685
13686
13687
13688 func (c *PropertiesChannelGroupsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListChannelGroupsResponse, error) {
13689 gensupport.SetOptions(c.urlParams_, opts...)
13690 res, err := c.doRequest("json")
13691 if res != nil && res.StatusCode == http.StatusNotModified {
13692 if res.Body != nil {
13693 res.Body.Close()
13694 }
13695 return nil, gensupport.WrapError(&googleapi.Error{
13696 Code: res.StatusCode,
13697 Header: res.Header,
13698 })
13699 }
13700 if err != nil {
13701 return nil, err
13702 }
13703 defer googleapi.CloseBody(res)
13704 if err := googleapi.CheckResponse(res); err != nil {
13705 return nil, gensupport.WrapError(err)
13706 }
13707 ret := &GoogleAnalyticsAdminV1alphaListChannelGroupsResponse{
13708 ServerResponse: googleapi.ServerResponse{
13709 Header: res.Header,
13710 HTTPStatusCode: res.StatusCode,
13711 },
13712 }
13713 target := &ret
13714 if err := gensupport.DecodeResponse(target, res); err != nil {
13715 return nil, err
13716 }
13717 return ret, nil
13718 }
13719
13720
13721
13722
13723 func (c *PropertiesChannelGroupsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListChannelGroupsResponse) error) error {
13724 c.ctx_ = ctx
13725 defer c.PageToken(c.urlParams_.Get("pageToken"))
13726 for {
13727 x, err := c.Do()
13728 if err != nil {
13729 return err
13730 }
13731 if err := f(x); err != nil {
13732 return err
13733 }
13734 if x.NextPageToken == "" {
13735 return nil
13736 }
13737 c.PageToken(x.NextPageToken)
13738 }
13739 }
13740
13741 type PropertiesChannelGroupsPatchCall struct {
13742 s *Service
13743 name string
13744 googleanalyticsadminv1alphachannelgroup *GoogleAnalyticsAdminV1alphaChannelGroup
13745 urlParams_ gensupport.URLParams
13746 ctx_ context.Context
13747 header_ http.Header
13748 }
13749
13750
13751
13752
13753
13754 func (r *PropertiesChannelGroupsService) Patch(name string, googleanalyticsadminv1alphachannelgroup *GoogleAnalyticsAdminV1alphaChannelGroup) *PropertiesChannelGroupsPatchCall {
13755 c := &PropertiesChannelGroupsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13756 c.name = name
13757 c.googleanalyticsadminv1alphachannelgroup = googleanalyticsadminv1alphachannelgroup
13758 return c
13759 }
13760
13761
13762
13763
13764
13765 func (c *PropertiesChannelGroupsPatchCall) UpdateMask(updateMask string) *PropertiesChannelGroupsPatchCall {
13766 c.urlParams_.Set("updateMask", updateMask)
13767 return c
13768 }
13769
13770
13771
13772
13773 func (c *PropertiesChannelGroupsPatchCall) Fields(s ...googleapi.Field) *PropertiesChannelGroupsPatchCall {
13774 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13775 return c
13776 }
13777
13778
13779 func (c *PropertiesChannelGroupsPatchCall) Context(ctx context.Context) *PropertiesChannelGroupsPatchCall {
13780 c.ctx_ = ctx
13781 return c
13782 }
13783
13784
13785
13786 func (c *PropertiesChannelGroupsPatchCall) Header() http.Header {
13787 if c.header_ == nil {
13788 c.header_ = make(http.Header)
13789 }
13790 return c.header_
13791 }
13792
13793 func (c *PropertiesChannelGroupsPatchCall) doRequest(alt string) (*http.Response, error) {
13794 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13795 var body io.Reader = nil
13796 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphachannelgroup)
13797 if err != nil {
13798 return nil, err
13799 }
13800 c.urlParams_.Set("alt", alt)
13801 c.urlParams_.Set("prettyPrint", "false")
13802 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
13803 urls += "?" + c.urlParams_.Encode()
13804 req, err := http.NewRequest("PATCH", urls, body)
13805 if err != nil {
13806 return nil, err
13807 }
13808 req.Header = reqHeaders
13809 googleapi.Expand(req.URL, map[string]string{
13810 "name": c.name,
13811 })
13812 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13813 }
13814
13815
13816
13817
13818
13819
13820
13821 func (c *PropertiesChannelGroupsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaChannelGroup, error) {
13822 gensupport.SetOptions(c.urlParams_, opts...)
13823 res, err := c.doRequest("json")
13824 if res != nil && res.StatusCode == http.StatusNotModified {
13825 if res.Body != nil {
13826 res.Body.Close()
13827 }
13828 return nil, gensupport.WrapError(&googleapi.Error{
13829 Code: res.StatusCode,
13830 Header: res.Header,
13831 })
13832 }
13833 if err != nil {
13834 return nil, err
13835 }
13836 defer googleapi.CloseBody(res)
13837 if err := googleapi.CheckResponse(res); err != nil {
13838 return nil, gensupport.WrapError(err)
13839 }
13840 ret := &GoogleAnalyticsAdminV1alphaChannelGroup{
13841 ServerResponse: googleapi.ServerResponse{
13842 Header: res.Header,
13843 HTTPStatusCode: res.StatusCode,
13844 },
13845 }
13846 target := &ret
13847 if err := gensupport.DecodeResponse(target, res); err != nil {
13848 return nil, err
13849 }
13850 return ret, nil
13851 }
13852
13853 type PropertiesConversionEventsCreateCall struct {
13854 s *Service
13855 parent string
13856 googleanalyticsadminv1alphaconversionevent *GoogleAnalyticsAdminV1alphaConversionEvent
13857 urlParams_ gensupport.URLParams
13858 ctx_ context.Context
13859 header_ http.Header
13860 }
13861
13862
13863
13864
13865
13866 func (r *PropertiesConversionEventsService) Create(parent string, googleanalyticsadminv1alphaconversionevent *GoogleAnalyticsAdminV1alphaConversionEvent) *PropertiesConversionEventsCreateCall {
13867 c := &PropertiesConversionEventsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13868 c.parent = parent
13869 c.googleanalyticsadminv1alphaconversionevent = googleanalyticsadminv1alphaconversionevent
13870 return c
13871 }
13872
13873
13874
13875
13876 func (c *PropertiesConversionEventsCreateCall) Fields(s ...googleapi.Field) *PropertiesConversionEventsCreateCall {
13877 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13878 return c
13879 }
13880
13881
13882 func (c *PropertiesConversionEventsCreateCall) Context(ctx context.Context) *PropertiesConversionEventsCreateCall {
13883 c.ctx_ = ctx
13884 return c
13885 }
13886
13887
13888
13889 func (c *PropertiesConversionEventsCreateCall) Header() http.Header {
13890 if c.header_ == nil {
13891 c.header_ = make(http.Header)
13892 }
13893 return c.header_
13894 }
13895
13896 func (c *PropertiesConversionEventsCreateCall) doRequest(alt string) (*http.Response, error) {
13897 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13898 var body io.Reader = nil
13899 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaconversionevent)
13900 if err != nil {
13901 return nil, err
13902 }
13903 c.urlParams_.Set("alt", alt)
13904 c.urlParams_.Set("prettyPrint", "false")
13905 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/conversionEvents")
13906 urls += "?" + c.urlParams_.Encode()
13907 req, err := http.NewRequest("POST", urls, body)
13908 if err != nil {
13909 return nil, err
13910 }
13911 req.Header = reqHeaders
13912 googleapi.Expand(req.URL, map[string]string{
13913 "parent": c.parent,
13914 })
13915 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13916 }
13917
13918
13919
13920
13921
13922
13923
13924 func (c *PropertiesConversionEventsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaConversionEvent, error) {
13925 gensupport.SetOptions(c.urlParams_, opts...)
13926 res, err := c.doRequest("json")
13927 if res != nil && res.StatusCode == http.StatusNotModified {
13928 if res.Body != nil {
13929 res.Body.Close()
13930 }
13931 return nil, gensupport.WrapError(&googleapi.Error{
13932 Code: res.StatusCode,
13933 Header: res.Header,
13934 })
13935 }
13936 if err != nil {
13937 return nil, err
13938 }
13939 defer googleapi.CloseBody(res)
13940 if err := googleapi.CheckResponse(res); err != nil {
13941 return nil, gensupport.WrapError(err)
13942 }
13943 ret := &GoogleAnalyticsAdminV1alphaConversionEvent{
13944 ServerResponse: googleapi.ServerResponse{
13945 Header: res.Header,
13946 HTTPStatusCode: res.StatusCode,
13947 },
13948 }
13949 target := &ret
13950 if err := gensupport.DecodeResponse(target, res); err != nil {
13951 return nil, err
13952 }
13953 return ret, nil
13954 }
13955
13956 type PropertiesConversionEventsDeleteCall struct {
13957 s *Service
13958 name string
13959 urlParams_ gensupport.URLParams
13960 ctx_ context.Context
13961 header_ http.Header
13962 }
13963
13964
13965
13966
13967
13968
13969 func (r *PropertiesConversionEventsService) Delete(name string) *PropertiesConversionEventsDeleteCall {
13970 c := &PropertiesConversionEventsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13971 c.name = name
13972 return c
13973 }
13974
13975
13976
13977
13978 func (c *PropertiesConversionEventsDeleteCall) Fields(s ...googleapi.Field) *PropertiesConversionEventsDeleteCall {
13979 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13980 return c
13981 }
13982
13983
13984 func (c *PropertiesConversionEventsDeleteCall) Context(ctx context.Context) *PropertiesConversionEventsDeleteCall {
13985 c.ctx_ = ctx
13986 return c
13987 }
13988
13989
13990
13991 func (c *PropertiesConversionEventsDeleteCall) Header() http.Header {
13992 if c.header_ == nil {
13993 c.header_ = make(http.Header)
13994 }
13995 return c.header_
13996 }
13997
13998 func (c *PropertiesConversionEventsDeleteCall) doRequest(alt string) (*http.Response, error) {
13999 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14000 var body io.Reader = nil
14001 c.urlParams_.Set("alt", alt)
14002 c.urlParams_.Set("prettyPrint", "false")
14003 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
14004 urls += "?" + c.urlParams_.Encode()
14005 req, err := http.NewRequest("DELETE", urls, body)
14006 if err != nil {
14007 return nil, err
14008 }
14009 req.Header = reqHeaders
14010 googleapi.Expand(req.URL, map[string]string{
14011 "name": c.name,
14012 })
14013 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14014 }
14015
14016
14017
14018
14019
14020
14021
14022 func (c *PropertiesConversionEventsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
14023 gensupport.SetOptions(c.urlParams_, opts...)
14024 res, err := c.doRequest("json")
14025 if res != nil && res.StatusCode == http.StatusNotModified {
14026 if res.Body != nil {
14027 res.Body.Close()
14028 }
14029 return nil, gensupport.WrapError(&googleapi.Error{
14030 Code: res.StatusCode,
14031 Header: res.Header,
14032 })
14033 }
14034 if err != nil {
14035 return nil, err
14036 }
14037 defer googleapi.CloseBody(res)
14038 if err := googleapi.CheckResponse(res); err != nil {
14039 return nil, gensupport.WrapError(err)
14040 }
14041 ret := &GoogleProtobufEmpty{
14042 ServerResponse: googleapi.ServerResponse{
14043 Header: res.Header,
14044 HTTPStatusCode: res.StatusCode,
14045 },
14046 }
14047 target := &ret
14048 if err := gensupport.DecodeResponse(target, res); err != nil {
14049 return nil, err
14050 }
14051 return ret, nil
14052 }
14053
14054 type PropertiesConversionEventsGetCall struct {
14055 s *Service
14056 name string
14057 urlParams_ gensupport.URLParams
14058 ifNoneMatch_ string
14059 ctx_ context.Context
14060 header_ http.Header
14061 }
14062
14063
14064
14065
14066
14067
14068 func (r *PropertiesConversionEventsService) Get(name string) *PropertiesConversionEventsGetCall {
14069 c := &PropertiesConversionEventsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14070 c.name = name
14071 return c
14072 }
14073
14074
14075
14076
14077 func (c *PropertiesConversionEventsGetCall) Fields(s ...googleapi.Field) *PropertiesConversionEventsGetCall {
14078 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14079 return c
14080 }
14081
14082
14083
14084
14085 func (c *PropertiesConversionEventsGetCall) IfNoneMatch(entityTag string) *PropertiesConversionEventsGetCall {
14086 c.ifNoneMatch_ = entityTag
14087 return c
14088 }
14089
14090
14091 func (c *PropertiesConversionEventsGetCall) Context(ctx context.Context) *PropertiesConversionEventsGetCall {
14092 c.ctx_ = ctx
14093 return c
14094 }
14095
14096
14097
14098 func (c *PropertiesConversionEventsGetCall) Header() http.Header {
14099 if c.header_ == nil {
14100 c.header_ = make(http.Header)
14101 }
14102 return c.header_
14103 }
14104
14105 func (c *PropertiesConversionEventsGetCall) doRequest(alt string) (*http.Response, error) {
14106 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14107 if c.ifNoneMatch_ != "" {
14108 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14109 }
14110 var body io.Reader = nil
14111 c.urlParams_.Set("alt", alt)
14112 c.urlParams_.Set("prettyPrint", "false")
14113 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
14114 urls += "?" + c.urlParams_.Encode()
14115 req, err := http.NewRequest("GET", urls, body)
14116 if err != nil {
14117 return nil, err
14118 }
14119 req.Header = reqHeaders
14120 googleapi.Expand(req.URL, map[string]string{
14121 "name": c.name,
14122 })
14123 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14124 }
14125
14126
14127
14128
14129
14130
14131
14132 func (c *PropertiesConversionEventsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaConversionEvent, error) {
14133 gensupport.SetOptions(c.urlParams_, opts...)
14134 res, err := c.doRequest("json")
14135 if res != nil && res.StatusCode == http.StatusNotModified {
14136 if res.Body != nil {
14137 res.Body.Close()
14138 }
14139 return nil, gensupport.WrapError(&googleapi.Error{
14140 Code: res.StatusCode,
14141 Header: res.Header,
14142 })
14143 }
14144 if err != nil {
14145 return nil, err
14146 }
14147 defer googleapi.CloseBody(res)
14148 if err := googleapi.CheckResponse(res); err != nil {
14149 return nil, gensupport.WrapError(err)
14150 }
14151 ret := &GoogleAnalyticsAdminV1alphaConversionEvent{
14152 ServerResponse: googleapi.ServerResponse{
14153 Header: res.Header,
14154 HTTPStatusCode: res.StatusCode,
14155 },
14156 }
14157 target := &ret
14158 if err := gensupport.DecodeResponse(target, res); err != nil {
14159 return nil, err
14160 }
14161 return ret, nil
14162 }
14163
14164 type PropertiesConversionEventsListCall struct {
14165 s *Service
14166 parent string
14167 urlParams_ gensupport.URLParams
14168 ifNoneMatch_ string
14169 ctx_ context.Context
14170 header_ http.Header
14171 }
14172
14173
14174
14175
14176
14177
14178 func (r *PropertiesConversionEventsService) List(parent string) *PropertiesConversionEventsListCall {
14179 c := &PropertiesConversionEventsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14180 c.parent = parent
14181 return c
14182 }
14183
14184
14185
14186
14187 func (c *PropertiesConversionEventsListCall) PageSize(pageSize int64) *PropertiesConversionEventsListCall {
14188 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
14189 return c
14190 }
14191
14192
14193
14194
14195
14196 func (c *PropertiesConversionEventsListCall) PageToken(pageToken string) *PropertiesConversionEventsListCall {
14197 c.urlParams_.Set("pageToken", pageToken)
14198 return c
14199 }
14200
14201
14202
14203
14204 func (c *PropertiesConversionEventsListCall) Fields(s ...googleapi.Field) *PropertiesConversionEventsListCall {
14205 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14206 return c
14207 }
14208
14209
14210
14211
14212 func (c *PropertiesConversionEventsListCall) IfNoneMatch(entityTag string) *PropertiesConversionEventsListCall {
14213 c.ifNoneMatch_ = entityTag
14214 return c
14215 }
14216
14217
14218 func (c *PropertiesConversionEventsListCall) Context(ctx context.Context) *PropertiesConversionEventsListCall {
14219 c.ctx_ = ctx
14220 return c
14221 }
14222
14223
14224
14225 func (c *PropertiesConversionEventsListCall) Header() http.Header {
14226 if c.header_ == nil {
14227 c.header_ = make(http.Header)
14228 }
14229 return c.header_
14230 }
14231
14232 func (c *PropertiesConversionEventsListCall) doRequest(alt string) (*http.Response, error) {
14233 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14234 if c.ifNoneMatch_ != "" {
14235 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14236 }
14237 var body io.Reader = nil
14238 c.urlParams_.Set("alt", alt)
14239 c.urlParams_.Set("prettyPrint", "false")
14240 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/conversionEvents")
14241 urls += "?" + c.urlParams_.Encode()
14242 req, err := http.NewRequest("GET", urls, body)
14243 if err != nil {
14244 return nil, err
14245 }
14246 req.Header = reqHeaders
14247 googleapi.Expand(req.URL, map[string]string{
14248 "parent": c.parent,
14249 })
14250 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14251 }
14252
14253
14254
14255
14256
14257
14258
14259 func (c *PropertiesConversionEventsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListConversionEventsResponse, error) {
14260 gensupport.SetOptions(c.urlParams_, opts...)
14261 res, err := c.doRequest("json")
14262 if res != nil && res.StatusCode == http.StatusNotModified {
14263 if res.Body != nil {
14264 res.Body.Close()
14265 }
14266 return nil, gensupport.WrapError(&googleapi.Error{
14267 Code: res.StatusCode,
14268 Header: res.Header,
14269 })
14270 }
14271 if err != nil {
14272 return nil, err
14273 }
14274 defer googleapi.CloseBody(res)
14275 if err := googleapi.CheckResponse(res); err != nil {
14276 return nil, gensupport.WrapError(err)
14277 }
14278 ret := &GoogleAnalyticsAdminV1alphaListConversionEventsResponse{
14279 ServerResponse: googleapi.ServerResponse{
14280 Header: res.Header,
14281 HTTPStatusCode: res.StatusCode,
14282 },
14283 }
14284 target := &ret
14285 if err := gensupport.DecodeResponse(target, res); err != nil {
14286 return nil, err
14287 }
14288 return ret, nil
14289 }
14290
14291
14292
14293
14294 func (c *PropertiesConversionEventsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListConversionEventsResponse) error) error {
14295 c.ctx_ = ctx
14296 defer c.PageToken(c.urlParams_.Get("pageToken"))
14297 for {
14298 x, err := c.Do()
14299 if err != nil {
14300 return err
14301 }
14302 if err := f(x); err != nil {
14303 return err
14304 }
14305 if x.NextPageToken == "" {
14306 return nil
14307 }
14308 c.PageToken(x.NextPageToken)
14309 }
14310 }
14311
14312 type PropertiesConversionEventsPatchCall struct {
14313 s *Service
14314 name string
14315 googleanalyticsadminv1alphaconversionevent *GoogleAnalyticsAdminV1alphaConversionEvent
14316 urlParams_ gensupport.URLParams
14317 ctx_ context.Context
14318 header_ http.Header
14319 }
14320
14321
14322
14323
14324
14325 func (r *PropertiesConversionEventsService) Patch(name string, googleanalyticsadminv1alphaconversionevent *GoogleAnalyticsAdminV1alphaConversionEvent) *PropertiesConversionEventsPatchCall {
14326 c := &PropertiesConversionEventsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14327 c.name = name
14328 c.googleanalyticsadminv1alphaconversionevent = googleanalyticsadminv1alphaconversionevent
14329 return c
14330 }
14331
14332
14333
14334
14335
14336 func (c *PropertiesConversionEventsPatchCall) UpdateMask(updateMask string) *PropertiesConversionEventsPatchCall {
14337 c.urlParams_.Set("updateMask", updateMask)
14338 return c
14339 }
14340
14341
14342
14343
14344 func (c *PropertiesConversionEventsPatchCall) Fields(s ...googleapi.Field) *PropertiesConversionEventsPatchCall {
14345 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14346 return c
14347 }
14348
14349
14350 func (c *PropertiesConversionEventsPatchCall) Context(ctx context.Context) *PropertiesConversionEventsPatchCall {
14351 c.ctx_ = ctx
14352 return c
14353 }
14354
14355
14356
14357 func (c *PropertiesConversionEventsPatchCall) Header() http.Header {
14358 if c.header_ == nil {
14359 c.header_ = make(http.Header)
14360 }
14361 return c.header_
14362 }
14363
14364 func (c *PropertiesConversionEventsPatchCall) doRequest(alt string) (*http.Response, error) {
14365 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14366 var body io.Reader = nil
14367 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaconversionevent)
14368 if err != nil {
14369 return nil, err
14370 }
14371 c.urlParams_.Set("alt", alt)
14372 c.urlParams_.Set("prettyPrint", "false")
14373 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
14374 urls += "?" + c.urlParams_.Encode()
14375 req, err := http.NewRequest("PATCH", urls, body)
14376 if err != nil {
14377 return nil, err
14378 }
14379 req.Header = reqHeaders
14380 googleapi.Expand(req.URL, map[string]string{
14381 "name": c.name,
14382 })
14383 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14384 }
14385
14386
14387
14388
14389
14390
14391
14392 func (c *PropertiesConversionEventsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaConversionEvent, error) {
14393 gensupport.SetOptions(c.urlParams_, opts...)
14394 res, err := c.doRequest("json")
14395 if res != nil && res.StatusCode == http.StatusNotModified {
14396 if res.Body != nil {
14397 res.Body.Close()
14398 }
14399 return nil, gensupport.WrapError(&googleapi.Error{
14400 Code: res.StatusCode,
14401 Header: res.Header,
14402 })
14403 }
14404 if err != nil {
14405 return nil, err
14406 }
14407 defer googleapi.CloseBody(res)
14408 if err := googleapi.CheckResponse(res); err != nil {
14409 return nil, gensupport.WrapError(err)
14410 }
14411 ret := &GoogleAnalyticsAdminV1alphaConversionEvent{
14412 ServerResponse: googleapi.ServerResponse{
14413 Header: res.Header,
14414 HTTPStatusCode: res.StatusCode,
14415 },
14416 }
14417 target := &ret
14418 if err := gensupport.DecodeResponse(target, res); err != nil {
14419 return nil, err
14420 }
14421 return ret, nil
14422 }
14423
14424 type PropertiesCustomDimensionsArchiveCall struct {
14425 s *Service
14426 name string
14427 googleanalyticsadminv1alphaarchivecustomdimensionrequest *GoogleAnalyticsAdminV1alphaArchiveCustomDimensionRequest
14428 urlParams_ gensupport.URLParams
14429 ctx_ context.Context
14430 header_ http.Header
14431 }
14432
14433
14434
14435
14436
14437 func (r *PropertiesCustomDimensionsService) Archive(name string, googleanalyticsadminv1alphaarchivecustomdimensionrequest *GoogleAnalyticsAdminV1alphaArchiveCustomDimensionRequest) *PropertiesCustomDimensionsArchiveCall {
14438 c := &PropertiesCustomDimensionsArchiveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14439 c.name = name
14440 c.googleanalyticsadminv1alphaarchivecustomdimensionrequest = googleanalyticsadminv1alphaarchivecustomdimensionrequest
14441 return c
14442 }
14443
14444
14445
14446
14447 func (c *PropertiesCustomDimensionsArchiveCall) Fields(s ...googleapi.Field) *PropertiesCustomDimensionsArchiveCall {
14448 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14449 return c
14450 }
14451
14452
14453 func (c *PropertiesCustomDimensionsArchiveCall) Context(ctx context.Context) *PropertiesCustomDimensionsArchiveCall {
14454 c.ctx_ = ctx
14455 return c
14456 }
14457
14458
14459
14460 func (c *PropertiesCustomDimensionsArchiveCall) Header() http.Header {
14461 if c.header_ == nil {
14462 c.header_ = make(http.Header)
14463 }
14464 return c.header_
14465 }
14466
14467 func (c *PropertiesCustomDimensionsArchiveCall) doRequest(alt string) (*http.Response, error) {
14468 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14469 var body io.Reader = nil
14470 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaarchivecustomdimensionrequest)
14471 if err != nil {
14472 return nil, err
14473 }
14474 c.urlParams_.Set("alt", alt)
14475 c.urlParams_.Set("prettyPrint", "false")
14476 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}:archive")
14477 urls += "?" + c.urlParams_.Encode()
14478 req, err := http.NewRequest("POST", urls, body)
14479 if err != nil {
14480 return nil, err
14481 }
14482 req.Header = reqHeaders
14483 googleapi.Expand(req.URL, map[string]string{
14484 "name": c.name,
14485 })
14486 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14487 }
14488
14489
14490
14491
14492
14493
14494
14495 func (c *PropertiesCustomDimensionsArchiveCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
14496 gensupport.SetOptions(c.urlParams_, opts...)
14497 res, err := c.doRequest("json")
14498 if res != nil && res.StatusCode == http.StatusNotModified {
14499 if res.Body != nil {
14500 res.Body.Close()
14501 }
14502 return nil, gensupport.WrapError(&googleapi.Error{
14503 Code: res.StatusCode,
14504 Header: res.Header,
14505 })
14506 }
14507 if err != nil {
14508 return nil, err
14509 }
14510 defer googleapi.CloseBody(res)
14511 if err := googleapi.CheckResponse(res); err != nil {
14512 return nil, gensupport.WrapError(err)
14513 }
14514 ret := &GoogleProtobufEmpty{
14515 ServerResponse: googleapi.ServerResponse{
14516 Header: res.Header,
14517 HTTPStatusCode: res.StatusCode,
14518 },
14519 }
14520 target := &ret
14521 if err := gensupport.DecodeResponse(target, res); err != nil {
14522 return nil, err
14523 }
14524 return ret, nil
14525 }
14526
14527 type PropertiesCustomDimensionsCreateCall struct {
14528 s *Service
14529 parent string
14530 googleanalyticsadminv1alphacustomdimension *GoogleAnalyticsAdminV1alphaCustomDimension
14531 urlParams_ gensupport.URLParams
14532 ctx_ context.Context
14533 header_ http.Header
14534 }
14535
14536
14537
14538
14539 func (r *PropertiesCustomDimensionsService) Create(parent string, googleanalyticsadminv1alphacustomdimension *GoogleAnalyticsAdminV1alphaCustomDimension) *PropertiesCustomDimensionsCreateCall {
14540 c := &PropertiesCustomDimensionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14541 c.parent = parent
14542 c.googleanalyticsadminv1alphacustomdimension = googleanalyticsadminv1alphacustomdimension
14543 return c
14544 }
14545
14546
14547
14548
14549 func (c *PropertiesCustomDimensionsCreateCall) Fields(s ...googleapi.Field) *PropertiesCustomDimensionsCreateCall {
14550 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14551 return c
14552 }
14553
14554
14555 func (c *PropertiesCustomDimensionsCreateCall) Context(ctx context.Context) *PropertiesCustomDimensionsCreateCall {
14556 c.ctx_ = ctx
14557 return c
14558 }
14559
14560
14561
14562 func (c *PropertiesCustomDimensionsCreateCall) Header() http.Header {
14563 if c.header_ == nil {
14564 c.header_ = make(http.Header)
14565 }
14566 return c.header_
14567 }
14568
14569 func (c *PropertiesCustomDimensionsCreateCall) doRequest(alt string) (*http.Response, error) {
14570 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14571 var body io.Reader = nil
14572 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacustomdimension)
14573 if err != nil {
14574 return nil, err
14575 }
14576 c.urlParams_.Set("alt", alt)
14577 c.urlParams_.Set("prettyPrint", "false")
14578 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/customDimensions")
14579 urls += "?" + c.urlParams_.Encode()
14580 req, err := http.NewRequest("POST", urls, body)
14581 if err != nil {
14582 return nil, err
14583 }
14584 req.Header = reqHeaders
14585 googleapi.Expand(req.URL, map[string]string{
14586 "parent": c.parent,
14587 })
14588 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14589 }
14590
14591
14592
14593
14594
14595
14596
14597 func (c *PropertiesCustomDimensionsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCustomDimension, error) {
14598 gensupport.SetOptions(c.urlParams_, opts...)
14599 res, err := c.doRequest("json")
14600 if res != nil && res.StatusCode == http.StatusNotModified {
14601 if res.Body != nil {
14602 res.Body.Close()
14603 }
14604 return nil, gensupport.WrapError(&googleapi.Error{
14605 Code: res.StatusCode,
14606 Header: res.Header,
14607 })
14608 }
14609 if err != nil {
14610 return nil, err
14611 }
14612 defer googleapi.CloseBody(res)
14613 if err := googleapi.CheckResponse(res); err != nil {
14614 return nil, gensupport.WrapError(err)
14615 }
14616 ret := &GoogleAnalyticsAdminV1alphaCustomDimension{
14617 ServerResponse: googleapi.ServerResponse{
14618 Header: res.Header,
14619 HTTPStatusCode: res.StatusCode,
14620 },
14621 }
14622 target := &ret
14623 if err := gensupport.DecodeResponse(target, res); err != nil {
14624 return nil, err
14625 }
14626 return ret, nil
14627 }
14628
14629 type PropertiesCustomDimensionsGetCall struct {
14630 s *Service
14631 name string
14632 urlParams_ gensupport.URLParams
14633 ifNoneMatch_ string
14634 ctx_ context.Context
14635 header_ http.Header
14636 }
14637
14638
14639
14640
14641
14642 func (r *PropertiesCustomDimensionsService) Get(name string) *PropertiesCustomDimensionsGetCall {
14643 c := &PropertiesCustomDimensionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14644 c.name = name
14645 return c
14646 }
14647
14648
14649
14650
14651 func (c *PropertiesCustomDimensionsGetCall) Fields(s ...googleapi.Field) *PropertiesCustomDimensionsGetCall {
14652 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14653 return c
14654 }
14655
14656
14657
14658
14659 func (c *PropertiesCustomDimensionsGetCall) IfNoneMatch(entityTag string) *PropertiesCustomDimensionsGetCall {
14660 c.ifNoneMatch_ = entityTag
14661 return c
14662 }
14663
14664
14665 func (c *PropertiesCustomDimensionsGetCall) Context(ctx context.Context) *PropertiesCustomDimensionsGetCall {
14666 c.ctx_ = ctx
14667 return c
14668 }
14669
14670
14671
14672 func (c *PropertiesCustomDimensionsGetCall) Header() http.Header {
14673 if c.header_ == nil {
14674 c.header_ = make(http.Header)
14675 }
14676 return c.header_
14677 }
14678
14679 func (c *PropertiesCustomDimensionsGetCall) doRequest(alt string) (*http.Response, error) {
14680 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14681 if c.ifNoneMatch_ != "" {
14682 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14683 }
14684 var body io.Reader = nil
14685 c.urlParams_.Set("alt", alt)
14686 c.urlParams_.Set("prettyPrint", "false")
14687 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
14688 urls += "?" + c.urlParams_.Encode()
14689 req, err := http.NewRequest("GET", urls, body)
14690 if err != nil {
14691 return nil, err
14692 }
14693 req.Header = reqHeaders
14694 googleapi.Expand(req.URL, map[string]string{
14695 "name": c.name,
14696 })
14697 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14698 }
14699
14700
14701
14702
14703
14704
14705
14706 func (c *PropertiesCustomDimensionsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCustomDimension, error) {
14707 gensupport.SetOptions(c.urlParams_, opts...)
14708 res, err := c.doRequest("json")
14709 if res != nil && res.StatusCode == http.StatusNotModified {
14710 if res.Body != nil {
14711 res.Body.Close()
14712 }
14713 return nil, gensupport.WrapError(&googleapi.Error{
14714 Code: res.StatusCode,
14715 Header: res.Header,
14716 })
14717 }
14718 if err != nil {
14719 return nil, err
14720 }
14721 defer googleapi.CloseBody(res)
14722 if err := googleapi.CheckResponse(res); err != nil {
14723 return nil, gensupport.WrapError(err)
14724 }
14725 ret := &GoogleAnalyticsAdminV1alphaCustomDimension{
14726 ServerResponse: googleapi.ServerResponse{
14727 Header: res.Header,
14728 HTTPStatusCode: res.StatusCode,
14729 },
14730 }
14731 target := &ret
14732 if err := gensupport.DecodeResponse(target, res); err != nil {
14733 return nil, err
14734 }
14735 return ret, nil
14736 }
14737
14738 type PropertiesCustomDimensionsListCall struct {
14739 s *Service
14740 parent string
14741 urlParams_ gensupport.URLParams
14742 ifNoneMatch_ string
14743 ctx_ context.Context
14744 header_ http.Header
14745 }
14746
14747
14748
14749
14750 func (r *PropertiesCustomDimensionsService) List(parent string) *PropertiesCustomDimensionsListCall {
14751 c := &PropertiesCustomDimensionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14752 c.parent = parent
14753 return c
14754 }
14755
14756
14757
14758
14759 func (c *PropertiesCustomDimensionsListCall) PageSize(pageSize int64) *PropertiesCustomDimensionsListCall {
14760 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
14761 return c
14762 }
14763
14764
14765
14766
14767
14768 func (c *PropertiesCustomDimensionsListCall) PageToken(pageToken string) *PropertiesCustomDimensionsListCall {
14769 c.urlParams_.Set("pageToken", pageToken)
14770 return c
14771 }
14772
14773
14774
14775
14776 func (c *PropertiesCustomDimensionsListCall) Fields(s ...googleapi.Field) *PropertiesCustomDimensionsListCall {
14777 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14778 return c
14779 }
14780
14781
14782
14783
14784 func (c *PropertiesCustomDimensionsListCall) IfNoneMatch(entityTag string) *PropertiesCustomDimensionsListCall {
14785 c.ifNoneMatch_ = entityTag
14786 return c
14787 }
14788
14789
14790 func (c *PropertiesCustomDimensionsListCall) Context(ctx context.Context) *PropertiesCustomDimensionsListCall {
14791 c.ctx_ = ctx
14792 return c
14793 }
14794
14795
14796
14797 func (c *PropertiesCustomDimensionsListCall) Header() http.Header {
14798 if c.header_ == nil {
14799 c.header_ = make(http.Header)
14800 }
14801 return c.header_
14802 }
14803
14804 func (c *PropertiesCustomDimensionsListCall) doRequest(alt string) (*http.Response, error) {
14805 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14806 if c.ifNoneMatch_ != "" {
14807 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14808 }
14809 var body io.Reader = nil
14810 c.urlParams_.Set("alt", alt)
14811 c.urlParams_.Set("prettyPrint", "false")
14812 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/customDimensions")
14813 urls += "?" + c.urlParams_.Encode()
14814 req, err := http.NewRequest("GET", urls, body)
14815 if err != nil {
14816 return nil, err
14817 }
14818 req.Header = reqHeaders
14819 googleapi.Expand(req.URL, map[string]string{
14820 "parent": c.parent,
14821 })
14822 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14823 }
14824
14825
14826
14827
14828
14829
14830
14831 func (c *PropertiesCustomDimensionsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListCustomDimensionsResponse, error) {
14832 gensupport.SetOptions(c.urlParams_, opts...)
14833 res, err := c.doRequest("json")
14834 if res != nil && res.StatusCode == http.StatusNotModified {
14835 if res.Body != nil {
14836 res.Body.Close()
14837 }
14838 return nil, gensupport.WrapError(&googleapi.Error{
14839 Code: res.StatusCode,
14840 Header: res.Header,
14841 })
14842 }
14843 if err != nil {
14844 return nil, err
14845 }
14846 defer googleapi.CloseBody(res)
14847 if err := googleapi.CheckResponse(res); err != nil {
14848 return nil, gensupport.WrapError(err)
14849 }
14850 ret := &GoogleAnalyticsAdminV1alphaListCustomDimensionsResponse{
14851 ServerResponse: googleapi.ServerResponse{
14852 Header: res.Header,
14853 HTTPStatusCode: res.StatusCode,
14854 },
14855 }
14856 target := &ret
14857 if err := gensupport.DecodeResponse(target, res); err != nil {
14858 return nil, err
14859 }
14860 return ret, nil
14861 }
14862
14863
14864
14865
14866 func (c *PropertiesCustomDimensionsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListCustomDimensionsResponse) error) error {
14867 c.ctx_ = ctx
14868 defer c.PageToken(c.urlParams_.Get("pageToken"))
14869 for {
14870 x, err := c.Do()
14871 if err != nil {
14872 return err
14873 }
14874 if err := f(x); err != nil {
14875 return err
14876 }
14877 if x.NextPageToken == "" {
14878 return nil
14879 }
14880 c.PageToken(x.NextPageToken)
14881 }
14882 }
14883
14884 type PropertiesCustomDimensionsPatchCall struct {
14885 s *Service
14886 name string
14887 googleanalyticsadminv1alphacustomdimension *GoogleAnalyticsAdminV1alphaCustomDimension
14888 urlParams_ gensupport.URLParams
14889 ctx_ context.Context
14890 header_ http.Header
14891 }
14892
14893
14894
14895
14896
14897 func (r *PropertiesCustomDimensionsService) Patch(name string, googleanalyticsadminv1alphacustomdimension *GoogleAnalyticsAdminV1alphaCustomDimension) *PropertiesCustomDimensionsPatchCall {
14898 c := &PropertiesCustomDimensionsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14899 c.name = name
14900 c.googleanalyticsadminv1alphacustomdimension = googleanalyticsadminv1alphacustomdimension
14901 return c
14902 }
14903
14904
14905
14906
14907 func (c *PropertiesCustomDimensionsPatchCall) UpdateMask(updateMask string) *PropertiesCustomDimensionsPatchCall {
14908 c.urlParams_.Set("updateMask", updateMask)
14909 return c
14910 }
14911
14912
14913
14914
14915 func (c *PropertiesCustomDimensionsPatchCall) Fields(s ...googleapi.Field) *PropertiesCustomDimensionsPatchCall {
14916 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14917 return c
14918 }
14919
14920
14921 func (c *PropertiesCustomDimensionsPatchCall) Context(ctx context.Context) *PropertiesCustomDimensionsPatchCall {
14922 c.ctx_ = ctx
14923 return c
14924 }
14925
14926
14927
14928 func (c *PropertiesCustomDimensionsPatchCall) Header() http.Header {
14929 if c.header_ == nil {
14930 c.header_ = make(http.Header)
14931 }
14932 return c.header_
14933 }
14934
14935 func (c *PropertiesCustomDimensionsPatchCall) doRequest(alt string) (*http.Response, error) {
14936 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14937 var body io.Reader = nil
14938 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacustomdimension)
14939 if err != nil {
14940 return nil, err
14941 }
14942 c.urlParams_.Set("alt", alt)
14943 c.urlParams_.Set("prettyPrint", "false")
14944 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
14945 urls += "?" + c.urlParams_.Encode()
14946 req, err := http.NewRequest("PATCH", urls, body)
14947 if err != nil {
14948 return nil, err
14949 }
14950 req.Header = reqHeaders
14951 googleapi.Expand(req.URL, map[string]string{
14952 "name": c.name,
14953 })
14954 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14955 }
14956
14957
14958
14959
14960
14961
14962
14963 func (c *PropertiesCustomDimensionsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCustomDimension, error) {
14964 gensupport.SetOptions(c.urlParams_, opts...)
14965 res, err := c.doRequest("json")
14966 if res != nil && res.StatusCode == http.StatusNotModified {
14967 if res.Body != nil {
14968 res.Body.Close()
14969 }
14970 return nil, gensupport.WrapError(&googleapi.Error{
14971 Code: res.StatusCode,
14972 Header: res.Header,
14973 })
14974 }
14975 if err != nil {
14976 return nil, err
14977 }
14978 defer googleapi.CloseBody(res)
14979 if err := googleapi.CheckResponse(res); err != nil {
14980 return nil, gensupport.WrapError(err)
14981 }
14982 ret := &GoogleAnalyticsAdminV1alphaCustomDimension{
14983 ServerResponse: googleapi.ServerResponse{
14984 Header: res.Header,
14985 HTTPStatusCode: res.StatusCode,
14986 },
14987 }
14988 target := &ret
14989 if err := gensupport.DecodeResponse(target, res); err != nil {
14990 return nil, err
14991 }
14992 return ret, nil
14993 }
14994
14995 type PropertiesCustomMetricsArchiveCall struct {
14996 s *Service
14997 name string
14998 googleanalyticsadminv1alphaarchivecustommetricrequest *GoogleAnalyticsAdminV1alphaArchiveCustomMetricRequest
14999 urlParams_ gensupport.URLParams
15000 ctx_ context.Context
15001 header_ http.Header
15002 }
15003
15004
15005
15006
15007
15008 func (r *PropertiesCustomMetricsService) Archive(name string, googleanalyticsadminv1alphaarchivecustommetricrequest *GoogleAnalyticsAdminV1alphaArchiveCustomMetricRequest) *PropertiesCustomMetricsArchiveCall {
15009 c := &PropertiesCustomMetricsArchiveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15010 c.name = name
15011 c.googleanalyticsadminv1alphaarchivecustommetricrequest = googleanalyticsadminv1alphaarchivecustommetricrequest
15012 return c
15013 }
15014
15015
15016
15017
15018 func (c *PropertiesCustomMetricsArchiveCall) Fields(s ...googleapi.Field) *PropertiesCustomMetricsArchiveCall {
15019 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15020 return c
15021 }
15022
15023
15024 func (c *PropertiesCustomMetricsArchiveCall) Context(ctx context.Context) *PropertiesCustomMetricsArchiveCall {
15025 c.ctx_ = ctx
15026 return c
15027 }
15028
15029
15030
15031 func (c *PropertiesCustomMetricsArchiveCall) Header() http.Header {
15032 if c.header_ == nil {
15033 c.header_ = make(http.Header)
15034 }
15035 return c.header_
15036 }
15037
15038 func (c *PropertiesCustomMetricsArchiveCall) doRequest(alt string) (*http.Response, error) {
15039 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15040 var body io.Reader = nil
15041 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaarchivecustommetricrequest)
15042 if err != nil {
15043 return nil, err
15044 }
15045 c.urlParams_.Set("alt", alt)
15046 c.urlParams_.Set("prettyPrint", "false")
15047 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}:archive")
15048 urls += "?" + c.urlParams_.Encode()
15049 req, err := http.NewRequest("POST", urls, body)
15050 if err != nil {
15051 return nil, err
15052 }
15053 req.Header = reqHeaders
15054 googleapi.Expand(req.URL, map[string]string{
15055 "name": c.name,
15056 })
15057 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15058 }
15059
15060
15061
15062
15063
15064
15065
15066 func (c *PropertiesCustomMetricsArchiveCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
15067 gensupport.SetOptions(c.urlParams_, opts...)
15068 res, err := c.doRequest("json")
15069 if res != nil && res.StatusCode == http.StatusNotModified {
15070 if res.Body != nil {
15071 res.Body.Close()
15072 }
15073 return nil, gensupport.WrapError(&googleapi.Error{
15074 Code: res.StatusCode,
15075 Header: res.Header,
15076 })
15077 }
15078 if err != nil {
15079 return nil, err
15080 }
15081 defer googleapi.CloseBody(res)
15082 if err := googleapi.CheckResponse(res); err != nil {
15083 return nil, gensupport.WrapError(err)
15084 }
15085 ret := &GoogleProtobufEmpty{
15086 ServerResponse: googleapi.ServerResponse{
15087 Header: res.Header,
15088 HTTPStatusCode: res.StatusCode,
15089 },
15090 }
15091 target := &ret
15092 if err := gensupport.DecodeResponse(target, res); err != nil {
15093 return nil, err
15094 }
15095 return ret, nil
15096 }
15097
15098 type PropertiesCustomMetricsCreateCall struct {
15099 s *Service
15100 parent string
15101 googleanalyticsadminv1alphacustommetric *GoogleAnalyticsAdminV1alphaCustomMetric
15102 urlParams_ gensupport.URLParams
15103 ctx_ context.Context
15104 header_ http.Header
15105 }
15106
15107
15108
15109
15110 func (r *PropertiesCustomMetricsService) Create(parent string, googleanalyticsadminv1alphacustommetric *GoogleAnalyticsAdminV1alphaCustomMetric) *PropertiesCustomMetricsCreateCall {
15111 c := &PropertiesCustomMetricsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15112 c.parent = parent
15113 c.googleanalyticsadminv1alphacustommetric = googleanalyticsadminv1alphacustommetric
15114 return c
15115 }
15116
15117
15118
15119
15120 func (c *PropertiesCustomMetricsCreateCall) Fields(s ...googleapi.Field) *PropertiesCustomMetricsCreateCall {
15121 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15122 return c
15123 }
15124
15125
15126 func (c *PropertiesCustomMetricsCreateCall) Context(ctx context.Context) *PropertiesCustomMetricsCreateCall {
15127 c.ctx_ = ctx
15128 return c
15129 }
15130
15131
15132
15133 func (c *PropertiesCustomMetricsCreateCall) Header() http.Header {
15134 if c.header_ == nil {
15135 c.header_ = make(http.Header)
15136 }
15137 return c.header_
15138 }
15139
15140 func (c *PropertiesCustomMetricsCreateCall) doRequest(alt string) (*http.Response, error) {
15141 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15142 var body io.Reader = nil
15143 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacustommetric)
15144 if err != nil {
15145 return nil, err
15146 }
15147 c.urlParams_.Set("alt", alt)
15148 c.urlParams_.Set("prettyPrint", "false")
15149 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/customMetrics")
15150 urls += "?" + c.urlParams_.Encode()
15151 req, err := http.NewRequest("POST", urls, body)
15152 if err != nil {
15153 return nil, err
15154 }
15155 req.Header = reqHeaders
15156 googleapi.Expand(req.URL, map[string]string{
15157 "parent": c.parent,
15158 })
15159 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15160 }
15161
15162
15163
15164
15165
15166
15167
15168 func (c *PropertiesCustomMetricsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCustomMetric, error) {
15169 gensupport.SetOptions(c.urlParams_, opts...)
15170 res, err := c.doRequest("json")
15171 if res != nil && res.StatusCode == http.StatusNotModified {
15172 if res.Body != nil {
15173 res.Body.Close()
15174 }
15175 return nil, gensupport.WrapError(&googleapi.Error{
15176 Code: res.StatusCode,
15177 Header: res.Header,
15178 })
15179 }
15180 if err != nil {
15181 return nil, err
15182 }
15183 defer googleapi.CloseBody(res)
15184 if err := googleapi.CheckResponse(res); err != nil {
15185 return nil, gensupport.WrapError(err)
15186 }
15187 ret := &GoogleAnalyticsAdminV1alphaCustomMetric{
15188 ServerResponse: googleapi.ServerResponse{
15189 Header: res.Header,
15190 HTTPStatusCode: res.StatusCode,
15191 },
15192 }
15193 target := &ret
15194 if err := gensupport.DecodeResponse(target, res); err != nil {
15195 return nil, err
15196 }
15197 return ret, nil
15198 }
15199
15200 type PropertiesCustomMetricsGetCall struct {
15201 s *Service
15202 name string
15203 urlParams_ gensupport.URLParams
15204 ifNoneMatch_ string
15205 ctx_ context.Context
15206 header_ http.Header
15207 }
15208
15209
15210
15211
15212
15213 func (r *PropertiesCustomMetricsService) Get(name string) *PropertiesCustomMetricsGetCall {
15214 c := &PropertiesCustomMetricsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15215 c.name = name
15216 return c
15217 }
15218
15219
15220
15221
15222 func (c *PropertiesCustomMetricsGetCall) Fields(s ...googleapi.Field) *PropertiesCustomMetricsGetCall {
15223 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15224 return c
15225 }
15226
15227
15228
15229
15230 func (c *PropertiesCustomMetricsGetCall) IfNoneMatch(entityTag string) *PropertiesCustomMetricsGetCall {
15231 c.ifNoneMatch_ = entityTag
15232 return c
15233 }
15234
15235
15236 func (c *PropertiesCustomMetricsGetCall) Context(ctx context.Context) *PropertiesCustomMetricsGetCall {
15237 c.ctx_ = ctx
15238 return c
15239 }
15240
15241
15242
15243 func (c *PropertiesCustomMetricsGetCall) Header() http.Header {
15244 if c.header_ == nil {
15245 c.header_ = make(http.Header)
15246 }
15247 return c.header_
15248 }
15249
15250 func (c *PropertiesCustomMetricsGetCall) doRequest(alt string) (*http.Response, error) {
15251 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15252 if c.ifNoneMatch_ != "" {
15253 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15254 }
15255 var body io.Reader = nil
15256 c.urlParams_.Set("alt", alt)
15257 c.urlParams_.Set("prettyPrint", "false")
15258 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
15259 urls += "?" + c.urlParams_.Encode()
15260 req, err := http.NewRequest("GET", urls, body)
15261 if err != nil {
15262 return nil, err
15263 }
15264 req.Header = reqHeaders
15265 googleapi.Expand(req.URL, map[string]string{
15266 "name": c.name,
15267 })
15268 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15269 }
15270
15271
15272
15273
15274
15275
15276
15277 func (c *PropertiesCustomMetricsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCustomMetric, error) {
15278 gensupport.SetOptions(c.urlParams_, opts...)
15279 res, err := c.doRequest("json")
15280 if res != nil && res.StatusCode == http.StatusNotModified {
15281 if res.Body != nil {
15282 res.Body.Close()
15283 }
15284 return nil, gensupport.WrapError(&googleapi.Error{
15285 Code: res.StatusCode,
15286 Header: res.Header,
15287 })
15288 }
15289 if err != nil {
15290 return nil, err
15291 }
15292 defer googleapi.CloseBody(res)
15293 if err := googleapi.CheckResponse(res); err != nil {
15294 return nil, gensupport.WrapError(err)
15295 }
15296 ret := &GoogleAnalyticsAdminV1alphaCustomMetric{
15297 ServerResponse: googleapi.ServerResponse{
15298 Header: res.Header,
15299 HTTPStatusCode: res.StatusCode,
15300 },
15301 }
15302 target := &ret
15303 if err := gensupport.DecodeResponse(target, res); err != nil {
15304 return nil, err
15305 }
15306 return ret, nil
15307 }
15308
15309 type PropertiesCustomMetricsListCall struct {
15310 s *Service
15311 parent string
15312 urlParams_ gensupport.URLParams
15313 ifNoneMatch_ string
15314 ctx_ context.Context
15315 header_ http.Header
15316 }
15317
15318
15319
15320
15321 func (r *PropertiesCustomMetricsService) List(parent string) *PropertiesCustomMetricsListCall {
15322 c := &PropertiesCustomMetricsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15323 c.parent = parent
15324 return c
15325 }
15326
15327
15328
15329
15330 func (c *PropertiesCustomMetricsListCall) PageSize(pageSize int64) *PropertiesCustomMetricsListCall {
15331 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
15332 return c
15333 }
15334
15335
15336
15337
15338
15339 func (c *PropertiesCustomMetricsListCall) PageToken(pageToken string) *PropertiesCustomMetricsListCall {
15340 c.urlParams_.Set("pageToken", pageToken)
15341 return c
15342 }
15343
15344
15345
15346
15347 func (c *PropertiesCustomMetricsListCall) Fields(s ...googleapi.Field) *PropertiesCustomMetricsListCall {
15348 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15349 return c
15350 }
15351
15352
15353
15354
15355 func (c *PropertiesCustomMetricsListCall) IfNoneMatch(entityTag string) *PropertiesCustomMetricsListCall {
15356 c.ifNoneMatch_ = entityTag
15357 return c
15358 }
15359
15360
15361 func (c *PropertiesCustomMetricsListCall) Context(ctx context.Context) *PropertiesCustomMetricsListCall {
15362 c.ctx_ = ctx
15363 return c
15364 }
15365
15366
15367
15368 func (c *PropertiesCustomMetricsListCall) Header() http.Header {
15369 if c.header_ == nil {
15370 c.header_ = make(http.Header)
15371 }
15372 return c.header_
15373 }
15374
15375 func (c *PropertiesCustomMetricsListCall) doRequest(alt string) (*http.Response, error) {
15376 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15377 if c.ifNoneMatch_ != "" {
15378 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15379 }
15380 var body io.Reader = nil
15381 c.urlParams_.Set("alt", alt)
15382 c.urlParams_.Set("prettyPrint", "false")
15383 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/customMetrics")
15384 urls += "?" + c.urlParams_.Encode()
15385 req, err := http.NewRequest("GET", urls, body)
15386 if err != nil {
15387 return nil, err
15388 }
15389 req.Header = reqHeaders
15390 googleapi.Expand(req.URL, map[string]string{
15391 "parent": c.parent,
15392 })
15393 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15394 }
15395
15396
15397
15398
15399
15400
15401
15402 func (c *PropertiesCustomMetricsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListCustomMetricsResponse, error) {
15403 gensupport.SetOptions(c.urlParams_, opts...)
15404 res, err := c.doRequest("json")
15405 if res != nil && res.StatusCode == http.StatusNotModified {
15406 if res.Body != nil {
15407 res.Body.Close()
15408 }
15409 return nil, gensupport.WrapError(&googleapi.Error{
15410 Code: res.StatusCode,
15411 Header: res.Header,
15412 })
15413 }
15414 if err != nil {
15415 return nil, err
15416 }
15417 defer googleapi.CloseBody(res)
15418 if err := googleapi.CheckResponse(res); err != nil {
15419 return nil, gensupport.WrapError(err)
15420 }
15421 ret := &GoogleAnalyticsAdminV1alphaListCustomMetricsResponse{
15422 ServerResponse: googleapi.ServerResponse{
15423 Header: res.Header,
15424 HTTPStatusCode: res.StatusCode,
15425 },
15426 }
15427 target := &ret
15428 if err := gensupport.DecodeResponse(target, res); err != nil {
15429 return nil, err
15430 }
15431 return ret, nil
15432 }
15433
15434
15435
15436
15437 func (c *PropertiesCustomMetricsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListCustomMetricsResponse) error) error {
15438 c.ctx_ = ctx
15439 defer c.PageToken(c.urlParams_.Get("pageToken"))
15440 for {
15441 x, err := c.Do()
15442 if err != nil {
15443 return err
15444 }
15445 if err := f(x); err != nil {
15446 return err
15447 }
15448 if x.NextPageToken == "" {
15449 return nil
15450 }
15451 c.PageToken(x.NextPageToken)
15452 }
15453 }
15454
15455 type PropertiesCustomMetricsPatchCall struct {
15456 s *Service
15457 name string
15458 googleanalyticsadminv1alphacustommetric *GoogleAnalyticsAdminV1alphaCustomMetric
15459 urlParams_ gensupport.URLParams
15460 ctx_ context.Context
15461 header_ http.Header
15462 }
15463
15464
15465
15466
15467
15468 func (r *PropertiesCustomMetricsService) Patch(name string, googleanalyticsadminv1alphacustommetric *GoogleAnalyticsAdminV1alphaCustomMetric) *PropertiesCustomMetricsPatchCall {
15469 c := &PropertiesCustomMetricsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15470 c.name = name
15471 c.googleanalyticsadminv1alphacustommetric = googleanalyticsadminv1alphacustommetric
15472 return c
15473 }
15474
15475
15476
15477
15478 func (c *PropertiesCustomMetricsPatchCall) UpdateMask(updateMask string) *PropertiesCustomMetricsPatchCall {
15479 c.urlParams_.Set("updateMask", updateMask)
15480 return c
15481 }
15482
15483
15484
15485
15486 func (c *PropertiesCustomMetricsPatchCall) Fields(s ...googleapi.Field) *PropertiesCustomMetricsPatchCall {
15487 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15488 return c
15489 }
15490
15491
15492 func (c *PropertiesCustomMetricsPatchCall) Context(ctx context.Context) *PropertiesCustomMetricsPatchCall {
15493 c.ctx_ = ctx
15494 return c
15495 }
15496
15497
15498
15499 func (c *PropertiesCustomMetricsPatchCall) Header() http.Header {
15500 if c.header_ == nil {
15501 c.header_ = make(http.Header)
15502 }
15503 return c.header_
15504 }
15505
15506 func (c *PropertiesCustomMetricsPatchCall) doRequest(alt string) (*http.Response, error) {
15507 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15508 var body io.Reader = nil
15509 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacustommetric)
15510 if err != nil {
15511 return nil, err
15512 }
15513 c.urlParams_.Set("alt", alt)
15514 c.urlParams_.Set("prettyPrint", "false")
15515 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
15516 urls += "?" + c.urlParams_.Encode()
15517 req, err := http.NewRequest("PATCH", urls, body)
15518 if err != nil {
15519 return nil, err
15520 }
15521 req.Header = reqHeaders
15522 googleapi.Expand(req.URL, map[string]string{
15523 "name": c.name,
15524 })
15525 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15526 }
15527
15528
15529
15530
15531
15532
15533
15534 func (c *PropertiesCustomMetricsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaCustomMetric, error) {
15535 gensupport.SetOptions(c.urlParams_, opts...)
15536 res, err := c.doRequest("json")
15537 if res != nil && res.StatusCode == http.StatusNotModified {
15538 if res.Body != nil {
15539 res.Body.Close()
15540 }
15541 return nil, gensupport.WrapError(&googleapi.Error{
15542 Code: res.StatusCode,
15543 Header: res.Header,
15544 })
15545 }
15546 if err != nil {
15547 return nil, err
15548 }
15549 defer googleapi.CloseBody(res)
15550 if err := googleapi.CheckResponse(res); err != nil {
15551 return nil, gensupport.WrapError(err)
15552 }
15553 ret := &GoogleAnalyticsAdminV1alphaCustomMetric{
15554 ServerResponse: googleapi.ServerResponse{
15555 Header: res.Header,
15556 HTTPStatusCode: res.StatusCode,
15557 },
15558 }
15559 target := &ret
15560 if err := gensupport.DecodeResponse(target, res); err != nil {
15561 return nil, err
15562 }
15563 return ret, nil
15564 }
15565
15566 type PropertiesDataStreamsCreateCall struct {
15567 s *Service
15568 parent string
15569 googleanalyticsadminv1alphadatastream *GoogleAnalyticsAdminV1alphaDataStream
15570 urlParams_ gensupport.URLParams
15571 ctx_ context.Context
15572 header_ http.Header
15573 }
15574
15575
15576
15577
15578 func (r *PropertiesDataStreamsService) Create(parent string, googleanalyticsadminv1alphadatastream *GoogleAnalyticsAdminV1alphaDataStream) *PropertiesDataStreamsCreateCall {
15579 c := &PropertiesDataStreamsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15580 c.parent = parent
15581 c.googleanalyticsadminv1alphadatastream = googleanalyticsadminv1alphadatastream
15582 return c
15583 }
15584
15585
15586
15587
15588 func (c *PropertiesDataStreamsCreateCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsCreateCall {
15589 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15590 return c
15591 }
15592
15593
15594 func (c *PropertiesDataStreamsCreateCall) Context(ctx context.Context) *PropertiesDataStreamsCreateCall {
15595 c.ctx_ = ctx
15596 return c
15597 }
15598
15599
15600
15601 func (c *PropertiesDataStreamsCreateCall) Header() http.Header {
15602 if c.header_ == nil {
15603 c.header_ = make(http.Header)
15604 }
15605 return c.header_
15606 }
15607
15608 func (c *PropertiesDataStreamsCreateCall) doRequest(alt string) (*http.Response, error) {
15609 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15610 var body io.Reader = nil
15611 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphadatastream)
15612 if err != nil {
15613 return nil, err
15614 }
15615 c.urlParams_.Set("alt", alt)
15616 c.urlParams_.Set("prettyPrint", "false")
15617 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/dataStreams")
15618 urls += "?" + c.urlParams_.Encode()
15619 req, err := http.NewRequest("POST", urls, body)
15620 if err != nil {
15621 return nil, err
15622 }
15623 req.Header = reqHeaders
15624 googleapi.Expand(req.URL, map[string]string{
15625 "parent": c.parent,
15626 })
15627 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15628 }
15629
15630
15631
15632
15633
15634
15635
15636 func (c *PropertiesDataStreamsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDataStream, error) {
15637 gensupport.SetOptions(c.urlParams_, opts...)
15638 res, err := c.doRequest("json")
15639 if res != nil && res.StatusCode == http.StatusNotModified {
15640 if res.Body != nil {
15641 res.Body.Close()
15642 }
15643 return nil, gensupport.WrapError(&googleapi.Error{
15644 Code: res.StatusCode,
15645 Header: res.Header,
15646 })
15647 }
15648 if err != nil {
15649 return nil, err
15650 }
15651 defer googleapi.CloseBody(res)
15652 if err := googleapi.CheckResponse(res); err != nil {
15653 return nil, gensupport.WrapError(err)
15654 }
15655 ret := &GoogleAnalyticsAdminV1alphaDataStream{
15656 ServerResponse: googleapi.ServerResponse{
15657 Header: res.Header,
15658 HTTPStatusCode: res.StatusCode,
15659 },
15660 }
15661 target := &ret
15662 if err := gensupport.DecodeResponse(target, res); err != nil {
15663 return nil, err
15664 }
15665 return ret, nil
15666 }
15667
15668 type PropertiesDataStreamsDeleteCall struct {
15669 s *Service
15670 name string
15671 urlParams_ gensupport.URLParams
15672 ctx_ context.Context
15673 header_ http.Header
15674 }
15675
15676
15677
15678
15679
15680 func (r *PropertiesDataStreamsService) Delete(name string) *PropertiesDataStreamsDeleteCall {
15681 c := &PropertiesDataStreamsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15682 c.name = name
15683 return c
15684 }
15685
15686
15687
15688
15689 func (c *PropertiesDataStreamsDeleteCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsDeleteCall {
15690 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15691 return c
15692 }
15693
15694
15695 func (c *PropertiesDataStreamsDeleteCall) Context(ctx context.Context) *PropertiesDataStreamsDeleteCall {
15696 c.ctx_ = ctx
15697 return c
15698 }
15699
15700
15701
15702 func (c *PropertiesDataStreamsDeleteCall) Header() http.Header {
15703 if c.header_ == nil {
15704 c.header_ = make(http.Header)
15705 }
15706 return c.header_
15707 }
15708
15709 func (c *PropertiesDataStreamsDeleteCall) doRequest(alt string) (*http.Response, error) {
15710 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15711 var body io.Reader = nil
15712 c.urlParams_.Set("alt", alt)
15713 c.urlParams_.Set("prettyPrint", "false")
15714 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
15715 urls += "?" + c.urlParams_.Encode()
15716 req, err := http.NewRequest("DELETE", urls, body)
15717 if err != nil {
15718 return nil, err
15719 }
15720 req.Header = reqHeaders
15721 googleapi.Expand(req.URL, map[string]string{
15722 "name": c.name,
15723 })
15724 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15725 }
15726
15727
15728
15729
15730
15731
15732
15733 func (c *PropertiesDataStreamsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
15734 gensupport.SetOptions(c.urlParams_, opts...)
15735 res, err := c.doRequest("json")
15736 if res != nil && res.StatusCode == http.StatusNotModified {
15737 if res.Body != nil {
15738 res.Body.Close()
15739 }
15740 return nil, gensupport.WrapError(&googleapi.Error{
15741 Code: res.StatusCode,
15742 Header: res.Header,
15743 })
15744 }
15745 if err != nil {
15746 return nil, err
15747 }
15748 defer googleapi.CloseBody(res)
15749 if err := googleapi.CheckResponse(res); err != nil {
15750 return nil, gensupport.WrapError(err)
15751 }
15752 ret := &GoogleProtobufEmpty{
15753 ServerResponse: googleapi.ServerResponse{
15754 Header: res.Header,
15755 HTTPStatusCode: res.StatusCode,
15756 },
15757 }
15758 target := &ret
15759 if err := gensupport.DecodeResponse(target, res); err != nil {
15760 return nil, err
15761 }
15762 return ret, nil
15763 }
15764
15765 type PropertiesDataStreamsGetCall struct {
15766 s *Service
15767 name string
15768 urlParams_ gensupport.URLParams
15769 ifNoneMatch_ string
15770 ctx_ context.Context
15771 header_ http.Header
15772 }
15773
15774
15775
15776
15777
15778 func (r *PropertiesDataStreamsService) Get(name string) *PropertiesDataStreamsGetCall {
15779 c := &PropertiesDataStreamsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15780 c.name = name
15781 return c
15782 }
15783
15784
15785
15786
15787 func (c *PropertiesDataStreamsGetCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsGetCall {
15788 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15789 return c
15790 }
15791
15792
15793
15794
15795 func (c *PropertiesDataStreamsGetCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsGetCall {
15796 c.ifNoneMatch_ = entityTag
15797 return c
15798 }
15799
15800
15801 func (c *PropertiesDataStreamsGetCall) Context(ctx context.Context) *PropertiesDataStreamsGetCall {
15802 c.ctx_ = ctx
15803 return c
15804 }
15805
15806
15807
15808 func (c *PropertiesDataStreamsGetCall) Header() http.Header {
15809 if c.header_ == nil {
15810 c.header_ = make(http.Header)
15811 }
15812 return c.header_
15813 }
15814
15815 func (c *PropertiesDataStreamsGetCall) doRequest(alt string) (*http.Response, error) {
15816 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15817 if c.ifNoneMatch_ != "" {
15818 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15819 }
15820 var body io.Reader = nil
15821 c.urlParams_.Set("alt", alt)
15822 c.urlParams_.Set("prettyPrint", "false")
15823 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
15824 urls += "?" + c.urlParams_.Encode()
15825 req, err := http.NewRequest("GET", urls, body)
15826 if err != nil {
15827 return nil, err
15828 }
15829 req.Header = reqHeaders
15830 googleapi.Expand(req.URL, map[string]string{
15831 "name": c.name,
15832 })
15833 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15834 }
15835
15836
15837
15838
15839
15840
15841
15842 func (c *PropertiesDataStreamsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDataStream, error) {
15843 gensupport.SetOptions(c.urlParams_, opts...)
15844 res, err := c.doRequest("json")
15845 if res != nil && res.StatusCode == http.StatusNotModified {
15846 if res.Body != nil {
15847 res.Body.Close()
15848 }
15849 return nil, gensupport.WrapError(&googleapi.Error{
15850 Code: res.StatusCode,
15851 Header: res.Header,
15852 })
15853 }
15854 if err != nil {
15855 return nil, err
15856 }
15857 defer googleapi.CloseBody(res)
15858 if err := googleapi.CheckResponse(res); err != nil {
15859 return nil, gensupport.WrapError(err)
15860 }
15861 ret := &GoogleAnalyticsAdminV1alphaDataStream{
15862 ServerResponse: googleapi.ServerResponse{
15863 Header: res.Header,
15864 HTTPStatusCode: res.StatusCode,
15865 },
15866 }
15867 target := &ret
15868 if err := gensupport.DecodeResponse(target, res); err != nil {
15869 return nil, err
15870 }
15871 return ret, nil
15872 }
15873
15874 type PropertiesDataStreamsGetDataRedactionSettingsCall struct {
15875 s *Service
15876 name string
15877 urlParams_ gensupport.URLParams
15878 ifNoneMatch_ string
15879 ctx_ context.Context
15880 header_ http.Header
15881 }
15882
15883
15884
15885
15886
15887
15888 func (r *PropertiesDataStreamsService) GetDataRedactionSettings(name string) *PropertiesDataStreamsGetDataRedactionSettingsCall {
15889 c := &PropertiesDataStreamsGetDataRedactionSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15890 c.name = name
15891 return c
15892 }
15893
15894
15895
15896
15897 func (c *PropertiesDataStreamsGetDataRedactionSettingsCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsGetDataRedactionSettingsCall {
15898 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15899 return c
15900 }
15901
15902
15903
15904
15905 func (c *PropertiesDataStreamsGetDataRedactionSettingsCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsGetDataRedactionSettingsCall {
15906 c.ifNoneMatch_ = entityTag
15907 return c
15908 }
15909
15910
15911 func (c *PropertiesDataStreamsGetDataRedactionSettingsCall) Context(ctx context.Context) *PropertiesDataStreamsGetDataRedactionSettingsCall {
15912 c.ctx_ = ctx
15913 return c
15914 }
15915
15916
15917
15918 func (c *PropertiesDataStreamsGetDataRedactionSettingsCall) Header() http.Header {
15919 if c.header_ == nil {
15920 c.header_ = make(http.Header)
15921 }
15922 return c.header_
15923 }
15924
15925 func (c *PropertiesDataStreamsGetDataRedactionSettingsCall) doRequest(alt string) (*http.Response, error) {
15926 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15927 if c.ifNoneMatch_ != "" {
15928 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15929 }
15930 var body io.Reader = nil
15931 c.urlParams_.Set("alt", alt)
15932 c.urlParams_.Set("prettyPrint", "false")
15933 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
15934 urls += "?" + c.urlParams_.Encode()
15935 req, err := http.NewRequest("GET", urls, body)
15936 if err != nil {
15937 return nil, err
15938 }
15939 req.Header = reqHeaders
15940 googleapi.Expand(req.URL, map[string]string{
15941 "name": c.name,
15942 })
15943 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15944 }
15945
15946
15947
15948
15949
15950
15951
15952 func (c *PropertiesDataStreamsGetDataRedactionSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDataRedactionSettings, error) {
15953 gensupport.SetOptions(c.urlParams_, opts...)
15954 res, err := c.doRequest("json")
15955 if res != nil && res.StatusCode == http.StatusNotModified {
15956 if res.Body != nil {
15957 res.Body.Close()
15958 }
15959 return nil, gensupport.WrapError(&googleapi.Error{
15960 Code: res.StatusCode,
15961 Header: res.Header,
15962 })
15963 }
15964 if err != nil {
15965 return nil, err
15966 }
15967 defer googleapi.CloseBody(res)
15968 if err := googleapi.CheckResponse(res); err != nil {
15969 return nil, gensupport.WrapError(err)
15970 }
15971 ret := &GoogleAnalyticsAdminV1alphaDataRedactionSettings{
15972 ServerResponse: googleapi.ServerResponse{
15973 Header: res.Header,
15974 HTTPStatusCode: res.StatusCode,
15975 },
15976 }
15977 target := &ret
15978 if err := gensupport.DecodeResponse(target, res); err != nil {
15979 return nil, err
15980 }
15981 return ret, nil
15982 }
15983
15984 type PropertiesDataStreamsGetEnhancedMeasurementSettingsCall struct {
15985 s *Service
15986 name string
15987 urlParams_ gensupport.URLParams
15988 ifNoneMatch_ string
15989 ctx_ context.Context
15990 header_ http.Header
15991 }
15992
15993
15994
15995
15996
15997
15998
15999
16000 func (r *PropertiesDataStreamsService) GetEnhancedMeasurementSettings(name string) *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall {
16001 c := &PropertiesDataStreamsGetEnhancedMeasurementSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16002 c.name = name
16003 return c
16004 }
16005
16006
16007
16008
16009 func (c *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall {
16010 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16011 return c
16012 }
16013
16014
16015
16016
16017 func (c *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall {
16018 c.ifNoneMatch_ = entityTag
16019 return c
16020 }
16021
16022
16023 func (c *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall) Context(ctx context.Context) *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall {
16024 c.ctx_ = ctx
16025 return c
16026 }
16027
16028
16029
16030 func (c *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall) Header() http.Header {
16031 if c.header_ == nil {
16032 c.header_ = make(http.Header)
16033 }
16034 return c.header_
16035 }
16036
16037 func (c *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall) doRequest(alt string) (*http.Response, error) {
16038 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16039 if c.ifNoneMatch_ != "" {
16040 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16041 }
16042 var body io.Reader = nil
16043 c.urlParams_.Set("alt", alt)
16044 c.urlParams_.Set("prettyPrint", "false")
16045 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16046 urls += "?" + c.urlParams_.Encode()
16047 req, err := http.NewRequest("GET", urls, body)
16048 if err != nil {
16049 return nil, err
16050 }
16051 req.Header = reqHeaders
16052 googleapi.Expand(req.URL, map[string]string{
16053 "name": c.name,
16054 })
16055 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16056 }
16057
16058
16059
16060
16061
16062
16063
16064
16065
16066 func (c *PropertiesDataStreamsGetEnhancedMeasurementSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings, error) {
16067 gensupport.SetOptions(c.urlParams_, opts...)
16068 res, err := c.doRequest("json")
16069 if res != nil && res.StatusCode == http.StatusNotModified {
16070 if res.Body != nil {
16071 res.Body.Close()
16072 }
16073 return nil, gensupport.WrapError(&googleapi.Error{
16074 Code: res.StatusCode,
16075 Header: res.Header,
16076 })
16077 }
16078 if err != nil {
16079 return nil, err
16080 }
16081 defer googleapi.CloseBody(res)
16082 if err := googleapi.CheckResponse(res); err != nil {
16083 return nil, gensupport.WrapError(err)
16084 }
16085 ret := &GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings{
16086 ServerResponse: googleapi.ServerResponse{
16087 Header: res.Header,
16088 HTTPStatusCode: res.StatusCode,
16089 },
16090 }
16091 target := &ret
16092 if err := gensupport.DecodeResponse(target, res); err != nil {
16093 return nil, err
16094 }
16095 return ret, nil
16096 }
16097
16098 type PropertiesDataStreamsGetGlobalSiteTagCall struct {
16099 s *Service
16100 name string
16101 urlParams_ gensupport.URLParams
16102 ifNoneMatch_ string
16103 ctx_ context.Context
16104 header_ http.Header
16105 }
16106
16107
16108
16109
16110
16111
16112
16113
16114 func (r *PropertiesDataStreamsService) GetGlobalSiteTag(name string) *PropertiesDataStreamsGetGlobalSiteTagCall {
16115 c := &PropertiesDataStreamsGetGlobalSiteTagCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16116 c.name = name
16117 return c
16118 }
16119
16120
16121
16122
16123 func (c *PropertiesDataStreamsGetGlobalSiteTagCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsGetGlobalSiteTagCall {
16124 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16125 return c
16126 }
16127
16128
16129
16130
16131 func (c *PropertiesDataStreamsGetGlobalSiteTagCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsGetGlobalSiteTagCall {
16132 c.ifNoneMatch_ = entityTag
16133 return c
16134 }
16135
16136
16137 func (c *PropertiesDataStreamsGetGlobalSiteTagCall) Context(ctx context.Context) *PropertiesDataStreamsGetGlobalSiteTagCall {
16138 c.ctx_ = ctx
16139 return c
16140 }
16141
16142
16143
16144 func (c *PropertiesDataStreamsGetGlobalSiteTagCall) Header() http.Header {
16145 if c.header_ == nil {
16146 c.header_ = make(http.Header)
16147 }
16148 return c.header_
16149 }
16150
16151 func (c *PropertiesDataStreamsGetGlobalSiteTagCall) doRequest(alt string) (*http.Response, error) {
16152 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16153 if c.ifNoneMatch_ != "" {
16154 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16155 }
16156 var body io.Reader = nil
16157 c.urlParams_.Set("alt", alt)
16158 c.urlParams_.Set("prettyPrint", "false")
16159 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16160 urls += "?" + c.urlParams_.Encode()
16161 req, err := http.NewRequest("GET", urls, body)
16162 if err != nil {
16163 return nil, err
16164 }
16165 req.Header = reqHeaders
16166 googleapi.Expand(req.URL, map[string]string{
16167 "name": c.name,
16168 })
16169 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16170 }
16171
16172
16173
16174
16175
16176
16177
16178 func (c *PropertiesDataStreamsGetGlobalSiteTagCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaGlobalSiteTag, error) {
16179 gensupport.SetOptions(c.urlParams_, opts...)
16180 res, err := c.doRequest("json")
16181 if res != nil && res.StatusCode == http.StatusNotModified {
16182 if res.Body != nil {
16183 res.Body.Close()
16184 }
16185 return nil, gensupport.WrapError(&googleapi.Error{
16186 Code: res.StatusCode,
16187 Header: res.Header,
16188 })
16189 }
16190 if err != nil {
16191 return nil, err
16192 }
16193 defer googleapi.CloseBody(res)
16194 if err := googleapi.CheckResponse(res); err != nil {
16195 return nil, gensupport.WrapError(err)
16196 }
16197 ret := &GoogleAnalyticsAdminV1alphaGlobalSiteTag{
16198 ServerResponse: googleapi.ServerResponse{
16199 Header: res.Header,
16200 HTTPStatusCode: res.StatusCode,
16201 },
16202 }
16203 target := &ret
16204 if err := gensupport.DecodeResponse(target, res); err != nil {
16205 return nil, err
16206 }
16207 return ret, nil
16208 }
16209
16210 type PropertiesDataStreamsListCall struct {
16211 s *Service
16212 parent string
16213 urlParams_ gensupport.URLParams
16214 ifNoneMatch_ string
16215 ctx_ context.Context
16216 header_ http.Header
16217 }
16218
16219
16220
16221
16222 func (r *PropertiesDataStreamsService) List(parent string) *PropertiesDataStreamsListCall {
16223 c := &PropertiesDataStreamsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16224 c.parent = parent
16225 return c
16226 }
16227
16228
16229
16230
16231 func (c *PropertiesDataStreamsListCall) PageSize(pageSize int64) *PropertiesDataStreamsListCall {
16232 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
16233 return c
16234 }
16235
16236
16237
16238
16239
16240 func (c *PropertiesDataStreamsListCall) PageToken(pageToken string) *PropertiesDataStreamsListCall {
16241 c.urlParams_.Set("pageToken", pageToken)
16242 return c
16243 }
16244
16245
16246
16247
16248 func (c *PropertiesDataStreamsListCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsListCall {
16249 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16250 return c
16251 }
16252
16253
16254
16255
16256 func (c *PropertiesDataStreamsListCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsListCall {
16257 c.ifNoneMatch_ = entityTag
16258 return c
16259 }
16260
16261
16262 func (c *PropertiesDataStreamsListCall) Context(ctx context.Context) *PropertiesDataStreamsListCall {
16263 c.ctx_ = ctx
16264 return c
16265 }
16266
16267
16268
16269 func (c *PropertiesDataStreamsListCall) Header() http.Header {
16270 if c.header_ == nil {
16271 c.header_ = make(http.Header)
16272 }
16273 return c.header_
16274 }
16275
16276 func (c *PropertiesDataStreamsListCall) doRequest(alt string) (*http.Response, error) {
16277 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16278 if c.ifNoneMatch_ != "" {
16279 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16280 }
16281 var body io.Reader = nil
16282 c.urlParams_.Set("alt", alt)
16283 c.urlParams_.Set("prettyPrint", "false")
16284 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/dataStreams")
16285 urls += "?" + c.urlParams_.Encode()
16286 req, err := http.NewRequest("GET", urls, body)
16287 if err != nil {
16288 return nil, err
16289 }
16290 req.Header = reqHeaders
16291 googleapi.Expand(req.URL, map[string]string{
16292 "parent": c.parent,
16293 })
16294 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16295 }
16296
16297
16298
16299
16300
16301
16302
16303 func (c *PropertiesDataStreamsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListDataStreamsResponse, error) {
16304 gensupport.SetOptions(c.urlParams_, opts...)
16305 res, err := c.doRequest("json")
16306 if res != nil && res.StatusCode == http.StatusNotModified {
16307 if res.Body != nil {
16308 res.Body.Close()
16309 }
16310 return nil, gensupport.WrapError(&googleapi.Error{
16311 Code: res.StatusCode,
16312 Header: res.Header,
16313 })
16314 }
16315 if err != nil {
16316 return nil, err
16317 }
16318 defer googleapi.CloseBody(res)
16319 if err := googleapi.CheckResponse(res); err != nil {
16320 return nil, gensupport.WrapError(err)
16321 }
16322 ret := &GoogleAnalyticsAdminV1alphaListDataStreamsResponse{
16323 ServerResponse: googleapi.ServerResponse{
16324 Header: res.Header,
16325 HTTPStatusCode: res.StatusCode,
16326 },
16327 }
16328 target := &ret
16329 if err := gensupport.DecodeResponse(target, res); err != nil {
16330 return nil, err
16331 }
16332 return ret, nil
16333 }
16334
16335
16336
16337
16338 func (c *PropertiesDataStreamsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListDataStreamsResponse) error) error {
16339 c.ctx_ = ctx
16340 defer c.PageToken(c.urlParams_.Get("pageToken"))
16341 for {
16342 x, err := c.Do()
16343 if err != nil {
16344 return err
16345 }
16346 if err := f(x); err != nil {
16347 return err
16348 }
16349 if x.NextPageToken == "" {
16350 return nil
16351 }
16352 c.PageToken(x.NextPageToken)
16353 }
16354 }
16355
16356 type PropertiesDataStreamsPatchCall struct {
16357 s *Service
16358 name string
16359 googleanalyticsadminv1alphadatastream *GoogleAnalyticsAdminV1alphaDataStream
16360 urlParams_ gensupport.URLParams
16361 ctx_ context.Context
16362 header_ http.Header
16363 }
16364
16365
16366
16367
16368
16369
16370 func (r *PropertiesDataStreamsService) Patch(name string, googleanalyticsadminv1alphadatastream *GoogleAnalyticsAdminV1alphaDataStream) *PropertiesDataStreamsPatchCall {
16371 c := &PropertiesDataStreamsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16372 c.name = name
16373 c.googleanalyticsadminv1alphadatastream = googleanalyticsadminv1alphadatastream
16374 return c
16375 }
16376
16377
16378
16379
16380 func (c *PropertiesDataStreamsPatchCall) UpdateMask(updateMask string) *PropertiesDataStreamsPatchCall {
16381 c.urlParams_.Set("updateMask", updateMask)
16382 return c
16383 }
16384
16385
16386
16387
16388 func (c *PropertiesDataStreamsPatchCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsPatchCall {
16389 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16390 return c
16391 }
16392
16393
16394 func (c *PropertiesDataStreamsPatchCall) Context(ctx context.Context) *PropertiesDataStreamsPatchCall {
16395 c.ctx_ = ctx
16396 return c
16397 }
16398
16399
16400
16401 func (c *PropertiesDataStreamsPatchCall) Header() http.Header {
16402 if c.header_ == nil {
16403 c.header_ = make(http.Header)
16404 }
16405 return c.header_
16406 }
16407
16408 func (c *PropertiesDataStreamsPatchCall) doRequest(alt string) (*http.Response, error) {
16409 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16410 var body io.Reader = nil
16411 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphadatastream)
16412 if err != nil {
16413 return nil, err
16414 }
16415 c.urlParams_.Set("alt", alt)
16416 c.urlParams_.Set("prettyPrint", "false")
16417 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16418 urls += "?" + c.urlParams_.Encode()
16419 req, err := http.NewRequest("PATCH", urls, body)
16420 if err != nil {
16421 return nil, err
16422 }
16423 req.Header = reqHeaders
16424 googleapi.Expand(req.URL, map[string]string{
16425 "name": c.name,
16426 })
16427 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16428 }
16429
16430
16431
16432
16433
16434
16435
16436 func (c *PropertiesDataStreamsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDataStream, error) {
16437 gensupport.SetOptions(c.urlParams_, opts...)
16438 res, err := c.doRequest("json")
16439 if res != nil && res.StatusCode == http.StatusNotModified {
16440 if res.Body != nil {
16441 res.Body.Close()
16442 }
16443 return nil, gensupport.WrapError(&googleapi.Error{
16444 Code: res.StatusCode,
16445 Header: res.Header,
16446 })
16447 }
16448 if err != nil {
16449 return nil, err
16450 }
16451 defer googleapi.CloseBody(res)
16452 if err := googleapi.CheckResponse(res); err != nil {
16453 return nil, gensupport.WrapError(err)
16454 }
16455 ret := &GoogleAnalyticsAdminV1alphaDataStream{
16456 ServerResponse: googleapi.ServerResponse{
16457 Header: res.Header,
16458 HTTPStatusCode: res.StatusCode,
16459 },
16460 }
16461 target := &ret
16462 if err := gensupport.DecodeResponse(target, res); err != nil {
16463 return nil, err
16464 }
16465 return ret, nil
16466 }
16467
16468 type PropertiesDataStreamsUpdateDataRedactionSettingsCall struct {
16469 s *Service
16470 name string
16471 googleanalyticsadminv1alphadataredactionsettings *GoogleAnalyticsAdminV1alphaDataRedactionSettings
16472 urlParams_ gensupport.URLParams
16473 ctx_ context.Context
16474 header_ http.Header
16475 }
16476
16477
16478
16479
16480
16481
16482 func (r *PropertiesDataStreamsService) UpdateDataRedactionSettings(name string, googleanalyticsadminv1alphadataredactionsettings *GoogleAnalyticsAdminV1alphaDataRedactionSettings) *PropertiesDataStreamsUpdateDataRedactionSettingsCall {
16483 c := &PropertiesDataStreamsUpdateDataRedactionSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16484 c.name = name
16485 c.googleanalyticsadminv1alphadataredactionsettings = googleanalyticsadminv1alphadataredactionsettings
16486 return c
16487 }
16488
16489
16490
16491
16492
16493 func (c *PropertiesDataStreamsUpdateDataRedactionSettingsCall) UpdateMask(updateMask string) *PropertiesDataStreamsUpdateDataRedactionSettingsCall {
16494 c.urlParams_.Set("updateMask", updateMask)
16495 return c
16496 }
16497
16498
16499
16500
16501 func (c *PropertiesDataStreamsUpdateDataRedactionSettingsCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsUpdateDataRedactionSettingsCall {
16502 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16503 return c
16504 }
16505
16506
16507 func (c *PropertiesDataStreamsUpdateDataRedactionSettingsCall) Context(ctx context.Context) *PropertiesDataStreamsUpdateDataRedactionSettingsCall {
16508 c.ctx_ = ctx
16509 return c
16510 }
16511
16512
16513
16514 func (c *PropertiesDataStreamsUpdateDataRedactionSettingsCall) Header() http.Header {
16515 if c.header_ == nil {
16516 c.header_ = make(http.Header)
16517 }
16518 return c.header_
16519 }
16520
16521 func (c *PropertiesDataStreamsUpdateDataRedactionSettingsCall) doRequest(alt string) (*http.Response, error) {
16522 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16523 var body io.Reader = nil
16524 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphadataredactionsettings)
16525 if err != nil {
16526 return nil, err
16527 }
16528 c.urlParams_.Set("alt", alt)
16529 c.urlParams_.Set("prettyPrint", "false")
16530 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16531 urls += "?" + c.urlParams_.Encode()
16532 req, err := http.NewRequest("PATCH", urls, body)
16533 if err != nil {
16534 return nil, err
16535 }
16536 req.Header = reqHeaders
16537 googleapi.Expand(req.URL, map[string]string{
16538 "name": c.name,
16539 })
16540 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16541 }
16542
16543
16544
16545
16546
16547
16548
16549 func (c *PropertiesDataStreamsUpdateDataRedactionSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDataRedactionSettings, error) {
16550 gensupport.SetOptions(c.urlParams_, opts...)
16551 res, err := c.doRequest("json")
16552 if res != nil && res.StatusCode == http.StatusNotModified {
16553 if res.Body != nil {
16554 res.Body.Close()
16555 }
16556 return nil, gensupport.WrapError(&googleapi.Error{
16557 Code: res.StatusCode,
16558 Header: res.Header,
16559 })
16560 }
16561 if err != nil {
16562 return nil, err
16563 }
16564 defer googleapi.CloseBody(res)
16565 if err := googleapi.CheckResponse(res); err != nil {
16566 return nil, gensupport.WrapError(err)
16567 }
16568 ret := &GoogleAnalyticsAdminV1alphaDataRedactionSettings{
16569 ServerResponse: googleapi.ServerResponse{
16570 Header: res.Header,
16571 HTTPStatusCode: res.StatusCode,
16572 },
16573 }
16574 target := &ret
16575 if err := gensupport.DecodeResponse(target, res); err != nil {
16576 return nil, err
16577 }
16578 return ret, nil
16579 }
16580
16581 type PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall struct {
16582 s *Service
16583 name string
16584 googleanalyticsadminv1alphaenhancedmeasurementsettings *GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings
16585 urlParams_ gensupport.URLParams
16586 ctx_ context.Context
16587 header_ http.Header
16588 }
16589
16590
16591
16592
16593
16594
16595
16596
16597
16598
16599 func (r *PropertiesDataStreamsService) UpdateEnhancedMeasurementSettings(name string, googleanalyticsadminv1alphaenhancedmeasurementsettings *GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings) *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall {
16600 c := &PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16601 c.name = name
16602 c.googleanalyticsadminv1alphaenhancedmeasurementsettings = googleanalyticsadminv1alphaenhancedmeasurementsettings
16603 return c
16604 }
16605
16606
16607
16608
16609
16610 func (c *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall) UpdateMask(updateMask string) *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall {
16611 c.urlParams_.Set("updateMask", updateMask)
16612 return c
16613 }
16614
16615
16616
16617
16618 func (c *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall {
16619 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16620 return c
16621 }
16622
16623
16624 func (c *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall) Context(ctx context.Context) *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall {
16625 c.ctx_ = ctx
16626 return c
16627 }
16628
16629
16630
16631 func (c *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall) Header() http.Header {
16632 if c.header_ == nil {
16633 c.header_ = make(http.Header)
16634 }
16635 return c.header_
16636 }
16637
16638 func (c *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall) doRequest(alt string) (*http.Response, error) {
16639 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16640 var body io.Reader = nil
16641 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaenhancedmeasurementsettings)
16642 if err != nil {
16643 return nil, err
16644 }
16645 c.urlParams_.Set("alt", alt)
16646 c.urlParams_.Set("prettyPrint", "false")
16647 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16648 urls += "?" + c.urlParams_.Encode()
16649 req, err := http.NewRequest("PATCH", urls, body)
16650 if err != nil {
16651 return nil, err
16652 }
16653 req.Header = reqHeaders
16654 googleapi.Expand(req.URL, map[string]string{
16655 "name": c.name,
16656 })
16657 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16658 }
16659
16660
16661
16662
16663
16664
16665
16666
16667
16668 func (c *PropertiesDataStreamsUpdateEnhancedMeasurementSettingsCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings, error) {
16669 gensupport.SetOptions(c.urlParams_, opts...)
16670 res, err := c.doRequest("json")
16671 if res != nil && res.StatusCode == http.StatusNotModified {
16672 if res.Body != nil {
16673 res.Body.Close()
16674 }
16675 return nil, gensupport.WrapError(&googleapi.Error{
16676 Code: res.StatusCode,
16677 Header: res.Header,
16678 })
16679 }
16680 if err != nil {
16681 return nil, err
16682 }
16683 defer googleapi.CloseBody(res)
16684 if err := googleapi.CheckResponse(res); err != nil {
16685 return nil, gensupport.WrapError(err)
16686 }
16687 ret := &GoogleAnalyticsAdminV1alphaEnhancedMeasurementSettings{
16688 ServerResponse: googleapi.ServerResponse{
16689 Header: res.Header,
16690 HTTPStatusCode: res.StatusCode,
16691 },
16692 }
16693 target := &ret
16694 if err := gensupport.DecodeResponse(target, res); err != nil {
16695 return nil, err
16696 }
16697 return ret, nil
16698 }
16699
16700 type PropertiesDataStreamsEventCreateRulesCreateCall struct {
16701 s *Service
16702 parent string
16703 googleanalyticsadminv1alphaeventcreaterule *GoogleAnalyticsAdminV1alphaEventCreateRule
16704 urlParams_ gensupport.URLParams
16705 ctx_ context.Context
16706 header_ http.Header
16707 }
16708
16709
16710
16711
16712 func (r *PropertiesDataStreamsEventCreateRulesService) Create(parent string, googleanalyticsadminv1alphaeventcreaterule *GoogleAnalyticsAdminV1alphaEventCreateRule) *PropertiesDataStreamsEventCreateRulesCreateCall {
16713 c := &PropertiesDataStreamsEventCreateRulesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16714 c.parent = parent
16715 c.googleanalyticsadminv1alphaeventcreaterule = googleanalyticsadminv1alphaeventcreaterule
16716 return c
16717 }
16718
16719
16720
16721
16722 func (c *PropertiesDataStreamsEventCreateRulesCreateCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsEventCreateRulesCreateCall {
16723 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16724 return c
16725 }
16726
16727
16728 func (c *PropertiesDataStreamsEventCreateRulesCreateCall) Context(ctx context.Context) *PropertiesDataStreamsEventCreateRulesCreateCall {
16729 c.ctx_ = ctx
16730 return c
16731 }
16732
16733
16734
16735 func (c *PropertiesDataStreamsEventCreateRulesCreateCall) Header() http.Header {
16736 if c.header_ == nil {
16737 c.header_ = make(http.Header)
16738 }
16739 return c.header_
16740 }
16741
16742 func (c *PropertiesDataStreamsEventCreateRulesCreateCall) doRequest(alt string) (*http.Response, error) {
16743 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16744 var body io.Reader = nil
16745 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaeventcreaterule)
16746 if err != nil {
16747 return nil, err
16748 }
16749 c.urlParams_.Set("alt", alt)
16750 c.urlParams_.Set("prettyPrint", "false")
16751 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/eventCreateRules")
16752 urls += "?" + c.urlParams_.Encode()
16753 req, err := http.NewRequest("POST", urls, body)
16754 if err != nil {
16755 return nil, err
16756 }
16757 req.Header = reqHeaders
16758 googleapi.Expand(req.URL, map[string]string{
16759 "parent": c.parent,
16760 })
16761 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16762 }
16763
16764
16765
16766
16767
16768
16769
16770 func (c *PropertiesDataStreamsEventCreateRulesCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaEventCreateRule, error) {
16771 gensupport.SetOptions(c.urlParams_, opts...)
16772 res, err := c.doRequest("json")
16773 if res != nil && res.StatusCode == http.StatusNotModified {
16774 if res.Body != nil {
16775 res.Body.Close()
16776 }
16777 return nil, gensupport.WrapError(&googleapi.Error{
16778 Code: res.StatusCode,
16779 Header: res.Header,
16780 })
16781 }
16782 if err != nil {
16783 return nil, err
16784 }
16785 defer googleapi.CloseBody(res)
16786 if err := googleapi.CheckResponse(res); err != nil {
16787 return nil, gensupport.WrapError(err)
16788 }
16789 ret := &GoogleAnalyticsAdminV1alphaEventCreateRule{
16790 ServerResponse: googleapi.ServerResponse{
16791 Header: res.Header,
16792 HTTPStatusCode: res.StatusCode,
16793 },
16794 }
16795 target := &ret
16796 if err := gensupport.DecodeResponse(target, res); err != nil {
16797 return nil, err
16798 }
16799 return ret, nil
16800 }
16801
16802 type PropertiesDataStreamsEventCreateRulesDeleteCall struct {
16803 s *Service
16804 name string
16805 urlParams_ gensupport.URLParams
16806 ctx_ context.Context
16807 header_ http.Header
16808 }
16809
16810
16811
16812
16813 func (r *PropertiesDataStreamsEventCreateRulesService) Delete(name string) *PropertiesDataStreamsEventCreateRulesDeleteCall {
16814 c := &PropertiesDataStreamsEventCreateRulesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16815 c.name = name
16816 return c
16817 }
16818
16819
16820
16821
16822 func (c *PropertiesDataStreamsEventCreateRulesDeleteCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsEventCreateRulesDeleteCall {
16823 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16824 return c
16825 }
16826
16827
16828 func (c *PropertiesDataStreamsEventCreateRulesDeleteCall) Context(ctx context.Context) *PropertiesDataStreamsEventCreateRulesDeleteCall {
16829 c.ctx_ = ctx
16830 return c
16831 }
16832
16833
16834
16835 func (c *PropertiesDataStreamsEventCreateRulesDeleteCall) Header() http.Header {
16836 if c.header_ == nil {
16837 c.header_ = make(http.Header)
16838 }
16839 return c.header_
16840 }
16841
16842 func (c *PropertiesDataStreamsEventCreateRulesDeleteCall) doRequest(alt string) (*http.Response, error) {
16843 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16844 var body io.Reader = nil
16845 c.urlParams_.Set("alt", alt)
16846 c.urlParams_.Set("prettyPrint", "false")
16847 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16848 urls += "?" + c.urlParams_.Encode()
16849 req, err := http.NewRequest("DELETE", urls, body)
16850 if err != nil {
16851 return nil, err
16852 }
16853 req.Header = reqHeaders
16854 googleapi.Expand(req.URL, map[string]string{
16855 "name": c.name,
16856 })
16857 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16858 }
16859
16860
16861
16862
16863
16864
16865
16866 func (c *PropertiesDataStreamsEventCreateRulesDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
16867 gensupport.SetOptions(c.urlParams_, opts...)
16868 res, err := c.doRequest("json")
16869 if res != nil && res.StatusCode == http.StatusNotModified {
16870 if res.Body != nil {
16871 res.Body.Close()
16872 }
16873 return nil, gensupport.WrapError(&googleapi.Error{
16874 Code: res.StatusCode,
16875 Header: res.Header,
16876 })
16877 }
16878 if err != nil {
16879 return nil, err
16880 }
16881 defer googleapi.CloseBody(res)
16882 if err := googleapi.CheckResponse(res); err != nil {
16883 return nil, gensupport.WrapError(err)
16884 }
16885 ret := &GoogleProtobufEmpty{
16886 ServerResponse: googleapi.ServerResponse{
16887 Header: res.Header,
16888 HTTPStatusCode: res.StatusCode,
16889 },
16890 }
16891 target := &ret
16892 if err := gensupport.DecodeResponse(target, res); err != nil {
16893 return nil, err
16894 }
16895 return ret, nil
16896 }
16897
16898 type PropertiesDataStreamsEventCreateRulesGetCall struct {
16899 s *Service
16900 name string
16901 urlParams_ gensupport.URLParams
16902 ifNoneMatch_ string
16903 ctx_ context.Context
16904 header_ http.Header
16905 }
16906
16907
16908
16909
16910
16911 func (r *PropertiesDataStreamsEventCreateRulesService) Get(name string) *PropertiesDataStreamsEventCreateRulesGetCall {
16912 c := &PropertiesDataStreamsEventCreateRulesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16913 c.name = name
16914 return c
16915 }
16916
16917
16918
16919
16920 func (c *PropertiesDataStreamsEventCreateRulesGetCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsEventCreateRulesGetCall {
16921 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16922 return c
16923 }
16924
16925
16926
16927
16928 func (c *PropertiesDataStreamsEventCreateRulesGetCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsEventCreateRulesGetCall {
16929 c.ifNoneMatch_ = entityTag
16930 return c
16931 }
16932
16933
16934 func (c *PropertiesDataStreamsEventCreateRulesGetCall) Context(ctx context.Context) *PropertiesDataStreamsEventCreateRulesGetCall {
16935 c.ctx_ = ctx
16936 return c
16937 }
16938
16939
16940
16941 func (c *PropertiesDataStreamsEventCreateRulesGetCall) Header() http.Header {
16942 if c.header_ == nil {
16943 c.header_ = make(http.Header)
16944 }
16945 return c.header_
16946 }
16947
16948 func (c *PropertiesDataStreamsEventCreateRulesGetCall) doRequest(alt string) (*http.Response, error) {
16949 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16950 if c.ifNoneMatch_ != "" {
16951 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16952 }
16953 var body io.Reader = nil
16954 c.urlParams_.Set("alt", alt)
16955 c.urlParams_.Set("prettyPrint", "false")
16956 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16957 urls += "?" + c.urlParams_.Encode()
16958 req, err := http.NewRequest("GET", urls, body)
16959 if err != nil {
16960 return nil, err
16961 }
16962 req.Header = reqHeaders
16963 googleapi.Expand(req.URL, map[string]string{
16964 "name": c.name,
16965 })
16966 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16967 }
16968
16969
16970
16971
16972
16973
16974
16975 func (c *PropertiesDataStreamsEventCreateRulesGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaEventCreateRule, error) {
16976 gensupport.SetOptions(c.urlParams_, opts...)
16977 res, err := c.doRequest("json")
16978 if res != nil && res.StatusCode == http.StatusNotModified {
16979 if res.Body != nil {
16980 res.Body.Close()
16981 }
16982 return nil, gensupport.WrapError(&googleapi.Error{
16983 Code: res.StatusCode,
16984 Header: res.Header,
16985 })
16986 }
16987 if err != nil {
16988 return nil, err
16989 }
16990 defer googleapi.CloseBody(res)
16991 if err := googleapi.CheckResponse(res); err != nil {
16992 return nil, gensupport.WrapError(err)
16993 }
16994 ret := &GoogleAnalyticsAdminV1alphaEventCreateRule{
16995 ServerResponse: googleapi.ServerResponse{
16996 Header: res.Header,
16997 HTTPStatusCode: res.StatusCode,
16998 },
16999 }
17000 target := &ret
17001 if err := gensupport.DecodeResponse(target, res); err != nil {
17002 return nil, err
17003 }
17004 return ret, nil
17005 }
17006
17007 type PropertiesDataStreamsEventCreateRulesListCall struct {
17008 s *Service
17009 parent string
17010 urlParams_ gensupport.URLParams
17011 ifNoneMatch_ string
17012 ctx_ context.Context
17013 header_ http.Header
17014 }
17015
17016
17017
17018
17019 func (r *PropertiesDataStreamsEventCreateRulesService) List(parent string) *PropertiesDataStreamsEventCreateRulesListCall {
17020 c := &PropertiesDataStreamsEventCreateRulesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17021 c.parent = parent
17022 return c
17023 }
17024
17025
17026
17027
17028 func (c *PropertiesDataStreamsEventCreateRulesListCall) PageSize(pageSize int64) *PropertiesDataStreamsEventCreateRulesListCall {
17029 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
17030 return c
17031 }
17032
17033
17034
17035
17036
17037 func (c *PropertiesDataStreamsEventCreateRulesListCall) PageToken(pageToken string) *PropertiesDataStreamsEventCreateRulesListCall {
17038 c.urlParams_.Set("pageToken", pageToken)
17039 return c
17040 }
17041
17042
17043
17044
17045 func (c *PropertiesDataStreamsEventCreateRulesListCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsEventCreateRulesListCall {
17046 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17047 return c
17048 }
17049
17050
17051
17052
17053 func (c *PropertiesDataStreamsEventCreateRulesListCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsEventCreateRulesListCall {
17054 c.ifNoneMatch_ = entityTag
17055 return c
17056 }
17057
17058
17059 func (c *PropertiesDataStreamsEventCreateRulesListCall) Context(ctx context.Context) *PropertiesDataStreamsEventCreateRulesListCall {
17060 c.ctx_ = ctx
17061 return c
17062 }
17063
17064
17065
17066 func (c *PropertiesDataStreamsEventCreateRulesListCall) Header() http.Header {
17067 if c.header_ == nil {
17068 c.header_ = make(http.Header)
17069 }
17070 return c.header_
17071 }
17072
17073 func (c *PropertiesDataStreamsEventCreateRulesListCall) doRequest(alt string) (*http.Response, error) {
17074 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17075 if c.ifNoneMatch_ != "" {
17076 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17077 }
17078 var body io.Reader = nil
17079 c.urlParams_.Set("alt", alt)
17080 c.urlParams_.Set("prettyPrint", "false")
17081 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/eventCreateRules")
17082 urls += "?" + c.urlParams_.Encode()
17083 req, err := http.NewRequest("GET", urls, body)
17084 if err != nil {
17085 return nil, err
17086 }
17087 req.Header = reqHeaders
17088 googleapi.Expand(req.URL, map[string]string{
17089 "parent": c.parent,
17090 })
17091 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17092 }
17093
17094
17095
17096
17097
17098
17099
17100 func (c *PropertiesDataStreamsEventCreateRulesListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListEventCreateRulesResponse, error) {
17101 gensupport.SetOptions(c.urlParams_, opts...)
17102 res, err := c.doRequest("json")
17103 if res != nil && res.StatusCode == http.StatusNotModified {
17104 if res.Body != nil {
17105 res.Body.Close()
17106 }
17107 return nil, gensupport.WrapError(&googleapi.Error{
17108 Code: res.StatusCode,
17109 Header: res.Header,
17110 })
17111 }
17112 if err != nil {
17113 return nil, err
17114 }
17115 defer googleapi.CloseBody(res)
17116 if err := googleapi.CheckResponse(res); err != nil {
17117 return nil, gensupport.WrapError(err)
17118 }
17119 ret := &GoogleAnalyticsAdminV1alphaListEventCreateRulesResponse{
17120 ServerResponse: googleapi.ServerResponse{
17121 Header: res.Header,
17122 HTTPStatusCode: res.StatusCode,
17123 },
17124 }
17125 target := &ret
17126 if err := gensupport.DecodeResponse(target, res); err != nil {
17127 return nil, err
17128 }
17129 return ret, nil
17130 }
17131
17132
17133
17134
17135 func (c *PropertiesDataStreamsEventCreateRulesListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListEventCreateRulesResponse) error) error {
17136 c.ctx_ = ctx
17137 defer c.PageToken(c.urlParams_.Get("pageToken"))
17138 for {
17139 x, err := c.Do()
17140 if err != nil {
17141 return err
17142 }
17143 if err := f(x); err != nil {
17144 return err
17145 }
17146 if x.NextPageToken == "" {
17147 return nil
17148 }
17149 c.PageToken(x.NextPageToken)
17150 }
17151 }
17152
17153 type PropertiesDataStreamsEventCreateRulesPatchCall struct {
17154 s *Service
17155 name string
17156 googleanalyticsadminv1alphaeventcreaterule *GoogleAnalyticsAdminV1alphaEventCreateRule
17157 urlParams_ gensupport.URLParams
17158 ctx_ context.Context
17159 header_ http.Header
17160 }
17161
17162
17163
17164
17165
17166
17167
17168 func (r *PropertiesDataStreamsEventCreateRulesService) Patch(name string, googleanalyticsadminv1alphaeventcreaterule *GoogleAnalyticsAdminV1alphaEventCreateRule) *PropertiesDataStreamsEventCreateRulesPatchCall {
17169 c := &PropertiesDataStreamsEventCreateRulesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17170 c.name = name
17171 c.googleanalyticsadminv1alphaeventcreaterule = googleanalyticsadminv1alphaeventcreaterule
17172 return c
17173 }
17174
17175
17176
17177
17178
17179 func (c *PropertiesDataStreamsEventCreateRulesPatchCall) UpdateMask(updateMask string) *PropertiesDataStreamsEventCreateRulesPatchCall {
17180 c.urlParams_.Set("updateMask", updateMask)
17181 return c
17182 }
17183
17184
17185
17186
17187 func (c *PropertiesDataStreamsEventCreateRulesPatchCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsEventCreateRulesPatchCall {
17188 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17189 return c
17190 }
17191
17192
17193 func (c *PropertiesDataStreamsEventCreateRulesPatchCall) Context(ctx context.Context) *PropertiesDataStreamsEventCreateRulesPatchCall {
17194 c.ctx_ = ctx
17195 return c
17196 }
17197
17198
17199
17200 func (c *PropertiesDataStreamsEventCreateRulesPatchCall) Header() http.Header {
17201 if c.header_ == nil {
17202 c.header_ = make(http.Header)
17203 }
17204 return c.header_
17205 }
17206
17207 func (c *PropertiesDataStreamsEventCreateRulesPatchCall) doRequest(alt string) (*http.Response, error) {
17208 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17209 var body io.Reader = nil
17210 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaeventcreaterule)
17211 if err != nil {
17212 return nil, err
17213 }
17214 c.urlParams_.Set("alt", alt)
17215 c.urlParams_.Set("prettyPrint", "false")
17216 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
17217 urls += "?" + c.urlParams_.Encode()
17218 req, err := http.NewRequest("PATCH", urls, body)
17219 if err != nil {
17220 return nil, err
17221 }
17222 req.Header = reqHeaders
17223 googleapi.Expand(req.URL, map[string]string{
17224 "name": c.name,
17225 })
17226 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17227 }
17228
17229
17230
17231
17232
17233
17234
17235 func (c *PropertiesDataStreamsEventCreateRulesPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaEventCreateRule, error) {
17236 gensupport.SetOptions(c.urlParams_, opts...)
17237 res, err := c.doRequest("json")
17238 if res != nil && res.StatusCode == http.StatusNotModified {
17239 if res.Body != nil {
17240 res.Body.Close()
17241 }
17242 return nil, gensupport.WrapError(&googleapi.Error{
17243 Code: res.StatusCode,
17244 Header: res.Header,
17245 })
17246 }
17247 if err != nil {
17248 return nil, err
17249 }
17250 defer googleapi.CloseBody(res)
17251 if err := googleapi.CheckResponse(res); err != nil {
17252 return nil, gensupport.WrapError(err)
17253 }
17254 ret := &GoogleAnalyticsAdminV1alphaEventCreateRule{
17255 ServerResponse: googleapi.ServerResponse{
17256 Header: res.Header,
17257 HTTPStatusCode: res.StatusCode,
17258 },
17259 }
17260 target := &ret
17261 if err := gensupport.DecodeResponse(target, res); err != nil {
17262 return nil, err
17263 }
17264 return ret, nil
17265 }
17266
17267 type PropertiesDataStreamsMeasurementProtocolSecretsCreateCall struct {
17268 s *Service
17269 parent string
17270 googleanalyticsadminv1alphameasurementprotocolsecret *GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret
17271 urlParams_ gensupport.URLParams
17272 ctx_ context.Context
17273 header_ http.Header
17274 }
17275
17276
17277
17278
17279
17280 func (r *PropertiesDataStreamsMeasurementProtocolSecretsService) Create(parent string, googleanalyticsadminv1alphameasurementprotocolsecret *GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret) *PropertiesDataStreamsMeasurementProtocolSecretsCreateCall {
17281 c := &PropertiesDataStreamsMeasurementProtocolSecretsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17282 c.parent = parent
17283 c.googleanalyticsadminv1alphameasurementprotocolsecret = googleanalyticsadminv1alphameasurementprotocolsecret
17284 return c
17285 }
17286
17287
17288
17289
17290 func (c *PropertiesDataStreamsMeasurementProtocolSecretsCreateCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsMeasurementProtocolSecretsCreateCall {
17291 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17292 return c
17293 }
17294
17295
17296 func (c *PropertiesDataStreamsMeasurementProtocolSecretsCreateCall) Context(ctx context.Context) *PropertiesDataStreamsMeasurementProtocolSecretsCreateCall {
17297 c.ctx_ = ctx
17298 return c
17299 }
17300
17301
17302
17303 func (c *PropertiesDataStreamsMeasurementProtocolSecretsCreateCall) Header() http.Header {
17304 if c.header_ == nil {
17305 c.header_ = make(http.Header)
17306 }
17307 return c.header_
17308 }
17309
17310 func (c *PropertiesDataStreamsMeasurementProtocolSecretsCreateCall) doRequest(alt string) (*http.Response, error) {
17311 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17312 var body io.Reader = nil
17313 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphameasurementprotocolsecret)
17314 if err != nil {
17315 return nil, err
17316 }
17317 c.urlParams_.Set("alt", alt)
17318 c.urlParams_.Set("prettyPrint", "false")
17319 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/measurementProtocolSecrets")
17320 urls += "?" + c.urlParams_.Encode()
17321 req, err := http.NewRequest("POST", urls, body)
17322 if err != nil {
17323 return nil, err
17324 }
17325 req.Header = reqHeaders
17326 googleapi.Expand(req.URL, map[string]string{
17327 "parent": c.parent,
17328 })
17329 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17330 }
17331
17332
17333
17334
17335
17336
17337
17338 func (c *PropertiesDataStreamsMeasurementProtocolSecretsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret, error) {
17339 gensupport.SetOptions(c.urlParams_, opts...)
17340 res, err := c.doRequest("json")
17341 if res != nil && res.StatusCode == http.StatusNotModified {
17342 if res.Body != nil {
17343 res.Body.Close()
17344 }
17345 return nil, gensupport.WrapError(&googleapi.Error{
17346 Code: res.StatusCode,
17347 Header: res.Header,
17348 })
17349 }
17350 if err != nil {
17351 return nil, err
17352 }
17353 defer googleapi.CloseBody(res)
17354 if err := googleapi.CheckResponse(res); err != nil {
17355 return nil, gensupport.WrapError(err)
17356 }
17357 ret := &GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret{
17358 ServerResponse: googleapi.ServerResponse{
17359 Header: res.Header,
17360 HTTPStatusCode: res.StatusCode,
17361 },
17362 }
17363 target := &ret
17364 if err := gensupport.DecodeResponse(target, res); err != nil {
17365 return nil, err
17366 }
17367 return ret, nil
17368 }
17369
17370 type PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall struct {
17371 s *Service
17372 name string
17373 urlParams_ gensupport.URLParams
17374 ctx_ context.Context
17375 header_ http.Header
17376 }
17377
17378
17379
17380
17381
17382
17383 func (r *PropertiesDataStreamsMeasurementProtocolSecretsService) Delete(name string) *PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall {
17384 c := &PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17385 c.name = name
17386 return c
17387 }
17388
17389
17390
17391
17392 func (c *PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall {
17393 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17394 return c
17395 }
17396
17397
17398 func (c *PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall) Context(ctx context.Context) *PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall {
17399 c.ctx_ = ctx
17400 return c
17401 }
17402
17403
17404
17405 func (c *PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall) Header() http.Header {
17406 if c.header_ == nil {
17407 c.header_ = make(http.Header)
17408 }
17409 return c.header_
17410 }
17411
17412 func (c *PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall) doRequest(alt string) (*http.Response, error) {
17413 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17414 var body io.Reader = nil
17415 c.urlParams_.Set("alt", alt)
17416 c.urlParams_.Set("prettyPrint", "false")
17417 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
17418 urls += "?" + c.urlParams_.Encode()
17419 req, err := http.NewRequest("DELETE", urls, body)
17420 if err != nil {
17421 return nil, err
17422 }
17423 req.Header = reqHeaders
17424 googleapi.Expand(req.URL, map[string]string{
17425 "name": c.name,
17426 })
17427 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17428 }
17429
17430
17431
17432
17433
17434
17435
17436 func (c *PropertiesDataStreamsMeasurementProtocolSecretsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
17437 gensupport.SetOptions(c.urlParams_, opts...)
17438 res, err := c.doRequest("json")
17439 if res != nil && res.StatusCode == http.StatusNotModified {
17440 if res.Body != nil {
17441 res.Body.Close()
17442 }
17443 return nil, gensupport.WrapError(&googleapi.Error{
17444 Code: res.StatusCode,
17445 Header: res.Header,
17446 })
17447 }
17448 if err != nil {
17449 return nil, err
17450 }
17451 defer googleapi.CloseBody(res)
17452 if err := googleapi.CheckResponse(res); err != nil {
17453 return nil, gensupport.WrapError(err)
17454 }
17455 ret := &GoogleProtobufEmpty{
17456 ServerResponse: googleapi.ServerResponse{
17457 Header: res.Header,
17458 HTTPStatusCode: res.StatusCode,
17459 },
17460 }
17461 target := &ret
17462 if err := gensupport.DecodeResponse(target, res); err != nil {
17463 return nil, err
17464 }
17465 return ret, nil
17466 }
17467
17468 type PropertiesDataStreamsMeasurementProtocolSecretsGetCall struct {
17469 s *Service
17470 name string
17471 urlParams_ gensupport.URLParams
17472 ifNoneMatch_ string
17473 ctx_ context.Context
17474 header_ http.Header
17475 }
17476
17477
17478
17479
17480
17481
17482 func (r *PropertiesDataStreamsMeasurementProtocolSecretsService) Get(name string) *PropertiesDataStreamsMeasurementProtocolSecretsGetCall {
17483 c := &PropertiesDataStreamsMeasurementProtocolSecretsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17484 c.name = name
17485 return c
17486 }
17487
17488
17489
17490
17491 func (c *PropertiesDataStreamsMeasurementProtocolSecretsGetCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsMeasurementProtocolSecretsGetCall {
17492 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17493 return c
17494 }
17495
17496
17497
17498
17499 func (c *PropertiesDataStreamsMeasurementProtocolSecretsGetCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsMeasurementProtocolSecretsGetCall {
17500 c.ifNoneMatch_ = entityTag
17501 return c
17502 }
17503
17504
17505 func (c *PropertiesDataStreamsMeasurementProtocolSecretsGetCall) Context(ctx context.Context) *PropertiesDataStreamsMeasurementProtocolSecretsGetCall {
17506 c.ctx_ = ctx
17507 return c
17508 }
17509
17510
17511
17512 func (c *PropertiesDataStreamsMeasurementProtocolSecretsGetCall) Header() http.Header {
17513 if c.header_ == nil {
17514 c.header_ = make(http.Header)
17515 }
17516 return c.header_
17517 }
17518
17519 func (c *PropertiesDataStreamsMeasurementProtocolSecretsGetCall) doRequest(alt string) (*http.Response, error) {
17520 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17521 if c.ifNoneMatch_ != "" {
17522 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17523 }
17524 var body io.Reader = nil
17525 c.urlParams_.Set("alt", alt)
17526 c.urlParams_.Set("prettyPrint", "false")
17527 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
17528 urls += "?" + c.urlParams_.Encode()
17529 req, err := http.NewRequest("GET", urls, body)
17530 if err != nil {
17531 return nil, err
17532 }
17533 req.Header = reqHeaders
17534 googleapi.Expand(req.URL, map[string]string{
17535 "name": c.name,
17536 })
17537 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17538 }
17539
17540
17541
17542
17543
17544
17545
17546 func (c *PropertiesDataStreamsMeasurementProtocolSecretsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret, error) {
17547 gensupport.SetOptions(c.urlParams_, opts...)
17548 res, err := c.doRequest("json")
17549 if res != nil && res.StatusCode == http.StatusNotModified {
17550 if res.Body != nil {
17551 res.Body.Close()
17552 }
17553 return nil, gensupport.WrapError(&googleapi.Error{
17554 Code: res.StatusCode,
17555 Header: res.Header,
17556 })
17557 }
17558 if err != nil {
17559 return nil, err
17560 }
17561 defer googleapi.CloseBody(res)
17562 if err := googleapi.CheckResponse(res); err != nil {
17563 return nil, gensupport.WrapError(err)
17564 }
17565 ret := &GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret{
17566 ServerResponse: googleapi.ServerResponse{
17567 Header: res.Header,
17568 HTTPStatusCode: res.StatusCode,
17569 },
17570 }
17571 target := &ret
17572 if err := gensupport.DecodeResponse(target, res); err != nil {
17573 return nil, err
17574 }
17575 return ret, nil
17576 }
17577
17578 type PropertiesDataStreamsMeasurementProtocolSecretsListCall struct {
17579 s *Service
17580 parent string
17581 urlParams_ gensupport.URLParams
17582 ifNoneMatch_ string
17583 ctx_ context.Context
17584 header_ http.Header
17585 }
17586
17587
17588
17589
17590
17591
17592 func (r *PropertiesDataStreamsMeasurementProtocolSecretsService) List(parent string) *PropertiesDataStreamsMeasurementProtocolSecretsListCall {
17593 c := &PropertiesDataStreamsMeasurementProtocolSecretsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17594 c.parent = parent
17595 return c
17596 }
17597
17598
17599
17600
17601 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) PageSize(pageSize int64) *PropertiesDataStreamsMeasurementProtocolSecretsListCall {
17602 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
17603 return c
17604 }
17605
17606
17607
17608
17609
17610
17611 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) PageToken(pageToken string) *PropertiesDataStreamsMeasurementProtocolSecretsListCall {
17612 c.urlParams_.Set("pageToken", pageToken)
17613 return c
17614 }
17615
17616
17617
17618
17619 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsMeasurementProtocolSecretsListCall {
17620 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17621 return c
17622 }
17623
17624
17625
17626
17627 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsMeasurementProtocolSecretsListCall {
17628 c.ifNoneMatch_ = entityTag
17629 return c
17630 }
17631
17632
17633 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) Context(ctx context.Context) *PropertiesDataStreamsMeasurementProtocolSecretsListCall {
17634 c.ctx_ = ctx
17635 return c
17636 }
17637
17638
17639
17640 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) Header() http.Header {
17641 if c.header_ == nil {
17642 c.header_ = make(http.Header)
17643 }
17644 return c.header_
17645 }
17646
17647 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) doRequest(alt string) (*http.Response, error) {
17648 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17649 if c.ifNoneMatch_ != "" {
17650 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17651 }
17652 var body io.Reader = nil
17653 c.urlParams_.Set("alt", alt)
17654 c.urlParams_.Set("prettyPrint", "false")
17655 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/measurementProtocolSecrets")
17656 urls += "?" + c.urlParams_.Encode()
17657 req, err := http.NewRequest("GET", urls, body)
17658 if err != nil {
17659 return nil, err
17660 }
17661 req.Header = reqHeaders
17662 googleapi.Expand(req.URL, map[string]string{
17663 "parent": c.parent,
17664 })
17665 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17666 }
17667
17668
17669
17670
17671
17672
17673
17674 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListMeasurementProtocolSecretsResponse, error) {
17675 gensupport.SetOptions(c.urlParams_, opts...)
17676 res, err := c.doRequest("json")
17677 if res != nil && res.StatusCode == http.StatusNotModified {
17678 if res.Body != nil {
17679 res.Body.Close()
17680 }
17681 return nil, gensupport.WrapError(&googleapi.Error{
17682 Code: res.StatusCode,
17683 Header: res.Header,
17684 })
17685 }
17686 if err != nil {
17687 return nil, err
17688 }
17689 defer googleapi.CloseBody(res)
17690 if err := googleapi.CheckResponse(res); err != nil {
17691 return nil, gensupport.WrapError(err)
17692 }
17693 ret := &GoogleAnalyticsAdminV1alphaListMeasurementProtocolSecretsResponse{
17694 ServerResponse: googleapi.ServerResponse{
17695 Header: res.Header,
17696 HTTPStatusCode: res.StatusCode,
17697 },
17698 }
17699 target := &ret
17700 if err := gensupport.DecodeResponse(target, res); err != nil {
17701 return nil, err
17702 }
17703 return ret, nil
17704 }
17705
17706
17707
17708
17709 func (c *PropertiesDataStreamsMeasurementProtocolSecretsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListMeasurementProtocolSecretsResponse) error) error {
17710 c.ctx_ = ctx
17711 defer c.PageToken(c.urlParams_.Get("pageToken"))
17712 for {
17713 x, err := c.Do()
17714 if err != nil {
17715 return err
17716 }
17717 if err := f(x); err != nil {
17718 return err
17719 }
17720 if x.NextPageToken == "" {
17721 return nil
17722 }
17723 c.PageToken(x.NextPageToken)
17724 }
17725 }
17726
17727 type PropertiesDataStreamsMeasurementProtocolSecretsPatchCall struct {
17728 s *Service
17729 name string
17730 googleanalyticsadminv1alphameasurementprotocolsecret *GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret
17731 urlParams_ gensupport.URLParams
17732 ctx_ context.Context
17733 header_ http.Header
17734 }
17735
17736
17737
17738
17739
17740
17741
17742 func (r *PropertiesDataStreamsMeasurementProtocolSecretsService) Patch(name string, googleanalyticsadminv1alphameasurementprotocolsecret *GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret) *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall {
17743 c := &PropertiesDataStreamsMeasurementProtocolSecretsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17744 c.name = name
17745 c.googleanalyticsadminv1alphameasurementprotocolsecret = googleanalyticsadminv1alphameasurementprotocolsecret
17746 return c
17747 }
17748
17749
17750
17751 func (c *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall) UpdateMask(updateMask string) *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall {
17752 c.urlParams_.Set("updateMask", updateMask)
17753 return c
17754 }
17755
17756
17757
17758
17759 func (c *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall {
17760 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17761 return c
17762 }
17763
17764
17765 func (c *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall) Context(ctx context.Context) *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall {
17766 c.ctx_ = ctx
17767 return c
17768 }
17769
17770
17771
17772 func (c *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall) Header() http.Header {
17773 if c.header_ == nil {
17774 c.header_ = make(http.Header)
17775 }
17776 return c.header_
17777 }
17778
17779 func (c *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall) doRequest(alt string) (*http.Response, error) {
17780 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17781 var body io.Reader = nil
17782 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphameasurementprotocolsecret)
17783 if err != nil {
17784 return nil, err
17785 }
17786 c.urlParams_.Set("alt", alt)
17787 c.urlParams_.Set("prettyPrint", "false")
17788 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
17789 urls += "?" + c.urlParams_.Encode()
17790 req, err := http.NewRequest("PATCH", urls, body)
17791 if err != nil {
17792 return nil, err
17793 }
17794 req.Header = reqHeaders
17795 googleapi.Expand(req.URL, map[string]string{
17796 "name": c.name,
17797 })
17798 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17799 }
17800
17801
17802
17803
17804
17805
17806
17807 func (c *PropertiesDataStreamsMeasurementProtocolSecretsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret, error) {
17808 gensupport.SetOptions(c.urlParams_, opts...)
17809 res, err := c.doRequest("json")
17810 if res != nil && res.StatusCode == http.StatusNotModified {
17811 if res.Body != nil {
17812 res.Body.Close()
17813 }
17814 return nil, gensupport.WrapError(&googleapi.Error{
17815 Code: res.StatusCode,
17816 Header: res.Header,
17817 })
17818 }
17819 if err != nil {
17820 return nil, err
17821 }
17822 defer googleapi.CloseBody(res)
17823 if err := googleapi.CheckResponse(res); err != nil {
17824 return nil, gensupport.WrapError(err)
17825 }
17826 ret := &GoogleAnalyticsAdminV1alphaMeasurementProtocolSecret{
17827 ServerResponse: googleapi.ServerResponse{
17828 Header: res.Header,
17829 HTTPStatusCode: res.StatusCode,
17830 },
17831 }
17832 target := &ret
17833 if err := gensupport.DecodeResponse(target, res); err != nil {
17834 return nil, err
17835 }
17836 return ret, nil
17837 }
17838
17839 type PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall struct {
17840 s *Service
17841 parent string
17842 googleanalyticsadminv1alphaskadnetworkconversionvalueschema *GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema
17843 urlParams_ gensupport.URLParams
17844 ctx_ context.Context
17845 header_ http.Header
17846 }
17847
17848
17849
17850
17851
17852 func (r *PropertiesDataStreamsSKAdNetworkConversionValueSchemaService) Create(parent string, googleanalyticsadminv1alphaskadnetworkconversionvalueschema *GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall {
17853 c := &PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17854 c.parent = parent
17855 c.googleanalyticsadminv1alphaskadnetworkconversionvalueschema = googleanalyticsadminv1alphaskadnetworkconversionvalueschema
17856 return c
17857 }
17858
17859
17860
17861
17862 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall {
17863 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17864 return c
17865 }
17866
17867
17868 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall) Context(ctx context.Context) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall {
17869 c.ctx_ = ctx
17870 return c
17871 }
17872
17873
17874
17875 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall) Header() http.Header {
17876 if c.header_ == nil {
17877 c.header_ = make(http.Header)
17878 }
17879 return c.header_
17880 }
17881
17882 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall) doRequest(alt string) (*http.Response, error) {
17883 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17884 var body io.Reader = nil
17885 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaskadnetworkconversionvalueschema)
17886 if err != nil {
17887 return nil, err
17888 }
17889 c.urlParams_.Set("alt", alt)
17890 c.urlParams_.Set("prettyPrint", "false")
17891 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/sKAdNetworkConversionValueSchema")
17892 urls += "?" + c.urlParams_.Encode()
17893 req, err := http.NewRequest("POST", urls, body)
17894 if err != nil {
17895 return nil, err
17896 }
17897 req.Header = reqHeaders
17898 googleapi.Expand(req.URL, map[string]string{
17899 "parent": c.parent,
17900 })
17901 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17902 }
17903
17904
17905
17906
17907
17908
17909
17910 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema, error) {
17911 gensupport.SetOptions(c.urlParams_, opts...)
17912 res, err := c.doRequest("json")
17913 if res != nil && res.StatusCode == http.StatusNotModified {
17914 if res.Body != nil {
17915 res.Body.Close()
17916 }
17917 return nil, gensupport.WrapError(&googleapi.Error{
17918 Code: res.StatusCode,
17919 Header: res.Header,
17920 })
17921 }
17922 if err != nil {
17923 return nil, err
17924 }
17925 defer googleapi.CloseBody(res)
17926 if err := googleapi.CheckResponse(res); err != nil {
17927 return nil, gensupport.WrapError(err)
17928 }
17929 ret := &GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema{
17930 ServerResponse: googleapi.ServerResponse{
17931 Header: res.Header,
17932 HTTPStatusCode: res.StatusCode,
17933 },
17934 }
17935 target := &ret
17936 if err := gensupport.DecodeResponse(target, res); err != nil {
17937 return nil, err
17938 }
17939 return ret, nil
17940 }
17941
17942 type PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall struct {
17943 s *Service
17944 name string
17945 urlParams_ gensupport.URLParams
17946 ctx_ context.Context
17947 header_ http.Header
17948 }
17949
17950
17951
17952
17953
17954
17955 func (r *PropertiesDataStreamsSKAdNetworkConversionValueSchemaService) Delete(name string) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall {
17956 c := &PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17957 c.name = name
17958 return c
17959 }
17960
17961
17962
17963
17964 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall {
17965 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17966 return c
17967 }
17968
17969
17970 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall) Context(ctx context.Context) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall {
17971 c.ctx_ = ctx
17972 return c
17973 }
17974
17975
17976
17977 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall) Header() http.Header {
17978 if c.header_ == nil {
17979 c.header_ = make(http.Header)
17980 }
17981 return c.header_
17982 }
17983
17984 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall) doRequest(alt string) (*http.Response, error) {
17985 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17986 var body io.Reader = nil
17987 c.urlParams_.Set("alt", alt)
17988 c.urlParams_.Set("prettyPrint", "false")
17989 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
17990 urls += "?" + c.urlParams_.Encode()
17991 req, err := http.NewRequest("DELETE", urls, body)
17992 if err != nil {
17993 return nil, err
17994 }
17995 req.Header = reqHeaders
17996 googleapi.Expand(req.URL, map[string]string{
17997 "name": c.name,
17998 })
17999 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18000 }
18001
18002
18003
18004
18005
18006
18007
18008 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
18009 gensupport.SetOptions(c.urlParams_, opts...)
18010 res, err := c.doRequest("json")
18011 if res != nil && res.StatusCode == http.StatusNotModified {
18012 if res.Body != nil {
18013 res.Body.Close()
18014 }
18015 return nil, gensupport.WrapError(&googleapi.Error{
18016 Code: res.StatusCode,
18017 Header: res.Header,
18018 })
18019 }
18020 if err != nil {
18021 return nil, err
18022 }
18023 defer googleapi.CloseBody(res)
18024 if err := googleapi.CheckResponse(res); err != nil {
18025 return nil, gensupport.WrapError(err)
18026 }
18027 ret := &GoogleProtobufEmpty{
18028 ServerResponse: googleapi.ServerResponse{
18029 Header: res.Header,
18030 HTTPStatusCode: res.StatusCode,
18031 },
18032 }
18033 target := &ret
18034 if err := gensupport.DecodeResponse(target, res); err != nil {
18035 return nil, err
18036 }
18037 return ret, nil
18038 }
18039
18040 type PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall struct {
18041 s *Service
18042 name string
18043 urlParams_ gensupport.URLParams
18044 ifNoneMatch_ string
18045 ctx_ context.Context
18046 header_ http.Header
18047 }
18048
18049
18050
18051
18052
18053
18054
18055 func (r *PropertiesDataStreamsSKAdNetworkConversionValueSchemaService) Get(name string) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall {
18056 c := &PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18057 c.name = name
18058 return c
18059 }
18060
18061
18062
18063
18064 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall {
18065 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18066 return c
18067 }
18068
18069
18070
18071
18072 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall {
18073 c.ifNoneMatch_ = entityTag
18074 return c
18075 }
18076
18077
18078 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall) Context(ctx context.Context) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall {
18079 c.ctx_ = ctx
18080 return c
18081 }
18082
18083
18084
18085 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall) Header() http.Header {
18086 if c.header_ == nil {
18087 c.header_ = make(http.Header)
18088 }
18089 return c.header_
18090 }
18091
18092 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall) doRequest(alt string) (*http.Response, error) {
18093 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18094 if c.ifNoneMatch_ != "" {
18095 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18096 }
18097 var body io.Reader = nil
18098 c.urlParams_.Set("alt", alt)
18099 c.urlParams_.Set("prettyPrint", "false")
18100 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
18101 urls += "?" + c.urlParams_.Encode()
18102 req, err := http.NewRequest("GET", urls, body)
18103 if err != nil {
18104 return nil, err
18105 }
18106 req.Header = reqHeaders
18107 googleapi.Expand(req.URL, map[string]string{
18108 "name": c.name,
18109 })
18110 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18111 }
18112
18113
18114
18115
18116
18117
18118
18119 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema, error) {
18120 gensupport.SetOptions(c.urlParams_, opts...)
18121 res, err := c.doRequest("json")
18122 if res != nil && res.StatusCode == http.StatusNotModified {
18123 if res.Body != nil {
18124 res.Body.Close()
18125 }
18126 return nil, gensupport.WrapError(&googleapi.Error{
18127 Code: res.StatusCode,
18128 Header: res.Header,
18129 })
18130 }
18131 if err != nil {
18132 return nil, err
18133 }
18134 defer googleapi.CloseBody(res)
18135 if err := googleapi.CheckResponse(res); err != nil {
18136 return nil, gensupport.WrapError(err)
18137 }
18138 ret := &GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema{
18139 ServerResponse: googleapi.ServerResponse{
18140 Header: res.Header,
18141 HTTPStatusCode: res.StatusCode,
18142 },
18143 }
18144 target := &ret
18145 if err := gensupport.DecodeResponse(target, res); err != nil {
18146 return nil, err
18147 }
18148 return ret, nil
18149 }
18150
18151 type PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall struct {
18152 s *Service
18153 parent string
18154 urlParams_ gensupport.URLParams
18155 ifNoneMatch_ string
18156 ctx_ context.Context
18157 header_ http.Header
18158 }
18159
18160
18161
18162
18163
18164
18165
18166 func (r *PropertiesDataStreamsSKAdNetworkConversionValueSchemaService) List(parent string) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall {
18167 c := &PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18168 c.parent = parent
18169 return c
18170 }
18171
18172
18173
18174
18175
18176
18177 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) PageSize(pageSize int64) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall {
18178 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
18179 return c
18180 }
18181
18182
18183
18184
18185
18186
18187 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) PageToken(pageToken string) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall {
18188 c.urlParams_.Set("pageToken", pageToken)
18189 return c
18190 }
18191
18192
18193
18194
18195 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall {
18196 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18197 return c
18198 }
18199
18200
18201
18202
18203 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) IfNoneMatch(entityTag string) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall {
18204 c.ifNoneMatch_ = entityTag
18205 return c
18206 }
18207
18208
18209 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) Context(ctx context.Context) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall {
18210 c.ctx_ = ctx
18211 return c
18212 }
18213
18214
18215
18216 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) Header() http.Header {
18217 if c.header_ == nil {
18218 c.header_ = make(http.Header)
18219 }
18220 return c.header_
18221 }
18222
18223 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) doRequest(alt string) (*http.Response, error) {
18224 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18225 if c.ifNoneMatch_ != "" {
18226 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18227 }
18228 var body io.Reader = nil
18229 c.urlParams_.Set("alt", alt)
18230 c.urlParams_.Set("prettyPrint", "false")
18231 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/sKAdNetworkConversionValueSchema")
18232 urls += "?" + c.urlParams_.Encode()
18233 req, err := http.NewRequest("GET", urls, body)
18234 if err != nil {
18235 return nil, err
18236 }
18237 req.Header = reqHeaders
18238 googleapi.Expand(req.URL, map[string]string{
18239 "parent": c.parent,
18240 })
18241 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18242 }
18243
18244
18245
18246
18247
18248
18249
18250 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListSKAdNetworkConversionValueSchemasResponse, error) {
18251 gensupport.SetOptions(c.urlParams_, opts...)
18252 res, err := c.doRequest("json")
18253 if res != nil && res.StatusCode == http.StatusNotModified {
18254 if res.Body != nil {
18255 res.Body.Close()
18256 }
18257 return nil, gensupport.WrapError(&googleapi.Error{
18258 Code: res.StatusCode,
18259 Header: res.Header,
18260 })
18261 }
18262 if err != nil {
18263 return nil, err
18264 }
18265 defer googleapi.CloseBody(res)
18266 if err := googleapi.CheckResponse(res); err != nil {
18267 return nil, gensupport.WrapError(err)
18268 }
18269 ret := &GoogleAnalyticsAdminV1alphaListSKAdNetworkConversionValueSchemasResponse{
18270 ServerResponse: googleapi.ServerResponse{
18271 Header: res.Header,
18272 HTTPStatusCode: res.StatusCode,
18273 },
18274 }
18275 target := &ret
18276 if err := gensupport.DecodeResponse(target, res); err != nil {
18277 return nil, err
18278 }
18279 return ret, nil
18280 }
18281
18282
18283
18284
18285 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListSKAdNetworkConversionValueSchemasResponse) error) error {
18286 c.ctx_ = ctx
18287 defer c.PageToken(c.urlParams_.Get("pageToken"))
18288 for {
18289 x, err := c.Do()
18290 if err != nil {
18291 return err
18292 }
18293 if err := f(x); err != nil {
18294 return err
18295 }
18296 if x.NextPageToken == "" {
18297 return nil
18298 }
18299 c.PageToken(x.NextPageToken)
18300 }
18301 }
18302
18303 type PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall struct {
18304 s *Service
18305 name string
18306 googleanalyticsadminv1alphaskadnetworkconversionvalueschema *GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema
18307 urlParams_ gensupport.URLParams
18308 ctx_ context.Context
18309 header_ http.Header
18310 }
18311
18312
18313
18314
18315
18316
18317
18318
18319 func (r *PropertiesDataStreamsSKAdNetworkConversionValueSchemaService) Patch(name string, googleanalyticsadminv1alphaskadnetworkconversionvalueschema *GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall {
18320 c := &PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18321 c.name = name
18322 c.googleanalyticsadminv1alphaskadnetworkconversionvalueschema = googleanalyticsadminv1alphaskadnetworkconversionvalueschema
18323 return c
18324 }
18325
18326
18327
18328 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall) UpdateMask(updateMask string) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall {
18329 c.urlParams_.Set("updateMask", updateMask)
18330 return c
18331 }
18332
18333
18334
18335
18336 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall) Fields(s ...googleapi.Field) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall {
18337 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18338 return c
18339 }
18340
18341
18342 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall) Context(ctx context.Context) *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall {
18343 c.ctx_ = ctx
18344 return c
18345 }
18346
18347
18348
18349 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall) Header() http.Header {
18350 if c.header_ == nil {
18351 c.header_ = make(http.Header)
18352 }
18353 return c.header_
18354 }
18355
18356 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall) doRequest(alt string) (*http.Response, error) {
18357 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
18358 var body io.Reader = nil
18359 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaskadnetworkconversionvalueschema)
18360 if err != nil {
18361 return nil, err
18362 }
18363 c.urlParams_.Set("alt", alt)
18364 c.urlParams_.Set("prettyPrint", "false")
18365 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
18366 urls += "?" + c.urlParams_.Encode()
18367 req, err := http.NewRequest("PATCH", urls, body)
18368 if err != nil {
18369 return nil, err
18370 }
18371 req.Header = reqHeaders
18372 googleapi.Expand(req.URL, map[string]string{
18373 "name": c.name,
18374 })
18375 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18376 }
18377
18378
18379
18380
18381
18382
18383
18384 func (c *PropertiesDataStreamsSKAdNetworkConversionValueSchemaPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema, error) {
18385 gensupport.SetOptions(c.urlParams_, opts...)
18386 res, err := c.doRequest("json")
18387 if res != nil && res.StatusCode == http.StatusNotModified {
18388 if res.Body != nil {
18389 res.Body.Close()
18390 }
18391 return nil, gensupport.WrapError(&googleapi.Error{
18392 Code: res.StatusCode,
18393 Header: res.Header,
18394 })
18395 }
18396 if err != nil {
18397 return nil, err
18398 }
18399 defer googleapi.CloseBody(res)
18400 if err := googleapi.CheckResponse(res); err != nil {
18401 return nil, gensupport.WrapError(err)
18402 }
18403 ret := &GoogleAnalyticsAdminV1alphaSKAdNetworkConversionValueSchema{
18404 ServerResponse: googleapi.ServerResponse{
18405 Header: res.Header,
18406 HTTPStatusCode: res.StatusCode,
18407 },
18408 }
18409 target := &ret
18410 if err := gensupport.DecodeResponse(target, res); err != nil {
18411 return nil, err
18412 }
18413 return ret, nil
18414 }
18415
18416 type PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall struct {
18417 s *Service
18418 name string
18419 googleanalyticsadminv1alphaapprovedisplayvideo360advertiserlinkproposalrequest *GoogleAnalyticsAdminV1alphaApproveDisplayVideo360AdvertiserLinkProposalRequest
18420 urlParams_ gensupport.URLParams
18421 ctx_ context.Context
18422 header_ http.Header
18423 }
18424
18425
18426
18427
18428
18429
18430
18431
18432 func (r *PropertiesDisplayVideo360AdvertiserLinkProposalsService) Approve(name string, googleanalyticsadminv1alphaapprovedisplayvideo360advertiserlinkproposalrequest *GoogleAnalyticsAdminV1alphaApproveDisplayVideo360AdvertiserLinkProposalRequest) *PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall {
18433 c := &PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18434 c.name = name
18435 c.googleanalyticsadminv1alphaapprovedisplayvideo360advertiserlinkproposalrequest = googleanalyticsadminv1alphaapprovedisplayvideo360advertiserlinkproposalrequest
18436 return c
18437 }
18438
18439
18440
18441
18442 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall {
18443 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18444 return c
18445 }
18446
18447
18448 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall {
18449 c.ctx_ = ctx
18450 return c
18451 }
18452
18453
18454
18455 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall) Header() http.Header {
18456 if c.header_ == nil {
18457 c.header_ = make(http.Header)
18458 }
18459 return c.header_
18460 }
18461
18462 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall) doRequest(alt string) (*http.Response, error) {
18463 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
18464 var body io.Reader = nil
18465 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaapprovedisplayvideo360advertiserlinkproposalrequest)
18466 if err != nil {
18467 return nil, err
18468 }
18469 c.urlParams_.Set("alt", alt)
18470 c.urlParams_.Set("prettyPrint", "false")
18471 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}:approve")
18472 urls += "?" + c.urlParams_.Encode()
18473 req, err := http.NewRequest("POST", urls, body)
18474 if err != nil {
18475 return nil, err
18476 }
18477 req.Header = reqHeaders
18478 googleapi.Expand(req.URL, map[string]string{
18479 "name": c.name,
18480 })
18481 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18482 }
18483
18484
18485
18486
18487
18488
18489
18490 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsApproveCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaApproveDisplayVideo360AdvertiserLinkProposalResponse, error) {
18491 gensupport.SetOptions(c.urlParams_, opts...)
18492 res, err := c.doRequest("json")
18493 if res != nil && res.StatusCode == http.StatusNotModified {
18494 if res.Body != nil {
18495 res.Body.Close()
18496 }
18497 return nil, gensupport.WrapError(&googleapi.Error{
18498 Code: res.StatusCode,
18499 Header: res.Header,
18500 })
18501 }
18502 if err != nil {
18503 return nil, err
18504 }
18505 defer googleapi.CloseBody(res)
18506 if err := googleapi.CheckResponse(res); err != nil {
18507 return nil, gensupport.WrapError(err)
18508 }
18509 ret := &GoogleAnalyticsAdminV1alphaApproveDisplayVideo360AdvertiserLinkProposalResponse{
18510 ServerResponse: googleapi.ServerResponse{
18511 Header: res.Header,
18512 HTTPStatusCode: res.StatusCode,
18513 },
18514 }
18515 target := &ret
18516 if err := gensupport.DecodeResponse(target, res); err != nil {
18517 return nil, err
18518 }
18519 return ret, nil
18520 }
18521
18522 type PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall struct {
18523 s *Service
18524 name string
18525 googleanalyticsadminv1alphacanceldisplayvideo360advertiserlinkproposalrequest *GoogleAnalyticsAdminV1alphaCancelDisplayVideo360AdvertiserLinkProposalRequest
18526 urlParams_ gensupport.URLParams
18527 ctx_ context.Context
18528 header_ http.Header
18529 }
18530
18531
18532
18533
18534
18535
18536
18537
18538
18539 func (r *PropertiesDisplayVideo360AdvertiserLinkProposalsService) Cancel(name string, googleanalyticsadminv1alphacanceldisplayvideo360advertiserlinkproposalrequest *GoogleAnalyticsAdminV1alphaCancelDisplayVideo360AdvertiserLinkProposalRequest) *PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall {
18540 c := &PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18541 c.name = name
18542 c.googleanalyticsadminv1alphacanceldisplayvideo360advertiserlinkproposalrequest = googleanalyticsadminv1alphacanceldisplayvideo360advertiserlinkproposalrequest
18543 return c
18544 }
18545
18546
18547
18548
18549 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall {
18550 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18551 return c
18552 }
18553
18554
18555 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall {
18556 c.ctx_ = ctx
18557 return c
18558 }
18559
18560
18561
18562 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall) Header() http.Header {
18563 if c.header_ == nil {
18564 c.header_ = make(http.Header)
18565 }
18566 return c.header_
18567 }
18568
18569 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall) doRequest(alt string) (*http.Response, error) {
18570 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
18571 var body io.Reader = nil
18572 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphacanceldisplayvideo360advertiserlinkproposalrequest)
18573 if err != nil {
18574 return nil, err
18575 }
18576 c.urlParams_.Set("alt", alt)
18577 c.urlParams_.Set("prettyPrint", "false")
18578 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}:cancel")
18579 urls += "?" + c.urlParams_.Encode()
18580 req, err := http.NewRequest("POST", urls, body)
18581 if err != nil {
18582 return nil, err
18583 }
18584 req.Header = reqHeaders
18585 googleapi.Expand(req.URL, map[string]string{
18586 "name": c.name,
18587 })
18588 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18589 }
18590
18591
18592
18593
18594
18595
18596
18597 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCancelCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal, error) {
18598 gensupport.SetOptions(c.urlParams_, opts...)
18599 res, err := c.doRequest("json")
18600 if res != nil && res.StatusCode == http.StatusNotModified {
18601 if res.Body != nil {
18602 res.Body.Close()
18603 }
18604 return nil, gensupport.WrapError(&googleapi.Error{
18605 Code: res.StatusCode,
18606 Header: res.Header,
18607 })
18608 }
18609 if err != nil {
18610 return nil, err
18611 }
18612 defer googleapi.CloseBody(res)
18613 if err := googleapi.CheckResponse(res); err != nil {
18614 return nil, gensupport.WrapError(err)
18615 }
18616 ret := &GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal{
18617 ServerResponse: googleapi.ServerResponse{
18618 Header: res.Header,
18619 HTTPStatusCode: res.StatusCode,
18620 },
18621 }
18622 target := &ret
18623 if err := gensupport.DecodeResponse(target, res); err != nil {
18624 return nil, err
18625 }
18626 return ret, nil
18627 }
18628
18629 type PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall struct {
18630 s *Service
18631 parent string
18632 googleanalyticsadminv1alphadisplayvideo360advertiserlinkproposal *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal
18633 urlParams_ gensupport.URLParams
18634 ctx_ context.Context
18635 header_ http.Header
18636 }
18637
18638
18639
18640
18641 func (r *PropertiesDisplayVideo360AdvertiserLinkProposalsService) Create(parent string, googleanalyticsadminv1alphadisplayvideo360advertiserlinkproposal *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal) *PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall {
18642 c := &PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18643 c.parent = parent
18644 c.googleanalyticsadminv1alphadisplayvideo360advertiserlinkproposal = googleanalyticsadminv1alphadisplayvideo360advertiserlinkproposal
18645 return c
18646 }
18647
18648
18649
18650
18651 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall {
18652 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18653 return c
18654 }
18655
18656
18657 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall {
18658 c.ctx_ = ctx
18659 return c
18660 }
18661
18662
18663
18664 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall) Header() http.Header {
18665 if c.header_ == nil {
18666 c.header_ = make(http.Header)
18667 }
18668 return c.header_
18669 }
18670
18671 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall) doRequest(alt string) (*http.Response, error) {
18672 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
18673 var body io.Reader = nil
18674 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphadisplayvideo360advertiserlinkproposal)
18675 if err != nil {
18676 return nil, err
18677 }
18678 c.urlParams_.Set("alt", alt)
18679 c.urlParams_.Set("prettyPrint", "false")
18680 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/displayVideo360AdvertiserLinkProposals")
18681 urls += "?" + c.urlParams_.Encode()
18682 req, err := http.NewRequest("POST", urls, body)
18683 if err != nil {
18684 return nil, err
18685 }
18686 req.Header = reqHeaders
18687 googleapi.Expand(req.URL, map[string]string{
18688 "parent": c.parent,
18689 })
18690 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18691 }
18692
18693
18694
18695
18696
18697
18698
18699 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal, error) {
18700 gensupport.SetOptions(c.urlParams_, opts...)
18701 res, err := c.doRequest("json")
18702 if res != nil && res.StatusCode == http.StatusNotModified {
18703 if res.Body != nil {
18704 res.Body.Close()
18705 }
18706 return nil, gensupport.WrapError(&googleapi.Error{
18707 Code: res.StatusCode,
18708 Header: res.Header,
18709 })
18710 }
18711 if err != nil {
18712 return nil, err
18713 }
18714 defer googleapi.CloseBody(res)
18715 if err := googleapi.CheckResponse(res); err != nil {
18716 return nil, gensupport.WrapError(err)
18717 }
18718 ret := &GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal{
18719 ServerResponse: googleapi.ServerResponse{
18720 Header: res.Header,
18721 HTTPStatusCode: res.StatusCode,
18722 },
18723 }
18724 target := &ret
18725 if err := gensupport.DecodeResponse(target, res); err != nil {
18726 return nil, err
18727 }
18728 return ret, nil
18729 }
18730
18731 type PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall struct {
18732 s *Service
18733 name string
18734 urlParams_ gensupport.URLParams
18735 ctx_ context.Context
18736 header_ http.Header
18737 }
18738
18739
18740
18741
18742
18743
18744
18745 func (r *PropertiesDisplayVideo360AdvertiserLinkProposalsService) Delete(name string) *PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall {
18746 c := &PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18747 c.name = name
18748 return c
18749 }
18750
18751
18752
18753
18754 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall {
18755 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18756 return c
18757 }
18758
18759
18760 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall {
18761 c.ctx_ = ctx
18762 return c
18763 }
18764
18765
18766
18767 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall) Header() http.Header {
18768 if c.header_ == nil {
18769 c.header_ = make(http.Header)
18770 }
18771 return c.header_
18772 }
18773
18774 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall) doRequest(alt string) (*http.Response, error) {
18775 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18776 var body io.Reader = nil
18777 c.urlParams_.Set("alt", alt)
18778 c.urlParams_.Set("prettyPrint", "false")
18779 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
18780 urls += "?" + c.urlParams_.Encode()
18781 req, err := http.NewRequest("DELETE", urls, body)
18782 if err != nil {
18783 return nil, err
18784 }
18785 req.Header = reqHeaders
18786 googleapi.Expand(req.URL, map[string]string{
18787 "name": c.name,
18788 })
18789 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18790 }
18791
18792
18793
18794
18795
18796
18797
18798 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
18799 gensupport.SetOptions(c.urlParams_, opts...)
18800 res, err := c.doRequest("json")
18801 if res != nil && res.StatusCode == http.StatusNotModified {
18802 if res.Body != nil {
18803 res.Body.Close()
18804 }
18805 return nil, gensupport.WrapError(&googleapi.Error{
18806 Code: res.StatusCode,
18807 Header: res.Header,
18808 })
18809 }
18810 if err != nil {
18811 return nil, err
18812 }
18813 defer googleapi.CloseBody(res)
18814 if err := googleapi.CheckResponse(res); err != nil {
18815 return nil, gensupport.WrapError(err)
18816 }
18817 ret := &GoogleProtobufEmpty{
18818 ServerResponse: googleapi.ServerResponse{
18819 Header: res.Header,
18820 HTTPStatusCode: res.StatusCode,
18821 },
18822 }
18823 target := &ret
18824 if err := gensupport.DecodeResponse(target, res); err != nil {
18825 return nil, err
18826 }
18827 return ret, nil
18828 }
18829
18830 type PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall struct {
18831 s *Service
18832 name string
18833 urlParams_ gensupport.URLParams
18834 ifNoneMatch_ string
18835 ctx_ context.Context
18836 header_ http.Header
18837 }
18838
18839
18840
18841
18842
18843
18844 func (r *PropertiesDisplayVideo360AdvertiserLinkProposalsService) Get(name string) *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall {
18845 c := &PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18846 c.name = name
18847 return c
18848 }
18849
18850
18851
18852
18853 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall {
18854 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18855 return c
18856 }
18857
18858
18859
18860
18861 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall) IfNoneMatch(entityTag string) *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall {
18862 c.ifNoneMatch_ = entityTag
18863 return c
18864 }
18865
18866
18867 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall {
18868 c.ctx_ = ctx
18869 return c
18870 }
18871
18872
18873
18874 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall) Header() http.Header {
18875 if c.header_ == nil {
18876 c.header_ = make(http.Header)
18877 }
18878 return c.header_
18879 }
18880
18881 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall) doRequest(alt string) (*http.Response, error) {
18882 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18883 if c.ifNoneMatch_ != "" {
18884 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18885 }
18886 var body io.Reader = nil
18887 c.urlParams_.Set("alt", alt)
18888 c.urlParams_.Set("prettyPrint", "false")
18889 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
18890 urls += "?" + c.urlParams_.Encode()
18891 req, err := http.NewRequest("GET", urls, body)
18892 if err != nil {
18893 return nil, err
18894 }
18895 req.Header = reqHeaders
18896 googleapi.Expand(req.URL, map[string]string{
18897 "name": c.name,
18898 })
18899 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18900 }
18901
18902
18903
18904
18905
18906
18907
18908 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal, error) {
18909 gensupport.SetOptions(c.urlParams_, opts...)
18910 res, err := c.doRequest("json")
18911 if res != nil && res.StatusCode == http.StatusNotModified {
18912 if res.Body != nil {
18913 res.Body.Close()
18914 }
18915 return nil, gensupport.WrapError(&googleapi.Error{
18916 Code: res.StatusCode,
18917 Header: res.Header,
18918 })
18919 }
18920 if err != nil {
18921 return nil, err
18922 }
18923 defer googleapi.CloseBody(res)
18924 if err := googleapi.CheckResponse(res); err != nil {
18925 return nil, gensupport.WrapError(err)
18926 }
18927 ret := &GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLinkProposal{
18928 ServerResponse: googleapi.ServerResponse{
18929 Header: res.Header,
18930 HTTPStatusCode: res.StatusCode,
18931 },
18932 }
18933 target := &ret
18934 if err := gensupport.DecodeResponse(target, res); err != nil {
18935 return nil, err
18936 }
18937 return ret, nil
18938 }
18939
18940 type PropertiesDisplayVideo360AdvertiserLinkProposalsListCall struct {
18941 s *Service
18942 parent string
18943 urlParams_ gensupport.URLParams
18944 ifNoneMatch_ string
18945 ctx_ context.Context
18946 header_ http.Header
18947 }
18948
18949
18950
18951
18952 func (r *PropertiesDisplayVideo360AdvertiserLinkProposalsService) List(parent string) *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall {
18953 c := &PropertiesDisplayVideo360AdvertiserLinkProposalsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18954 c.parent = parent
18955 return c
18956 }
18957
18958
18959
18960
18961 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) PageSize(pageSize int64) *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall {
18962 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
18963 return c
18964 }
18965
18966
18967
18968
18969
18970
18971 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) PageToken(pageToken string) *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall {
18972 c.urlParams_.Set("pageToken", pageToken)
18973 return c
18974 }
18975
18976
18977
18978
18979 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall {
18980 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18981 return c
18982 }
18983
18984
18985
18986
18987 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) IfNoneMatch(entityTag string) *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall {
18988 c.ifNoneMatch_ = entityTag
18989 return c
18990 }
18991
18992
18993 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall {
18994 c.ctx_ = ctx
18995 return c
18996 }
18997
18998
18999
19000 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) Header() http.Header {
19001 if c.header_ == nil {
19002 c.header_ = make(http.Header)
19003 }
19004 return c.header_
19005 }
19006
19007 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) doRequest(alt string) (*http.Response, error) {
19008 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19009 if c.ifNoneMatch_ != "" {
19010 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
19011 }
19012 var body io.Reader = nil
19013 c.urlParams_.Set("alt", alt)
19014 c.urlParams_.Set("prettyPrint", "false")
19015 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/displayVideo360AdvertiserLinkProposals")
19016 urls += "?" + c.urlParams_.Encode()
19017 req, err := http.NewRequest("GET", urls, body)
19018 if err != nil {
19019 return nil, err
19020 }
19021 req.Header = reqHeaders
19022 googleapi.Expand(req.URL, map[string]string{
19023 "parent": c.parent,
19024 })
19025 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19026 }
19027
19028
19029
19030
19031
19032
19033
19034 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinkProposalsResponse, error) {
19035 gensupport.SetOptions(c.urlParams_, opts...)
19036 res, err := c.doRequest("json")
19037 if res != nil && res.StatusCode == http.StatusNotModified {
19038 if res.Body != nil {
19039 res.Body.Close()
19040 }
19041 return nil, gensupport.WrapError(&googleapi.Error{
19042 Code: res.StatusCode,
19043 Header: res.Header,
19044 })
19045 }
19046 if err != nil {
19047 return nil, err
19048 }
19049 defer googleapi.CloseBody(res)
19050 if err := googleapi.CheckResponse(res); err != nil {
19051 return nil, gensupport.WrapError(err)
19052 }
19053 ret := &GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinkProposalsResponse{
19054 ServerResponse: googleapi.ServerResponse{
19055 Header: res.Header,
19056 HTTPStatusCode: res.StatusCode,
19057 },
19058 }
19059 target := &ret
19060 if err := gensupport.DecodeResponse(target, res); err != nil {
19061 return nil, err
19062 }
19063 return ret, nil
19064 }
19065
19066
19067
19068
19069 func (c *PropertiesDisplayVideo360AdvertiserLinkProposalsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinkProposalsResponse) error) error {
19070 c.ctx_ = ctx
19071 defer c.PageToken(c.urlParams_.Get("pageToken"))
19072 for {
19073 x, err := c.Do()
19074 if err != nil {
19075 return err
19076 }
19077 if err := f(x); err != nil {
19078 return err
19079 }
19080 if x.NextPageToken == "" {
19081 return nil
19082 }
19083 c.PageToken(x.NextPageToken)
19084 }
19085 }
19086
19087 type PropertiesDisplayVideo360AdvertiserLinksCreateCall struct {
19088 s *Service
19089 parent string
19090 googleanalyticsadminv1alphadisplayvideo360advertiserlink *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink
19091 urlParams_ gensupport.URLParams
19092 ctx_ context.Context
19093 header_ http.Header
19094 }
19095
19096
19097
19098
19099
19100
19101
19102
19103 func (r *PropertiesDisplayVideo360AdvertiserLinksService) Create(parent string, googleanalyticsadminv1alphadisplayvideo360advertiserlink *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink) *PropertiesDisplayVideo360AdvertiserLinksCreateCall {
19104 c := &PropertiesDisplayVideo360AdvertiserLinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19105 c.parent = parent
19106 c.googleanalyticsadminv1alphadisplayvideo360advertiserlink = googleanalyticsadminv1alphadisplayvideo360advertiserlink
19107 return c
19108 }
19109
19110
19111
19112
19113 func (c *PropertiesDisplayVideo360AdvertiserLinksCreateCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinksCreateCall {
19114 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19115 return c
19116 }
19117
19118
19119 func (c *PropertiesDisplayVideo360AdvertiserLinksCreateCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinksCreateCall {
19120 c.ctx_ = ctx
19121 return c
19122 }
19123
19124
19125
19126 func (c *PropertiesDisplayVideo360AdvertiserLinksCreateCall) Header() http.Header {
19127 if c.header_ == nil {
19128 c.header_ = make(http.Header)
19129 }
19130 return c.header_
19131 }
19132
19133 func (c *PropertiesDisplayVideo360AdvertiserLinksCreateCall) doRequest(alt string) (*http.Response, error) {
19134 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
19135 var body io.Reader = nil
19136 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphadisplayvideo360advertiserlink)
19137 if err != nil {
19138 return nil, err
19139 }
19140 c.urlParams_.Set("alt", alt)
19141 c.urlParams_.Set("prettyPrint", "false")
19142 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/displayVideo360AdvertiserLinks")
19143 urls += "?" + c.urlParams_.Encode()
19144 req, err := http.NewRequest("POST", urls, body)
19145 if err != nil {
19146 return nil, err
19147 }
19148 req.Header = reqHeaders
19149 googleapi.Expand(req.URL, map[string]string{
19150 "parent": c.parent,
19151 })
19152 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19153 }
19154
19155
19156
19157
19158
19159
19160
19161 func (c *PropertiesDisplayVideo360AdvertiserLinksCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink, error) {
19162 gensupport.SetOptions(c.urlParams_, opts...)
19163 res, err := c.doRequest("json")
19164 if res != nil && res.StatusCode == http.StatusNotModified {
19165 if res.Body != nil {
19166 res.Body.Close()
19167 }
19168 return nil, gensupport.WrapError(&googleapi.Error{
19169 Code: res.StatusCode,
19170 Header: res.Header,
19171 })
19172 }
19173 if err != nil {
19174 return nil, err
19175 }
19176 defer googleapi.CloseBody(res)
19177 if err := googleapi.CheckResponse(res); err != nil {
19178 return nil, gensupport.WrapError(err)
19179 }
19180 ret := &GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink{
19181 ServerResponse: googleapi.ServerResponse{
19182 Header: res.Header,
19183 HTTPStatusCode: res.StatusCode,
19184 },
19185 }
19186 target := &ret
19187 if err := gensupport.DecodeResponse(target, res); err != nil {
19188 return nil, err
19189 }
19190 return ret, nil
19191 }
19192
19193 type PropertiesDisplayVideo360AdvertiserLinksDeleteCall struct {
19194 s *Service
19195 name string
19196 urlParams_ gensupport.URLParams
19197 ctx_ context.Context
19198 header_ http.Header
19199 }
19200
19201
19202
19203
19204
19205 func (r *PropertiesDisplayVideo360AdvertiserLinksService) Delete(name string) *PropertiesDisplayVideo360AdvertiserLinksDeleteCall {
19206 c := &PropertiesDisplayVideo360AdvertiserLinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19207 c.name = name
19208 return c
19209 }
19210
19211
19212
19213
19214 func (c *PropertiesDisplayVideo360AdvertiserLinksDeleteCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinksDeleteCall {
19215 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19216 return c
19217 }
19218
19219
19220 func (c *PropertiesDisplayVideo360AdvertiserLinksDeleteCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinksDeleteCall {
19221 c.ctx_ = ctx
19222 return c
19223 }
19224
19225
19226
19227 func (c *PropertiesDisplayVideo360AdvertiserLinksDeleteCall) Header() http.Header {
19228 if c.header_ == nil {
19229 c.header_ = make(http.Header)
19230 }
19231 return c.header_
19232 }
19233
19234 func (c *PropertiesDisplayVideo360AdvertiserLinksDeleteCall) doRequest(alt string) (*http.Response, error) {
19235 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19236 var body io.Reader = nil
19237 c.urlParams_.Set("alt", alt)
19238 c.urlParams_.Set("prettyPrint", "false")
19239 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
19240 urls += "?" + c.urlParams_.Encode()
19241 req, err := http.NewRequest("DELETE", urls, body)
19242 if err != nil {
19243 return nil, err
19244 }
19245 req.Header = reqHeaders
19246 googleapi.Expand(req.URL, map[string]string{
19247 "name": c.name,
19248 })
19249 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19250 }
19251
19252
19253
19254
19255
19256
19257
19258 func (c *PropertiesDisplayVideo360AdvertiserLinksDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
19259 gensupport.SetOptions(c.urlParams_, opts...)
19260 res, err := c.doRequest("json")
19261 if res != nil && res.StatusCode == http.StatusNotModified {
19262 if res.Body != nil {
19263 res.Body.Close()
19264 }
19265 return nil, gensupport.WrapError(&googleapi.Error{
19266 Code: res.StatusCode,
19267 Header: res.Header,
19268 })
19269 }
19270 if err != nil {
19271 return nil, err
19272 }
19273 defer googleapi.CloseBody(res)
19274 if err := googleapi.CheckResponse(res); err != nil {
19275 return nil, gensupport.WrapError(err)
19276 }
19277 ret := &GoogleProtobufEmpty{
19278 ServerResponse: googleapi.ServerResponse{
19279 Header: res.Header,
19280 HTTPStatusCode: res.StatusCode,
19281 },
19282 }
19283 target := &ret
19284 if err := gensupport.DecodeResponse(target, res); err != nil {
19285 return nil, err
19286 }
19287 return ret, nil
19288 }
19289
19290 type PropertiesDisplayVideo360AdvertiserLinksGetCall struct {
19291 s *Service
19292 name string
19293 urlParams_ gensupport.URLParams
19294 ifNoneMatch_ string
19295 ctx_ context.Context
19296 header_ http.Header
19297 }
19298
19299
19300
19301
19302
19303 func (r *PropertiesDisplayVideo360AdvertiserLinksService) Get(name string) *PropertiesDisplayVideo360AdvertiserLinksGetCall {
19304 c := &PropertiesDisplayVideo360AdvertiserLinksGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19305 c.name = name
19306 return c
19307 }
19308
19309
19310
19311
19312 func (c *PropertiesDisplayVideo360AdvertiserLinksGetCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinksGetCall {
19313 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19314 return c
19315 }
19316
19317
19318
19319
19320 func (c *PropertiesDisplayVideo360AdvertiserLinksGetCall) IfNoneMatch(entityTag string) *PropertiesDisplayVideo360AdvertiserLinksGetCall {
19321 c.ifNoneMatch_ = entityTag
19322 return c
19323 }
19324
19325
19326 func (c *PropertiesDisplayVideo360AdvertiserLinksGetCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinksGetCall {
19327 c.ctx_ = ctx
19328 return c
19329 }
19330
19331
19332
19333 func (c *PropertiesDisplayVideo360AdvertiserLinksGetCall) Header() http.Header {
19334 if c.header_ == nil {
19335 c.header_ = make(http.Header)
19336 }
19337 return c.header_
19338 }
19339
19340 func (c *PropertiesDisplayVideo360AdvertiserLinksGetCall) doRequest(alt string) (*http.Response, error) {
19341 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19342 if c.ifNoneMatch_ != "" {
19343 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
19344 }
19345 var body io.Reader = nil
19346 c.urlParams_.Set("alt", alt)
19347 c.urlParams_.Set("prettyPrint", "false")
19348 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
19349 urls += "?" + c.urlParams_.Encode()
19350 req, err := http.NewRequest("GET", urls, body)
19351 if err != nil {
19352 return nil, err
19353 }
19354 req.Header = reqHeaders
19355 googleapi.Expand(req.URL, map[string]string{
19356 "name": c.name,
19357 })
19358 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19359 }
19360
19361
19362
19363
19364
19365
19366
19367 func (c *PropertiesDisplayVideo360AdvertiserLinksGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink, error) {
19368 gensupport.SetOptions(c.urlParams_, opts...)
19369 res, err := c.doRequest("json")
19370 if res != nil && res.StatusCode == http.StatusNotModified {
19371 if res.Body != nil {
19372 res.Body.Close()
19373 }
19374 return nil, gensupport.WrapError(&googleapi.Error{
19375 Code: res.StatusCode,
19376 Header: res.Header,
19377 })
19378 }
19379 if err != nil {
19380 return nil, err
19381 }
19382 defer googleapi.CloseBody(res)
19383 if err := googleapi.CheckResponse(res); err != nil {
19384 return nil, gensupport.WrapError(err)
19385 }
19386 ret := &GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink{
19387 ServerResponse: googleapi.ServerResponse{
19388 Header: res.Header,
19389 HTTPStatusCode: res.StatusCode,
19390 },
19391 }
19392 target := &ret
19393 if err := gensupport.DecodeResponse(target, res); err != nil {
19394 return nil, err
19395 }
19396 return ret, nil
19397 }
19398
19399 type PropertiesDisplayVideo360AdvertiserLinksListCall struct {
19400 s *Service
19401 parent string
19402 urlParams_ gensupport.URLParams
19403 ifNoneMatch_ string
19404 ctx_ context.Context
19405 header_ http.Header
19406 }
19407
19408
19409
19410
19411 func (r *PropertiesDisplayVideo360AdvertiserLinksService) List(parent string) *PropertiesDisplayVideo360AdvertiserLinksListCall {
19412 c := &PropertiesDisplayVideo360AdvertiserLinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19413 c.parent = parent
19414 return c
19415 }
19416
19417
19418
19419
19420 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) PageSize(pageSize int64) *PropertiesDisplayVideo360AdvertiserLinksListCall {
19421 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
19422 return c
19423 }
19424
19425
19426
19427
19428
19429
19430 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) PageToken(pageToken string) *PropertiesDisplayVideo360AdvertiserLinksListCall {
19431 c.urlParams_.Set("pageToken", pageToken)
19432 return c
19433 }
19434
19435
19436
19437
19438 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinksListCall {
19439 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19440 return c
19441 }
19442
19443
19444
19445
19446 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) IfNoneMatch(entityTag string) *PropertiesDisplayVideo360AdvertiserLinksListCall {
19447 c.ifNoneMatch_ = entityTag
19448 return c
19449 }
19450
19451
19452 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinksListCall {
19453 c.ctx_ = ctx
19454 return c
19455 }
19456
19457
19458
19459 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) Header() http.Header {
19460 if c.header_ == nil {
19461 c.header_ = make(http.Header)
19462 }
19463 return c.header_
19464 }
19465
19466 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) doRequest(alt string) (*http.Response, error) {
19467 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19468 if c.ifNoneMatch_ != "" {
19469 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
19470 }
19471 var body io.Reader = nil
19472 c.urlParams_.Set("alt", alt)
19473 c.urlParams_.Set("prettyPrint", "false")
19474 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/displayVideo360AdvertiserLinks")
19475 urls += "?" + c.urlParams_.Encode()
19476 req, err := http.NewRequest("GET", urls, body)
19477 if err != nil {
19478 return nil, err
19479 }
19480 req.Header = reqHeaders
19481 googleapi.Expand(req.URL, map[string]string{
19482 "parent": c.parent,
19483 })
19484 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19485 }
19486
19487
19488
19489
19490
19491
19492
19493 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinksResponse, error) {
19494 gensupport.SetOptions(c.urlParams_, opts...)
19495 res, err := c.doRequest("json")
19496 if res != nil && res.StatusCode == http.StatusNotModified {
19497 if res.Body != nil {
19498 res.Body.Close()
19499 }
19500 return nil, gensupport.WrapError(&googleapi.Error{
19501 Code: res.StatusCode,
19502 Header: res.Header,
19503 })
19504 }
19505 if err != nil {
19506 return nil, err
19507 }
19508 defer googleapi.CloseBody(res)
19509 if err := googleapi.CheckResponse(res); err != nil {
19510 return nil, gensupport.WrapError(err)
19511 }
19512 ret := &GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinksResponse{
19513 ServerResponse: googleapi.ServerResponse{
19514 Header: res.Header,
19515 HTTPStatusCode: res.StatusCode,
19516 },
19517 }
19518 target := &ret
19519 if err := gensupport.DecodeResponse(target, res); err != nil {
19520 return nil, err
19521 }
19522 return ret, nil
19523 }
19524
19525
19526
19527
19528 func (c *PropertiesDisplayVideo360AdvertiserLinksListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListDisplayVideo360AdvertiserLinksResponse) error) error {
19529 c.ctx_ = ctx
19530 defer c.PageToken(c.urlParams_.Get("pageToken"))
19531 for {
19532 x, err := c.Do()
19533 if err != nil {
19534 return err
19535 }
19536 if err := f(x); err != nil {
19537 return err
19538 }
19539 if x.NextPageToken == "" {
19540 return nil
19541 }
19542 c.PageToken(x.NextPageToken)
19543 }
19544 }
19545
19546 type PropertiesDisplayVideo360AdvertiserLinksPatchCall struct {
19547 s *Service
19548 name string
19549 googleanalyticsadminv1alphadisplayvideo360advertiserlink *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink
19550 urlParams_ gensupport.URLParams
19551 ctx_ context.Context
19552 header_ http.Header
19553 }
19554
19555
19556
19557
19558
19559
19560
19561 func (r *PropertiesDisplayVideo360AdvertiserLinksService) Patch(name string, googleanalyticsadminv1alphadisplayvideo360advertiserlink *GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink) *PropertiesDisplayVideo360AdvertiserLinksPatchCall {
19562 c := &PropertiesDisplayVideo360AdvertiserLinksPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19563 c.name = name
19564 c.googleanalyticsadminv1alphadisplayvideo360advertiserlink = googleanalyticsadminv1alphadisplayvideo360advertiserlink
19565 return c
19566 }
19567
19568
19569
19570
19571 func (c *PropertiesDisplayVideo360AdvertiserLinksPatchCall) UpdateMask(updateMask string) *PropertiesDisplayVideo360AdvertiserLinksPatchCall {
19572 c.urlParams_.Set("updateMask", updateMask)
19573 return c
19574 }
19575
19576
19577
19578
19579 func (c *PropertiesDisplayVideo360AdvertiserLinksPatchCall) Fields(s ...googleapi.Field) *PropertiesDisplayVideo360AdvertiserLinksPatchCall {
19580 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19581 return c
19582 }
19583
19584
19585 func (c *PropertiesDisplayVideo360AdvertiserLinksPatchCall) Context(ctx context.Context) *PropertiesDisplayVideo360AdvertiserLinksPatchCall {
19586 c.ctx_ = ctx
19587 return c
19588 }
19589
19590
19591
19592 func (c *PropertiesDisplayVideo360AdvertiserLinksPatchCall) Header() http.Header {
19593 if c.header_ == nil {
19594 c.header_ = make(http.Header)
19595 }
19596 return c.header_
19597 }
19598
19599 func (c *PropertiesDisplayVideo360AdvertiserLinksPatchCall) doRequest(alt string) (*http.Response, error) {
19600 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
19601 var body io.Reader = nil
19602 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphadisplayvideo360advertiserlink)
19603 if err != nil {
19604 return nil, err
19605 }
19606 c.urlParams_.Set("alt", alt)
19607 c.urlParams_.Set("prettyPrint", "false")
19608 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
19609 urls += "?" + c.urlParams_.Encode()
19610 req, err := http.NewRequest("PATCH", urls, body)
19611 if err != nil {
19612 return nil, err
19613 }
19614 req.Header = reqHeaders
19615 googleapi.Expand(req.URL, map[string]string{
19616 "name": c.name,
19617 })
19618 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19619 }
19620
19621
19622
19623
19624
19625
19626
19627 func (c *PropertiesDisplayVideo360AdvertiserLinksPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink, error) {
19628 gensupport.SetOptions(c.urlParams_, opts...)
19629 res, err := c.doRequest("json")
19630 if res != nil && res.StatusCode == http.StatusNotModified {
19631 if res.Body != nil {
19632 res.Body.Close()
19633 }
19634 return nil, gensupport.WrapError(&googleapi.Error{
19635 Code: res.StatusCode,
19636 Header: res.Header,
19637 })
19638 }
19639 if err != nil {
19640 return nil, err
19641 }
19642 defer googleapi.CloseBody(res)
19643 if err := googleapi.CheckResponse(res); err != nil {
19644 return nil, gensupport.WrapError(err)
19645 }
19646 ret := &GoogleAnalyticsAdminV1alphaDisplayVideo360AdvertiserLink{
19647 ServerResponse: googleapi.ServerResponse{
19648 Header: res.Header,
19649 HTTPStatusCode: res.StatusCode,
19650 },
19651 }
19652 target := &ret
19653 if err := gensupport.DecodeResponse(target, res); err != nil {
19654 return nil, err
19655 }
19656 return ret, nil
19657 }
19658
19659 type PropertiesExpandedDataSetsCreateCall struct {
19660 s *Service
19661 parent string
19662 googleanalyticsadminv1alphaexpandeddataset *GoogleAnalyticsAdminV1alphaExpandedDataSet
19663 urlParams_ gensupport.URLParams
19664 ctx_ context.Context
19665 header_ http.Header
19666 }
19667
19668
19669
19670
19671 func (r *PropertiesExpandedDataSetsService) Create(parent string, googleanalyticsadminv1alphaexpandeddataset *GoogleAnalyticsAdminV1alphaExpandedDataSet) *PropertiesExpandedDataSetsCreateCall {
19672 c := &PropertiesExpandedDataSetsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19673 c.parent = parent
19674 c.googleanalyticsadminv1alphaexpandeddataset = googleanalyticsadminv1alphaexpandeddataset
19675 return c
19676 }
19677
19678
19679
19680
19681 func (c *PropertiesExpandedDataSetsCreateCall) Fields(s ...googleapi.Field) *PropertiesExpandedDataSetsCreateCall {
19682 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19683 return c
19684 }
19685
19686
19687 func (c *PropertiesExpandedDataSetsCreateCall) Context(ctx context.Context) *PropertiesExpandedDataSetsCreateCall {
19688 c.ctx_ = ctx
19689 return c
19690 }
19691
19692
19693
19694 func (c *PropertiesExpandedDataSetsCreateCall) Header() http.Header {
19695 if c.header_ == nil {
19696 c.header_ = make(http.Header)
19697 }
19698 return c.header_
19699 }
19700
19701 func (c *PropertiesExpandedDataSetsCreateCall) doRequest(alt string) (*http.Response, error) {
19702 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
19703 var body io.Reader = nil
19704 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaexpandeddataset)
19705 if err != nil {
19706 return nil, err
19707 }
19708 c.urlParams_.Set("alt", alt)
19709 c.urlParams_.Set("prettyPrint", "false")
19710 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/expandedDataSets")
19711 urls += "?" + c.urlParams_.Encode()
19712 req, err := http.NewRequest("POST", urls, body)
19713 if err != nil {
19714 return nil, err
19715 }
19716 req.Header = reqHeaders
19717 googleapi.Expand(req.URL, map[string]string{
19718 "parent": c.parent,
19719 })
19720 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19721 }
19722
19723
19724
19725
19726
19727
19728
19729 func (c *PropertiesExpandedDataSetsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaExpandedDataSet, error) {
19730 gensupport.SetOptions(c.urlParams_, opts...)
19731 res, err := c.doRequest("json")
19732 if res != nil && res.StatusCode == http.StatusNotModified {
19733 if res.Body != nil {
19734 res.Body.Close()
19735 }
19736 return nil, gensupport.WrapError(&googleapi.Error{
19737 Code: res.StatusCode,
19738 Header: res.Header,
19739 })
19740 }
19741 if err != nil {
19742 return nil, err
19743 }
19744 defer googleapi.CloseBody(res)
19745 if err := googleapi.CheckResponse(res); err != nil {
19746 return nil, gensupport.WrapError(err)
19747 }
19748 ret := &GoogleAnalyticsAdminV1alphaExpandedDataSet{
19749 ServerResponse: googleapi.ServerResponse{
19750 Header: res.Header,
19751 HTTPStatusCode: res.StatusCode,
19752 },
19753 }
19754 target := &ret
19755 if err := gensupport.DecodeResponse(target, res); err != nil {
19756 return nil, err
19757 }
19758 return ret, nil
19759 }
19760
19761 type PropertiesExpandedDataSetsDeleteCall struct {
19762 s *Service
19763 name string
19764 urlParams_ gensupport.URLParams
19765 ctx_ context.Context
19766 header_ http.Header
19767 }
19768
19769
19770
19771
19772 func (r *PropertiesExpandedDataSetsService) Delete(name string) *PropertiesExpandedDataSetsDeleteCall {
19773 c := &PropertiesExpandedDataSetsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19774 c.name = name
19775 return c
19776 }
19777
19778
19779
19780
19781 func (c *PropertiesExpandedDataSetsDeleteCall) Fields(s ...googleapi.Field) *PropertiesExpandedDataSetsDeleteCall {
19782 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19783 return c
19784 }
19785
19786
19787 func (c *PropertiesExpandedDataSetsDeleteCall) Context(ctx context.Context) *PropertiesExpandedDataSetsDeleteCall {
19788 c.ctx_ = ctx
19789 return c
19790 }
19791
19792
19793
19794 func (c *PropertiesExpandedDataSetsDeleteCall) Header() http.Header {
19795 if c.header_ == nil {
19796 c.header_ = make(http.Header)
19797 }
19798 return c.header_
19799 }
19800
19801 func (c *PropertiesExpandedDataSetsDeleteCall) doRequest(alt string) (*http.Response, error) {
19802 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19803 var body io.Reader = nil
19804 c.urlParams_.Set("alt", alt)
19805 c.urlParams_.Set("prettyPrint", "false")
19806 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
19807 urls += "?" + c.urlParams_.Encode()
19808 req, err := http.NewRequest("DELETE", urls, body)
19809 if err != nil {
19810 return nil, err
19811 }
19812 req.Header = reqHeaders
19813 googleapi.Expand(req.URL, map[string]string{
19814 "name": c.name,
19815 })
19816 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19817 }
19818
19819
19820
19821
19822
19823
19824
19825 func (c *PropertiesExpandedDataSetsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
19826 gensupport.SetOptions(c.urlParams_, opts...)
19827 res, err := c.doRequest("json")
19828 if res != nil && res.StatusCode == http.StatusNotModified {
19829 if res.Body != nil {
19830 res.Body.Close()
19831 }
19832 return nil, gensupport.WrapError(&googleapi.Error{
19833 Code: res.StatusCode,
19834 Header: res.Header,
19835 })
19836 }
19837 if err != nil {
19838 return nil, err
19839 }
19840 defer googleapi.CloseBody(res)
19841 if err := googleapi.CheckResponse(res); err != nil {
19842 return nil, gensupport.WrapError(err)
19843 }
19844 ret := &GoogleProtobufEmpty{
19845 ServerResponse: googleapi.ServerResponse{
19846 Header: res.Header,
19847 HTTPStatusCode: res.StatusCode,
19848 },
19849 }
19850 target := &ret
19851 if err := gensupport.DecodeResponse(target, res); err != nil {
19852 return nil, err
19853 }
19854 return ret, nil
19855 }
19856
19857 type PropertiesExpandedDataSetsGetCall struct {
19858 s *Service
19859 name string
19860 urlParams_ gensupport.URLParams
19861 ifNoneMatch_ string
19862 ctx_ context.Context
19863 header_ http.Header
19864 }
19865
19866
19867
19868
19869
19870 func (r *PropertiesExpandedDataSetsService) Get(name string) *PropertiesExpandedDataSetsGetCall {
19871 c := &PropertiesExpandedDataSetsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19872 c.name = name
19873 return c
19874 }
19875
19876
19877
19878
19879 func (c *PropertiesExpandedDataSetsGetCall) Fields(s ...googleapi.Field) *PropertiesExpandedDataSetsGetCall {
19880 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19881 return c
19882 }
19883
19884
19885
19886
19887 func (c *PropertiesExpandedDataSetsGetCall) IfNoneMatch(entityTag string) *PropertiesExpandedDataSetsGetCall {
19888 c.ifNoneMatch_ = entityTag
19889 return c
19890 }
19891
19892
19893 func (c *PropertiesExpandedDataSetsGetCall) Context(ctx context.Context) *PropertiesExpandedDataSetsGetCall {
19894 c.ctx_ = ctx
19895 return c
19896 }
19897
19898
19899
19900 func (c *PropertiesExpandedDataSetsGetCall) Header() http.Header {
19901 if c.header_ == nil {
19902 c.header_ = make(http.Header)
19903 }
19904 return c.header_
19905 }
19906
19907 func (c *PropertiesExpandedDataSetsGetCall) doRequest(alt string) (*http.Response, error) {
19908 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19909 if c.ifNoneMatch_ != "" {
19910 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
19911 }
19912 var body io.Reader = nil
19913 c.urlParams_.Set("alt", alt)
19914 c.urlParams_.Set("prettyPrint", "false")
19915 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
19916 urls += "?" + c.urlParams_.Encode()
19917 req, err := http.NewRequest("GET", urls, body)
19918 if err != nil {
19919 return nil, err
19920 }
19921 req.Header = reqHeaders
19922 googleapi.Expand(req.URL, map[string]string{
19923 "name": c.name,
19924 })
19925 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19926 }
19927
19928
19929
19930
19931
19932
19933
19934 func (c *PropertiesExpandedDataSetsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaExpandedDataSet, error) {
19935 gensupport.SetOptions(c.urlParams_, opts...)
19936 res, err := c.doRequest("json")
19937 if res != nil && res.StatusCode == http.StatusNotModified {
19938 if res.Body != nil {
19939 res.Body.Close()
19940 }
19941 return nil, gensupport.WrapError(&googleapi.Error{
19942 Code: res.StatusCode,
19943 Header: res.Header,
19944 })
19945 }
19946 if err != nil {
19947 return nil, err
19948 }
19949 defer googleapi.CloseBody(res)
19950 if err := googleapi.CheckResponse(res); err != nil {
19951 return nil, gensupport.WrapError(err)
19952 }
19953 ret := &GoogleAnalyticsAdminV1alphaExpandedDataSet{
19954 ServerResponse: googleapi.ServerResponse{
19955 Header: res.Header,
19956 HTTPStatusCode: res.StatusCode,
19957 },
19958 }
19959 target := &ret
19960 if err := gensupport.DecodeResponse(target, res); err != nil {
19961 return nil, err
19962 }
19963 return ret, nil
19964 }
19965
19966 type PropertiesExpandedDataSetsListCall struct {
19967 s *Service
19968 parent string
19969 urlParams_ gensupport.URLParams
19970 ifNoneMatch_ string
19971 ctx_ context.Context
19972 header_ http.Header
19973 }
19974
19975
19976
19977
19978 func (r *PropertiesExpandedDataSetsService) List(parent string) *PropertiesExpandedDataSetsListCall {
19979 c := &PropertiesExpandedDataSetsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19980 c.parent = parent
19981 return c
19982 }
19983
19984
19985
19986
19987 func (c *PropertiesExpandedDataSetsListCall) PageSize(pageSize int64) *PropertiesExpandedDataSetsListCall {
19988 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
19989 return c
19990 }
19991
19992
19993
19994
19995
19996 func (c *PropertiesExpandedDataSetsListCall) PageToken(pageToken string) *PropertiesExpandedDataSetsListCall {
19997 c.urlParams_.Set("pageToken", pageToken)
19998 return c
19999 }
20000
20001
20002
20003
20004 func (c *PropertiesExpandedDataSetsListCall) Fields(s ...googleapi.Field) *PropertiesExpandedDataSetsListCall {
20005 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20006 return c
20007 }
20008
20009
20010
20011
20012 func (c *PropertiesExpandedDataSetsListCall) IfNoneMatch(entityTag string) *PropertiesExpandedDataSetsListCall {
20013 c.ifNoneMatch_ = entityTag
20014 return c
20015 }
20016
20017
20018 func (c *PropertiesExpandedDataSetsListCall) Context(ctx context.Context) *PropertiesExpandedDataSetsListCall {
20019 c.ctx_ = ctx
20020 return c
20021 }
20022
20023
20024
20025 func (c *PropertiesExpandedDataSetsListCall) Header() http.Header {
20026 if c.header_ == nil {
20027 c.header_ = make(http.Header)
20028 }
20029 return c.header_
20030 }
20031
20032 func (c *PropertiesExpandedDataSetsListCall) doRequest(alt string) (*http.Response, error) {
20033 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
20034 if c.ifNoneMatch_ != "" {
20035 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20036 }
20037 var body io.Reader = nil
20038 c.urlParams_.Set("alt", alt)
20039 c.urlParams_.Set("prettyPrint", "false")
20040 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/expandedDataSets")
20041 urls += "?" + c.urlParams_.Encode()
20042 req, err := http.NewRequest("GET", urls, body)
20043 if err != nil {
20044 return nil, err
20045 }
20046 req.Header = reqHeaders
20047 googleapi.Expand(req.URL, map[string]string{
20048 "parent": c.parent,
20049 })
20050 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20051 }
20052
20053
20054
20055
20056
20057
20058
20059 func (c *PropertiesExpandedDataSetsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListExpandedDataSetsResponse, error) {
20060 gensupport.SetOptions(c.urlParams_, opts...)
20061 res, err := c.doRequest("json")
20062 if res != nil && res.StatusCode == http.StatusNotModified {
20063 if res.Body != nil {
20064 res.Body.Close()
20065 }
20066 return nil, gensupport.WrapError(&googleapi.Error{
20067 Code: res.StatusCode,
20068 Header: res.Header,
20069 })
20070 }
20071 if err != nil {
20072 return nil, err
20073 }
20074 defer googleapi.CloseBody(res)
20075 if err := googleapi.CheckResponse(res); err != nil {
20076 return nil, gensupport.WrapError(err)
20077 }
20078 ret := &GoogleAnalyticsAdminV1alphaListExpandedDataSetsResponse{
20079 ServerResponse: googleapi.ServerResponse{
20080 Header: res.Header,
20081 HTTPStatusCode: res.StatusCode,
20082 },
20083 }
20084 target := &ret
20085 if err := gensupport.DecodeResponse(target, res); err != nil {
20086 return nil, err
20087 }
20088 return ret, nil
20089 }
20090
20091
20092
20093
20094 func (c *PropertiesExpandedDataSetsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListExpandedDataSetsResponse) error) error {
20095 c.ctx_ = ctx
20096 defer c.PageToken(c.urlParams_.Get("pageToken"))
20097 for {
20098 x, err := c.Do()
20099 if err != nil {
20100 return err
20101 }
20102 if err := f(x); err != nil {
20103 return err
20104 }
20105 if x.NextPageToken == "" {
20106 return nil
20107 }
20108 c.PageToken(x.NextPageToken)
20109 }
20110 }
20111
20112 type PropertiesExpandedDataSetsPatchCall struct {
20113 s *Service
20114 name string
20115 googleanalyticsadminv1alphaexpandeddataset *GoogleAnalyticsAdminV1alphaExpandedDataSet
20116 urlParams_ gensupport.URLParams
20117 ctx_ context.Context
20118 header_ http.Header
20119 }
20120
20121
20122
20123
20124
20125 func (r *PropertiesExpandedDataSetsService) Patch(name string, googleanalyticsadminv1alphaexpandeddataset *GoogleAnalyticsAdminV1alphaExpandedDataSet) *PropertiesExpandedDataSetsPatchCall {
20126 c := &PropertiesExpandedDataSetsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20127 c.name = name
20128 c.googleanalyticsadminv1alphaexpandeddataset = googleanalyticsadminv1alphaexpandeddataset
20129 return c
20130 }
20131
20132
20133
20134
20135
20136 func (c *PropertiesExpandedDataSetsPatchCall) UpdateMask(updateMask string) *PropertiesExpandedDataSetsPatchCall {
20137 c.urlParams_.Set("updateMask", updateMask)
20138 return c
20139 }
20140
20141
20142
20143
20144 func (c *PropertiesExpandedDataSetsPatchCall) Fields(s ...googleapi.Field) *PropertiesExpandedDataSetsPatchCall {
20145 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20146 return c
20147 }
20148
20149
20150 func (c *PropertiesExpandedDataSetsPatchCall) Context(ctx context.Context) *PropertiesExpandedDataSetsPatchCall {
20151 c.ctx_ = ctx
20152 return c
20153 }
20154
20155
20156
20157 func (c *PropertiesExpandedDataSetsPatchCall) Header() http.Header {
20158 if c.header_ == nil {
20159 c.header_ = make(http.Header)
20160 }
20161 return c.header_
20162 }
20163
20164 func (c *PropertiesExpandedDataSetsPatchCall) doRequest(alt string) (*http.Response, error) {
20165 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
20166 var body io.Reader = nil
20167 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphaexpandeddataset)
20168 if err != nil {
20169 return nil, err
20170 }
20171 c.urlParams_.Set("alt", alt)
20172 c.urlParams_.Set("prettyPrint", "false")
20173 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
20174 urls += "?" + c.urlParams_.Encode()
20175 req, err := http.NewRequest("PATCH", urls, body)
20176 if err != nil {
20177 return nil, err
20178 }
20179 req.Header = reqHeaders
20180 googleapi.Expand(req.URL, map[string]string{
20181 "name": c.name,
20182 })
20183 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20184 }
20185
20186
20187
20188
20189
20190
20191
20192 func (c *PropertiesExpandedDataSetsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaExpandedDataSet, error) {
20193 gensupport.SetOptions(c.urlParams_, opts...)
20194 res, err := c.doRequest("json")
20195 if res != nil && res.StatusCode == http.StatusNotModified {
20196 if res.Body != nil {
20197 res.Body.Close()
20198 }
20199 return nil, gensupport.WrapError(&googleapi.Error{
20200 Code: res.StatusCode,
20201 Header: res.Header,
20202 })
20203 }
20204 if err != nil {
20205 return nil, err
20206 }
20207 defer googleapi.CloseBody(res)
20208 if err := googleapi.CheckResponse(res); err != nil {
20209 return nil, gensupport.WrapError(err)
20210 }
20211 ret := &GoogleAnalyticsAdminV1alphaExpandedDataSet{
20212 ServerResponse: googleapi.ServerResponse{
20213 Header: res.Header,
20214 HTTPStatusCode: res.StatusCode,
20215 },
20216 }
20217 target := &ret
20218 if err := gensupport.DecodeResponse(target, res); err != nil {
20219 return nil, err
20220 }
20221 return ret, nil
20222 }
20223
20224 type PropertiesFirebaseLinksCreateCall struct {
20225 s *Service
20226 parent string
20227 googleanalyticsadminv1alphafirebaselink *GoogleAnalyticsAdminV1alphaFirebaseLink
20228 urlParams_ gensupport.URLParams
20229 ctx_ context.Context
20230 header_ http.Header
20231 }
20232
20233
20234
20235
20236
20237 func (r *PropertiesFirebaseLinksService) Create(parent string, googleanalyticsadminv1alphafirebaselink *GoogleAnalyticsAdminV1alphaFirebaseLink) *PropertiesFirebaseLinksCreateCall {
20238 c := &PropertiesFirebaseLinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20239 c.parent = parent
20240 c.googleanalyticsadminv1alphafirebaselink = googleanalyticsadminv1alphafirebaselink
20241 return c
20242 }
20243
20244
20245
20246
20247 func (c *PropertiesFirebaseLinksCreateCall) Fields(s ...googleapi.Field) *PropertiesFirebaseLinksCreateCall {
20248 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20249 return c
20250 }
20251
20252
20253 func (c *PropertiesFirebaseLinksCreateCall) Context(ctx context.Context) *PropertiesFirebaseLinksCreateCall {
20254 c.ctx_ = ctx
20255 return c
20256 }
20257
20258
20259
20260 func (c *PropertiesFirebaseLinksCreateCall) Header() http.Header {
20261 if c.header_ == nil {
20262 c.header_ = make(http.Header)
20263 }
20264 return c.header_
20265 }
20266
20267 func (c *PropertiesFirebaseLinksCreateCall) doRequest(alt string) (*http.Response, error) {
20268 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
20269 var body io.Reader = nil
20270 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphafirebaselink)
20271 if err != nil {
20272 return nil, err
20273 }
20274 c.urlParams_.Set("alt", alt)
20275 c.urlParams_.Set("prettyPrint", "false")
20276 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/firebaseLinks")
20277 urls += "?" + c.urlParams_.Encode()
20278 req, err := http.NewRequest("POST", urls, body)
20279 if err != nil {
20280 return nil, err
20281 }
20282 req.Header = reqHeaders
20283 googleapi.Expand(req.URL, map[string]string{
20284 "parent": c.parent,
20285 })
20286 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20287 }
20288
20289
20290
20291
20292
20293
20294
20295 func (c *PropertiesFirebaseLinksCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaFirebaseLink, error) {
20296 gensupport.SetOptions(c.urlParams_, opts...)
20297 res, err := c.doRequest("json")
20298 if res != nil && res.StatusCode == http.StatusNotModified {
20299 if res.Body != nil {
20300 res.Body.Close()
20301 }
20302 return nil, gensupport.WrapError(&googleapi.Error{
20303 Code: res.StatusCode,
20304 Header: res.Header,
20305 })
20306 }
20307 if err != nil {
20308 return nil, err
20309 }
20310 defer googleapi.CloseBody(res)
20311 if err := googleapi.CheckResponse(res); err != nil {
20312 return nil, gensupport.WrapError(err)
20313 }
20314 ret := &GoogleAnalyticsAdminV1alphaFirebaseLink{
20315 ServerResponse: googleapi.ServerResponse{
20316 Header: res.Header,
20317 HTTPStatusCode: res.StatusCode,
20318 },
20319 }
20320 target := &ret
20321 if err := gensupport.DecodeResponse(target, res); err != nil {
20322 return nil, err
20323 }
20324 return ret, nil
20325 }
20326
20327 type PropertiesFirebaseLinksDeleteCall struct {
20328 s *Service
20329 name string
20330 urlParams_ gensupport.URLParams
20331 ctx_ context.Context
20332 header_ http.Header
20333 }
20334
20335
20336
20337
20338
20339 func (r *PropertiesFirebaseLinksService) Delete(name string) *PropertiesFirebaseLinksDeleteCall {
20340 c := &PropertiesFirebaseLinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20341 c.name = name
20342 return c
20343 }
20344
20345
20346
20347
20348 func (c *PropertiesFirebaseLinksDeleteCall) Fields(s ...googleapi.Field) *PropertiesFirebaseLinksDeleteCall {
20349 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20350 return c
20351 }
20352
20353
20354 func (c *PropertiesFirebaseLinksDeleteCall) Context(ctx context.Context) *PropertiesFirebaseLinksDeleteCall {
20355 c.ctx_ = ctx
20356 return c
20357 }
20358
20359
20360
20361 func (c *PropertiesFirebaseLinksDeleteCall) Header() http.Header {
20362 if c.header_ == nil {
20363 c.header_ = make(http.Header)
20364 }
20365 return c.header_
20366 }
20367
20368 func (c *PropertiesFirebaseLinksDeleteCall) doRequest(alt string) (*http.Response, error) {
20369 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
20370 var body io.Reader = nil
20371 c.urlParams_.Set("alt", alt)
20372 c.urlParams_.Set("prettyPrint", "false")
20373 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
20374 urls += "?" + c.urlParams_.Encode()
20375 req, err := http.NewRequest("DELETE", urls, body)
20376 if err != nil {
20377 return nil, err
20378 }
20379 req.Header = reqHeaders
20380 googleapi.Expand(req.URL, map[string]string{
20381 "name": c.name,
20382 })
20383 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20384 }
20385
20386
20387
20388
20389
20390
20391
20392 func (c *PropertiesFirebaseLinksDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
20393 gensupport.SetOptions(c.urlParams_, opts...)
20394 res, err := c.doRequest("json")
20395 if res != nil && res.StatusCode == http.StatusNotModified {
20396 if res.Body != nil {
20397 res.Body.Close()
20398 }
20399 return nil, gensupport.WrapError(&googleapi.Error{
20400 Code: res.StatusCode,
20401 Header: res.Header,
20402 })
20403 }
20404 if err != nil {
20405 return nil, err
20406 }
20407 defer googleapi.CloseBody(res)
20408 if err := googleapi.CheckResponse(res); err != nil {
20409 return nil, gensupport.WrapError(err)
20410 }
20411 ret := &GoogleProtobufEmpty{
20412 ServerResponse: googleapi.ServerResponse{
20413 Header: res.Header,
20414 HTTPStatusCode: res.StatusCode,
20415 },
20416 }
20417 target := &ret
20418 if err := gensupport.DecodeResponse(target, res); err != nil {
20419 return nil, err
20420 }
20421 return ret, nil
20422 }
20423
20424 type PropertiesFirebaseLinksListCall struct {
20425 s *Service
20426 parent string
20427 urlParams_ gensupport.URLParams
20428 ifNoneMatch_ string
20429 ctx_ context.Context
20430 header_ http.Header
20431 }
20432
20433
20434
20435
20436
20437 func (r *PropertiesFirebaseLinksService) List(parent string) *PropertiesFirebaseLinksListCall {
20438 c := &PropertiesFirebaseLinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20439 c.parent = parent
20440 return c
20441 }
20442
20443
20444
20445
20446
20447
20448 func (c *PropertiesFirebaseLinksListCall) PageSize(pageSize int64) *PropertiesFirebaseLinksListCall {
20449 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
20450 return c
20451 }
20452
20453
20454
20455
20456
20457 func (c *PropertiesFirebaseLinksListCall) PageToken(pageToken string) *PropertiesFirebaseLinksListCall {
20458 c.urlParams_.Set("pageToken", pageToken)
20459 return c
20460 }
20461
20462
20463
20464
20465 func (c *PropertiesFirebaseLinksListCall) Fields(s ...googleapi.Field) *PropertiesFirebaseLinksListCall {
20466 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20467 return c
20468 }
20469
20470
20471
20472
20473 func (c *PropertiesFirebaseLinksListCall) IfNoneMatch(entityTag string) *PropertiesFirebaseLinksListCall {
20474 c.ifNoneMatch_ = entityTag
20475 return c
20476 }
20477
20478
20479 func (c *PropertiesFirebaseLinksListCall) Context(ctx context.Context) *PropertiesFirebaseLinksListCall {
20480 c.ctx_ = ctx
20481 return c
20482 }
20483
20484
20485
20486 func (c *PropertiesFirebaseLinksListCall) Header() http.Header {
20487 if c.header_ == nil {
20488 c.header_ = make(http.Header)
20489 }
20490 return c.header_
20491 }
20492
20493 func (c *PropertiesFirebaseLinksListCall) doRequest(alt string) (*http.Response, error) {
20494 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
20495 if c.ifNoneMatch_ != "" {
20496 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20497 }
20498 var body io.Reader = nil
20499 c.urlParams_.Set("alt", alt)
20500 c.urlParams_.Set("prettyPrint", "false")
20501 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/firebaseLinks")
20502 urls += "?" + c.urlParams_.Encode()
20503 req, err := http.NewRequest("GET", urls, body)
20504 if err != nil {
20505 return nil, err
20506 }
20507 req.Header = reqHeaders
20508 googleapi.Expand(req.URL, map[string]string{
20509 "parent": c.parent,
20510 })
20511 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20512 }
20513
20514
20515
20516
20517
20518
20519
20520 func (c *PropertiesFirebaseLinksListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListFirebaseLinksResponse, error) {
20521 gensupport.SetOptions(c.urlParams_, opts...)
20522 res, err := c.doRequest("json")
20523 if res != nil && res.StatusCode == http.StatusNotModified {
20524 if res.Body != nil {
20525 res.Body.Close()
20526 }
20527 return nil, gensupport.WrapError(&googleapi.Error{
20528 Code: res.StatusCode,
20529 Header: res.Header,
20530 })
20531 }
20532 if err != nil {
20533 return nil, err
20534 }
20535 defer googleapi.CloseBody(res)
20536 if err := googleapi.CheckResponse(res); err != nil {
20537 return nil, gensupport.WrapError(err)
20538 }
20539 ret := &GoogleAnalyticsAdminV1alphaListFirebaseLinksResponse{
20540 ServerResponse: googleapi.ServerResponse{
20541 Header: res.Header,
20542 HTTPStatusCode: res.StatusCode,
20543 },
20544 }
20545 target := &ret
20546 if err := gensupport.DecodeResponse(target, res); err != nil {
20547 return nil, err
20548 }
20549 return ret, nil
20550 }
20551
20552
20553
20554
20555 func (c *PropertiesFirebaseLinksListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListFirebaseLinksResponse) error) error {
20556 c.ctx_ = ctx
20557 defer c.PageToken(c.urlParams_.Get("pageToken"))
20558 for {
20559 x, err := c.Do()
20560 if err != nil {
20561 return err
20562 }
20563 if err := f(x); err != nil {
20564 return err
20565 }
20566 if x.NextPageToken == "" {
20567 return nil
20568 }
20569 c.PageToken(x.NextPageToken)
20570 }
20571 }
20572
20573 type PropertiesGoogleAdsLinksCreateCall struct {
20574 s *Service
20575 parent string
20576 googleanalyticsadminv1alphagoogleadslink *GoogleAnalyticsAdminV1alphaGoogleAdsLink
20577 urlParams_ gensupport.URLParams
20578 ctx_ context.Context
20579 header_ http.Header
20580 }
20581
20582
20583
20584
20585 func (r *PropertiesGoogleAdsLinksService) Create(parent string, googleanalyticsadminv1alphagoogleadslink *GoogleAnalyticsAdminV1alphaGoogleAdsLink) *PropertiesGoogleAdsLinksCreateCall {
20586 c := &PropertiesGoogleAdsLinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20587 c.parent = parent
20588 c.googleanalyticsadminv1alphagoogleadslink = googleanalyticsadminv1alphagoogleadslink
20589 return c
20590 }
20591
20592
20593
20594
20595 func (c *PropertiesGoogleAdsLinksCreateCall) Fields(s ...googleapi.Field) *PropertiesGoogleAdsLinksCreateCall {
20596 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20597 return c
20598 }
20599
20600
20601 func (c *PropertiesGoogleAdsLinksCreateCall) Context(ctx context.Context) *PropertiesGoogleAdsLinksCreateCall {
20602 c.ctx_ = ctx
20603 return c
20604 }
20605
20606
20607
20608 func (c *PropertiesGoogleAdsLinksCreateCall) Header() http.Header {
20609 if c.header_ == nil {
20610 c.header_ = make(http.Header)
20611 }
20612 return c.header_
20613 }
20614
20615 func (c *PropertiesGoogleAdsLinksCreateCall) doRequest(alt string) (*http.Response, error) {
20616 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
20617 var body io.Reader = nil
20618 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphagoogleadslink)
20619 if err != nil {
20620 return nil, err
20621 }
20622 c.urlParams_.Set("alt", alt)
20623 c.urlParams_.Set("prettyPrint", "false")
20624 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/googleAdsLinks")
20625 urls += "?" + c.urlParams_.Encode()
20626 req, err := http.NewRequest("POST", urls, body)
20627 if err != nil {
20628 return nil, err
20629 }
20630 req.Header = reqHeaders
20631 googleapi.Expand(req.URL, map[string]string{
20632 "parent": c.parent,
20633 })
20634 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20635 }
20636
20637
20638
20639
20640
20641
20642
20643 func (c *PropertiesGoogleAdsLinksCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaGoogleAdsLink, error) {
20644 gensupport.SetOptions(c.urlParams_, opts...)
20645 res, err := c.doRequest("json")
20646 if res != nil && res.StatusCode == http.StatusNotModified {
20647 if res.Body != nil {
20648 res.Body.Close()
20649 }
20650 return nil, gensupport.WrapError(&googleapi.Error{
20651 Code: res.StatusCode,
20652 Header: res.Header,
20653 })
20654 }
20655 if err != nil {
20656 return nil, err
20657 }
20658 defer googleapi.CloseBody(res)
20659 if err := googleapi.CheckResponse(res); err != nil {
20660 return nil, gensupport.WrapError(err)
20661 }
20662 ret := &GoogleAnalyticsAdminV1alphaGoogleAdsLink{
20663 ServerResponse: googleapi.ServerResponse{
20664 Header: res.Header,
20665 HTTPStatusCode: res.StatusCode,
20666 },
20667 }
20668 target := &ret
20669 if err := gensupport.DecodeResponse(target, res); err != nil {
20670 return nil, err
20671 }
20672 return ret, nil
20673 }
20674
20675 type PropertiesGoogleAdsLinksDeleteCall struct {
20676 s *Service
20677 name string
20678 urlParams_ gensupport.URLParams
20679 ctx_ context.Context
20680 header_ http.Header
20681 }
20682
20683
20684
20685
20686 func (r *PropertiesGoogleAdsLinksService) Delete(name string) *PropertiesGoogleAdsLinksDeleteCall {
20687 c := &PropertiesGoogleAdsLinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20688 c.name = name
20689 return c
20690 }
20691
20692
20693
20694
20695 func (c *PropertiesGoogleAdsLinksDeleteCall) Fields(s ...googleapi.Field) *PropertiesGoogleAdsLinksDeleteCall {
20696 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20697 return c
20698 }
20699
20700
20701 func (c *PropertiesGoogleAdsLinksDeleteCall) Context(ctx context.Context) *PropertiesGoogleAdsLinksDeleteCall {
20702 c.ctx_ = ctx
20703 return c
20704 }
20705
20706
20707
20708 func (c *PropertiesGoogleAdsLinksDeleteCall) Header() http.Header {
20709 if c.header_ == nil {
20710 c.header_ = make(http.Header)
20711 }
20712 return c.header_
20713 }
20714
20715 func (c *PropertiesGoogleAdsLinksDeleteCall) doRequest(alt string) (*http.Response, error) {
20716 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
20717 var body io.Reader = nil
20718 c.urlParams_.Set("alt", alt)
20719 c.urlParams_.Set("prettyPrint", "false")
20720 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
20721 urls += "?" + c.urlParams_.Encode()
20722 req, err := http.NewRequest("DELETE", urls, body)
20723 if err != nil {
20724 return nil, err
20725 }
20726 req.Header = reqHeaders
20727 googleapi.Expand(req.URL, map[string]string{
20728 "name": c.name,
20729 })
20730 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20731 }
20732
20733
20734
20735
20736
20737
20738
20739 func (c *PropertiesGoogleAdsLinksDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
20740 gensupport.SetOptions(c.urlParams_, opts...)
20741 res, err := c.doRequest("json")
20742 if res != nil && res.StatusCode == http.StatusNotModified {
20743 if res.Body != nil {
20744 res.Body.Close()
20745 }
20746 return nil, gensupport.WrapError(&googleapi.Error{
20747 Code: res.StatusCode,
20748 Header: res.Header,
20749 })
20750 }
20751 if err != nil {
20752 return nil, err
20753 }
20754 defer googleapi.CloseBody(res)
20755 if err := googleapi.CheckResponse(res); err != nil {
20756 return nil, gensupport.WrapError(err)
20757 }
20758 ret := &GoogleProtobufEmpty{
20759 ServerResponse: googleapi.ServerResponse{
20760 Header: res.Header,
20761 HTTPStatusCode: res.StatusCode,
20762 },
20763 }
20764 target := &ret
20765 if err := gensupport.DecodeResponse(target, res); err != nil {
20766 return nil, err
20767 }
20768 return ret, nil
20769 }
20770
20771 type PropertiesGoogleAdsLinksListCall struct {
20772 s *Service
20773 parent string
20774 urlParams_ gensupport.URLParams
20775 ifNoneMatch_ string
20776 ctx_ context.Context
20777 header_ http.Header
20778 }
20779
20780
20781
20782
20783 func (r *PropertiesGoogleAdsLinksService) List(parent string) *PropertiesGoogleAdsLinksListCall {
20784 c := &PropertiesGoogleAdsLinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20785 c.parent = parent
20786 return c
20787 }
20788
20789
20790
20791
20792 func (c *PropertiesGoogleAdsLinksListCall) PageSize(pageSize int64) *PropertiesGoogleAdsLinksListCall {
20793 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
20794 return c
20795 }
20796
20797
20798
20799
20800
20801 func (c *PropertiesGoogleAdsLinksListCall) PageToken(pageToken string) *PropertiesGoogleAdsLinksListCall {
20802 c.urlParams_.Set("pageToken", pageToken)
20803 return c
20804 }
20805
20806
20807
20808
20809 func (c *PropertiesGoogleAdsLinksListCall) Fields(s ...googleapi.Field) *PropertiesGoogleAdsLinksListCall {
20810 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20811 return c
20812 }
20813
20814
20815
20816
20817 func (c *PropertiesGoogleAdsLinksListCall) IfNoneMatch(entityTag string) *PropertiesGoogleAdsLinksListCall {
20818 c.ifNoneMatch_ = entityTag
20819 return c
20820 }
20821
20822
20823 func (c *PropertiesGoogleAdsLinksListCall) Context(ctx context.Context) *PropertiesGoogleAdsLinksListCall {
20824 c.ctx_ = ctx
20825 return c
20826 }
20827
20828
20829
20830 func (c *PropertiesGoogleAdsLinksListCall) Header() http.Header {
20831 if c.header_ == nil {
20832 c.header_ = make(http.Header)
20833 }
20834 return c.header_
20835 }
20836
20837 func (c *PropertiesGoogleAdsLinksListCall) doRequest(alt string) (*http.Response, error) {
20838 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
20839 if c.ifNoneMatch_ != "" {
20840 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20841 }
20842 var body io.Reader = nil
20843 c.urlParams_.Set("alt", alt)
20844 c.urlParams_.Set("prettyPrint", "false")
20845 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/googleAdsLinks")
20846 urls += "?" + c.urlParams_.Encode()
20847 req, err := http.NewRequest("GET", urls, body)
20848 if err != nil {
20849 return nil, err
20850 }
20851 req.Header = reqHeaders
20852 googleapi.Expand(req.URL, map[string]string{
20853 "parent": c.parent,
20854 })
20855 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20856 }
20857
20858
20859
20860
20861
20862
20863
20864 func (c *PropertiesGoogleAdsLinksListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListGoogleAdsLinksResponse, error) {
20865 gensupport.SetOptions(c.urlParams_, opts...)
20866 res, err := c.doRequest("json")
20867 if res != nil && res.StatusCode == http.StatusNotModified {
20868 if res.Body != nil {
20869 res.Body.Close()
20870 }
20871 return nil, gensupport.WrapError(&googleapi.Error{
20872 Code: res.StatusCode,
20873 Header: res.Header,
20874 })
20875 }
20876 if err != nil {
20877 return nil, err
20878 }
20879 defer googleapi.CloseBody(res)
20880 if err := googleapi.CheckResponse(res); err != nil {
20881 return nil, gensupport.WrapError(err)
20882 }
20883 ret := &GoogleAnalyticsAdminV1alphaListGoogleAdsLinksResponse{
20884 ServerResponse: googleapi.ServerResponse{
20885 Header: res.Header,
20886 HTTPStatusCode: res.StatusCode,
20887 },
20888 }
20889 target := &ret
20890 if err := gensupport.DecodeResponse(target, res); err != nil {
20891 return nil, err
20892 }
20893 return ret, nil
20894 }
20895
20896
20897
20898
20899 func (c *PropertiesGoogleAdsLinksListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListGoogleAdsLinksResponse) error) error {
20900 c.ctx_ = ctx
20901 defer c.PageToken(c.urlParams_.Get("pageToken"))
20902 for {
20903 x, err := c.Do()
20904 if err != nil {
20905 return err
20906 }
20907 if err := f(x); err != nil {
20908 return err
20909 }
20910 if x.NextPageToken == "" {
20911 return nil
20912 }
20913 c.PageToken(x.NextPageToken)
20914 }
20915 }
20916
20917 type PropertiesGoogleAdsLinksPatchCall struct {
20918 s *Service
20919 name string
20920 googleanalyticsadminv1alphagoogleadslink *GoogleAnalyticsAdminV1alphaGoogleAdsLink
20921 urlParams_ gensupport.URLParams
20922 ctx_ context.Context
20923 header_ http.Header
20924 }
20925
20926
20927
20928
20929
20930
20931 func (r *PropertiesGoogleAdsLinksService) Patch(name string, googleanalyticsadminv1alphagoogleadslink *GoogleAnalyticsAdminV1alphaGoogleAdsLink) *PropertiesGoogleAdsLinksPatchCall {
20932 c := &PropertiesGoogleAdsLinksPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20933 c.name = name
20934 c.googleanalyticsadminv1alphagoogleadslink = googleanalyticsadminv1alphagoogleadslink
20935 return c
20936 }
20937
20938
20939
20940
20941
20942 func (c *PropertiesGoogleAdsLinksPatchCall) UpdateMask(updateMask string) *PropertiesGoogleAdsLinksPatchCall {
20943 c.urlParams_.Set("updateMask", updateMask)
20944 return c
20945 }
20946
20947
20948
20949
20950 func (c *PropertiesGoogleAdsLinksPatchCall) Fields(s ...googleapi.Field) *PropertiesGoogleAdsLinksPatchCall {
20951 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20952 return c
20953 }
20954
20955
20956 func (c *PropertiesGoogleAdsLinksPatchCall) Context(ctx context.Context) *PropertiesGoogleAdsLinksPatchCall {
20957 c.ctx_ = ctx
20958 return c
20959 }
20960
20961
20962
20963 func (c *PropertiesGoogleAdsLinksPatchCall) Header() http.Header {
20964 if c.header_ == nil {
20965 c.header_ = make(http.Header)
20966 }
20967 return c.header_
20968 }
20969
20970 func (c *PropertiesGoogleAdsLinksPatchCall) doRequest(alt string) (*http.Response, error) {
20971 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
20972 var body io.Reader = nil
20973 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphagoogleadslink)
20974 if err != nil {
20975 return nil, err
20976 }
20977 c.urlParams_.Set("alt", alt)
20978 c.urlParams_.Set("prettyPrint", "false")
20979 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
20980 urls += "?" + c.urlParams_.Encode()
20981 req, err := http.NewRequest("PATCH", urls, body)
20982 if err != nil {
20983 return nil, err
20984 }
20985 req.Header = reqHeaders
20986 googleapi.Expand(req.URL, map[string]string{
20987 "name": c.name,
20988 })
20989 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20990 }
20991
20992
20993
20994
20995
20996
20997
20998 func (c *PropertiesGoogleAdsLinksPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaGoogleAdsLink, error) {
20999 gensupport.SetOptions(c.urlParams_, opts...)
21000 res, err := c.doRequest("json")
21001 if res != nil && res.StatusCode == http.StatusNotModified {
21002 if res.Body != nil {
21003 res.Body.Close()
21004 }
21005 return nil, gensupport.WrapError(&googleapi.Error{
21006 Code: res.StatusCode,
21007 Header: res.Header,
21008 })
21009 }
21010 if err != nil {
21011 return nil, err
21012 }
21013 defer googleapi.CloseBody(res)
21014 if err := googleapi.CheckResponse(res); err != nil {
21015 return nil, gensupport.WrapError(err)
21016 }
21017 ret := &GoogleAnalyticsAdminV1alphaGoogleAdsLink{
21018 ServerResponse: googleapi.ServerResponse{
21019 Header: res.Header,
21020 HTTPStatusCode: res.StatusCode,
21021 },
21022 }
21023 target := &ret
21024 if err := gensupport.DecodeResponse(target, res); err != nil {
21025 return nil, err
21026 }
21027 return ret, nil
21028 }
21029
21030 type PropertiesKeyEventsCreateCall struct {
21031 s *Service
21032 parent string
21033 googleanalyticsadminv1alphakeyevent *GoogleAnalyticsAdminV1alphaKeyEvent
21034 urlParams_ gensupport.URLParams
21035 ctx_ context.Context
21036 header_ http.Header
21037 }
21038
21039
21040
21041
21042
21043 func (r *PropertiesKeyEventsService) Create(parent string, googleanalyticsadminv1alphakeyevent *GoogleAnalyticsAdminV1alphaKeyEvent) *PropertiesKeyEventsCreateCall {
21044 c := &PropertiesKeyEventsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21045 c.parent = parent
21046 c.googleanalyticsadminv1alphakeyevent = googleanalyticsadminv1alphakeyevent
21047 return c
21048 }
21049
21050
21051
21052
21053 func (c *PropertiesKeyEventsCreateCall) Fields(s ...googleapi.Field) *PropertiesKeyEventsCreateCall {
21054 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21055 return c
21056 }
21057
21058
21059 func (c *PropertiesKeyEventsCreateCall) Context(ctx context.Context) *PropertiesKeyEventsCreateCall {
21060 c.ctx_ = ctx
21061 return c
21062 }
21063
21064
21065
21066 func (c *PropertiesKeyEventsCreateCall) Header() http.Header {
21067 if c.header_ == nil {
21068 c.header_ = make(http.Header)
21069 }
21070 return c.header_
21071 }
21072
21073 func (c *PropertiesKeyEventsCreateCall) doRequest(alt string) (*http.Response, error) {
21074 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
21075 var body io.Reader = nil
21076 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphakeyevent)
21077 if err != nil {
21078 return nil, err
21079 }
21080 c.urlParams_.Set("alt", alt)
21081 c.urlParams_.Set("prettyPrint", "false")
21082 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/keyEvents")
21083 urls += "?" + c.urlParams_.Encode()
21084 req, err := http.NewRequest("POST", urls, body)
21085 if err != nil {
21086 return nil, err
21087 }
21088 req.Header = reqHeaders
21089 googleapi.Expand(req.URL, map[string]string{
21090 "parent": c.parent,
21091 })
21092 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21093 }
21094
21095
21096
21097
21098
21099
21100
21101 func (c *PropertiesKeyEventsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaKeyEvent, error) {
21102 gensupport.SetOptions(c.urlParams_, opts...)
21103 res, err := c.doRequest("json")
21104 if res != nil && res.StatusCode == http.StatusNotModified {
21105 if res.Body != nil {
21106 res.Body.Close()
21107 }
21108 return nil, gensupport.WrapError(&googleapi.Error{
21109 Code: res.StatusCode,
21110 Header: res.Header,
21111 })
21112 }
21113 if err != nil {
21114 return nil, err
21115 }
21116 defer googleapi.CloseBody(res)
21117 if err := googleapi.CheckResponse(res); err != nil {
21118 return nil, gensupport.WrapError(err)
21119 }
21120 ret := &GoogleAnalyticsAdminV1alphaKeyEvent{
21121 ServerResponse: googleapi.ServerResponse{
21122 Header: res.Header,
21123 HTTPStatusCode: res.StatusCode,
21124 },
21125 }
21126 target := &ret
21127 if err := gensupport.DecodeResponse(target, res); err != nil {
21128 return nil, err
21129 }
21130 return ret, nil
21131 }
21132
21133 type PropertiesKeyEventsDeleteCall struct {
21134 s *Service
21135 name string
21136 urlParams_ gensupport.URLParams
21137 ctx_ context.Context
21138 header_ http.Header
21139 }
21140
21141
21142
21143
21144
21145
21146 func (r *PropertiesKeyEventsService) Delete(name string) *PropertiesKeyEventsDeleteCall {
21147 c := &PropertiesKeyEventsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21148 c.name = name
21149 return c
21150 }
21151
21152
21153
21154
21155 func (c *PropertiesKeyEventsDeleteCall) Fields(s ...googleapi.Field) *PropertiesKeyEventsDeleteCall {
21156 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21157 return c
21158 }
21159
21160
21161 func (c *PropertiesKeyEventsDeleteCall) Context(ctx context.Context) *PropertiesKeyEventsDeleteCall {
21162 c.ctx_ = ctx
21163 return c
21164 }
21165
21166
21167
21168 func (c *PropertiesKeyEventsDeleteCall) Header() http.Header {
21169 if c.header_ == nil {
21170 c.header_ = make(http.Header)
21171 }
21172 return c.header_
21173 }
21174
21175 func (c *PropertiesKeyEventsDeleteCall) doRequest(alt string) (*http.Response, error) {
21176 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
21177 var body io.Reader = nil
21178 c.urlParams_.Set("alt", alt)
21179 c.urlParams_.Set("prettyPrint", "false")
21180 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
21181 urls += "?" + c.urlParams_.Encode()
21182 req, err := http.NewRequest("DELETE", urls, body)
21183 if err != nil {
21184 return nil, err
21185 }
21186 req.Header = reqHeaders
21187 googleapi.Expand(req.URL, map[string]string{
21188 "name": c.name,
21189 })
21190 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21191 }
21192
21193
21194
21195
21196
21197
21198
21199 func (c *PropertiesKeyEventsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
21200 gensupport.SetOptions(c.urlParams_, opts...)
21201 res, err := c.doRequest("json")
21202 if res != nil && res.StatusCode == http.StatusNotModified {
21203 if res.Body != nil {
21204 res.Body.Close()
21205 }
21206 return nil, gensupport.WrapError(&googleapi.Error{
21207 Code: res.StatusCode,
21208 Header: res.Header,
21209 })
21210 }
21211 if err != nil {
21212 return nil, err
21213 }
21214 defer googleapi.CloseBody(res)
21215 if err := googleapi.CheckResponse(res); err != nil {
21216 return nil, gensupport.WrapError(err)
21217 }
21218 ret := &GoogleProtobufEmpty{
21219 ServerResponse: googleapi.ServerResponse{
21220 Header: res.Header,
21221 HTTPStatusCode: res.StatusCode,
21222 },
21223 }
21224 target := &ret
21225 if err := gensupport.DecodeResponse(target, res); err != nil {
21226 return nil, err
21227 }
21228 return ret, nil
21229 }
21230
21231 type PropertiesKeyEventsGetCall struct {
21232 s *Service
21233 name string
21234 urlParams_ gensupport.URLParams
21235 ifNoneMatch_ string
21236 ctx_ context.Context
21237 header_ http.Header
21238 }
21239
21240
21241
21242
21243
21244
21245 func (r *PropertiesKeyEventsService) Get(name string) *PropertiesKeyEventsGetCall {
21246 c := &PropertiesKeyEventsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21247 c.name = name
21248 return c
21249 }
21250
21251
21252
21253
21254 func (c *PropertiesKeyEventsGetCall) Fields(s ...googleapi.Field) *PropertiesKeyEventsGetCall {
21255 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21256 return c
21257 }
21258
21259
21260
21261
21262 func (c *PropertiesKeyEventsGetCall) IfNoneMatch(entityTag string) *PropertiesKeyEventsGetCall {
21263 c.ifNoneMatch_ = entityTag
21264 return c
21265 }
21266
21267
21268 func (c *PropertiesKeyEventsGetCall) Context(ctx context.Context) *PropertiesKeyEventsGetCall {
21269 c.ctx_ = ctx
21270 return c
21271 }
21272
21273
21274
21275 func (c *PropertiesKeyEventsGetCall) Header() http.Header {
21276 if c.header_ == nil {
21277 c.header_ = make(http.Header)
21278 }
21279 return c.header_
21280 }
21281
21282 func (c *PropertiesKeyEventsGetCall) doRequest(alt string) (*http.Response, error) {
21283 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
21284 if c.ifNoneMatch_ != "" {
21285 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
21286 }
21287 var body io.Reader = nil
21288 c.urlParams_.Set("alt", alt)
21289 c.urlParams_.Set("prettyPrint", "false")
21290 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
21291 urls += "?" + c.urlParams_.Encode()
21292 req, err := http.NewRequest("GET", urls, body)
21293 if err != nil {
21294 return nil, err
21295 }
21296 req.Header = reqHeaders
21297 googleapi.Expand(req.URL, map[string]string{
21298 "name": c.name,
21299 })
21300 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21301 }
21302
21303
21304
21305
21306
21307
21308
21309 func (c *PropertiesKeyEventsGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaKeyEvent, error) {
21310 gensupport.SetOptions(c.urlParams_, opts...)
21311 res, err := c.doRequest("json")
21312 if res != nil && res.StatusCode == http.StatusNotModified {
21313 if res.Body != nil {
21314 res.Body.Close()
21315 }
21316 return nil, gensupport.WrapError(&googleapi.Error{
21317 Code: res.StatusCode,
21318 Header: res.Header,
21319 })
21320 }
21321 if err != nil {
21322 return nil, err
21323 }
21324 defer googleapi.CloseBody(res)
21325 if err := googleapi.CheckResponse(res); err != nil {
21326 return nil, gensupport.WrapError(err)
21327 }
21328 ret := &GoogleAnalyticsAdminV1alphaKeyEvent{
21329 ServerResponse: googleapi.ServerResponse{
21330 Header: res.Header,
21331 HTTPStatusCode: res.StatusCode,
21332 },
21333 }
21334 target := &ret
21335 if err := gensupport.DecodeResponse(target, res); err != nil {
21336 return nil, err
21337 }
21338 return ret, nil
21339 }
21340
21341 type PropertiesKeyEventsListCall struct {
21342 s *Service
21343 parent string
21344 urlParams_ gensupport.URLParams
21345 ifNoneMatch_ string
21346 ctx_ context.Context
21347 header_ http.Header
21348 }
21349
21350
21351
21352
21353
21354
21355 func (r *PropertiesKeyEventsService) List(parent string) *PropertiesKeyEventsListCall {
21356 c := &PropertiesKeyEventsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21357 c.parent = parent
21358 return c
21359 }
21360
21361
21362
21363
21364 func (c *PropertiesKeyEventsListCall) PageSize(pageSize int64) *PropertiesKeyEventsListCall {
21365 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
21366 return c
21367 }
21368
21369
21370
21371
21372
21373 func (c *PropertiesKeyEventsListCall) PageToken(pageToken string) *PropertiesKeyEventsListCall {
21374 c.urlParams_.Set("pageToken", pageToken)
21375 return c
21376 }
21377
21378
21379
21380
21381 func (c *PropertiesKeyEventsListCall) Fields(s ...googleapi.Field) *PropertiesKeyEventsListCall {
21382 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21383 return c
21384 }
21385
21386
21387
21388
21389 func (c *PropertiesKeyEventsListCall) IfNoneMatch(entityTag string) *PropertiesKeyEventsListCall {
21390 c.ifNoneMatch_ = entityTag
21391 return c
21392 }
21393
21394
21395 func (c *PropertiesKeyEventsListCall) Context(ctx context.Context) *PropertiesKeyEventsListCall {
21396 c.ctx_ = ctx
21397 return c
21398 }
21399
21400
21401
21402 func (c *PropertiesKeyEventsListCall) Header() http.Header {
21403 if c.header_ == nil {
21404 c.header_ = make(http.Header)
21405 }
21406 return c.header_
21407 }
21408
21409 func (c *PropertiesKeyEventsListCall) doRequest(alt string) (*http.Response, error) {
21410 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
21411 if c.ifNoneMatch_ != "" {
21412 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
21413 }
21414 var body io.Reader = nil
21415 c.urlParams_.Set("alt", alt)
21416 c.urlParams_.Set("prettyPrint", "false")
21417 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/keyEvents")
21418 urls += "?" + c.urlParams_.Encode()
21419 req, err := http.NewRequest("GET", urls, body)
21420 if err != nil {
21421 return nil, err
21422 }
21423 req.Header = reqHeaders
21424 googleapi.Expand(req.URL, map[string]string{
21425 "parent": c.parent,
21426 })
21427 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21428 }
21429
21430
21431
21432
21433
21434
21435
21436 func (c *PropertiesKeyEventsListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListKeyEventsResponse, error) {
21437 gensupport.SetOptions(c.urlParams_, opts...)
21438 res, err := c.doRequest("json")
21439 if res != nil && res.StatusCode == http.StatusNotModified {
21440 if res.Body != nil {
21441 res.Body.Close()
21442 }
21443 return nil, gensupport.WrapError(&googleapi.Error{
21444 Code: res.StatusCode,
21445 Header: res.Header,
21446 })
21447 }
21448 if err != nil {
21449 return nil, err
21450 }
21451 defer googleapi.CloseBody(res)
21452 if err := googleapi.CheckResponse(res); err != nil {
21453 return nil, gensupport.WrapError(err)
21454 }
21455 ret := &GoogleAnalyticsAdminV1alphaListKeyEventsResponse{
21456 ServerResponse: googleapi.ServerResponse{
21457 Header: res.Header,
21458 HTTPStatusCode: res.StatusCode,
21459 },
21460 }
21461 target := &ret
21462 if err := gensupport.DecodeResponse(target, res); err != nil {
21463 return nil, err
21464 }
21465 return ret, nil
21466 }
21467
21468
21469
21470
21471 func (c *PropertiesKeyEventsListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListKeyEventsResponse) error) error {
21472 c.ctx_ = ctx
21473 defer c.PageToken(c.urlParams_.Get("pageToken"))
21474 for {
21475 x, err := c.Do()
21476 if err != nil {
21477 return err
21478 }
21479 if err := f(x); err != nil {
21480 return err
21481 }
21482 if x.NextPageToken == "" {
21483 return nil
21484 }
21485 c.PageToken(x.NextPageToken)
21486 }
21487 }
21488
21489 type PropertiesKeyEventsPatchCall struct {
21490 s *Service
21491 name string
21492 googleanalyticsadminv1alphakeyevent *GoogleAnalyticsAdminV1alphaKeyEvent
21493 urlParams_ gensupport.URLParams
21494 ctx_ context.Context
21495 header_ http.Header
21496 }
21497
21498
21499
21500
21501
21502 func (r *PropertiesKeyEventsService) Patch(name string, googleanalyticsadminv1alphakeyevent *GoogleAnalyticsAdminV1alphaKeyEvent) *PropertiesKeyEventsPatchCall {
21503 c := &PropertiesKeyEventsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21504 c.name = name
21505 c.googleanalyticsadminv1alphakeyevent = googleanalyticsadminv1alphakeyevent
21506 return c
21507 }
21508
21509
21510
21511
21512
21513 func (c *PropertiesKeyEventsPatchCall) UpdateMask(updateMask string) *PropertiesKeyEventsPatchCall {
21514 c.urlParams_.Set("updateMask", updateMask)
21515 return c
21516 }
21517
21518
21519
21520
21521 func (c *PropertiesKeyEventsPatchCall) Fields(s ...googleapi.Field) *PropertiesKeyEventsPatchCall {
21522 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21523 return c
21524 }
21525
21526
21527 func (c *PropertiesKeyEventsPatchCall) Context(ctx context.Context) *PropertiesKeyEventsPatchCall {
21528 c.ctx_ = ctx
21529 return c
21530 }
21531
21532
21533
21534 func (c *PropertiesKeyEventsPatchCall) Header() http.Header {
21535 if c.header_ == nil {
21536 c.header_ = make(http.Header)
21537 }
21538 return c.header_
21539 }
21540
21541 func (c *PropertiesKeyEventsPatchCall) doRequest(alt string) (*http.Response, error) {
21542 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
21543 var body io.Reader = nil
21544 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphakeyevent)
21545 if err != nil {
21546 return nil, err
21547 }
21548 c.urlParams_.Set("alt", alt)
21549 c.urlParams_.Set("prettyPrint", "false")
21550 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
21551 urls += "?" + c.urlParams_.Encode()
21552 req, err := http.NewRequest("PATCH", urls, body)
21553 if err != nil {
21554 return nil, err
21555 }
21556 req.Header = reqHeaders
21557 googleapi.Expand(req.URL, map[string]string{
21558 "name": c.name,
21559 })
21560 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21561 }
21562
21563
21564
21565
21566
21567
21568
21569 func (c *PropertiesKeyEventsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaKeyEvent, error) {
21570 gensupport.SetOptions(c.urlParams_, opts...)
21571 res, err := c.doRequest("json")
21572 if res != nil && res.StatusCode == http.StatusNotModified {
21573 if res.Body != nil {
21574 res.Body.Close()
21575 }
21576 return nil, gensupport.WrapError(&googleapi.Error{
21577 Code: res.StatusCode,
21578 Header: res.Header,
21579 })
21580 }
21581 if err != nil {
21582 return nil, err
21583 }
21584 defer googleapi.CloseBody(res)
21585 if err := googleapi.CheckResponse(res); err != nil {
21586 return nil, gensupport.WrapError(err)
21587 }
21588 ret := &GoogleAnalyticsAdminV1alphaKeyEvent{
21589 ServerResponse: googleapi.ServerResponse{
21590 Header: res.Header,
21591 HTTPStatusCode: res.StatusCode,
21592 },
21593 }
21594 target := &ret
21595 if err := gensupport.DecodeResponse(target, res); err != nil {
21596 return nil, err
21597 }
21598 return ret, nil
21599 }
21600
21601 type PropertiesRollupPropertySourceLinksCreateCall struct {
21602 s *Service
21603 parent string
21604 googleanalyticsadminv1alpharolluppropertysourcelink *GoogleAnalyticsAdminV1alphaRollupPropertySourceLink
21605 urlParams_ gensupport.URLParams
21606 ctx_ context.Context
21607 header_ http.Header
21608 }
21609
21610
21611
21612
21613
21614
21615 func (r *PropertiesRollupPropertySourceLinksService) Create(parent string, googleanalyticsadminv1alpharolluppropertysourcelink *GoogleAnalyticsAdminV1alphaRollupPropertySourceLink) *PropertiesRollupPropertySourceLinksCreateCall {
21616 c := &PropertiesRollupPropertySourceLinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21617 c.parent = parent
21618 c.googleanalyticsadminv1alpharolluppropertysourcelink = googleanalyticsadminv1alpharolluppropertysourcelink
21619 return c
21620 }
21621
21622
21623
21624
21625 func (c *PropertiesRollupPropertySourceLinksCreateCall) Fields(s ...googleapi.Field) *PropertiesRollupPropertySourceLinksCreateCall {
21626 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21627 return c
21628 }
21629
21630
21631 func (c *PropertiesRollupPropertySourceLinksCreateCall) Context(ctx context.Context) *PropertiesRollupPropertySourceLinksCreateCall {
21632 c.ctx_ = ctx
21633 return c
21634 }
21635
21636
21637
21638 func (c *PropertiesRollupPropertySourceLinksCreateCall) Header() http.Header {
21639 if c.header_ == nil {
21640 c.header_ = make(http.Header)
21641 }
21642 return c.header_
21643 }
21644
21645 func (c *PropertiesRollupPropertySourceLinksCreateCall) doRequest(alt string) (*http.Response, error) {
21646 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
21647 var body io.Reader = nil
21648 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alpharolluppropertysourcelink)
21649 if err != nil {
21650 return nil, err
21651 }
21652 c.urlParams_.Set("alt", alt)
21653 c.urlParams_.Set("prettyPrint", "false")
21654 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/rollupPropertySourceLinks")
21655 urls += "?" + c.urlParams_.Encode()
21656 req, err := http.NewRequest("POST", urls, body)
21657 if err != nil {
21658 return nil, err
21659 }
21660 req.Header = reqHeaders
21661 googleapi.Expand(req.URL, map[string]string{
21662 "parent": c.parent,
21663 })
21664 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21665 }
21666
21667
21668
21669
21670
21671
21672
21673 func (c *PropertiesRollupPropertySourceLinksCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaRollupPropertySourceLink, error) {
21674 gensupport.SetOptions(c.urlParams_, opts...)
21675 res, err := c.doRequest("json")
21676 if res != nil && res.StatusCode == http.StatusNotModified {
21677 if res.Body != nil {
21678 res.Body.Close()
21679 }
21680 return nil, gensupport.WrapError(&googleapi.Error{
21681 Code: res.StatusCode,
21682 Header: res.Header,
21683 })
21684 }
21685 if err != nil {
21686 return nil, err
21687 }
21688 defer googleapi.CloseBody(res)
21689 if err := googleapi.CheckResponse(res); err != nil {
21690 return nil, gensupport.WrapError(err)
21691 }
21692 ret := &GoogleAnalyticsAdminV1alphaRollupPropertySourceLink{
21693 ServerResponse: googleapi.ServerResponse{
21694 Header: res.Header,
21695 HTTPStatusCode: res.StatusCode,
21696 },
21697 }
21698 target := &ret
21699 if err := gensupport.DecodeResponse(target, res); err != nil {
21700 return nil, err
21701 }
21702 return ret, nil
21703 }
21704
21705 type PropertiesRollupPropertySourceLinksDeleteCall struct {
21706 s *Service
21707 name string
21708 urlParams_ gensupport.URLParams
21709 ctx_ context.Context
21710 header_ http.Header
21711 }
21712
21713
21714
21715
21716
21717
21718
21719
21720 func (r *PropertiesRollupPropertySourceLinksService) Delete(name string) *PropertiesRollupPropertySourceLinksDeleteCall {
21721 c := &PropertiesRollupPropertySourceLinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21722 c.name = name
21723 return c
21724 }
21725
21726
21727
21728
21729 func (c *PropertiesRollupPropertySourceLinksDeleteCall) Fields(s ...googleapi.Field) *PropertiesRollupPropertySourceLinksDeleteCall {
21730 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21731 return c
21732 }
21733
21734
21735 func (c *PropertiesRollupPropertySourceLinksDeleteCall) Context(ctx context.Context) *PropertiesRollupPropertySourceLinksDeleteCall {
21736 c.ctx_ = ctx
21737 return c
21738 }
21739
21740
21741
21742 func (c *PropertiesRollupPropertySourceLinksDeleteCall) Header() http.Header {
21743 if c.header_ == nil {
21744 c.header_ = make(http.Header)
21745 }
21746 return c.header_
21747 }
21748
21749 func (c *PropertiesRollupPropertySourceLinksDeleteCall) doRequest(alt string) (*http.Response, error) {
21750 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
21751 var body io.Reader = nil
21752 c.urlParams_.Set("alt", alt)
21753 c.urlParams_.Set("prettyPrint", "false")
21754 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
21755 urls += "?" + c.urlParams_.Encode()
21756 req, err := http.NewRequest("DELETE", urls, body)
21757 if err != nil {
21758 return nil, err
21759 }
21760 req.Header = reqHeaders
21761 googleapi.Expand(req.URL, map[string]string{
21762 "name": c.name,
21763 })
21764 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21765 }
21766
21767
21768
21769
21770
21771
21772
21773 func (c *PropertiesRollupPropertySourceLinksDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
21774 gensupport.SetOptions(c.urlParams_, opts...)
21775 res, err := c.doRequest("json")
21776 if res != nil && res.StatusCode == http.StatusNotModified {
21777 if res.Body != nil {
21778 res.Body.Close()
21779 }
21780 return nil, gensupport.WrapError(&googleapi.Error{
21781 Code: res.StatusCode,
21782 Header: res.Header,
21783 })
21784 }
21785 if err != nil {
21786 return nil, err
21787 }
21788 defer googleapi.CloseBody(res)
21789 if err := googleapi.CheckResponse(res); err != nil {
21790 return nil, gensupport.WrapError(err)
21791 }
21792 ret := &GoogleProtobufEmpty{
21793 ServerResponse: googleapi.ServerResponse{
21794 Header: res.Header,
21795 HTTPStatusCode: res.StatusCode,
21796 },
21797 }
21798 target := &ret
21799 if err := gensupport.DecodeResponse(target, res); err != nil {
21800 return nil, err
21801 }
21802 return ret, nil
21803 }
21804
21805 type PropertiesRollupPropertySourceLinksGetCall struct {
21806 s *Service
21807 name string
21808 urlParams_ gensupport.URLParams
21809 ifNoneMatch_ string
21810 ctx_ context.Context
21811 header_ http.Header
21812 }
21813
21814
21815
21816
21817
21818
21819
21820
21821 func (r *PropertiesRollupPropertySourceLinksService) Get(name string) *PropertiesRollupPropertySourceLinksGetCall {
21822 c := &PropertiesRollupPropertySourceLinksGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21823 c.name = name
21824 return c
21825 }
21826
21827
21828
21829
21830 func (c *PropertiesRollupPropertySourceLinksGetCall) Fields(s ...googleapi.Field) *PropertiesRollupPropertySourceLinksGetCall {
21831 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21832 return c
21833 }
21834
21835
21836
21837
21838 func (c *PropertiesRollupPropertySourceLinksGetCall) IfNoneMatch(entityTag string) *PropertiesRollupPropertySourceLinksGetCall {
21839 c.ifNoneMatch_ = entityTag
21840 return c
21841 }
21842
21843
21844 func (c *PropertiesRollupPropertySourceLinksGetCall) Context(ctx context.Context) *PropertiesRollupPropertySourceLinksGetCall {
21845 c.ctx_ = ctx
21846 return c
21847 }
21848
21849
21850
21851 func (c *PropertiesRollupPropertySourceLinksGetCall) Header() http.Header {
21852 if c.header_ == nil {
21853 c.header_ = make(http.Header)
21854 }
21855 return c.header_
21856 }
21857
21858 func (c *PropertiesRollupPropertySourceLinksGetCall) doRequest(alt string) (*http.Response, error) {
21859 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
21860 if c.ifNoneMatch_ != "" {
21861 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
21862 }
21863 var body io.Reader = nil
21864 c.urlParams_.Set("alt", alt)
21865 c.urlParams_.Set("prettyPrint", "false")
21866 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
21867 urls += "?" + c.urlParams_.Encode()
21868 req, err := http.NewRequest("GET", urls, body)
21869 if err != nil {
21870 return nil, err
21871 }
21872 req.Header = reqHeaders
21873 googleapi.Expand(req.URL, map[string]string{
21874 "name": c.name,
21875 })
21876 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21877 }
21878
21879
21880
21881
21882
21883
21884
21885 func (c *PropertiesRollupPropertySourceLinksGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaRollupPropertySourceLink, error) {
21886 gensupport.SetOptions(c.urlParams_, opts...)
21887 res, err := c.doRequest("json")
21888 if res != nil && res.StatusCode == http.StatusNotModified {
21889 if res.Body != nil {
21890 res.Body.Close()
21891 }
21892 return nil, gensupport.WrapError(&googleapi.Error{
21893 Code: res.StatusCode,
21894 Header: res.Header,
21895 })
21896 }
21897 if err != nil {
21898 return nil, err
21899 }
21900 defer googleapi.CloseBody(res)
21901 if err := googleapi.CheckResponse(res); err != nil {
21902 return nil, gensupport.WrapError(err)
21903 }
21904 ret := &GoogleAnalyticsAdminV1alphaRollupPropertySourceLink{
21905 ServerResponse: googleapi.ServerResponse{
21906 Header: res.Header,
21907 HTTPStatusCode: res.StatusCode,
21908 },
21909 }
21910 target := &ret
21911 if err := gensupport.DecodeResponse(target, res); err != nil {
21912 return nil, err
21913 }
21914 return ret, nil
21915 }
21916
21917 type PropertiesRollupPropertySourceLinksListCall struct {
21918 s *Service
21919 parent string
21920 urlParams_ gensupport.URLParams
21921 ifNoneMatch_ string
21922 ctx_ context.Context
21923 header_ http.Header
21924 }
21925
21926
21927
21928
21929
21930
21931
21932 func (r *PropertiesRollupPropertySourceLinksService) List(parent string) *PropertiesRollupPropertySourceLinksListCall {
21933 c := &PropertiesRollupPropertySourceLinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21934 c.parent = parent
21935 return c
21936 }
21937
21938
21939
21940
21941
21942
21943 func (c *PropertiesRollupPropertySourceLinksListCall) PageSize(pageSize int64) *PropertiesRollupPropertySourceLinksListCall {
21944 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
21945 return c
21946 }
21947
21948
21949
21950
21951
21952
21953 func (c *PropertiesRollupPropertySourceLinksListCall) PageToken(pageToken string) *PropertiesRollupPropertySourceLinksListCall {
21954 c.urlParams_.Set("pageToken", pageToken)
21955 return c
21956 }
21957
21958
21959
21960
21961 func (c *PropertiesRollupPropertySourceLinksListCall) Fields(s ...googleapi.Field) *PropertiesRollupPropertySourceLinksListCall {
21962 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21963 return c
21964 }
21965
21966
21967
21968
21969 func (c *PropertiesRollupPropertySourceLinksListCall) IfNoneMatch(entityTag string) *PropertiesRollupPropertySourceLinksListCall {
21970 c.ifNoneMatch_ = entityTag
21971 return c
21972 }
21973
21974
21975 func (c *PropertiesRollupPropertySourceLinksListCall) Context(ctx context.Context) *PropertiesRollupPropertySourceLinksListCall {
21976 c.ctx_ = ctx
21977 return c
21978 }
21979
21980
21981
21982 func (c *PropertiesRollupPropertySourceLinksListCall) Header() http.Header {
21983 if c.header_ == nil {
21984 c.header_ = make(http.Header)
21985 }
21986 return c.header_
21987 }
21988
21989 func (c *PropertiesRollupPropertySourceLinksListCall) doRequest(alt string) (*http.Response, error) {
21990 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
21991 if c.ifNoneMatch_ != "" {
21992 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
21993 }
21994 var body io.Reader = nil
21995 c.urlParams_.Set("alt", alt)
21996 c.urlParams_.Set("prettyPrint", "false")
21997 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/rollupPropertySourceLinks")
21998 urls += "?" + c.urlParams_.Encode()
21999 req, err := http.NewRequest("GET", urls, body)
22000 if err != nil {
22001 return nil, err
22002 }
22003 req.Header = reqHeaders
22004 googleapi.Expand(req.URL, map[string]string{
22005 "parent": c.parent,
22006 })
22007 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22008 }
22009
22010
22011
22012
22013
22014
22015
22016 func (c *PropertiesRollupPropertySourceLinksListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListRollupPropertySourceLinksResponse, error) {
22017 gensupport.SetOptions(c.urlParams_, opts...)
22018 res, err := c.doRequest("json")
22019 if res != nil && res.StatusCode == http.StatusNotModified {
22020 if res.Body != nil {
22021 res.Body.Close()
22022 }
22023 return nil, gensupport.WrapError(&googleapi.Error{
22024 Code: res.StatusCode,
22025 Header: res.Header,
22026 })
22027 }
22028 if err != nil {
22029 return nil, err
22030 }
22031 defer googleapi.CloseBody(res)
22032 if err := googleapi.CheckResponse(res); err != nil {
22033 return nil, gensupport.WrapError(err)
22034 }
22035 ret := &GoogleAnalyticsAdminV1alphaListRollupPropertySourceLinksResponse{
22036 ServerResponse: googleapi.ServerResponse{
22037 Header: res.Header,
22038 HTTPStatusCode: res.StatusCode,
22039 },
22040 }
22041 target := &ret
22042 if err := gensupport.DecodeResponse(target, res); err != nil {
22043 return nil, err
22044 }
22045 return ret, nil
22046 }
22047
22048
22049
22050
22051 func (c *PropertiesRollupPropertySourceLinksListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListRollupPropertySourceLinksResponse) error) error {
22052 c.ctx_ = ctx
22053 defer c.PageToken(c.urlParams_.Get("pageToken"))
22054 for {
22055 x, err := c.Do()
22056 if err != nil {
22057 return err
22058 }
22059 if err := f(x); err != nil {
22060 return err
22061 }
22062 if x.NextPageToken == "" {
22063 return nil
22064 }
22065 c.PageToken(x.NextPageToken)
22066 }
22067 }
22068
22069 type PropertiesSearchAds360LinksCreateCall struct {
22070 s *Service
22071 parent string
22072 googleanalyticsadminv1alphasearchads360link *GoogleAnalyticsAdminV1alphaSearchAds360Link
22073 urlParams_ gensupport.URLParams
22074 ctx_ context.Context
22075 header_ http.Header
22076 }
22077
22078
22079
22080
22081 func (r *PropertiesSearchAds360LinksService) Create(parent string, googleanalyticsadminv1alphasearchads360link *GoogleAnalyticsAdminV1alphaSearchAds360Link) *PropertiesSearchAds360LinksCreateCall {
22082 c := &PropertiesSearchAds360LinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22083 c.parent = parent
22084 c.googleanalyticsadminv1alphasearchads360link = googleanalyticsadminv1alphasearchads360link
22085 return c
22086 }
22087
22088
22089
22090
22091 func (c *PropertiesSearchAds360LinksCreateCall) Fields(s ...googleapi.Field) *PropertiesSearchAds360LinksCreateCall {
22092 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22093 return c
22094 }
22095
22096
22097 func (c *PropertiesSearchAds360LinksCreateCall) Context(ctx context.Context) *PropertiesSearchAds360LinksCreateCall {
22098 c.ctx_ = ctx
22099 return c
22100 }
22101
22102
22103
22104 func (c *PropertiesSearchAds360LinksCreateCall) Header() http.Header {
22105 if c.header_ == nil {
22106 c.header_ = make(http.Header)
22107 }
22108 return c.header_
22109 }
22110
22111 func (c *PropertiesSearchAds360LinksCreateCall) doRequest(alt string) (*http.Response, error) {
22112 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
22113 var body io.Reader = nil
22114 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphasearchads360link)
22115 if err != nil {
22116 return nil, err
22117 }
22118 c.urlParams_.Set("alt", alt)
22119 c.urlParams_.Set("prettyPrint", "false")
22120 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/searchAds360Links")
22121 urls += "?" + c.urlParams_.Encode()
22122 req, err := http.NewRequest("POST", urls, body)
22123 if err != nil {
22124 return nil, err
22125 }
22126 req.Header = reqHeaders
22127 googleapi.Expand(req.URL, map[string]string{
22128 "parent": c.parent,
22129 })
22130 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22131 }
22132
22133
22134
22135
22136
22137
22138
22139 func (c *PropertiesSearchAds360LinksCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSearchAds360Link, error) {
22140 gensupport.SetOptions(c.urlParams_, opts...)
22141 res, err := c.doRequest("json")
22142 if res != nil && res.StatusCode == http.StatusNotModified {
22143 if res.Body != nil {
22144 res.Body.Close()
22145 }
22146 return nil, gensupport.WrapError(&googleapi.Error{
22147 Code: res.StatusCode,
22148 Header: res.Header,
22149 })
22150 }
22151 if err != nil {
22152 return nil, err
22153 }
22154 defer googleapi.CloseBody(res)
22155 if err := googleapi.CheckResponse(res); err != nil {
22156 return nil, gensupport.WrapError(err)
22157 }
22158 ret := &GoogleAnalyticsAdminV1alphaSearchAds360Link{
22159 ServerResponse: googleapi.ServerResponse{
22160 Header: res.Header,
22161 HTTPStatusCode: res.StatusCode,
22162 },
22163 }
22164 target := &ret
22165 if err := gensupport.DecodeResponse(target, res); err != nil {
22166 return nil, err
22167 }
22168 return ret, nil
22169 }
22170
22171 type PropertiesSearchAds360LinksDeleteCall struct {
22172 s *Service
22173 name string
22174 urlParams_ gensupport.URLParams
22175 ctx_ context.Context
22176 header_ http.Header
22177 }
22178
22179
22180
22181
22182
22183 func (r *PropertiesSearchAds360LinksService) Delete(name string) *PropertiesSearchAds360LinksDeleteCall {
22184 c := &PropertiesSearchAds360LinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22185 c.name = name
22186 return c
22187 }
22188
22189
22190
22191
22192 func (c *PropertiesSearchAds360LinksDeleteCall) Fields(s ...googleapi.Field) *PropertiesSearchAds360LinksDeleteCall {
22193 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22194 return c
22195 }
22196
22197
22198 func (c *PropertiesSearchAds360LinksDeleteCall) Context(ctx context.Context) *PropertiesSearchAds360LinksDeleteCall {
22199 c.ctx_ = ctx
22200 return c
22201 }
22202
22203
22204
22205 func (c *PropertiesSearchAds360LinksDeleteCall) Header() http.Header {
22206 if c.header_ == nil {
22207 c.header_ = make(http.Header)
22208 }
22209 return c.header_
22210 }
22211
22212 func (c *PropertiesSearchAds360LinksDeleteCall) doRequest(alt string) (*http.Response, error) {
22213 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
22214 var body io.Reader = nil
22215 c.urlParams_.Set("alt", alt)
22216 c.urlParams_.Set("prettyPrint", "false")
22217 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
22218 urls += "?" + c.urlParams_.Encode()
22219 req, err := http.NewRequest("DELETE", urls, body)
22220 if err != nil {
22221 return nil, err
22222 }
22223 req.Header = reqHeaders
22224 googleapi.Expand(req.URL, map[string]string{
22225 "name": c.name,
22226 })
22227 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22228 }
22229
22230
22231
22232
22233
22234
22235
22236 func (c *PropertiesSearchAds360LinksDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
22237 gensupport.SetOptions(c.urlParams_, opts...)
22238 res, err := c.doRequest("json")
22239 if res != nil && res.StatusCode == http.StatusNotModified {
22240 if res.Body != nil {
22241 res.Body.Close()
22242 }
22243 return nil, gensupport.WrapError(&googleapi.Error{
22244 Code: res.StatusCode,
22245 Header: res.Header,
22246 })
22247 }
22248 if err != nil {
22249 return nil, err
22250 }
22251 defer googleapi.CloseBody(res)
22252 if err := googleapi.CheckResponse(res); err != nil {
22253 return nil, gensupport.WrapError(err)
22254 }
22255 ret := &GoogleProtobufEmpty{
22256 ServerResponse: googleapi.ServerResponse{
22257 Header: res.Header,
22258 HTTPStatusCode: res.StatusCode,
22259 },
22260 }
22261 target := &ret
22262 if err := gensupport.DecodeResponse(target, res); err != nil {
22263 return nil, err
22264 }
22265 return ret, nil
22266 }
22267
22268 type PropertiesSearchAds360LinksGetCall struct {
22269 s *Service
22270 name string
22271 urlParams_ gensupport.URLParams
22272 ifNoneMatch_ string
22273 ctx_ context.Context
22274 header_ http.Header
22275 }
22276
22277
22278
22279
22280
22281 func (r *PropertiesSearchAds360LinksService) Get(name string) *PropertiesSearchAds360LinksGetCall {
22282 c := &PropertiesSearchAds360LinksGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22283 c.name = name
22284 return c
22285 }
22286
22287
22288
22289
22290 func (c *PropertiesSearchAds360LinksGetCall) Fields(s ...googleapi.Field) *PropertiesSearchAds360LinksGetCall {
22291 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22292 return c
22293 }
22294
22295
22296
22297
22298 func (c *PropertiesSearchAds360LinksGetCall) IfNoneMatch(entityTag string) *PropertiesSearchAds360LinksGetCall {
22299 c.ifNoneMatch_ = entityTag
22300 return c
22301 }
22302
22303
22304 func (c *PropertiesSearchAds360LinksGetCall) Context(ctx context.Context) *PropertiesSearchAds360LinksGetCall {
22305 c.ctx_ = ctx
22306 return c
22307 }
22308
22309
22310
22311 func (c *PropertiesSearchAds360LinksGetCall) Header() http.Header {
22312 if c.header_ == nil {
22313 c.header_ = make(http.Header)
22314 }
22315 return c.header_
22316 }
22317
22318 func (c *PropertiesSearchAds360LinksGetCall) doRequest(alt string) (*http.Response, error) {
22319 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
22320 if c.ifNoneMatch_ != "" {
22321 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
22322 }
22323 var body io.Reader = nil
22324 c.urlParams_.Set("alt", alt)
22325 c.urlParams_.Set("prettyPrint", "false")
22326 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
22327 urls += "?" + c.urlParams_.Encode()
22328 req, err := http.NewRequest("GET", urls, body)
22329 if err != nil {
22330 return nil, err
22331 }
22332 req.Header = reqHeaders
22333 googleapi.Expand(req.URL, map[string]string{
22334 "name": c.name,
22335 })
22336 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22337 }
22338
22339
22340
22341
22342
22343
22344
22345 func (c *PropertiesSearchAds360LinksGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSearchAds360Link, error) {
22346 gensupport.SetOptions(c.urlParams_, opts...)
22347 res, err := c.doRequest("json")
22348 if res != nil && res.StatusCode == http.StatusNotModified {
22349 if res.Body != nil {
22350 res.Body.Close()
22351 }
22352 return nil, gensupport.WrapError(&googleapi.Error{
22353 Code: res.StatusCode,
22354 Header: res.Header,
22355 })
22356 }
22357 if err != nil {
22358 return nil, err
22359 }
22360 defer googleapi.CloseBody(res)
22361 if err := googleapi.CheckResponse(res); err != nil {
22362 return nil, gensupport.WrapError(err)
22363 }
22364 ret := &GoogleAnalyticsAdminV1alphaSearchAds360Link{
22365 ServerResponse: googleapi.ServerResponse{
22366 Header: res.Header,
22367 HTTPStatusCode: res.StatusCode,
22368 },
22369 }
22370 target := &ret
22371 if err := gensupport.DecodeResponse(target, res); err != nil {
22372 return nil, err
22373 }
22374 return ret, nil
22375 }
22376
22377 type PropertiesSearchAds360LinksListCall struct {
22378 s *Service
22379 parent string
22380 urlParams_ gensupport.URLParams
22381 ifNoneMatch_ string
22382 ctx_ context.Context
22383 header_ http.Header
22384 }
22385
22386
22387
22388
22389 func (r *PropertiesSearchAds360LinksService) List(parent string) *PropertiesSearchAds360LinksListCall {
22390 c := &PropertiesSearchAds360LinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22391 c.parent = parent
22392 return c
22393 }
22394
22395
22396
22397
22398 func (c *PropertiesSearchAds360LinksListCall) PageSize(pageSize int64) *PropertiesSearchAds360LinksListCall {
22399 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
22400 return c
22401 }
22402
22403
22404
22405
22406
22407 func (c *PropertiesSearchAds360LinksListCall) PageToken(pageToken string) *PropertiesSearchAds360LinksListCall {
22408 c.urlParams_.Set("pageToken", pageToken)
22409 return c
22410 }
22411
22412
22413
22414
22415 func (c *PropertiesSearchAds360LinksListCall) Fields(s ...googleapi.Field) *PropertiesSearchAds360LinksListCall {
22416 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22417 return c
22418 }
22419
22420
22421
22422
22423 func (c *PropertiesSearchAds360LinksListCall) IfNoneMatch(entityTag string) *PropertiesSearchAds360LinksListCall {
22424 c.ifNoneMatch_ = entityTag
22425 return c
22426 }
22427
22428
22429 func (c *PropertiesSearchAds360LinksListCall) Context(ctx context.Context) *PropertiesSearchAds360LinksListCall {
22430 c.ctx_ = ctx
22431 return c
22432 }
22433
22434
22435
22436 func (c *PropertiesSearchAds360LinksListCall) Header() http.Header {
22437 if c.header_ == nil {
22438 c.header_ = make(http.Header)
22439 }
22440 return c.header_
22441 }
22442
22443 func (c *PropertiesSearchAds360LinksListCall) doRequest(alt string) (*http.Response, error) {
22444 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
22445 if c.ifNoneMatch_ != "" {
22446 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
22447 }
22448 var body io.Reader = nil
22449 c.urlParams_.Set("alt", alt)
22450 c.urlParams_.Set("prettyPrint", "false")
22451 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/searchAds360Links")
22452 urls += "?" + c.urlParams_.Encode()
22453 req, err := http.NewRequest("GET", urls, body)
22454 if err != nil {
22455 return nil, err
22456 }
22457 req.Header = reqHeaders
22458 googleapi.Expand(req.URL, map[string]string{
22459 "parent": c.parent,
22460 })
22461 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22462 }
22463
22464
22465
22466
22467
22468
22469
22470 func (c *PropertiesSearchAds360LinksListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListSearchAds360LinksResponse, error) {
22471 gensupport.SetOptions(c.urlParams_, opts...)
22472 res, err := c.doRequest("json")
22473 if res != nil && res.StatusCode == http.StatusNotModified {
22474 if res.Body != nil {
22475 res.Body.Close()
22476 }
22477 return nil, gensupport.WrapError(&googleapi.Error{
22478 Code: res.StatusCode,
22479 Header: res.Header,
22480 })
22481 }
22482 if err != nil {
22483 return nil, err
22484 }
22485 defer googleapi.CloseBody(res)
22486 if err := googleapi.CheckResponse(res); err != nil {
22487 return nil, gensupport.WrapError(err)
22488 }
22489 ret := &GoogleAnalyticsAdminV1alphaListSearchAds360LinksResponse{
22490 ServerResponse: googleapi.ServerResponse{
22491 Header: res.Header,
22492 HTTPStatusCode: res.StatusCode,
22493 },
22494 }
22495 target := &ret
22496 if err := gensupport.DecodeResponse(target, res); err != nil {
22497 return nil, err
22498 }
22499 return ret, nil
22500 }
22501
22502
22503
22504
22505 func (c *PropertiesSearchAds360LinksListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListSearchAds360LinksResponse) error) error {
22506 c.ctx_ = ctx
22507 defer c.PageToken(c.urlParams_.Get("pageToken"))
22508 for {
22509 x, err := c.Do()
22510 if err != nil {
22511 return err
22512 }
22513 if err := f(x); err != nil {
22514 return err
22515 }
22516 if x.NextPageToken == "" {
22517 return nil
22518 }
22519 c.PageToken(x.NextPageToken)
22520 }
22521 }
22522
22523 type PropertiesSearchAds360LinksPatchCall struct {
22524 s *Service
22525 name string
22526 googleanalyticsadminv1alphasearchads360link *GoogleAnalyticsAdminV1alphaSearchAds360Link
22527 urlParams_ gensupport.URLParams
22528 ctx_ context.Context
22529 header_ http.Header
22530 }
22531
22532
22533
22534
22535
22536
22537 func (r *PropertiesSearchAds360LinksService) Patch(name string, googleanalyticsadminv1alphasearchads360link *GoogleAnalyticsAdminV1alphaSearchAds360Link) *PropertiesSearchAds360LinksPatchCall {
22538 c := &PropertiesSearchAds360LinksPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22539 c.name = name
22540 c.googleanalyticsadminv1alphasearchads360link = googleanalyticsadminv1alphasearchads360link
22541 return c
22542 }
22543
22544
22545
22546
22547 func (c *PropertiesSearchAds360LinksPatchCall) UpdateMask(updateMask string) *PropertiesSearchAds360LinksPatchCall {
22548 c.urlParams_.Set("updateMask", updateMask)
22549 return c
22550 }
22551
22552
22553
22554
22555 func (c *PropertiesSearchAds360LinksPatchCall) Fields(s ...googleapi.Field) *PropertiesSearchAds360LinksPatchCall {
22556 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22557 return c
22558 }
22559
22560
22561 func (c *PropertiesSearchAds360LinksPatchCall) Context(ctx context.Context) *PropertiesSearchAds360LinksPatchCall {
22562 c.ctx_ = ctx
22563 return c
22564 }
22565
22566
22567
22568 func (c *PropertiesSearchAds360LinksPatchCall) Header() http.Header {
22569 if c.header_ == nil {
22570 c.header_ = make(http.Header)
22571 }
22572 return c.header_
22573 }
22574
22575 func (c *PropertiesSearchAds360LinksPatchCall) doRequest(alt string) (*http.Response, error) {
22576 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
22577 var body io.Reader = nil
22578 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphasearchads360link)
22579 if err != nil {
22580 return nil, err
22581 }
22582 c.urlParams_.Set("alt", alt)
22583 c.urlParams_.Set("prettyPrint", "false")
22584 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
22585 urls += "?" + c.urlParams_.Encode()
22586 req, err := http.NewRequest("PATCH", urls, body)
22587 if err != nil {
22588 return nil, err
22589 }
22590 req.Header = reqHeaders
22591 googleapi.Expand(req.URL, map[string]string{
22592 "name": c.name,
22593 })
22594 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22595 }
22596
22597
22598
22599
22600
22601
22602
22603 func (c *PropertiesSearchAds360LinksPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSearchAds360Link, error) {
22604 gensupport.SetOptions(c.urlParams_, opts...)
22605 res, err := c.doRequest("json")
22606 if res != nil && res.StatusCode == http.StatusNotModified {
22607 if res.Body != nil {
22608 res.Body.Close()
22609 }
22610 return nil, gensupport.WrapError(&googleapi.Error{
22611 Code: res.StatusCode,
22612 Header: res.Header,
22613 })
22614 }
22615 if err != nil {
22616 return nil, err
22617 }
22618 defer googleapi.CloseBody(res)
22619 if err := googleapi.CheckResponse(res); err != nil {
22620 return nil, gensupport.WrapError(err)
22621 }
22622 ret := &GoogleAnalyticsAdminV1alphaSearchAds360Link{
22623 ServerResponse: googleapi.ServerResponse{
22624 Header: res.Header,
22625 HTTPStatusCode: res.StatusCode,
22626 },
22627 }
22628 target := &ret
22629 if err := gensupport.DecodeResponse(target, res); err != nil {
22630 return nil, err
22631 }
22632 return ret, nil
22633 }
22634
22635 type PropertiesSubpropertyEventFiltersCreateCall struct {
22636 s *Service
22637 parent string
22638 googleanalyticsadminv1alphasubpropertyeventfilter *GoogleAnalyticsAdminV1alphaSubpropertyEventFilter
22639 urlParams_ gensupport.URLParams
22640 ctx_ context.Context
22641 header_ http.Header
22642 }
22643
22644
22645
22646
22647
22648 func (r *PropertiesSubpropertyEventFiltersService) Create(parent string, googleanalyticsadminv1alphasubpropertyeventfilter *GoogleAnalyticsAdminV1alphaSubpropertyEventFilter) *PropertiesSubpropertyEventFiltersCreateCall {
22649 c := &PropertiesSubpropertyEventFiltersCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22650 c.parent = parent
22651 c.googleanalyticsadminv1alphasubpropertyeventfilter = googleanalyticsadminv1alphasubpropertyeventfilter
22652 return c
22653 }
22654
22655
22656
22657
22658 func (c *PropertiesSubpropertyEventFiltersCreateCall) Fields(s ...googleapi.Field) *PropertiesSubpropertyEventFiltersCreateCall {
22659 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22660 return c
22661 }
22662
22663
22664 func (c *PropertiesSubpropertyEventFiltersCreateCall) Context(ctx context.Context) *PropertiesSubpropertyEventFiltersCreateCall {
22665 c.ctx_ = ctx
22666 return c
22667 }
22668
22669
22670
22671 func (c *PropertiesSubpropertyEventFiltersCreateCall) Header() http.Header {
22672 if c.header_ == nil {
22673 c.header_ = make(http.Header)
22674 }
22675 return c.header_
22676 }
22677
22678 func (c *PropertiesSubpropertyEventFiltersCreateCall) doRequest(alt string) (*http.Response, error) {
22679 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
22680 var body io.Reader = nil
22681 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphasubpropertyeventfilter)
22682 if err != nil {
22683 return nil, err
22684 }
22685 c.urlParams_.Set("alt", alt)
22686 c.urlParams_.Set("prettyPrint", "false")
22687 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/subpropertyEventFilters")
22688 urls += "?" + c.urlParams_.Encode()
22689 req, err := http.NewRequest("POST", urls, body)
22690 if err != nil {
22691 return nil, err
22692 }
22693 req.Header = reqHeaders
22694 googleapi.Expand(req.URL, map[string]string{
22695 "parent": c.parent,
22696 })
22697 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22698 }
22699
22700
22701
22702
22703
22704
22705
22706 func (c *PropertiesSubpropertyEventFiltersCreateCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSubpropertyEventFilter, error) {
22707 gensupport.SetOptions(c.urlParams_, opts...)
22708 res, err := c.doRequest("json")
22709 if res != nil && res.StatusCode == http.StatusNotModified {
22710 if res.Body != nil {
22711 res.Body.Close()
22712 }
22713 return nil, gensupport.WrapError(&googleapi.Error{
22714 Code: res.StatusCode,
22715 Header: res.Header,
22716 })
22717 }
22718 if err != nil {
22719 return nil, err
22720 }
22721 defer googleapi.CloseBody(res)
22722 if err := googleapi.CheckResponse(res); err != nil {
22723 return nil, gensupport.WrapError(err)
22724 }
22725 ret := &GoogleAnalyticsAdminV1alphaSubpropertyEventFilter{
22726 ServerResponse: googleapi.ServerResponse{
22727 Header: res.Header,
22728 HTTPStatusCode: res.StatusCode,
22729 },
22730 }
22731 target := &ret
22732 if err := gensupport.DecodeResponse(target, res); err != nil {
22733 return nil, err
22734 }
22735 return ret, nil
22736 }
22737
22738 type PropertiesSubpropertyEventFiltersDeleteCall struct {
22739 s *Service
22740 name string
22741 urlParams_ gensupport.URLParams
22742 ctx_ context.Context
22743 header_ http.Header
22744 }
22745
22746
22747
22748
22749
22750
22751 func (r *PropertiesSubpropertyEventFiltersService) Delete(name string) *PropertiesSubpropertyEventFiltersDeleteCall {
22752 c := &PropertiesSubpropertyEventFiltersDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22753 c.name = name
22754 return c
22755 }
22756
22757
22758
22759
22760 func (c *PropertiesSubpropertyEventFiltersDeleteCall) Fields(s ...googleapi.Field) *PropertiesSubpropertyEventFiltersDeleteCall {
22761 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22762 return c
22763 }
22764
22765
22766 func (c *PropertiesSubpropertyEventFiltersDeleteCall) Context(ctx context.Context) *PropertiesSubpropertyEventFiltersDeleteCall {
22767 c.ctx_ = ctx
22768 return c
22769 }
22770
22771
22772
22773 func (c *PropertiesSubpropertyEventFiltersDeleteCall) Header() http.Header {
22774 if c.header_ == nil {
22775 c.header_ = make(http.Header)
22776 }
22777 return c.header_
22778 }
22779
22780 func (c *PropertiesSubpropertyEventFiltersDeleteCall) doRequest(alt string) (*http.Response, error) {
22781 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
22782 var body io.Reader = nil
22783 c.urlParams_.Set("alt", alt)
22784 c.urlParams_.Set("prettyPrint", "false")
22785 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
22786 urls += "?" + c.urlParams_.Encode()
22787 req, err := http.NewRequest("DELETE", urls, body)
22788 if err != nil {
22789 return nil, err
22790 }
22791 req.Header = reqHeaders
22792 googleapi.Expand(req.URL, map[string]string{
22793 "name": c.name,
22794 })
22795 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22796 }
22797
22798
22799
22800
22801
22802
22803
22804 func (c *PropertiesSubpropertyEventFiltersDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
22805 gensupport.SetOptions(c.urlParams_, opts...)
22806 res, err := c.doRequest("json")
22807 if res != nil && res.StatusCode == http.StatusNotModified {
22808 if res.Body != nil {
22809 res.Body.Close()
22810 }
22811 return nil, gensupport.WrapError(&googleapi.Error{
22812 Code: res.StatusCode,
22813 Header: res.Header,
22814 })
22815 }
22816 if err != nil {
22817 return nil, err
22818 }
22819 defer googleapi.CloseBody(res)
22820 if err := googleapi.CheckResponse(res); err != nil {
22821 return nil, gensupport.WrapError(err)
22822 }
22823 ret := &GoogleProtobufEmpty{
22824 ServerResponse: googleapi.ServerResponse{
22825 Header: res.Header,
22826 HTTPStatusCode: res.StatusCode,
22827 },
22828 }
22829 target := &ret
22830 if err := gensupport.DecodeResponse(target, res); err != nil {
22831 return nil, err
22832 }
22833 return ret, nil
22834 }
22835
22836 type PropertiesSubpropertyEventFiltersGetCall struct {
22837 s *Service
22838 name string
22839 urlParams_ gensupport.URLParams
22840 ifNoneMatch_ string
22841 ctx_ context.Context
22842 header_ http.Header
22843 }
22844
22845
22846
22847
22848
22849
22850 func (r *PropertiesSubpropertyEventFiltersService) Get(name string) *PropertiesSubpropertyEventFiltersGetCall {
22851 c := &PropertiesSubpropertyEventFiltersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22852 c.name = name
22853 return c
22854 }
22855
22856
22857
22858
22859 func (c *PropertiesSubpropertyEventFiltersGetCall) Fields(s ...googleapi.Field) *PropertiesSubpropertyEventFiltersGetCall {
22860 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22861 return c
22862 }
22863
22864
22865
22866
22867 func (c *PropertiesSubpropertyEventFiltersGetCall) IfNoneMatch(entityTag string) *PropertiesSubpropertyEventFiltersGetCall {
22868 c.ifNoneMatch_ = entityTag
22869 return c
22870 }
22871
22872
22873 func (c *PropertiesSubpropertyEventFiltersGetCall) Context(ctx context.Context) *PropertiesSubpropertyEventFiltersGetCall {
22874 c.ctx_ = ctx
22875 return c
22876 }
22877
22878
22879
22880 func (c *PropertiesSubpropertyEventFiltersGetCall) Header() http.Header {
22881 if c.header_ == nil {
22882 c.header_ = make(http.Header)
22883 }
22884 return c.header_
22885 }
22886
22887 func (c *PropertiesSubpropertyEventFiltersGetCall) doRequest(alt string) (*http.Response, error) {
22888 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
22889 if c.ifNoneMatch_ != "" {
22890 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
22891 }
22892 var body io.Reader = nil
22893 c.urlParams_.Set("alt", alt)
22894 c.urlParams_.Set("prettyPrint", "false")
22895 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
22896 urls += "?" + c.urlParams_.Encode()
22897 req, err := http.NewRequest("GET", urls, body)
22898 if err != nil {
22899 return nil, err
22900 }
22901 req.Header = reqHeaders
22902 googleapi.Expand(req.URL, map[string]string{
22903 "name": c.name,
22904 })
22905 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22906 }
22907
22908
22909
22910
22911
22912
22913
22914 func (c *PropertiesSubpropertyEventFiltersGetCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSubpropertyEventFilter, error) {
22915 gensupport.SetOptions(c.urlParams_, opts...)
22916 res, err := c.doRequest("json")
22917 if res != nil && res.StatusCode == http.StatusNotModified {
22918 if res.Body != nil {
22919 res.Body.Close()
22920 }
22921 return nil, gensupport.WrapError(&googleapi.Error{
22922 Code: res.StatusCode,
22923 Header: res.Header,
22924 })
22925 }
22926 if err != nil {
22927 return nil, err
22928 }
22929 defer googleapi.CloseBody(res)
22930 if err := googleapi.CheckResponse(res); err != nil {
22931 return nil, gensupport.WrapError(err)
22932 }
22933 ret := &GoogleAnalyticsAdminV1alphaSubpropertyEventFilter{
22934 ServerResponse: googleapi.ServerResponse{
22935 Header: res.Header,
22936 HTTPStatusCode: res.StatusCode,
22937 },
22938 }
22939 target := &ret
22940 if err := gensupport.DecodeResponse(target, res); err != nil {
22941 return nil, err
22942 }
22943 return ret, nil
22944 }
22945
22946 type PropertiesSubpropertyEventFiltersListCall struct {
22947 s *Service
22948 parent string
22949 urlParams_ gensupport.URLParams
22950 ifNoneMatch_ string
22951 ctx_ context.Context
22952 header_ http.Header
22953 }
22954
22955
22956
22957
22958
22959 func (r *PropertiesSubpropertyEventFiltersService) List(parent string) *PropertiesSubpropertyEventFiltersListCall {
22960 c := &PropertiesSubpropertyEventFiltersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22961 c.parent = parent
22962 return c
22963 }
22964
22965
22966
22967
22968
22969
22970 func (c *PropertiesSubpropertyEventFiltersListCall) PageSize(pageSize int64) *PropertiesSubpropertyEventFiltersListCall {
22971 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
22972 return c
22973 }
22974
22975
22976
22977
22978
22979
22980 func (c *PropertiesSubpropertyEventFiltersListCall) PageToken(pageToken string) *PropertiesSubpropertyEventFiltersListCall {
22981 c.urlParams_.Set("pageToken", pageToken)
22982 return c
22983 }
22984
22985
22986
22987
22988 func (c *PropertiesSubpropertyEventFiltersListCall) Fields(s ...googleapi.Field) *PropertiesSubpropertyEventFiltersListCall {
22989 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22990 return c
22991 }
22992
22993
22994
22995
22996 func (c *PropertiesSubpropertyEventFiltersListCall) IfNoneMatch(entityTag string) *PropertiesSubpropertyEventFiltersListCall {
22997 c.ifNoneMatch_ = entityTag
22998 return c
22999 }
23000
23001
23002 func (c *PropertiesSubpropertyEventFiltersListCall) Context(ctx context.Context) *PropertiesSubpropertyEventFiltersListCall {
23003 c.ctx_ = ctx
23004 return c
23005 }
23006
23007
23008
23009 func (c *PropertiesSubpropertyEventFiltersListCall) Header() http.Header {
23010 if c.header_ == nil {
23011 c.header_ = make(http.Header)
23012 }
23013 return c.header_
23014 }
23015
23016 func (c *PropertiesSubpropertyEventFiltersListCall) doRequest(alt string) (*http.Response, error) {
23017 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
23018 if c.ifNoneMatch_ != "" {
23019 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
23020 }
23021 var body io.Reader = nil
23022 c.urlParams_.Set("alt", alt)
23023 c.urlParams_.Set("prettyPrint", "false")
23024 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/subpropertyEventFilters")
23025 urls += "?" + c.urlParams_.Encode()
23026 req, err := http.NewRequest("GET", urls, body)
23027 if err != nil {
23028 return nil, err
23029 }
23030 req.Header = reqHeaders
23031 googleapi.Expand(req.URL, map[string]string{
23032 "parent": c.parent,
23033 })
23034 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23035 }
23036
23037
23038
23039
23040
23041
23042
23043 func (c *PropertiesSubpropertyEventFiltersListCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaListSubpropertyEventFiltersResponse, error) {
23044 gensupport.SetOptions(c.urlParams_, opts...)
23045 res, err := c.doRequest("json")
23046 if res != nil && res.StatusCode == http.StatusNotModified {
23047 if res.Body != nil {
23048 res.Body.Close()
23049 }
23050 return nil, gensupport.WrapError(&googleapi.Error{
23051 Code: res.StatusCode,
23052 Header: res.Header,
23053 })
23054 }
23055 if err != nil {
23056 return nil, err
23057 }
23058 defer googleapi.CloseBody(res)
23059 if err := googleapi.CheckResponse(res); err != nil {
23060 return nil, gensupport.WrapError(err)
23061 }
23062 ret := &GoogleAnalyticsAdminV1alphaListSubpropertyEventFiltersResponse{
23063 ServerResponse: googleapi.ServerResponse{
23064 Header: res.Header,
23065 HTTPStatusCode: res.StatusCode,
23066 },
23067 }
23068 target := &ret
23069 if err := gensupport.DecodeResponse(target, res); err != nil {
23070 return nil, err
23071 }
23072 return ret, nil
23073 }
23074
23075
23076
23077
23078 func (c *PropertiesSubpropertyEventFiltersListCall) Pages(ctx context.Context, f func(*GoogleAnalyticsAdminV1alphaListSubpropertyEventFiltersResponse) error) error {
23079 c.ctx_ = ctx
23080 defer c.PageToken(c.urlParams_.Get("pageToken"))
23081 for {
23082 x, err := c.Do()
23083 if err != nil {
23084 return err
23085 }
23086 if err := f(x); err != nil {
23087 return err
23088 }
23089 if x.NextPageToken == "" {
23090 return nil
23091 }
23092 c.PageToken(x.NextPageToken)
23093 }
23094 }
23095
23096 type PropertiesSubpropertyEventFiltersPatchCall struct {
23097 s *Service
23098 name string
23099 googleanalyticsadminv1alphasubpropertyeventfilter *GoogleAnalyticsAdminV1alphaSubpropertyEventFilter
23100 urlParams_ gensupport.URLParams
23101 ctx_ context.Context
23102 header_ http.Header
23103 }
23104
23105
23106
23107
23108
23109
23110 func (r *PropertiesSubpropertyEventFiltersService) Patch(name string, googleanalyticsadminv1alphasubpropertyeventfilter *GoogleAnalyticsAdminV1alphaSubpropertyEventFilter) *PropertiesSubpropertyEventFiltersPatchCall {
23111 c := &PropertiesSubpropertyEventFiltersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23112 c.name = name
23113 c.googleanalyticsadminv1alphasubpropertyeventfilter = googleanalyticsadminv1alphasubpropertyeventfilter
23114 return c
23115 }
23116
23117
23118
23119
23120
23121 func (c *PropertiesSubpropertyEventFiltersPatchCall) UpdateMask(updateMask string) *PropertiesSubpropertyEventFiltersPatchCall {
23122 c.urlParams_.Set("updateMask", updateMask)
23123 return c
23124 }
23125
23126
23127
23128
23129 func (c *PropertiesSubpropertyEventFiltersPatchCall) Fields(s ...googleapi.Field) *PropertiesSubpropertyEventFiltersPatchCall {
23130 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23131 return c
23132 }
23133
23134
23135 func (c *PropertiesSubpropertyEventFiltersPatchCall) Context(ctx context.Context) *PropertiesSubpropertyEventFiltersPatchCall {
23136 c.ctx_ = ctx
23137 return c
23138 }
23139
23140
23141
23142 func (c *PropertiesSubpropertyEventFiltersPatchCall) Header() http.Header {
23143 if c.header_ == nil {
23144 c.header_ = make(http.Header)
23145 }
23146 return c.header_
23147 }
23148
23149 func (c *PropertiesSubpropertyEventFiltersPatchCall) doRequest(alt string) (*http.Response, error) {
23150 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
23151 var body io.Reader = nil
23152 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleanalyticsadminv1alphasubpropertyeventfilter)
23153 if err != nil {
23154 return nil, err
23155 }
23156 c.urlParams_.Set("alt", alt)
23157 c.urlParams_.Set("prettyPrint", "false")
23158 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
23159 urls += "?" + c.urlParams_.Encode()
23160 req, err := http.NewRequest("PATCH", urls, body)
23161 if err != nil {
23162 return nil, err
23163 }
23164 req.Header = reqHeaders
23165 googleapi.Expand(req.URL, map[string]string{
23166 "name": c.name,
23167 })
23168 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23169 }
23170
23171
23172
23173
23174
23175
23176
23177 func (c *PropertiesSubpropertyEventFiltersPatchCall) Do(opts ...googleapi.CallOption) (*GoogleAnalyticsAdminV1alphaSubpropertyEventFilter, error) {
23178 gensupport.SetOptions(c.urlParams_, opts...)
23179 res, err := c.doRequest("json")
23180 if res != nil && res.StatusCode == http.StatusNotModified {
23181 if res.Body != nil {
23182 res.Body.Close()
23183 }
23184 return nil, gensupport.WrapError(&googleapi.Error{
23185 Code: res.StatusCode,
23186 Header: res.Header,
23187 })
23188 }
23189 if err != nil {
23190 return nil, err
23191 }
23192 defer googleapi.CloseBody(res)
23193 if err := googleapi.CheckResponse(res); err != nil {
23194 return nil, gensupport.WrapError(err)
23195 }
23196 ret := &GoogleAnalyticsAdminV1alphaSubpropertyEventFilter{
23197 ServerResponse: googleapi.ServerResponse{
23198 Header: res.Header,
23199 HTTPStatusCode: res.StatusCode,
23200 },
23201 }
23202 target := &ret
23203 if err := gensupport.DecodeResponse(target, res); err != nil {
23204 return nil, err
23205 }
23206 return ret, nil
23207 }
23208
View as plain text