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 package dfareporting
43
44 import (
45 "bytes"
46 "context"
47 "encoding/json"
48 "errors"
49 "fmt"
50 "io"
51 "net/http"
52 "net/url"
53 "strconv"
54 "strings"
55
56 googleapi "google.golang.org/api/googleapi"
57 gensupport "google.golang.org/api/internal/gensupport"
58 option "google.golang.org/api/option"
59 htransport "google.golang.org/api/transport/http"
60 )
61
62
63
64 var _ = bytes.NewBuffer
65 var _ = strconv.Itoa
66 var _ = fmt.Sprintf
67 var _ = json.NewDecoder
68 var _ = io.Copy
69 var _ = url.Parse
70 var _ = gensupport.MarshalJSON
71 var _ = googleapi.Version
72 var _ = errors.New
73 var _ = strings.Replace
74 var _ = context.Canceled
75
76 const apiId = "dfareporting:v3.1"
77 const apiName = "dfareporting"
78 const apiVersion = "v3.1"
79 const basePath = "https://www.googleapis.com/dfareporting/v3.1/"
80
81
82 const (
83
84 DdmconversionsScope = "https://www.googleapis.com/auth/ddmconversions"
85
86
87 DfareportingScope = "https://www.googleapis.com/auth/dfareporting"
88
89
90
91 DfatraffickingScope = "https://www.googleapis.com/auth/dfatrafficking"
92 )
93
94
95 func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
96 scopesOption := option.WithScopes(
97 "https://www.googleapis.com/auth/ddmconversions",
98 "https://www.googleapis.com/auth/dfareporting",
99 "https://www.googleapis.com/auth/dfatrafficking",
100 )
101
102 opts = append([]option.ClientOption{scopesOption}, opts...)
103 client, endpoint, err := htransport.NewClient(ctx, opts...)
104 if err != nil {
105 return nil, err
106 }
107 s, err := New(client)
108 if err != nil {
109 return nil, err
110 }
111 if endpoint != "" {
112 s.BasePath = endpoint
113 }
114 return s, nil
115 }
116
117
118
119
120
121
122 func New(client *http.Client) (*Service, error) {
123 if client == nil {
124 return nil, errors.New("client is nil")
125 }
126 s := &Service{client: client, BasePath: basePath}
127 s.AccountActiveAdSummaries = NewAccountActiveAdSummariesService(s)
128 s.AccountPermissionGroups = NewAccountPermissionGroupsService(s)
129 s.AccountPermissions = NewAccountPermissionsService(s)
130 s.AccountUserProfiles = NewAccountUserProfilesService(s)
131 s.Accounts = NewAccountsService(s)
132 s.Ads = NewAdsService(s)
133 s.AdvertiserGroups = NewAdvertiserGroupsService(s)
134 s.AdvertiserLandingPages = NewAdvertiserLandingPagesService(s)
135 s.Advertisers = NewAdvertisersService(s)
136 s.Browsers = NewBrowsersService(s)
137 s.CampaignCreativeAssociations = NewCampaignCreativeAssociationsService(s)
138 s.Campaigns = NewCampaignsService(s)
139 s.ChangeLogs = NewChangeLogsService(s)
140 s.Cities = NewCitiesService(s)
141 s.ConnectionTypes = NewConnectionTypesService(s)
142 s.ContentCategories = NewContentCategoriesService(s)
143 s.Conversions = NewConversionsService(s)
144 s.Countries = NewCountriesService(s)
145 s.CreativeAssets = NewCreativeAssetsService(s)
146 s.CreativeFieldValues = NewCreativeFieldValuesService(s)
147 s.CreativeFields = NewCreativeFieldsService(s)
148 s.CreativeGroups = NewCreativeGroupsService(s)
149 s.Creatives = NewCreativesService(s)
150 s.DimensionValues = NewDimensionValuesService(s)
151 s.DirectorySites = NewDirectorySitesService(s)
152 s.DynamicTargetingKeys = NewDynamicTargetingKeysService(s)
153 s.EventTags = NewEventTagsService(s)
154 s.Files = NewFilesService(s)
155 s.FloodlightActivities = NewFloodlightActivitiesService(s)
156 s.FloodlightActivityGroups = NewFloodlightActivityGroupsService(s)
157 s.FloodlightConfigurations = NewFloodlightConfigurationsService(s)
158 s.InventoryItems = NewInventoryItemsService(s)
159 s.Languages = NewLanguagesService(s)
160 s.Metros = NewMetrosService(s)
161 s.MobileApps = NewMobileAppsService(s)
162 s.MobileCarriers = NewMobileCarriersService(s)
163 s.OperatingSystemVersions = NewOperatingSystemVersionsService(s)
164 s.OperatingSystems = NewOperatingSystemsService(s)
165 s.OrderDocuments = NewOrderDocumentsService(s)
166 s.Orders = NewOrdersService(s)
167 s.PlacementGroups = NewPlacementGroupsService(s)
168 s.PlacementStrategies = NewPlacementStrategiesService(s)
169 s.Placements = NewPlacementsService(s)
170 s.PlatformTypes = NewPlatformTypesService(s)
171 s.PostalCodes = NewPostalCodesService(s)
172 s.Projects = NewProjectsService(s)
173 s.Regions = NewRegionsService(s)
174 s.RemarketingListShares = NewRemarketingListSharesService(s)
175 s.RemarketingLists = NewRemarketingListsService(s)
176 s.Reports = NewReportsService(s)
177 s.Sites = NewSitesService(s)
178 s.Sizes = NewSizesService(s)
179 s.Subaccounts = NewSubaccountsService(s)
180 s.TargetableRemarketingLists = NewTargetableRemarketingListsService(s)
181 s.TargetingTemplates = NewTargetingTemplatesService(s)
182 s.UserProfiles = NewUserProfilesService(s)
183 s.UserRolePermissionGroups = NewUserRolePermissionGroupsService(s)
184 s.UserRolePermissions = NewUserRolePermissionsService(s)
185 s.UserRoles = NewUserRolesService(s)
186 s.VideoFormats = NewVideoFormatsService(s)
187 return s, nil
188 }
189
190 type Service struct {
191 client *http.Client
192 BasePath string
193 UserAgent string
194
195 AccountActiveAdSummaries *AccountActiveAdSummariesService
196
197 AccountPermissionGroups *AccountPermissionGroupsService
198
199 AccountPermissions *AccountPermissionsService
200
201 AccountUserProfiles *AccountUserProfilesService
202
203 Accounts *AccountsService
204
205 Ads *AdsService
206
207 AdvertiserGroups *AdvertiserGroupsService
208
209 AdvertiserLandingPages *AdvertiserLandingPagesService
210
211 Advertisers *AdvertisersService
212
213 Browsers *BrowsersService
214
215 CampaignCreativeAssociations *CampaignCreativeAssociationsService
216
217 Campaigns *CampaignsService
218
219 ChangeLogs *ChangeLogsService
220
221 Cities *CitiesService
222
223 ConnectionTypes *ConnectionTypesService
224
225 ContentCategories *ContentCategoriesService
226
227 Conversions *ConversionsService
228
229 Countries *CountriesService
230
231 CreativeAssets *CreativeAssetsService
232
233 CreativeFieldValues *CreativeFieldValuesService
234
235 CreativeFields *CreativeFieldsService
236
237 CreativeGroups *CreativeGroupsService
238
239 Creatives *CreativesService
240
241 DimensionValues *DimensionValuesService
242
243 DirectorySites *DirectorySitesService
244
245 DynamicTargetingKeys *DynamicTargetingKeysService
246
247 EventTags *EventTagsService
248
249 Files *FilesService
250
251 FloodlightActivities *FloodlightActivitiesService
252
253 FloodlightActivityGroups *FloodlightActivityGroupsService
254
255 FloodlightConfigurations *FloodlightConfigurationsService
256
257 InventoryItems *InventoryItemsService
258
259 Languages *LanguagesService
260
261 Metros *MetrosService
262
263 MobileApps *MobileAppsService
264
265 MobileCarriers *MobileCarriersService
266
267 OperatingSystemVersions *OperatingSystemVersionsService
268
269 OperatingSystems *OperatingSystemsService
270
271 OrderDocuments *OrderDocumentsService
272
273 Orders *OrdersService
274
275 PlacementGroups *PlacementGroupsService
276
277 PlacementStrategies *PlacementStrategiesService
278
279 Placements *PlacementsService
280
281 PlatformTypes *PlatformTypesService
282
283 PostalCodes *PostalCodesService
284
285 Projects *ProjectsService
286
287 Regions *RegionsService
288
289 RemarketingListShares *RemarketingListSharesService
290
291 RemarketingLists *RemarketingListsService
292
293 Reports *ReportsService
294
295 Sites *SitesService
296
297 Sizes *SizesService
298
299 Subaccounts *SubaccountsService
300
301 TargetableRemarketingLists *TargetableRemarketingListsService
302
303 TargetingTemplates *TargetingTemplatesService
304
305 UserProfiles *UserProfilesService
306
307 UserRolePermissionGroups *UserRolePermissionGroupsService
308
309 UserRolePermissions *UserRolePermissionsService
310
311 UserRoles *UserRolesService
312
313 VideoFormats *VideoFormatsService
314 }
315
316 func (s *Service) userAgent() string {
317 if s.UserAgent == "" {
318 return googleapi.UserAgent
319 }
320 return googleapi.UserAgent + " " + s.UserAgent
321 }
322
323 func NewAccountActiveAdSummariesService(s *Service) *AccountActiveAdSummariesService {
324 rs := &AccountActiveAdSummariesService{s: s}
325 return rs
326 }
327
328 type AccountActiveAdSummariesService struct {
329 s *Service
330 }
331
332 func NewAccountPermissionGroupsService(s *Service) *AccountPermissionGroupsService {
333 rs := &AccountPermissionGroupsService{s: s}
334 return rs
335 }
336
337 type AccountPermissionGroupsService struct {
338 s *Service
339 }
340
341 func NewAccountPermissionsService(s *Service) *AccountPermissionsService {
342 rs := &AccountPermissionsService{s: s}
343 return rs
344 }
345
346 type AccountPermissionsService struct {
347 s *Service
348 }
349
350 func NewAccountUserProfilesService(s *Service) *AccountUserProfilesService {
351 rs := &AccountUserProfilesService{s: s}
352 return rs
353 }
354
355 type AccountUserProfilesService struct {
356 s *Service
357 }
358
359 func NewAccountsService(s *Service) *AccountsService {
360 rs := &AccountsService{s: s}
361 return rs
362 }
363
364 type AccountsService struct {
365 s *Service
366 }
367
368 func NewAdsService(s *Service) *AdsService {
369 rs := &AdsService{s: s}
370 return rs
371 }
372
373 type AdsService struct {
374 s *Service
375 }
376
377 func NewAdvertiserGroupsService(s *Service) *AdvertiserGroupsService {
378 rs := &AdvertiserGroupsService{s: s}
379 return rs
380 }
381
382 type AdvertiserGroupsService struct {
383 s *Service
384 }
385
386 func NewAdvertiserLandingPagesService(s *Service) *AdvertiserLandingPagesService {
387 rs := &AdvertiserLandingPagesService{s: s}
388 return rs
389 }
390
391 type AdvertiserLandingPagesService struct {
392 s *Service
393 }
394
395 func NewAdvertisersService(s *Service) *AdvertisersService {
396 rs := &AdvertisersService{s: s}
397 return rs
398 }
399
400 type AdvertisersService struct {
401 s *Service
402 }
403
404 func NewBrowsersService(s *Service) *BrowsersService {
405 rs := &BrowsersService{s: s}
406 return rs
407 }
408
409 type BrowsersService struct {
410 s *Service
411 }
412
413 func NewCampaignCreativeAssociationsService(s *Service) *CampaignCreativeAssociationsService {
414 rs := &CampaignCreativeAssociationsService{s: s}
415 return rs
416 }
417
418 type CampaignCreativeAssociationsService struct {
419 s *Service
420 }
421
422 func NewCampaignsService(s *Service) *CampaignsService {
423 rs := &CampaignsService{s: s}
424 return rs
425 }
426
427 type CampaignsService struct {
428 s *Service
429 }
430
431 func NewChangeLogsService(s *Service) *ChangeLogsService {
432 rs := &ChangeLogsService{s: s}
433 return rs
434 }
435
436 type ChangeLogsService struct {
437 s *Service
438 }
439
440 func NewCitiesService(s *Service) *CitiesService {
441 rs := &CitiesService{s: s}
442 return rs
443 }
444
445 type CitiesService struct {
446 s *Service
447 }
448
449 func NewConnectionTypesService(s *Service) *ConnectionTypesService {
450 rs := &ConnectionTypesService{s: s}
451 return rs
452 }
453
454 type ConnectionTypesService struct {
455 s *Service
456 }
457
458 func NewContentCategoriesService(s *Service) *ContentCategoriesService {
459 rs := &ContentCategoriesService{s: s}
460 return rs
461 }
462
463 type ContentCategoriesService struct {
464 s *Service
465 }
466
467 func NewConversionsService(s *Service) *ConversionsService {
468 rs := &ConversionsService{s: s}
469 return rs
470 }
471
472 type ConversionsService struct {
473 s *Service
474 }
475
476 func NewCountriesService(s *Service) *CountriesService {
477 rs := &CountriesService{s: s}
478 return rs
479 }
480
481 type CountriesService struct {
482 s *Service
483 }
484
485 func NewCreativeAssetsService(s *Service) *CreativeAssetsService {
486 rs := &CreativeAssetsService{s: s}
487 return rs
488 }
489
490 type CreativeAssetsService struct {
491 s *Service
492 }
493
494 func NewCreativeFieldValuesService(s *Service) *CreativeFieldValuesService {
495 rs := &CreativeFieldValuesService{s: s}
496 return rs
497 }
498
499 type CreativeFieldValuesService struct {
500 s *Service
501 }
502
503 func NewCreativeFieldsService(s *Service) *CreativeFieldsService {
504 rs := &CreativeFieldsService{s: s}
505 return rs
506 }
507
508 type CreativeFieldsService struct {
509 s *Service
510 }
511
512 func NewCreativeGroupsService(s *Service) *CreativeGroupsService {
513 rs := &CreativeGroupsService{s: s}
514 return rs
515 }
516
517 type CreativeGroupsService struct {
518 s *Service
519 }
520
521 func NewCreativesService(s *Service) *CreativesService {
522 rs := &CreativesService{s: s}
523 return rs
524 }
525
526 type CreativesService struct {
527 s *Service
528 }
529
530 func NewDimensionValuesService(s *Service) *DimensionValuesService {
531 rs := &DimensionValuesService{s: s}
532 return rs
533 }
534
535 type DimensionValuesService struct {
536 s *Service
537 }
538
539 func NewDirectorySitesService(s *Service) *DirectorySitesService {
540 rs := &DirectorySitesService{s: s}
541 return rs
542 }
543
544 type DirectorySitesService struct {
545 s *Service
546 }
547
548 func NewDynamicTargetingKeysService(s *Service) *DynamicTargetingKeysService {
549 rs := &DynamicTargetingKeysService{s: s}
550 return rs
551 }
552
553 type DynamicTargetingKeysService struct {
554 s *Service
555 }
556
557 func NewEventTagsService(s *Service) *EventTagsService {
558 rs := &EventTagsService{s: s}
559 return rs
560 }
561
562 type EventTagsService struct {
563 s *Service
564 }
565
566 func NewFilesService(s *Service) *FilesService {
567 rs := &FilesService{s: s}
568 return rs
569 }
570
571 type FilesService struct {
572 s *Service
573 }
574
575 func NewFloodlightActivitiesService(s *Service) *FloodlightActivitiesService {
576 rs := &FloodlightActivitiesService{s: s}
577 return rs
578 }
579
580 type FloodlightActivitiesService struct {
581 s *Service
582 }
583
584 func NewFloodlightActivityGroupsService(s *Service) *FloodlightActivityGroupsService {
585 rs := &FloodlightActivityGroupsService{s: s}
586 return rs
587 }
588
589 type FloodlightActivityGroupsService struct {
590 s *Service
591 }
592
593 func NewFloodlightConfigurationsService(s *Service) *FloodlightConfigurationsService {
594 rs := &FloodlightConfigurationsService{s: s}
595 return rs
596 }
597
598 type FloodlightConfigurationsService struct {
599 s *Service
600 }
601
602 func NewInventoryItemsService(s *Service) *InventoryItemsService {
603 rs := &InventoryItemsService{s: s}
604 return rs
605 }
606
607 type InventoryItemsService struct {
608 s *Service
609 }
610
611 func NewLanguagesService(s *Service) *LanguagesService {
612 rs := &LanguagesService{s: s}
613 return rs
614 }
615
616 type LanguagesService struct {
617 s *Service
618 }
619
620 func NewMetrosService(s *Service) *MetrosService {
621 rs := &MetrosService{s: s}
622 return rs
623 }
624
625 type MetrosService struct {
626 s *Service
627 }
628
629 func NewMobileAppsService(s *Service) *MobileAppsService {
630 rs := &MobileAppsService{s: s}
631 return rs
632 }
633
634 type MobileAppsService struct {
635 s *Service
636 }
637
638 func NewMobileCarriersService(s *Service) *MobileCarriersService {
639 rs := &MobileCarriersService{s: s}
640 return rs
641 }
642
643 type MobileCarriersService struct {
644 s *Service
645 }
646
647 func NewOperatingSystemVersionsService(s *Service) *OperatingSystemVersionsService {
648 rs := &OperatingSystemVersionsService{s: s}
649 return rs
650 }
651
652 type OperatingSystemVersionsService struct {
653 s *Service
654 }
655
656 func NewOperatingSystemsService(s *Service) *OperatingSystemsService {
657 rs := &OperatingSystemsService{s: s}
658 return rs
659 }
660
661 type OperatingSystemsService struct {
662 s *Service
663 }
664
665 func NewOrderDocumentsService(s *Service) *OrderDocumentsService {
666 rs := &OrderDocumentsService{s: s}
667 return rs
668 }
669
670 type OrderDocumentsService struct {
671 s *Service
672 }
673
674 func NewOrdersService(s *Service) *OrdersService {
675 rs := &OrdersService{s: s}
676 return rs
677 }
678
679 type OrdersService struct {
680 s *Service
681 }
682
683 func NewPlacementGroupsService(s *Service) *PlacementGroupsService {
684 rs := &PlacementGroupsService{s: s}
685 return rs
686 }
687
688 type PlacementGroupsService struct {
689 s *Service
690 }
691
692 func NewPlacementStrategiesService(s *Service) *PlacementStrategiesService {
693 rs := &PlacementStrategiesService{s: s}
694 return rs
695 }
696
697 type PlacementStrategiesService struct {
698 s *Service
699 }
700
701 func NewPlacementsService(s *Service) *PlacementsService {
702 rs := &PlacementsService{s: s}
703 return rs
704 }
705
706 type PlacementsService struct {
707 s *Service
708 }
709
710 func NewPlatformTypesService(s *Service) *PlatformTypesService {
711 rs := &PlatformTypesService{s: s}
712 return rs
713 }
714
715 type PlatformTypesService struct {
716 s *Service
717 }
718
719 func NewPostalCodesService(s *Service) *PostalCodesService {
720 rs := &PostalCodesService{s: s}
721 return rs
722 }
723
724 type PostalCodesService struct {
725 s *Service
726 }
727
728 func NewProjectsService(s *Service) *ProjectsService {
729 rs := &ProjectsService{s: s}
730 return rs
731 }
732
733 type ProjectsService struct {
734 s *Service
735 }
736
737 func NewRegionsService(s *Service) *RegionsService {
738 rs := &RegionsService{s: s}
739 return rs
740 }
741
742 type RegionsService struct {
743 s *Service
744 }
745
746 func NewRemarketingListSharesService(s *Service) *RemarketingListSharesService {
747 rs := &RemarketingListSharesService{s: s}
748 return rs
749 }
750
751 type RemarketingListSharesService struct {
752 s *Service
753 }
754
755 func NewRemarketingListsService(s *Service) *RemarketingListsService {
756 rs := &RemarketingListsService{s: s}
757 return rs
758 }
759
760 type RemarketingListsService struct {
761 s *Service
762 }
763
764 func NewReportsService(s *Service) *ReportsService {
765 rs := &ReportsService{s: s}
766 rs.CompatibleFields = NewReportsCompatibleFieldsService(s)
767 rs.Files = NewReportsFilesService(s)
768 return rs
769 }
770
771 type ReportsService struct {
772 s *Service
773
774 CompatibleFields *ReportsCompatibleFieldsService
775
776 Files *ReportsFilesService
777 }
778
779 func NewReportsCompatibleFieldsService(s *Service) *ReportsCompatibleFieldsService {
780 rs := &ReportsCompatibleFieldsService{s: s}
781 return rs
782 }
783
784 type ReportsCompatibleFieldsService struct {
785 s *Service
786 }
787
788 func NewReportsFilesService(s *Service) *ReportsFilesService {
789 rs := &ReportsFilesService{s: s}
790 return rs
791 }
792
793 type ReportsFilesService struct {
794 s *Service
795 }
796
797 func NewSitesService(s *Service) *SitesService {
798 rs := &SitesService{s: s}
799 return rs
800 }
801
802 type SitesService struct {
803 s *Service
804 }
805
806 func NewSizesService(s *Service) *SizesService {
807 rs := &SizesService{s: s}
808 return rs
809 }
810
811 type SizesService struct {
812 s *Service
813 }
814
815 func NewSubaccountsService(s *Service) *SubaccountsService {
816 rs := &SubaccountsService{s: s}
817 return rs
818 }
819
820 type SubaccountsService struct {
821 s *Service
822 }
823
824 func NewTargetableRemarketingListsService(s *Service) *TargetableRemarketingListsService {
825 rs := &TargetableRemarketingListsService{s: s}
826 return rs
827 }
828
829 type TargetableRemarketingListsService struct {
830 s *Service
831 }
832
833 func NewTargetingTemplatesService(s *Service) *TargetingTemplatesService {
834 rs := &TargetingTemplatesService{s: s}
835 return rs
836 }
837
838 type TargetingTemplatesService struct {
839 s *Service
840 }
841
842 func NewUserProfilesService(s *Service) *UserProfilesService {
843 rs := &UserProfilesService{s: s}
844 return rs
845 }
846
847 type UserProfilesService struct {
848 s *Service
849 }
850
851 func NewUserRolePermissionGroupsService(s *Service) *UserRolePermissionGroupsService {
852 rs := &UserRolePermissionGroupsService{s: s}
853 return rs
854 }
855
856 type UserRolePermissionGroupsService struct {
857 s *Service
858 }
859
860 func NewUserRolePermissionsService(s *Service) *UserRolePermissionsService {
861 rs := &UserRolePermissionsService{s: s}
862 return rs
863 }
864
865 type UserRolePermissionsService struct {
866 s *Service
867 }
868
869 func NewUserRolesService(s *Service) *UserRolesService {
870 rs := &UserRolesService{s: s}
871 return rs
872 }
873
874 type UserRolesService struct {
875 s *Service
876 }
877
878 func NewVideoFormatsService(s *Service) *VideoFormatsService {
879 rs := &VideoFormatsService{s: s}
880 return rs
881 }
882
883 type VideoFormatsService struct {
884 s *Service
885 }
886
887
888 type Account struct {
889
890 AccountPermissionIds googleapi.Int64s `json:"accountPermissionIds,omitempty"`
891
892
893
894
895
896
897
898 AccountProfile string `json:"accountProfile,omitempty"`
899
900
901 Active bool `json:"active,omitempty"`
902
903
904
905
906
907
908
909
910
911
912
913
914
915 ActiveAdsLimitTier string `json:"activeAdsLimitTier,omitempty"`
916
917
918
919
920 ActiveViewOptOut bool `json:"activeViewOptOut,omitempty"`
921
922
923
924 AvailablePermissionIds googleapi.Int64s `json:"availablePermissionIds,omitempty"`
925
926
927 CountryId int64 `json:"countryId,omitempty,string"`
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981 CurrencyId int64 `json:"currencyId,omitempty,string"`
982
983
984 DefaultCreativeSizeId int64 `json:"defaultCreativeSizeId,omitempty,string"`
985
986
987 Description string `json:"description,omitempty"`
988
989
990 Id int64 `json:"id,omitempty,string"`
991
992
993
994 Kind string `json:"kind,omitempty"`
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014 Locale string `json:"locale,omitempty"`
1015
1016
1017
1018 MaximumImageSize int64 `json:"maximumImageSize,omitempty,string"`
1019
1020
1021
1022 Name string `json:"name,omitempty"`
1023
1024
1025
1026 NielsenOcrEnabled bool `json:"nielsenOcrEnabled,omitempty"`
1027
1028
1029 ReportsConfiguration *ReportsConfiguration `json:"reportsConfiguration,omitempty"`
1030
1031
1032
1033 ShareReportsWithTwitter bool `json:"shareReportsWithTwitter,omitempty"`
1034
1035
1036
1037 TeaserSizeLimit int64 `json:"teaserSizeLimit,omitempty,string"`
1038
1039
1040
1041 googleapi.ServerResponse `json:"-"`
1042
1043
1044
1045
1046
1047
1048
1049
1050 ForceSendFields []string `json:"-"`
1051
1052
1053
1054
1055
1056
1057
1058
1059 NullFields []string `json:"-"`
1060 }
1061
1062 func (s *Account) MarshalJSON() ([]byte, error) {
1063 type NoMethod Account
1064 raw := NoMethod(*s)
1065 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1066 }
1067
1068
1069 type AccountActiveAdSummary struct {
1070
1071 AccountId int64 `json:"accountId,omitempty,string"`
1072
1073
1074 ActiveAds int64 `json:"activeAds,omitempty,string"`
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088 ActiveAdsLimitTier string `json:"activeAdsLimitTier,omitempty"`
1089
1090
1091 AvailableAds int64 `json:"availableAds,omitempty,string"`
1092
1093
1094
1095 Kind string `json:"kind,omitempty"`
1096
1097
1098
1099 googleapi.ServerResponse `json:"-"`
1100
1101
1102
1103
1104
1105
1106
1107 ForceSendFields []string `json:"-"`
1108
1109
1110
1111
1112
1113
1114
1115 NullFields []string `json:"-"`
1116 }
1117
1118 func (s *AccountActiveAdSummary) MarshalJSON() ([]byte, error) {
1119 type NoMethod AccountActiveAdSummary
1120 raw := NoMethod(*s)
1121 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1122 }
1123
1124
1125
1126
1127 type AccountPermission struct {
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138 AccountProfiles []string `json:"accountProfiles,omitempty"`
1139
1140
1141 Id int64 `json:"id,omitempty,string"`
1142
1143
1144
1145 Kind string `json:"kind,omitempty"`
1146
1147
1148
1149
1150
1151
1152
1153 Level string `json:"level,omitempty"`
1154
1155
1156 Name string `json:"name,omitempty"`
1157
1158
1159 PermissionGroupId int64 `json:"permissionGroupId,omitempty,string"`
1160
1161
1162
1163 googleapi.ServerResponse `json:"-"`
1164
1165
1166
1167
1168
1169
1170
1171 ForceSendFields []string `json:"-"`
1172
1173
1174
1175
1176
1177
1178
1179
1180 NullFields []string `json:"-"`
1181 }
1182
1183 func (s *AccountPermission) MarshalJSON() ([]byte, error) {
1184 type NoMethod AccountPermission
1185 raw := NoMethod(*s)
1186 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1187 }
1188
1189
1190
1191
1192 type AccountPermissionGroup struct {
1193
1194 Id int64 `json:"id,omitempty,string"`
1195
1196
1197
1198 Kind string `json:"kind,omitempty"`
1199
1200
1201 Name string `json:"name,omitempty"`
1202
1203
1204
1205 googleapi.ServerResponse `json:"-"`
1206
1207
1208
1209
1210
1211
1212
1213 ForceSendFields []string `json:"-"`
1214
1215
1216
1217
1218
1219
1220
1221 NullFields []string `json:"-"`
1222 }
1223
1224 func (s *AccountPermissionGroup) MarshalJSON() ([]byte, error) {
1225 type NoMethod AccountPermissionGroup
1226 raw := NoMethod(*s)
1227 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1228 }
1229
1230
1231
1232 type AccountPermissionGroupsListResponse struct {
1233
1234 AccountPermissionGroups []*AccountPermissionGroup `json:"accountPermissionGroups,omitempty"`
1235
1236
1237
1238 Kind string `json:"kind,omitempty"`
1239
1240
1241
1242 googleapi.ServerResponse `json:"-"`
1243
1244
1245
1246
1247
1248
1249
1250
1251 ForceSendFields []string `json:"-"`
1252
1253
1254
1255
1256
1257
1258
1259
1260 NullFields []string `json:"-"`
1261 }
1262
1263 func (s *AccountPermissionGroupsListResponse) MarshalJSON() ([]byte, error) {
1264 type NoMethod AccountPermissionGroupsListResponse
1265 raw := NoMethod(*s)
1266 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1267 }
1268
1269
1270 type AccountPermissionsListResponse struct {
1271
1272 AccountPermissions []*AccountPermission `json:"accountPermissions,omitempty"`
1273
1274
1275
1276 Kind string `json:"kind,omitempty"`
1277
1278
1279
1280 googleapi.ServerResponse `json:"-"`
1281
1282
1283
1284
1285
1286
1287
1288 ForceSendFields []string `json:"-"`
1289
1290
1291
1292
1293
1294
1295
1296
1297 NullFields []string `json:"-"`
1298 }
1299
1300 func (s *AccountPermissionsListResponse) MarshalJSON() ([]byte, error) {
1301 type NoMethod AccountPermissionsListResponse
1302 raw := NoMethod(*s)
1303 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1304 }
1305
1306
1307
1308
1309
1310 type AccountUserProfile struct {
1311
1312
1313 AccountId int64 `json:"accountId,omitempty,string"`
1314
1315
1316
1317 Active bool `json:"active,omitempty"`
1318
1319
1320
1321 AdvertiserFilter *ObjectFilter `json:"advertiserFilter,omitempty"`
1322
1323
1324
1325 CampaignFilter *ObjectFilter `json:"campaignFilter,omitempty"`
1326
1327
1328 Comments string `json:"comments,omitempty"`
1329
1330
1331
1332
1333 Email string `json:"email,omitempty"`
1334
1335
1336
1337 Id int64 `json:"id,omitempty,string"`
1338
1339
1340
1341 Kind string `json:"kind,omitempty"`
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362 Locale string `json:"locale,omitempty"`
1363
1364
1365
1366
1367 Name string `json:"name,omitempty"`
1368
1369
1370
1371 SiteFilter *ObjectFilter `json:"siteFilter,omitempty"`
1372
1373
1374
1375 SubaccountId int64 `json:"subaccountId,omitempty,string"`
1376
1377
1378
1379
1380
1381
1382
1383
1384 TraffickerType string `json:"traffickerType,omitempty"`
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394 UserAccessType string `json:"userAccessType,omitempty"`
1395
1396
1397
1398 UserRoleFilter *ObjectFilter `json:"userRoleFilter,omitempty"`
1399
1400
1401
1402 UserRoleId int64 `json:"userRoleId,omitempty,string"`
1403
1404
1405
1406 googleapi.ServerResponse `json:"-"`
1407
1408
1409
1410
1411
1412
1413
1414 ForceSendFields []string `json:"-"`
1415
1416
1417
1418
1419
1420
1421
1422 NullFields []string `json:"-"`
1423 }
1424
1425 func (s *AccountUserProfile) MarshalJSON() ([]byte, error) {
1426 type NoMethod AccountUserProfile
1427 raw := NoMethod(*s)
1428 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1429 }
1430
1431
1432 type AccountUserProfilesListResponse struct {
1433
1434 AccountUserProfiles []*AccountUserProfile `json:"accountUserProfiles,omitempty"`
1435
1436
1437
1438 Kind string `json:"kind,omitempty"`
1439
1440
1441
1442 NextPageToken string `json:"nextPageToken,omitempty"`
1443
1444
1445
1446 googleapi.ServerResponse `json:"-"`
1447
1448
1449
1450
1451
1452
1453
1454 ForceSendFields []string `json:"-"`
1455
1456
1457
1458
1459
1460
1461
1462
1463 NullFields []string `json:"-"`
1464 }
1465
1466 func (s *AccountUserProfilesListResponse) MarshalJSON() ([]byte, error) {
1467 type NoMethod AccountUserProfilesListResponse
1468 raw := NoMethod(*s)
1469 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1470 }
1471
1472
1473 type AccountsListResponse struct {
1474
1475 Accounts []*Account `json:"accounts,omitempty"`
1476
1477
1478
1479 Kind string `json:"kind,omitempty"`
1480
1481
1482
1483 NextPageToken string `json:"nextPageToken,omitempty"`
1484
1485
1486
1487 googleapi.ServerResponse `json:"-"`
1488
1489
1490
1491
1492
1493
1494
1495 ForceSendFields []string `json:"-"`
1496
1497
1498
1499
1500
1501
1502
1503 NullFields []string `json:"-"`
1504 }
1505
1506 func (s *AccountsListResponse) MarshalJSON() ([]byte, error) {
1507 type NoMethod AccountsListResponse
1508 raw := NoMethod(*s)
1509 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1510 }
1511
1512
1513 type Activities struct {
1514
1515
1516 Filters []*DimensionValue `json:"filters,omitempty"`
1517
1518
1519
1520 Kind string `json:"kind,omitempty"`
1521
1522
1523 MetricNames []string `json:"metricNames,omitempty"`
1524
1525
1526
1527
1528
1529
1530
1531 ForceSendFields []string `json:"-"`
1532
1533
1534
1535
1536
1537
1538
1539 NullFields []string `json:"-"`
1540 }
1541
1542 func (s *Activities) MarshalJSON() ([]byte, error) {
1543 type NoMethod Activities
1544 raw := NoMethod(*s)
1545 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1546 }
1547
1548
1549 type Ad struct {
1550
1551
1552 AccountId int64 `json:"accountId,omitempty,string"`
1553
1554
1555 Active bool `json:"active,omitempty"`
1556
1557
1558
1559 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
1560
1561
1562
1563 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
1564
1565
1566
1567 Archived bool `json:"archived,omitempty"`
1568
1569
1570
1571 AudienceSegmentId int64 `json:"audienceSegmentId,omitempty,string"`
1572
1573
1574
1575 CampaignId int64 `json:"campaignId,omitempty,string"`
1576
1577
1578
1579 CampaignIdDimensionValue *DimensionValue `json:"campaignIdDimensionValue,omitempty"`
1580
1581
1582
1583 ClickThroughUrl *ClickThroughUrl `json:"clickThroughUrl,omitempty"`
1584
1585
1586
1587
1588 ClickThroughUrlSuffixProperties *ClickThroughUrlSuffixProperties `json:"clickThroughUrlSuffixProperties,omitempty"`
1589
1590
1591 Comments string `json:"comments,omitempty"`
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610 Compatibility string `json:"compatibility,omitempty"`
1611
1612
1613
1614 CreateInfo *LastModifiedInfo `json:"createInfo,omitempty"`
1615
1616
1617
1618
1619
1620 CreativeGroupAssignments []*CreativeGroupAssignment `json:"creativeGroupAssignments,omitempty"`
1621
1622
1623
1624
1625
1626 CreativeRotation *CreativeRotation `json:"creativeRotation,omitempty"`
1627
1628
1629
1630
1631 DayPartTargeting *DayPartTargeting `json:"dayPartTargeting,omitempty"`
1632
1633
1634
1635 DefaultClickThroughEventTagProperties *DefaultClickThroughEventTagProperties `json:"defaultClickThroughEventTagProperties,omitempty"`
1636
1637
1638
1639
1640
1641
1642 DeliverySchedule *DeliverySchedule `json:"deliverySchedule,omitempty"`
1643
1644
1645
1646
1647 DynamicClickTracker bool `json:"dynamicClickTracker,omitempty"`
1648
1649
1650
1651 EndTime string `json:"endTime,omitempty"`
1652
1653
1654 EventTagOverrides []*EventTagOverride `json:"eventTagOverrides,omitempty"`
1655
1656
1657
1658
1659 GeoTargeting *GeoTargeting `json:"geoTargeting,omitempty"`
1660
1661
1662 Id int64 `json:"id,omitempty,string"`
1663
1664
1665
1666 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
1667
1668
1669
1670
1671 KeyValueTargetingExpression *KeyValueTargetingExpression `json:"keyValueTargetingExpression,omitempty"`
1672
1673
1674
1675 Kind string `json:"kind,omitempty"`
1676
1677
1678
1679
1680 LanguageTargeting *LanguageTargeting `json:"languageTargeting,omitempty"`
1681
1682
1683
1684 LastModifiedInfo *LastModifiedInfo `json:"lastModifiedInfo,omitempty"`
1685
1686
1687
1688 Name string `json:"name,omitempty"`
1689
1690
1691 PlacementAssignments []*PlacementAssignment `json:"placementAssignments,omitempty"`
1692
1693
1694
1695
1696 RemarketingListExpression *ListTargetingExpression `json:"remarketingListExpression,omitempty"`
1697
1698
1699 Size *Size `json:"size,omitempty"`
1700
1701
1702
1703 SslCompliant bool `json:"sslCompliant,omitempty"`
1704
1705
1706
1707 SslRequired bool `json:"sslRequired,omitempty"`
1708
1709
1710
1711
1712 StartTime string `json:"startTime,omitempty"`
1713
1714
1715
1716 SubaccountId int64 `json:"subaccountId,omitempty,string"`
1717
1718
1719
1720
1721
1722
1723
1724 TargetingTemplateId int64 `json:"targetingTemplateId,omitempty,string"`
1725
1726
1727
1728
1729 TechnologyTargeting *TechnologyTargeting `json:"technologyTargeting,omitempty"`
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740 Type string `json:"type,omitempty"`
1741
1742
1743
1744 googleapi.ServerResponse `json:"-"`
1745
1746
1747
1748
1749
1750
1751
1752 ForceSendFields []string `json:"-"`
1753
1754
1755
1756
1757
1758
1759
1760 NullFields []string `json:"-"`
1761 }
1762
1763 func (s *Ad) MarshalJSON() ([]byte, error) {
1764 type NoMethod Ad
1765 raw := NoMethod(*s)
1766 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1767 }
1768
1769
1770 type AdBlockingConfiguration struct {
1771
1772
1773 ClickThroughUrl string `json:"clickThroughUrl,omitempty"`
1774
1775
1776
1777
1778 CreativeBundleId int64 `json:"creativeBundleId,omitempty,string"`
1779
1780
1781
1782
1783
1784
1785 Enabled bool `json:"enabled,omitempty"`
1786
1787
1788
1789
1790
1791 OverrideClickThroughUrl bool `json:"overrideClickThroughUrl,omitempty"`
1792
1793
1794
1795
1796
1797
1798
1799 ForceSendFields []string `json:"-"`
1800
1801
1802
1803
1804
1805
1806
1807
1808 NullFields []string `json:"-"`
1809 }
1810
1811 func (s *AdBlockingConfiguration) MarshalJSON() ([]byte, error) {
1812 type NoMethod AdBlockingConfiguration
1813 raw := NoMethod(*s)
1814 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1815 }
1816
1817
1818 type AdSlot struct {
1819
1820 Comment string `json:"comment,omitempty"`
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836 Compatibility string `json:"compatibility,omitempty"`
1837
1838
1839 Height int64 `json:"height,omitempty,string"`
1840
1841
1842
1843 LinkedPlacementId int64 `json:"linkedPlacementId,omitempty,string"`
1844
1845
1846 Name string `json:"name,omitempty"`
1847
1848
1849
1850
1851
1852
1853 PaymentSourceType string `json:"paymentSourceType,omitempty"`
1854
1855
1856 Primary bool `json:"primary,omitempty"`
1857
1858
1859 Width int64 `json:"width,omitempty,string"`
1860
1861
1862
1863
1864
1865
1866
1867 ForceSendFields []string `json:"-"`
1868
1869
1870
1871
1872
1873
1874
1875 NullFields []string `json:"-"`
1876 }
1877
1878 func (s *AdSlot) MarshalJSON() ([]byte, error) {
1879 type NoMethod AdSlot
1880 raw := NoMethod(*s)
1881 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1882 }
1883
1884
1885 type AdsListResponse struct {
1886
1887 Ads []*Ad `json:"ads,omitempty"`
1888
1889
1890
1891 Kind string `json:"kind,omitempty"`
1892
1893
1894
1895 NextPageToken string `json:"nextPageToken,omitempty"`
1896
1897
1898
1899 googleapi.ServerResponse `json:"-"`
1900
1901
1902
1903
1904
1905
1906
1907 ForceSendFields []string `json:"-"`
1908
1909
1910
1911
1912
1913
1914
1915 NullFields []string `json:"-"`
1916 }
1917
1918 func (s *AdsListResponse) MarshalJSON() ([]byte, error) {
1919 type NoMethod AdsListResponse
1920 raw := NoMethod(*s)
1921 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1922 }
1923
1924
1925 type Advertiser struct {
1926
1927
1928 AccountId int64 `json:"accountId,omitempty,string"`
1929
1930
1931
1932
1933 AdvertiserGroupId int64 `json:"advertiserGroupId,omitempty,string"`
1934
1935
1936
1937
1938 ClickThroughUrlSuffix string `json:"clickThroughUrlSuffix,omitempty"`
1939
1940
1941
1942 DefaultClickThroughEventTagId int64 `json:"defaultClickThroughEventTagId,omitempty,string"`
1943
1944
1945
1946 DefaultEmail string `json:"defaultEmail,omitempty"`
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959 FloodlightConfigurationId int64 `json:"floodlightConfigurationId,omitempty,string"`
1960
1961
1962
1963
1964 FloodlightConfigurationIdDimensionValue *DimensionValue `json:"floodlightConfigurationIdDimensionValue,omitempty"`
1965
1966
1967 Id int64 `json:"id,omitempty,string"`
1968
1969
1970
1971 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
1972
1973
1974
1975 Kind string `json:"kind,omitempty"`
1976
1977
1978
1979
1980 Name string `json:"name,omitempty"`
1981
1982
1983
1984
1985
1986
1987
1988 OriginalFloodlightConfigurationId int64 `json:"originalFloodlightConfigurationId,omitempty,string"`
1989
1990
1991
1992
1993
1994
1995 Status string `json:"status,omitempty"`
1996
1997
1998
1999 SubaccountId int64 `json:"subaccountId,omitempty,string"`
2000
2001
2002 Suspended bool `json:"suspended,omitempty"`
2003
2004
2005
2006 googleapi.ServerResponse `json:"-"`
2007
2008
2009
2010
2011
2012
2013
2014 ForceSendFields []string `json:"-"`
2015
2016
2017
2018
2019
2020
2021
2022 NullFields []string `json:"-"`
2023 }
2024
2025 func (s *Advertiser) MarshalJSON() ([]byte, error) {
2026 type NoMethod Advertiser
2027 raw := NoMethod(*s)
2028 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2029 }
2030
2031
2032
2033 type AdvertiserGroup struct {
2034
2035
2036 AccountId int64 `json:"accountId,omitempty,string"`
2037
2038
2039
2040 Id int64 `json:"id,omitempty,string"`
2041
2042
2043
2044 Kind string `json:"kind,omitempty"`
2045
2046
2047
2048
2049 Name string `json:"name,omitempty"`
2050
2051
2052
2053 googleapi.ServerResponse `json:"-"`
2054
2055
2056
2057
2058
2059
2060
2061 ForceSendFields []string `json:"-"`
2062
2063
2064
2065
2066
2067
2068
2069 NullFields []string `json:"-"`
2070 }
2071
2072 func (s *AdvertiserGroup) MarshalJSON() ([]byte, error) {
2073 type NoMethod AdvertiserGroup
2074 raw := NoMethod(*s)
2075 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2076 }
2077
2078
2079 type AdvertiserGroupsListResponse struct {
2080
2081 AdvertiserGroups []*AdvertiserGroup `json:"advertiserGroups,omitempty"`
2082
2083
2084
2085 Kind string `json:"kind,omitempty"`
2086
2087
2088
2089 NextPageToken string `json:"nextPageToken,omitempty"`
2090
2091
2092
2093 googleapi.ServerResponse `json:"-"`
2094
2095
2096
2097
2098
2099
2100
2101 ForceSendFields []string `json:"-"`
2102
2103
2104
2105
2106
2107
2108
2109
2110 NullFields []string `json:"-"`
2111 }
2112
2113 func (s *AdvertiserGroupsListResponse) MarshalJSON() ([]byte, error) {
2114 type NoMethod AdvertiserGroupsListResponse
2115 raw := NoMethod(*s)
2116 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2117 }
2118
2119
2120 type AdvertiserLandingPagesListResponse struct {
2121
2122
2123 Kind string `json:"kind,omitempty"`
2124
2125
2126 LandingPages []*LandingPage `json:"landingPages,omitempty"`
2127
2128
2129
2130 NextPageToken string `json:"nextPageToken,omitempty"`
2131
2132
2133
2134 googleapi.ServerResponse `json:"-"`
2135
2136
2137
2138
2139
2140
2141
2142 ForceSendFields []string `json:"-"`
2143
2144
2145
2146
2147
2148
2149
2150 NullFields []string `json:"-"`
2151 }
2152
2153 func (s *AdvertiserLandingPagesListResponse) MarshalJSON() ([]byte, error) {
2154 type NoMethod AdvertiserLandingPagesListResponse
2155 raw := NoMethod(*s)
2156 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2157 }
2158
2159
2160 type AdvertisersListResponse struct {
2161
2162 Advertisers []*Advertiser `json:"advertisers,omitempty"`
2163
2164
2165
2166 Kind string `json:"kind,omitempty"`
2167
2168
2169
2170 NextPageToken string `json:"nextPageToken,omitempty"`
2171
2172
2173
2174 googleapi.ServerResponse `json:"-"`
2175
2176
2177
2178
2179
2180
2181
2182 ForceSendFields []string `json:"-"`
2183
2184
2185
2186
2187
2188
2189
2190 NullFields []string `json:"-"`
2191 }
2192
2193 func (s *AdvertisersListResponse) MarshalJSON() ([]byte, error) {
2194 type NoMethod AdvertisersListResponse
2195 raw := NoMethod(*s)
2196 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2197 }
2198
2199
2200 type AudienceSegment struct {
2201
2202
2203
2204
2205 Allocation int64 `json:"allocation,omitempty"`
2206
2207
2208
2209 Id int64 `json:"id,omitempty,string"`
2210
2211
2212
2213 Name string `json:"name,omitempty"`
2214
2215
2216
2217
2218
2219
2220
2221 ForceSendFields []string `json:"-"`
2222
2223
2224
2225
2226
2227
2228
2229 NullFields []string `json:"-"`
2230 }
2231
2232 func (s *AudienceSegment) MarshalJSON() ([]byte, error) {
2233 type NoMethod AudienceSegment
2234 raw := NoMethod(*s)
2235 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2236 }
2237
2238
2239 type AudienceSegmentGroup struct {
2240
2241
2242 AudienceSegments []*AudienceSegment `json:"audienceSegments,omitempty"`
2243
2244
2245
2246 Id int64 `json:"id,omitempty,string"`
2247
2248
2249
2250 Name string `json:"name,omitempty"`
2251
2252
2253
2254
2255
2256
2257
2258 ForceSendFields []string `json:"-"`
2259
2260
2261
2262
2263
2264
2265
2266
2267 NullFields []string `json:"-"`
2268 }
2269
2270 func (s *AudienceSegmentGroup) MarshalJSON() ([]byte, error) {
2271 type NoMethod AudienceSegmentGroup
2272 raw := NoMethod(*s)
2273 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2274 }
2275
2276
2277
2278 type Browser struct {
2279
2280
2281 BrowserVersionId int64 `json:"browserVersionId,omitempty,string"`
2282
2283
2284
2285 DartId int64 `json:"dartId,omitempty,string"`
2286
2287
2288
2289 Kind string `json:"kind,omitempty"`
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300 MajorVersion string `json:"majorVersion,omitempty"`
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311 MinorVersion string `json:"minorVersion,omitempty"`
2312
2313
2314 Name string `json:"name,omitempty"`
2315
2316
2317
2318
2319
2320
2321
2322 ForceSendFields []string `json:"-"`
2323
2324
2325
2326
2327
2328
2329
2330
2331 NullFields []string `json:"-"`
2332 }
2333
2334 func (s *Browser) MarshalJSON() ([]byte, error) {
2335 type NoMethod Browser
2336 raw := NoMethod(*s)
2337 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2338 }
2339
2340
2341 type BrowsersListResponse struct {
2342
2343 Browsers []*Browser `json:"browsers,omitempty"`
2344
2345
2346
2347 Kind string `json:"kind,omitempty"`
2348
2349
2350
2351 googleapi.ServerResponse `json:"-"`
2352
2353
2354
2355
2356
2357
2358
2359 ForceSendFields []string `json:"-"`
2360
2361
2362
2363
2364
2365
2366
2367 NullFields []string `json:"-"`
2368 }
2369
2370 func (s *BrowsersListResponse) MarshalJSON() ([]byte, error) {
2371 type NoMethod BrowsersListResponse
2372 raw := NoMethod(*s)
2373 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2374 }
2375
2376
2377 type Campaign struct {
2378
2379
2380 AccountId int64 `json:"accountId,omitempty,string"`
2381
2382
2383 AdBlockingConfiguration *AdBlockingConfiguration `json:"adBlockingConfiguration,omitempty"`
2384
2385
2386
2387 AdditionalCreativeOptimizationConfigurations []*CreativeOptimizationConfiguration `json:"additionalCreativeOptimizationConfigurations,omitempty"`
2388
2389
2390 AdvertiserGroupId int64 `json:"advertiserGroupId,omitempty,string"`
2391
2392
2393
2394 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
2395
2396
2397
2398 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
2399
2400
2401 Archived bool `json:"archived,omitempty"`
2402
2403
2404
2405 AudienceSegmentGroups []*AudienceSegmentGroup `json:"audienceSegmentGroups,omitempty"`
2406
2407
2408
2409 BillingInvoiceCode string `json:"billingInvoiceCode,omitempty"`
2410
2411
2412
2413 ClickThroughUrlSuffixProperties *ClickThroughUrlSuffixProperties `json:"clickThroughUrlSuffixProperties,omitempty"`
2414
2415
2416
2417 Comment string `json:"comment,omitempty"`
2418
2419
2420
2421 CreateInfo *LastModifiedInfo `json:"createInfo,omitempty"`
2422
2423
2424
2425 CreativeGroupIds googleapi.Int64s `json:"creativeGroupIds,omitempty"`
2426
2427
2428
2429 CreativeOptimizationConfiguration *CreativeOptimizationConfiguration `json:"creativeOptimizationConfiguration,omitempty"`
2430
2431
2432
2433 DefaultClickThroughEventTagProperties *DefaultClickThroughEventTagProperties `json:"defaultClickThroughEventTagProperties,omitempty"`
2434
2435
2436 DefaultLandingPageId int64 `json:"defaultLandingPageId,omitempty,string"`
2437
2438
2439
2440
2441
2442
2443
2444
2445 EndDate string `json:"endDate,omitempty"`
2446
2447
2448
2449 EventTagOverrides []*EventTagOverride `json:"eventTagOverrides,omitempty"`
2450
2451
2452 ExternalId string `json:"externalId,omitempty"`
2453
2454
2455 Id int64 `json:"id,omitempty,string"`
2456
2457
2458
2459 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
2460
2461
2462
2463 Kind string `json:"kind,omitempty"`
2464
2465
2466
2467 LastModifiedInfo *LastModifiedInfo `json:"lastModifiedInfo,omitempty"`
2468
2469
2470
2471
2472 Name string `json:"name,omitempty"`
2473
2474
2475
2476 NielsenOcrEnabled bool `json:"nielsenOcrEnabled,omitempty"`
2477
2478
2479
2480
2481
2482 StartDate string `json:"startDate,omitempty"`
2483
2484
2485
2486 SubaccountId int64 `json:"subaccountId,omitempty,string"`
2487
2488
2489 TraffickerEmails []string `json:"traffickerEmails,omitempty"`
2490
2491
2492
2493 googleapi.ServerResponse `json:"-"`
2494
2495
2496
2497
2498
2499
2500
2501 ForceSendFields []string `json:"-"`
2502
2503
2504
2505
2506
2507
2508
2509 NullFields []string `json:"-"`
2510 }
2511
2512 func (s *Campaign) MarshalJSON() ([]byte, error) {
2513 type NoMethod Campaign
2514 raw := NoMethod(*s)
2515 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2516 }
2517
2518
2519
2520 type CampaignCreativeAssociation struct {
2521
2522
2523 CreativeId int64 `json:"creativeId,omitempty,string"`
2524
2525
2526
2527 Kind string `json:"kind,omitempty"`
2528
2529
2530
2531 googleapi.ServerResponse `json:"-"`
2532
2533
2534
2535
2536
2537
2538
2539 ForceSendFields []string `json:"-"`
2540
2541
2542
2543
2544
2545
2546
2547 NullFields []string `json:"-"`
2548 }
2549
2550 func (s *CampaignCreativeAssociation) MarshalJSON() ([]byte, error) {
2551 type NoMethod CampaignCreativeAssociation
2552 raw := NoMethod(*s)
2553 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2554 }
2555
2556
2557
2558 type CampaignCreativeAssociationsListResponse struct {
2559
2560
2561 CampaignCreativeAssociations []*CampaignCreativeAssociation `json:"campaignCreativeAssociations,omitempty"`
2562
2563
2564
2565 Kind string `json:"kind,omitempty"`
2566
2567
2568
2569 NextPageToken string `json:"nextPageToken,omitempty"`
2570
2571
2572
2573 googleapi.ServerResponse `json:"-"`
2574
2575
2576
2577
2578
2579
2580
2581
2582 ForceSendFields []string `json:"-"`
2583
2584
2585
2586
2587
2588
2589
2590
2591 NullFields []string `json:"-"`
2592 }
2593
2594 func (s *CampaignCreativeAssociationsListResponse) MarshalJSON() ([]byte, error) {
2595 type NoMethod CampaignCreativeAssociationsListResponse
2596 raw := NoMethod(*s)
2597 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2598 }
2599
2600
2601 type CampaignsListResponse struct {
2602
2603 Campaigns []*Campaign `json:"campaigns,omitempty"`
2604
2605
2606
2607 Kind string `json:"kind,omitempty"`
2608
2609
2610
2611 NextPageToken string `json:"nextPageToken,omitempty"`
2612
2613
2614
2615 googleapi.ServerResponse `json:"-"`
2616
2617
2618
2619
2620
2621
2622
2623 ForceSendFields []string `json:"-"`
2624
2625
2626
2627
2628
2629
2630
2631 NullFields []string `json:"-"`
2632 }
2633
2634 func (s *CampaignsListResponse) MarshalJSON() ([]byte, error) {
2635 type NoMethod CampaignsListResponse
2636 raw := NoMethod(*s)
2637 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2638 }
2639
2640
2641 type ChangeLog struct {
2642
2643 AccountId int64 `json:"accountId,omitempty,string"`
2644
2645
2646 Action string `json:"action,omitempty"`
2647
2648
2649 ChangeTime string `json:"changeTime,omitempty"`
2650
2651
2652 FieldName string `json:"fieldName,omitempty"`
2653
2654
2655 Id int64 `json:"id,omitempty,string"`
2656
2657
2658
2659 Kind string `json:"kind,omitempty"`
2660
2661
2662 NewValue string `json:"newValue,omitempty"`
2663
2664
2665
2666 ObjectId int64 `json:"objectId,omitempty,string"`
2667
2668
2669 ObjectType string `json:"objectType,omitempty"`
2670
2671
2672 OldValue string `json:"oldValue,omitempty"`
2673
2674
2675 SubaccountId int64 `json:"subaccountId,omitempty,string"`
2676
2677
2678
2679
2680 TransactionId int64 `json:"transactionId,omitempty,string"`
2681
2682
2683 UserProfileId int64 `json:"userProfileId,omitempty,string"`
2684
2685
2686
2687 UserProfileName string `json:"userProfileName,omitempty"`
2688
2689
2690
2691 googleapi.ServerResponse `json:"-"`
2692
2693
2694
2695
2696
2697
2698
2699 ForceSendFields []string `json:"-"`
2700
2701
2702
2703
2704
2705
2706
2707 NullFields []string `json:"-"`
2708 }
2709
2710 func (s *ChangeLog) MarshalJSON() ([]byte, error) {
2711 type NoMethod ChangeLog
2712 raw := NoMethod(*s)
2713 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2714 }
2715
2716
2717 type ChangeLogsListResponse struct {
2718
2719 ChangeLogs []*ChangeLog `json:"changeLogs,omitempty"`
2720
2721
2722
2723 Kind string `json:"kind,omitempty"`
2724
2725
2726
2727 NextPageToken string `json:"nextPageToken,omitempty"`
2728
2729
2730
2731 googleapi.ServerResponse `json:"-"`
2732
2733
2734
2735
2736
2737
2738
2739 ForceSendFields []string `json:"-"`
2740
2741
2742
2743
2744
2745
2746
2747 NullFields []string `json:"-"`
2748 }
2749
2750 func (s *ChangeLogsListResponse) MarshalJSON() ([]byte, error) {
2751 type NoMethod ChangeLogsListResponse
2752 raw := NoMethod(*s)
2753 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2754 }
2755
2756
2757 type CitiesListResponse struct {
2758
2759 Cities []*City `json:"cities,omitempty"`
2760
2761
2762
2763 Kind string `json:"kind,omitempty"`
2764
2765
2766
2767 googleapi.ServerResponse `json:"-"`
2768
2769
2770
2771
2772
2773
2774
2775 ForceSendFields []string `json:"-"`
2776
2777
2778
2779
2780
2781
2782
2783 NullFields []string `json:"-"`
2784 }
2785
2786 func (s *CitiesListResponse) MarshalJSON() ([]byte, error) {
2787 type NoMethod CitiesListResponse
2788 raw := NoMethod(*s)
2789 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2790 }
2791
2792
2793 type City struct {
2794
2795 CountryCode string `json:"countryCode,omitempty"`
2796
2797
2798 CountryDartId int64 `json:"countryDartId,omitempty,string"`
2799
2800
2801
2802 DartId int64 `json:"dartId,omitempty,string"`
2803
2804
2805
2806 Kind string `json:"kind,omitempty"`
2807
2808
2809
2810 MetroCode string `json:"metroCode,omitempty"`
2811
2812
2813 MetroDmaId int64 `json:"metroDmaId,omitempty,string"`
2814
2815
2816 Name string `json:"name,omitempty"`
2817
2818
2819 RegionCode string `json:"regionCode,omitempty"`
2820
2821
2822 RegionDartId int64 `json:"regionDartId,omitempty,string"`
2823
2824
2825
2826
2827
2828
2829
2830 ForceSendFields []string `json:"-"`
2831
2832
2833
2834
2835
2836
2837
2838 NullFields []string `json:"-"`
2839 }
2840
2841 func (s *City) MarshalJSON() ([]byte, error) {
2842 type NoMethod City
2843 raw := NoMethod(*s)
2844 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2845 }
2846
2847
2848 type ClickTag struct {
2849
2850
2851 ClickThroughUrl *CreativeClickThroughUrl `json:"clickThroughUrl,omitempty"`
2852
2853
2854
2855
2856 EventName string `json:"eventName,omitempty"`
2857
2858
2859
2860
2861 Name string `json:"name,omitempty"`
2862
2863
2864
2865
2866
2867
2868
2869 ForceSendFields []string `json:"-"`
2870
2871
2872
2873
2874
2875
2876
2877
2878 NullFields []string `json:"-"`
2879 }
2880
2881 func (s *ClickTag) MarshalJSON() ([]byte, error) {
2882 type NoMethod ClickTag
2883 raw := NoMethod(*s)
2884 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2885 }
2886
2887
2888 type ClickThroughUrl struct {
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898 ComputedClickThroughUrl string `json:"computedClickThroughUrl,omitempty"`
2899
2900
2901
2902
2903 CustomClickThroughUrl string `json:"customClickThroughUrl,omitempty"`
2904
2905
2906
2907 DefaultLandingPage bool `json:"defaultLandingPage,omitempty"`
2908
2909
2910
2911 LandingPageId int64 `json:"landingPageId,omitempty,string"`
2912
2913
2914
2915
2916
2917
2918
2919
2920 ForceSendFields []string `json:"-"`
2921
2922
2923
2924
2925
2926
2927
2928
2929 NullFields []string `json:"-"`
2930 }
2931
2932 func (s *ClickThroughUrl) MarshalJSON() ([]byte, error) {
2933 type NoMethod ClickThroughUrl
2934 raw := NoMethod(*s)
2935 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2936 }
2937
2938
2939 type ClickThroughUrlSuffixProperties struct {
2940
2941
2942 ClickThroughUrlSuffix string `json:"clickThroughUrlSuffix,omitempty"`
2943
2944
2945
2946 OverrideInheritedSuffix bool `json:"overrideInheritedSuffix,omitempty"`
2947
2948
2949
2950
2951
2952
2953
2954
2955 ForceSendFields []string `json:"-"`
2956
2957
2958
2959
2960
2961
2962
2963
2964 NullFields []string `json:"-"`
2965 }
2966
2967 func (s *ClickThroughUrlSuffixProperties) MarshalJSON() ([]byte, error) {
2968 type NoMethod ClickThroughUrlSuffixProperties
2969 raw := NoMethod(*s)
2970 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2971 }
2972
2973
2974 type CompanionClickThroughOverride struct {
2975
2976
2977 ClickThroughUrl *ClickThroughUrl `json:"clickThroughUrl,omitempty"`
2978
2979
2980
2981 CreativeId int64 `json:"creativeId,omitempty,string"`
2982
2983
2984
2985
2986
2987
2988
2989 ForceSendFields []string `json:"-"`
2990
2991
2992
2993
2994
2995
2996
2997
2998 NullFields []string `json:"-"`
2999 }
3000
3001 func (s *CompanionClickThroughOverride) MarshalJSON() ([]byte, error) {
3002 type NoMethod CompanionClickThroughOverride
3003 raw := NoMethod(*s)
3004 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3005 }
3006
3007
3008 type CompanionSetting struct {
3009
3010
3011 CompanionsDisabled bool `json:"companionsDisabled,omitempty"`
3012
3013
3014
3015
3016 EnabledSizes []*Size `json:"enabledSizes,omitempty"`
3017
3018
3019 ImageOnly bool `json:"imageOnly,omitempty"`
3020
3021
3022
3023 Kind string `json:"kind,omitempty"`
3024
3025
3026
3027
3028
3029
3030
3031 ForceSendFields []string `json:"-"`
3032
3033
3034
3035
3036
3037
3038
3039
3040 NullFields []string `json:"-"`
3041 }
3042
3043 func (s *CompanionSetting) MarshalJSON() ([]byte, error) {
3044 type NoMethod CompanionSetting
3045 raw := NoMethod(*s)
3046 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3047 }
3048
3049
3050
3051 type CompatibleFields struct {
3052
3053
3054
3055 CrossDimensionReachReportCompatibleFields *CrossDimensionReachReportCompatibleFields `json:"crossDimensionReachReportCompatibleFields,omitempty"`
3056
3057
3058
3059 FloodlightReportCompatibleFields *FloodlightReportCompatibleFields `json:"floodlightReportCompatibleFields,omitempty"`
3060
3061
3062
3063 Kind string `json:"kind,omitempty"`
3064
3065
3066
3067 PathToConversionReportCompatibleFields *PathToConversionReportCompatibleFields `json:"pathToConversionReportCompatibleFields,omitempty"`
3068
3069
3070
3071 ReachReportCompatibleFields *ReachReportCompatibleFields `json:"reachReportCompatibleFields,omitempty"`
3072
3073
3074
3075 ReportCompatibleFields *ReportCompatibleFields `json:"reportCompatibleFields,omitempty"`
3076
3077
3078
3079 googleapi.ServerResponse `json:"-"`
3080
3081
3082
3083
3084
3085
3086
3087
3088 ForceSendFields []string `json:"-"`
3089
3090
3091
3092
3093
3094
3095
3096
3097 NullFields []string `json:"-"`
3098 }
3099
3100 func (s *CompatibleFields) MarshalJSON() ([]byte, error) {
3101 type NoMethod CompatibleFields
3102 raw := NoMethod(*s)
3103 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3104 }
3105
3106
3107
3108
3109 type ConnectionType struct {
3110
3111 Id int64 `json:"id,omitempty,string"`
3112
3113
3114
3115 Kind string `json:"kind,omitempty"`
3116
3117
3118 Name string `json:"name,omitempty"`
3119
3120
3121
3122 googleapi.ServerResponse `json:"-"`
3123
3124
3125
3126
3127
3128
3129
3130 ForceSendFields []string `json:"-"`
3131
3132
3133
3134
3135
3136
3137
3138 NullFields []string `json:"-"`
3139 }
3140
3141 func (s *ConnectionType) MarshalJSON() ([]byte, error) {
3142 type NoMethod ConnectionType
3143 raw := NoMethod(*s)
3144 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3145 }
3146
3147
3148 type ConnectionTypesListResponse struct {
3149
3150
3151 ConnectionTypes []*ConnectionType `json:"connectionTypes,omitempty"`
3152
3153
3154
3155 Kind string `json:"kind,omitempty"`
3156
3157
3158
3159 googleapi.ServerResponse `json:"-"`
3160
3161
3162
3163
3164
3165
3166
3167 ForceSendFields []string `json:"-"`
3168
3169
3170
3171
3172
3173
3174
3175
3176 NullFields []string `json:"-"`
3177 }
3178
3179 func (s *ConnectionTypesListResponse) MarshalJSON() ([]byte, error) {
3180 type NoMethod ConnectionTypesListResponse
3181 raw := NoMethod(*s)
3182 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3183 }
3184
3185
3186 type ContentCategoriesListResponse struct {
3187
3188 ContentCategories []*ContentCategory `json:"contentCategories,omitempty"`
3189
3190
3191
3192 Kind string `json:"kind,omitempty"`
3193
3194
3195
3196 NextPageToken string `json:"nextPageToken,omitempty"`
3197
3198
3199
3200 googleapi.ServerResponse `json:"-"`
3201
3202
3203
3204
3205
3206
3207
3208 ForceSendFields []string `json:"-"`
3209
3210
3211
3212
3213
3214
3215
3216
3217 NullFields []string `json:"-"`
3218 }
3219
3220 func (s *ContentCategoriesListResponse) MarshalJSON() ([]byte, error) {
3221 type NoMethod ContentCategoriesListResponse
3222 raw := NoMethod(*s)
3223 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3224 }
3225
3226
3227
3228 type ContentCategory struct {
3229
3230
3231 AccountId int64 `json:"accountId,omitempty,string"`
3232
3233
3234
3235 Id int64 `json:"id,omitempty,string"`
3236
3237
3238
3239 Kind string `json:"kind,omitempty"`
3240
3241
3242
3243
3244 Name string `json:"name,omitempty"`
3245
3246
3247
3248 googleapi.ServerResponse `json:"-"`
3249
3250
3251
3252
3253
3254
3255
3256 ForceSendFields []string `json:"-"`
3257
3258
3259
3260
3261
3262
3263
3264 NullFields []string `json:"-"`
3265 }
3266
3267 func (s *ContentCategory) MarshalJSON() ([]byte, error) {
3268 type NoMethod ContentCategory
3269 raw := NoMethod(*s)
3270 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3271 }
3272
3273
3274
3275 type Conversion struct {
3276
3277
3278 ChildDirectedTreatment bool `json:"childDirectedTreatment,omitempty"`
3279
3280
3281 CustomVariables []*CustomFloodlightVariable `json:"customVariables,omitempty"`
3282
3283
3284
3285
3286
3287
3288 EncryptedUserId string `json:"encryptedUserId,omitempty"`
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299 EncryptedUserIdCandidates []string `json:"encryptedUserIdCandidates,omitempty"`
3300
3301
3302
3303 FloodlightActivityId int64 `json:"floodlightActivityId,omitempty,string"`
3304
3305
3306
3307 FloodlightConfigurationId int64 `json:"floodlightConfigurationId,omitempty,string"`
3308
3309
3310
3311
3312
3313 Gclid string `json:"gclid,omitempty"`
3314
3315
3316
3317 Kind string `json:"kind,omitempty"`
3318
3319
3320
3321
3322 LimitAdTracking bool `json:"limitAdTracking,omitempty"`
3323
3324
3325
3326
3327
3328 MobileDeviceId string `json:"mobileDeviceId,omitempty"`
3329
3330
3331
3332 NonPersonalizedAd bool `json:"nonPersonalizedAd,omitempty"`
3333
3334
3335
3336
3337 Ordinal string `json:"ordinal,omitempty"`
3338
3339
3340 Quantity int64 `json:"quantity,omitempty,string"`
3341
3342
3343
3344 TimestampMicros int64 `json:"timestampMicros,omitempty,string"`
3345
3346
3347
3348
3349 TreatmentForUnderage bool `json:"treatmentForUnderage,omitempty"`
3350
3351
3352 Value float64 `json:"value,omitempty"`
3353
3354
3355
3356
3357
3358
3359
3360
3361 ForceSendFields []string `json:"-"`
3362
3363
3364
3365
3366
3367
3368
3369
3370 NullFields []string `json:"-"`
3371 }
3372
3373 func (s *Conversion) MarshalJSON() ([]byte, error) {
3374 type NoMethod Conversion
3375 raw := NoMethod(*s)
3376 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3377 }
3378
3379 func (s *Conversion) UnmarshalJSON(data []byte) error {
3380 type NoMethod Conversion
3381 var s1 struct {
3382 Value gensupport.JSONFloat64 `json:"value"`
3383 *NoMethod
3384 }
3385 s1.NoMethod = (*NoMethod)(s)
3386 if err := json.Unmarshal(data, &s1); err != nil {
3387 return err
3388 }
3389 s.Value = float64(s1.Value)
3390 return nil
3391 }
3392
3393
3394
3395 type ConversionError struct {
3396
3397
3398
3399
3400
3401
3402
3403 Code string `json:"code,omitempty"`
3404
3405
3406
3407 Kind string `json:"kind,omitempty"`
3408
3409
3410 Message string `json:"message,omitempty"`
3411
3412
3413
3414
3415
3416
3417
3418 ForceSendFields []string `json:"-"`
3419
3420
3421
3422
3423
3424
3425
3426 NullFields []string `json:"-"`
3427 }
3428
3429 func (s *ConversionError) MarshalJSON() ([]byte, error) {
3430 type NoMethod ConversionError
3431 raw := NoMethod(*s)
3432 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3433 }
3434
3435
3436
3437 type ConversionStatus struct {
3438
3439 Conversion *Conversion `json:"conversion,omitempty"`
3440
3441
3442 Errors []*ConversionError `json:"errors,omitempty"`
3443
3444
3445
3446 Kind string `json:"kind,omitempty"`
3447
3448
3449
3450
3451
3452
3453
3454 ForceSendFields []string `json:"-"`
3455
3456
3457
3458
3459
3460
3461
3462 NullFields []string `json:"-"`
3463 }
3464
3465 func (s *ConversionStatus) MarshalJSON() ([]byte, error) {
3466 type NoMethod ConversionStatus
3467 raw := NoMethod(*s)
3468 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3469 }
3470
3471
3472 type ConversionsBatchInsertRequest struct {
3473
3474 Conversions []*Conversion `json:"conversions,omitempty"`
3475
3476
3477
3478
3479 EncryptionInfo *EncryptionInfo `json:"encryptionInfo,omitempty"`
3480
3481
3482
3483 Kind string `json:"kind,omitempty"`
3484
3485
3486
3487
3488
3489
3490
3491 ForceSendFields []string `json:"-"`
3492
3493
3494
3495
3496
3497
3498
3499 NullFields []string `json:"-"`
3500 }
3501
3502 func (s *ConversionsBatchInsertRequest) MarshalJSON() ([]byte, error) {
3503 type NoMethod ConversionsBatchInsertRequest
3504 raw := NoMethod(*s)
3505 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3506 }
3507
3508
3509 type ConversionsBatchInsertResponse struct {
3510
3511 HasFailures bool `json:"hasFailures,omitempty"`
3512
3513
3514
3515 Kind string `json:"kind,omitempty"`
3516
3517
3518
3519 Status []*ConversionStatus `json:"status,omitempty"`
3520
3521
3522
3523 googleapi.ServerResponse `json:"-"`
3524
3525
3526
3527
3528
3529
3530
3531 ForceSendFields []string `json:"-"`
3532
3533
3534
3535
3536
3537
3538
3539 NullFields []string `json:"-"`
3540 }
3541
3542 func (s *ConversionsBatchInsertResponse) MarshalJSON() ([]byte, error) {
3543 type NoMethod ConversionsBatchInsertResponse
3544 raw := NoMethod(*s)
3545 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3546 }
3547
3548
3549 type ConversionsBatchUpdateRequest struct {
3550
3551 Conversions []*Conversion `json:"conversions,omitempty"`
3552
3553
3554
3555 EncryptionInfo *EncryptionInfo `json:"encryptionInfo,omitempty"`
3556
3557
3558
3559 Kind string `json:"kind,omitempty"`
3560
3561
3562
3563
3564
3565
3566
3567 ForceSendFields []string `json:"-"`
3568
3569
3570
3571
3572
3573
3574
3575 NullFields []string `json:"-"`
3576 }
3577
3578 func (s *ConversionsBatchUpdateRequest) MarshalJSON() ([]byte, error) {
3579 type NoMethod ConversionsBatchUpdateRequest
3580 raw := NoMethod(*s)
3581 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3582 }
3583
3584
3585 type ConversionsBatchUpdateResponse struct {
3586
3587 HasFailures bool `json:"hasFailures,omitempty"`
3588
3589
3590
3591 Kind string `json:"kind,omitempty"`
3592
3593
3594
3595 Status []*ConversionStatus `json:"status,omitempty"`
3596
3597
3598
3599 googleapi.ServerResponse `json:"-"`
3600
3601
3602
3603
3604
3605
3606
3607 ForceSendFields []string `json:"-"`
3608
3609
3610
3611
3612
3613
3614
3615 NullFields []string `json:"-"`
3616 }
3617
3618 func (s *ConversionsBatchUpdateResponse) MarshalJSON() ([]byte, error) {
3619 type NoMethod ConversionsBatchUpdateResponse
3620 raw := NoMethod(*s)
3621 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3622 }
3623
3624
3625 type CountriesListResponse struct {
3626
3627 Countries []*Country `json:"countries,omitempty"`
3628
3629
3630
3631 Kind string `json:"kind,omitempty"`
3632
3633
3634
3635 googleapi.ServerResponse `json:"-"`
3636
3637
3638
3639
3640
3641
3642
3643 ForceSendFields []string `json:"-"`
3644
3645
3646
3647
3648
3649
3650
3651 NullFields []string `json:"-"`
3652 }
3653
3654 func (s *CountriesListResponse) MarshalJSON() ([]byte, error) {
3655 type NoMethod CountriesListResponse
3656 raw := NoMethod(*s)
3657 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3658 }
3659
3660
3661
3662 type Country struct {
3663
3664 CountryCode string `json:"countryCode,omitempty"`
3665
3666
3667
3668 DartId int64 `json:"dartId,omitempty,string"`
3669
3670
3671
3672 Kind string `json:"kind,omitempty"`
3673
3674
3675 Name string `json:"name,omitempty"`
3676
3677
3678
3679 SslEnabled bool `json:"sslEnabled,omitempty"`
3680
3681
3682
3683 googleapi.ServerResponse `json:"-"`
3684
3685
3686
3687
3688
3689
3690
3691 ForceSendFields []string `json:"-"`
3692
3693
3694
3695
3696
3697
3698
3699 NullFields []string `json:"-"`
3700 }
3701
3702 func (s *Country) MarshalJSON() ([]byte, error) {
3703 type NoMethod Country
3704 raw := NoMethod(*s)
3705 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3706 }
3707
3708
3709 type Creative struct {
3710
3711
3712
3713 AccountId int64 `json:"accountId,omitempty,string"`
3714
3715
3716
3717 Active bool `json:"active,omitempty"`
3718
3719
3720
3721
3722 AdParameters string `json:"adParameters,omitempty"`
3723
3724
3725
3726
3727
3728
3729
3730 AdTagKeys []string `json:"adTagKeys,omitempty"`
3731
3732
3733
3734
3735
3736 AdditionalSizes []*Size `json:"additionalSizes,omitempty"`
3737
3738
3739
3740 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
3741
3742
3743
3744
3745
3746 AllowScriptAccess bool `json:"allowScriptAccess,omitempty"`
3747
3748
3749
3750 Archived bool `json:"archived,omitempty"`
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761 ArtworkType string `json:"artworkType,omitempty"`
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771 AuthoringSource string `json:"authoringSource,omitempty"`
3772
3773
3774
3775
3776
3777
3778
3779
3780 AuthoringTool string `json:"authoringTool,omitempty"`
3781
3782
3783
3784
3785 AutoAdvanceImages bool `json:"autoAdvanceImages,omitempty"`
3786
3787
3788
3789
3790
3791 BackgroundColor string `json:"backgroundColor,omitempty"`
3792
3793
3794
3795
3796 BackupImageClickThroughUrl *CreativeClickThroughUrl `json:"backupImageClickThroughUrl,omitempty"`
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876 BackupImageFeatures []string `json:"backupImageFeatures,omitempty"`
3877
3878
3879
3880
3881 BackupImageReportingLabel string `json:"backupImageReportingLabel,omitempty"`
3882
3883
3884
3885
3886 BackupImageTargetWindow *TargetWindow `json:"backupImageTargetWindow,omitempty"`
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901 ClickTags []*ClickTag `json:"clickTags,omitempty"`
3902
3903
3904
3905 CommercialId string `json:"commercialId,omitempty"`
3906
3907
3908
3909
3910
3911
3912 CompanionCreatives googleapi.Int64s `json:"companionCreatives,omitempty"`
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941 Compatibility []string `json:"compatibility,omitempty"`
3942
3943
3944
3945
3946
3947
3948
3949 ConvertFlashToHtml5 bool `json:"convertFlashToHtml5,omitempty"`
3950
3951
3952
3953
3954
3955 CounterCustomEvents []*CreativeCustomEvent `json:"counterCustomEvents,omitempty"`
3956
3957
3958 CreativeAssetSelection *CreativeAssetSelection `json:"creativeAssetSelection,omitempty"`
3959
3960
3961
3962
3963 CreativeAssets []*CreativeAsset `json:"creativeAssets,omitempty"`
3964
3965
3966
3967 CreativeFieldAssignments []*CreativeFieldAssignment `json:"creativeFieldAssignments,omitempty"`
3968
3969
3970
3971
3972
3973
3974
3975 CustomKeyValues []string `json:"customKeyValues,omitempty"`
3976
3977
3978
3979
3980
3981
3982
3983 DynamicAssetSelection bool `json:"dynamicAssetSelection,omitempty"`
3984
3985
3986
3987
3988
3989
3990
3991
3992 ExitCustomEvents []*CreativeCustomEvent `json:"exitCustomEvents,omitempty"`
3993
3994
3995
3996
3997
3998
3999 FsCommand *FsCommand `json:"fsCommand,omitempty"`
4000
4001
4002
4003
4004
4005 HtmlCode string `json:"htmlCode,omitempty"`
4006
4007
4008
4009
4010
4011 HtmlCodeLocked bool `json:"htmlCodeLocked,omitempty"`
4012
4013
4014
4015 Id int64 `json:"id,omitempty,string"`
4016
4017
4018
4019 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
4020
4021
4022
4023 Kind string `json:"kind,omitempty"`
4024
4025
4026
4027 LastModifiedInfo *LastModifiedInfo `json:"lastModifiedInfo,omitempty"`
4028
4029
4030
4031
4032
4033 LatestTraffickedCreativeId int64 `json:"latestTraffickedCreativeId,omitempty,string"`
4034
4035
4036
4037
4038 MediaDescription string `json:"mediaDescription,omitempty"`
4039
4040
4041
4042
4043 MediaDuration float64 `json:"mediaDuration,omitempty"`
4044
4045
4046
4047 Name string `json:"name,omitempty"`
4048
4049
4050
4051 OverrideCss string `json:"overrideCss,omitempty"`
4052
4053
4054
4055 ProgressOffset *VideoOffset `json:"progressOffset,omitempty"`
4056
4057
4058
4059
4060
4061
4062
4063
4064 RedirectUrl string `json:"redirectUrl,omitempty"`
4065
4066
4067
4068 RenderingId int64 `json:"renderingId,omitempty,string"`
4069
4070
4071
4072
4073 RenderingIdDimensionValue *DimensionValue `json:"renderingIdDimensionValue,omitempty"`
4074
4075
4076
4077
4078
4079 RequiredFlashPluginVersion string `json:"requiredFlashPluginVersion,omitempty"`
4080
4081
4082
4083
4084
4085 RequiredFlashVersion int64 `json:"requiredFlashVersion,omitempty"`
4086
4087
4088
4089
4090
4091
4092
4093
4094
4095
4096 Size *Size `json:"size,omitempty"`
4097
4098
4099
4100
4101 SkipOffset *VideoOffset `json:"skipOffset,omitempty"`
4102
4103
4104
4105
4106 Skippable bool `json:"skippable,omitempty"`
4107
4108
4109
4110 SslCompliant bool `json:"sslCompliant,omitempty"`
4111
4112
4113
4114 SslOverride bool `json:"sslOverride,omitempty"`
4115
4116
4117
4118
4119 StudioAdvertiserId int64 `json:"studioAdvertiserId,omitempty,string"`
4120
4121
4122
4123
4124 StudioCreativeId int64 `json:"studioCreativeId,omitempty,string"`
4125
4126
4127
4128
4129
4130 StudioTraffickedCreativeId int64 `json:"studioTraffickedCreativeId,omitempty,string"`
4131
4132
4133
4134
4135 SubaccountId int64 `json:"subaccountId,omitempty,string"`
4136
4137
4138
4139
4140 ThirdPartyBackupImageImpressionsUrl string `json:"thirdPartyBackupImageImpressionsUrl,omitempty"`
4141
4142
4143
4144
4145 ThirdPartyRichMediaImpressionsUrl string `json:"thirdPartyRichMediaImpressionsUrl,omitempty"`
4146
4147
4148
4149
4150 ThirdPartyUrls []*ThirdPartyTrackingUrl `json:"thirdPartyUrls,omitempty"`
4151
4152
4153
4154
4155
4156
4157 TimerCustomEvents []*CreativeCustomEvent `json:"timerCustomEvents,omitempty"`
4158
4159
4160
4161
4162 TotalFileSize int64 `json:"totalFileSize,omitempty,string"`
4163
4164
4165
4166
4167
4168
4169
4170
4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189
4190
4191
4192
4193
4194
4195
4196
4197 Type string `json:"type,omitempty"`
4198
4199
4200
4201
4202 UniversalAdId *UniversalAdId `json:"universalAdId,omitempty"`
4203
4204
4205
4206
4207
4208
4209
4210
4211
4212 Version int64 `json:"version,omitempty"`
4213
4214
4215
4216 googleapi.ServerResponse `json:"-"`
4217
4218
4219
4220
4221
4222
4223
4224 ForceSendFields []string `json:"-"`
4225
4226
4227
4228
4229
4230
4231
4232 NullFields []string `json:"-"`
4233 }
4234
4235 func (s *Creative) MarshalJSON() ([]byte, error) {
4236 type NoMethod Creative
4237 raw := NoMethod(*s)
4238 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4239 }
4240
4241 func (s *Creative) UnmarshalJSON(data []byte) error {
4242 type NoMethod Creative
4243 var s1 struct {
4244 MediaDuration gensupport.JSONFloat64 `json:"mediaDuration"`
4245 *NoMethod
4246 }
4247 s1.NoMethod = (*NoMethod)(s)
4248 if err := json.Unmarshal(data, &s1); err != nil {
4249 return err
4250 }
4251 s.MediaDuration = float64(s1.MediaDuration)
4252 return nil
4253 }
4254
4255
4256 type CreativeAsset struct {
4257
4258
4259
4260
4261 ActionScript3 bool `json:"actionScript3,omitempty"`
4262
4263
4264
4265
4266
4267 Active bool `json:"active,omitempty"`
4268
4269
4270
4271
4272 AdditionalSizes []*Size `json:"additionalSizes,omitempty"`
4273
4274
4275
4276
4277
4278
4279
4280
4281
4282
4283 Alignment string `json:"alignment,omitempty"`
4284
4285
4286
4287
4288
4289
4290
4291
4292
4293 ArtworkType string `json:"artworkType,omitempty"`
4294
4295
4296
4297
4298
4299 AssetIdentifier *CreativeAssetId `json:"assetIdentifier,omitempty"`
4300
4301
4302
4303 BackupImageExit *CreativeCustomEvent `json:"backupImageExit,omitempty"`
4304
4305
4306
4307
4308 BitRate int64 `json:"bitRate,omitempty"`
4309
4310
4311
4312
4313
4314
4315
4316
4317
4318 ChildAssetType string `json:"childAssetType,omitempty"`
4319
4320
4321
4322
4323
4324 CollapsedSize *Size `json:"collapsedSize,omitempty"`
4325
4326
4327
4328
4329
4330 CompanionCreativeIds googleapi.Int64s `json:"companionCreativeIds,omitempty"`
4331
4332
4333
4334
4335 CustomStartTimeValue int64 `json:"customStartTimeValue,omitempty"`
4336
4337
4338
4339
4340
4341
4342
4343
4344
4345
4346
4347
4348
4349
4350
4351
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375
4376
4377
4378
4379
4380
4381
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409
4410
4411 DetectedFeatures []string `json:"detectedFeatures,omitempty"`
4412
4413
4414
4415
4416
4417
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427 DisplayType string `json:"displayType,omitempty"`
4428
4429
4430
4431
4432
4433 Duration int64 `json:"duration,omitempty"`
4434
4435
4436
4437
4438
4439
4440
4441
4442 DurationType string `json:"durationType,omitempty"`
4443
4444
4445
4446
4447 ExpandedDimension *Size `json:"expandedDimension,omitempty"`
4448
4449
4450
4451
4452 FileSize int64 `json:"fileSize,omitempty,string"`
4453
4454
4455
4456
4457
4458 FlashVersion int64 `json:"flashVersion,omitempty"`
4459
4460
4461
4462 HideFlashObjects bool `json:"hideFlashObjects,omitempty"`
4463
4464
4465
4466 HideSelectionBoxes bool `json:"hideSelectionBoxes,omitempty"`
4467
4468
4469
4470
4471 HorizontallyLocked bool `json:"horizontallyLocked,omitempty"`
4472
4473
4474
4475
4476 Id int64 `json:"id,omitempty,string"`
4477
4478
4479
4480 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
4481
4482
4483
4484
4485 MediaDuration float64 `json:"mediaDuration,omitempty"`
4486
4487
4488
4489
4490 MimeType string `json:"mimeType,omitempty"`
4491
4492
4493
4494
4495
4496
4497 Offset *OffsetPosition `json:"offset,omitempty"`
4498
4499
4500
4501
4502
4503
4504
4505
4506 Orientation string `json:"orientation,omitempty"`
4507
4508
4509
4510
4511 OriginalBackup bool `json:"originalBackup,omitempty"`
4512
4513
4514
4515 Position *OffsetPosition `json:"position,omitempty"`
4516
4517
4518
4519
4520
4521
4522
4523
4524 PositionLeftUnit string `json:"positionLeftUnit,omitempty"`
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534 PositionTopUnit string `json:"positionTopUnit,omitempty"`
4535
4536
4537
4538
4539 ProgressiveServingUrl string `json:"progressiveServingUrl,omitempty"`
4540
4541
4542
4543
4544
4545
4546 Pushdown bool `json:"pushdown,omitempty"`
4547
4548
4549
4550
4551
4552
4553
4554 PushdownDuration float64 `json:"pushdownDuration,omitempty"`
4555
4556
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568
4569
4570
4571
4572
4573
4574
4575
4576
4577
4578
4579
4580
4581
4582
4583
4584
4585
4586
4587
4588
4589
4590
4591
4592
4593
4594
4595
4596
4597
4598
4599
4600
4601
4602 Role string `json:"role,omitempty"`
4603
4604
4605
4606
4607
4608
4609
4610
4611 Size *Size `json:"size,omitempty"`
4612
4613
4614
4615
4616 SslCompliant bool `json:"sslCompliant,omitempty"`
4617
4618
4619
4620
4621
4622
4623
4624 StartTimeType string `json:"startTimeType,omitempty"`
4625
4626
4627
4628
4629 StreamingServingUrl string `json:"streamingServingUrl,omitempty"`
4630
4631
4632
4633
4634 Transparency bool `json:"transparency,omitempty"`
4635
4636
4637
4638
4639 VerticallyLocked bool `json:"verticallyLocked,omitempty"`
4640
4641
4642
4643
4644
4645
4646
4647
4648
4649
4650 WindowMode string `json:"windowMode,omitempty"`
4651
4652
4653
4654
4655
4656
4657 ZIndex int64 `json:"zIndex,omitempty"`
4658
4659
4660
4661 ZipFilename string `json:"zipFilename,omitempty"`
4662
4663
4664
4665 ZipFilesize string `json:"zipFilesize,omitempty"`
4666
4667
4668
4669
4670
4671
4672
4673 ForceSendFields []string `json:"-"`
4674
4675
4676
4677
4678
4679
4680
4681 NullFields []string `json:"-"`
4682 }
4683
4684 func (s *CreativeAsset) MarshalJSON() ([]byte, error) {
4685 type NoMethod CreativeAsset
4686 raw := NoMethod(*s)
4687 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4688 }
4689
4690 func (s *CreativeAsset) UnmarshalJSON(data []byte) error {
4691 type NoMethod CreativeAsset
4692 var s1 struct {
4693 MediaDuration gensupport.JSONFloat64 `json:"mediaDuration"`
4694 PushdownDuration gensupport.JSONFloat64 `json:"pushdownDuration"`
4695 *NoMethod
4696 }
4697 s1.NoMethod = (*NoMethod)(s)
4698 if err := json.Unmarshal(data, &s1); err != nil {
4699 return err
4700 }
4701 s.MediaDuration = float64(s1.MediaDuration)
4702 s.PushdownDuration = float64(s1.PushdownDuration)
4703 return nil
4704 }
4705
4706
4707 type CreativeAssetId struct {
4708
4709
4710
4711
4712 Name string `json:"name,omitempty"`
4713
4714
4715
4716
4717
4718
4719
4720
4721
4722
4723
4724
4725 Type string `json:"type,omitempty"`
4726
4727
4728
4729
4730
4731
4732
4733 ForceSendFields []string `json:"-"`
4734
4735
4736
4737
4738
4739
4740
4741 NullFields []string `json:"-"`
4742 }
4743
4744 func (s *CreativeAssetId) MarshalJSON() ([]byte, error) {
4745 type NoMethod CreativeAssetId
4746 raw := NoMethod(*s)
4747 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4748 }
4749
4750
4751
4752
4753
4754 type CreativeAssetMetadata struct {
4755
4756 AssetIdentifier *CreativeAssetId `json:"assetIdentifier,omitempty"`
4757
4758
4759
4760 ClickTags []*ClickTag `json:"clickTags,omitempty"`
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773
4774
4775
4776
4777
4778
4779
4780
4781
4782
4783
4784
4785
4786
4787
4788
4789
4790
4791
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
4805
4806
4807
4808
4809
4810
4811
4812
4813
4814
4815
4816
4817
4818
4819
4820
4821
4822
4823
4824
4825
4826
4827
4828
4829
4830
4831
4832
4833
4834
4835 DetectedFeatures []string `json:"detectedFeatures,omitempty"`
4836
4837
4838
4839 Id int64 `json:"id,omitempty,string"`
4840
4841
4842
4843 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
4844
4845
4846
4847 Kind string `json:"kind,omitempty"`
4848
4849
4850
4851
4852
4853
4854
4855
4856
4857
4858
4859
4860
4861
4862
4863
4864
4865
4866
4867
4868
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884
4885
4886
4887
4888
4889
4890
4891
4892
4893
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904 WarnedValidationRules []string `json:"warnedValidationRules,omitempty"`
4905
4906
4907
4908 googleapi.ServerResponse `json:"-"`
4909
4910
4911
4912
4913
4914
4915
4916 ForceSendFields []string `json:"-"`
4917
4918
4919
4920
4921
4922
4923
4924
4925 NullFields []string `json:"-"`
4926 }
4927
4928 func (s *CreativeAssetMetadata) MarshalJSON() ([]byte, error) {
4929 type NoMethod CreativeAssetMetadata
4930 raw := NoMethod(*s)
4931 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4932 }
4933
4934
4935
4936
4937 type CreativeAssetSelection struct {
4938
4939
4940
4941 DefaultAssetId int64 `json:"defaultAssetId,omitempty,string"`
4942
4943
4944
4945
4946
4947 Rules []*Rule `json:"rules,omitempty"`
4948
4949
4950
4951
4952
4953
4954
4955 ForceSendFields []string `json:"-"`
4956
4957
4958
4959
4960
4961
4962
4963
4964 NullFields []string `json:"-"`
4965 }
4966
4967 func (s *CreativeAssetSelection) MarshalJSON() ([]byte, error) {
4968 type NoMethod CreativeAssetSelection
4969 raw := NoMethod(*s)
4970 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4971 }
4972
4973
4974 type CreativeAssignment struct {
4975
4976
4977 Active bool `json:"active,omitempty"`
4978
4979
4980
4981
4982
4983
4984 ApplyEventTags bool `json:"applyEventTags,omitempty"`
4985
4986
4987 ClickThroughUrl *ClickThroughUrl `json:"clickThroughUrl,omitempty"`
4988
4989
4990
4991 CompanionCreativeOverrides []*CompanionClickThroughOverride `json:"companionCreativeOverrides,omitempty"`
4992
4993
4994
4995
4996 CreativeGroupAssignments []*CreativeGroupAssignment `json:"creativeGroupAssignments,omitempty"`
4997
4998
4999
5000 CreativeId int64 `json:"creativeId,omitempty,string"`
5001
5002
5003
5004 CreativeIdDimensionValue *DimensionValue `json:"creativeIdDimensionValue,omitempty"`
5005
5006
5007
5008 EndTime string `json:"endTime,omitempty"`
5009
5010
5011
5012
5013
5014
5015
5016
5017
5018
5019
5020
5021
5022
5023
5024 RichMediaExitOverrides []*RichMediaExitOverride `json:"richMediaExitOverrides,omitempty"`
5025
5026
5027
5028
5029 Sequence int64 `json:"sequence,omitempty"`
5030
5031
5032
5033
5034 SslCompliant bool `json:"sslCompliant,omitempty"`
5035
5036
5037
5038 StartTime string `json:"startTime,omitempty"`
5039
5040
5041
5042
5043 Weight int64 `json:"weight,omitempty"`
5044
5045
5046
5047
5048
5049
5050
5051 ForceSendFields []string `json:"-"`
5052
5053
5054
5055
5056
5057
5058
5059 NullFields []string `json:"-"`
5060 }
5061
5062 func (s *CreativeAssignment) MarshalJSON() ([]byte, error) {
5063 type NoMethod CreativeAssignment
5064 raw := NoMethod(*s)
5065 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5066 }
5067
5068
5069 type CreativeClickThroughUrl struct {
5070
5071
5072
5073
5074
5075
5076 ComputedClickThroughUrl string `json:"computedClickThroughUrl,omitempty"`
5077
5078
5079
5080 CustomClickThroughUrl string `json:"customClickThroughUrl,omitempty"`
5081
5082
5083 LandingPageId int64 `json:"landingPageId,omitempty,string"`
5084
5085
5086
5087
5088
5089
5090
5091
5092 ForceSendFields []string `json:"-"`
5093
5094
5095
5096
5097
5098
5099
5100
5101 NullFields []string `json:"-"`
5102 }
5103
5104 func (s *CreativeClickThroughUrl) MarshalJSON() ([]byte, error) {
5105 type NoMethod CreativeClickThroughUrl
5106 raw := NoMethod(*s)
5107 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5108 }
5109
5110
5111 type CreativeCustomEvent struct {
5112
5113
5114 AdvertiserCustomEventId int64 `json:"advertiserCustomEventId,omitempty,string"`
5115
5116
5117 AdvertiserCustomEventName string `json:"advertiserCustomEventName,omitempty"`
5118
5119
5120
5121
5122
5123
5124
5125
5126 AdvertiserCustomEventType string `json:"advertiserCustomEventType,omitempty"`
5127
5128
5129
5130
5131 ArtworkLabel string `json:"artworkLabel,omitempty"`
5132
5133
5134
5135
5136
5137
5138
5139
5140
5141 ArtworkType string `json:"artworkType,omitempty"`
5142
5143
5144
5145 ExitClickThroughUrl *CreativeClickThroughUrl `json:"exitClickThroughUrl,omitempty"`
5146
5147
5148
5149 Id int64 `json:"id,omitempty,string"`
5150
5151
5152
5153 PopupWindowProperties *PopupWindowProperties `json:"popupWindowProperties,omitempty"`
5154
5155
5156
5157
5158
5159
5160
5161
5162
5163 TargetType string `json:"targetType,omitempty"`
5164
5165
5166
5167 VideoReportingId string `json:"videoReportingId,omitempty"`
5168
5169
5170
5171
5172
5173
5174
5175
5176 ForceSendFields []string `json:"-"`
5177
5178
5179
5180
5181
5182
5183
5184
5185 NullFields []string `json:"-"`
5186 }
5187
5188 func (s *CreativeCustomEvent) MarshalJSON() ([]byte, error) {
5189 type NoMethod CreativeCustomEvent
5190 raw := NoMethod(*s)
5191 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5192 }
5193
5194
5195 type CreativeField struct {
5196
5197
5198 AccountId int64 `json:"accountId,omitempty,string"`
5199
5200
5201
5202 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
5203
5204
5205
5206 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
5207
5208
5209
5210 Id int64 `json:"id,omitempty,string"`
5211
5212
5213
5214 Kind string `json:"kind,omitempty"`
5215
5216
5217
5218
5219 Name string `json:"name,omitempty"`
5220
5221
5222
5223 SubaccountId int64 `json:"subaccountId,omitempty,string"`
5224
5225
5226
5227 googleapi.ServerResponse `json:"-"`
5228
5229
5230
5231
5232
5233
5234
5235 ForceSendFields []string `json:"-"`
5236
5237
5238
5239
5240
5241
5242
5243 NullFields []string `json:"-"`
5244 }
5245
5246 func (s *CreativeField) MarshalJSON() ([]byte, error) {
5247 type NoMethod CreativeField
5248 raw := NoMethod(*s)
5249 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5250 }
5251
5252
5253 type CreativeFieldAssignment struct {
5254
5255 CreativeFieldId int64 `json:"creativeFieldId,omitempty,string"`
5256
5257
5258 CreativeFieldValueId int64 `json:"creativeFieldValueId,omitempty,string"`
5259
5260
5261
5262
5263
5264
5265
5266 ForceSendFields []string `json:"-"`
5267
5268
5269
5270
5271
5272
5273
5274
5275 NullFields []string `json:"-"`
5276 }
5277
5278 func (s *CreativeFieldAssignment) MarshalJSON() ([]byte, error) {
5279 type NoMethod CreativeFieldAssignment
5280 raw := NoMethod(*s)
5281 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5282 }
5283
5284
5285 type CreativeFieldValue struct {
5286
5287
5288 Id int64 `json:"id,omitempty,string"`
5289
5290
5291
5292 Kind string `json:"kind,omitempty"`
5293
5294
5295
5296 Value string `json:"value,omitempty"`
5297
5298
5299
5300 googleapi.ServerResponse `json:"-"`
5301
5302
5303
5304
5305
5306
5307
5308 ForceSendFields []string `json:"-"`
5309
5310
5311
5312
5313
5314
5315
5316 NullFields []string `json:"-"`
5317 }
5318
5319 func (s *CreativeFieldValue) MarshalJSON() ([]byte, error) {
5320 type NoMethod CreativeFieldValue
5321 raw := NoMethod(*s)
5322 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5323 }
5324
5325
5326 type CreativeFieldValuesListResponse struct {
5327
5328 CreativeFieldValues []*CreativeFieldValue `json:"creativeFieldValues,omitempty"`
5329
5330
5331
5332 Kind string `json:"kind,omitempty"`
5333
5334
5335
5336 NextPageToken string `json:"nextPageToken,omitempty"`
5337
5338
5339
5340 googleapi.ServerResponse `json:"-"`
5341
5342
5343
5344
5345
5346
5347
5348 ForceSendFields []string `json:"-"`
5349
5350
5351
5352
5353
5354
5355
5356
5357 NullFields []string `json:"-"`
5358 }
5359
5360 func (s *CreativeFieldValuesListResponse) MarshalJSON() ([]byte, error) {
5361 type NoMethod CreativeFieldValuesListResponse
5362 raw := NoMethod(*s)
5363 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5364 }
5365
5366
5367 type CreativeFieldsListResponse struct {
5368
5369 CreativeFields []*CreativeField `json:"creativeFields,omitempty"`
5370
5371
5372
5373 Kind string `json:"kind,omitempty"`
5374
5375
5376
5377 NextPageToken string `json:"nextPageToken,omitempty"`
5378
5379
5380
5381 googleapi.ServerResponse `json:"-"`
5382
5383
5384
5385
5386
5387
5388
5389 ForceSendFields []string `json:"-"`
5390
5391
5392
5393
5394
5395
5396
5397
5398 NullFields []string `json:"-"`
5399 }
5400
5401 func (s *CreativeFieldsListResponse) MarshalJSON() ([]byte, error) {
5402 type NoMethod CreativeFieldsListResponse
5403 raw := NoMethod(*s)
5404 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5405 }
5406
5407
5408 type CreativeGroup struct {
5409
5410
5411 AccountId int64 `json:"accountId,omitempty,string"`
5412
5413
5414
5415 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
5416
5417
5418
5419 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
5420
5421
5422
5423
5424
5425 GroupNumber int64 `json:"groupNumber,omitempty"`
5426
5427
5428
5429 Id int64 `json:"id,omitempty,string"`
5430
5431
5432
5433 Kind string `json:"kind,omitempty"`
5434
5435
5436
5437
5438 Name string `json:"name,omitempty"`
5439
5440
5441
5442 SubaccountId int64 `json:"subaccountId,omitempty,string"`
5443
5444
5445
5446 googleapi.ServerResponse `json:"-"`
5447
5448
5449
5450
5451
5452
5453
5454 ForceSendFields []string `json:"-"`
5455
5456
5457
5458
5459
5460
5461
5462 NullFields []string `json:"-"`
5463 }
5464
5465 func (s *CreativeGroup) MarshalJSON() ([]byte, error) {
5466 type NoMethod CreativeGroup
5467 raw := NoMethod(*s)
5468 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5469 }
5470
5471
5472 type CreativeGroupAssignment struct {
5473
5474 CreativeGroupId int64 `json:"creativeGroupId,omitempty,string"`
5475
5476
5477
5478
5479
5480
5481
5482 CreativeGroupNumber string `json:"creativeGroupNumber,omitempty"`
5483
5484
5485
5486
5487
5488
5489
5490 ForceSendFields []string `json:"-"`
5491
5492
5493
5494
5495
5496
5497
5498
5499 NullFields []string `json:"-"`
5500 }
5501
5502 func (s *CreativeGroupAssignment) MarshalJSON() ([]byte, error) {
5503 type NoMethod CreativeGroupAssignment
5504 raw := NoMethod(*s)
5505 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5506 }
5507
5508
5509 type CreativeGroupsListResponse struct {
5510
5511 CreativeGroups []*CreativeGroup `json:"creativeGroups,omitempty"`
5512
5513
5514
5515 Kind string `json:"kind,omitempty"`
5516
5517
5518
5519 NextPageToken string `json:"nextPageToken,omitempty"`
5520
5521
5522
5523 googleapi.ServerResponse `json:"-"`
5524
5525
5526
5527
5528
5529
5530
5531 ForceSendFields []string `json:"-"`
5532
5533
5534
5535
5536
5537
5538
5539
5540 NullFields []string `json:"-"`
5541 }
5542
5543 func (s *CreativeGroupsListResponse) MarshalJSON() ([]byte, error) {
5544 type NoMethod CreativeGroupsListResponse
5545 raw := NoMethod(*s)
5546 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5547 }
5548
5549
5550 type CreativeOptimizationConfiguration struct {
5551
5552
5553
5554 Id int64 `json:"id,omitempty,string"`
5555
5556
5557
5558 Name string `json:"name,omitempty"`
5559
5560
5561
5562 OptimizationActivitys []*OptimizationActivity `json:"optimizationActivitys,omitempty"`
5563
5564
5565
5566
5567
5568
5569
5570
5571
5572 OptimizationModel string `json:"optimizationModel,omitempty"`
5573
5574
5575
5576
5577
5578
5579
5580 ForceSendFields []string `json:"-"`
5581
5582
5583
5584
5585
5586
5587
5588 NullFields []string `json:"-"`
5589 }
5590
5591 func (s *CreativeOptimizationConfiguration) MarshalJSON() ([]byte, error) {
5592 type NoMethod CreativeOptimizationConfiguration
5593 raw := NoMethod(*s)
5594 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5595 }
5596
5597
5598 type CreativeRotation struct {
5599
5600 CreativeAssignments []*CreativeAssignment `json:"creativeAssignments,omitempty"`
5601
5602
5603
5604
5605
5606
5607 CreativeOptimizationConfigurationId int64 `json:"creativeOptimizationConfigurationId,omitempty,string"`
5608
5609
5610
5611
5612
5613
5614
5615 Type string `json:"type,omitempty"`
5616
5617
5618
5619
5620
5621
5622
5623
5624
5625 WeightCalculationStrategy string `json:"weightCalculationStrategy,omitempty"`
5626
5627
5628
5629
5630
5631
5632
5633 ForceSendFields []string `json:"-"`
5634
5635
5636
5637
5638
5639
5640
5641
5642 NullFields []string `json:"-"`
5643 }
5644
5645 func (s *CreativeRotation) MarshalJSON() ([]byte, error) {
5646 type NoMethod CreativeRotation
5647 raw := NoMethod(*s)
5648 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5649 }
5650
5651
5652 type CreativesListResponse struct {
5653
5654 Creatives []*Creative `json:"creatives,omitempty"`
5655
5656
5657
5658 Kind string `json:"kind,omitempty"`
5659
5660
5661
5662 NextPageToken string `json:"nextPageToken,omitempty"`
5663
5664
5665
5666 googleapi.ServerResponse `json:"-"`
5667
5668
5669
5670
5671
5672
5673
5674 ForceSendFields []string `json:"-"`
5675
5676
5677
5678
5679
5680
5681
5682 NullFields []string `json:"-"`
5683 }
5684
5685 func (s *CreativesListResponse) MarshalJSON() ([]byte, error) {
5686 type NoMethod CreativesListResponse
5687 raw := NoMethod(*s)
5688 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5689 }
5690
5691
5692
5693
5694 type CrossDimensionReachReportCompatibleFields struct {
5695
5696
5697 Breakdown []*Dimension `json:"breakdown,omitempty"`
5698
5699
5700
5701 DimensionFilters []*Dimension `json:"dimensionFilters,omitempty"`
5702
5703
5704
5705 Kind string `json:"kind,omitempty"`
5706
5707
5708
5709 Metrics []*Metric `json:"metrics,omitempty"`
5710
5711
5712
5713 OverlapMetrics []*Metric `json:"overlapMetrics,omitempty"`
5714
5715
5716
5717
5718
5719
5720
5721 ForceSendFields []string `json:"-"`
5722
5723
5724
5725
5726
5727
5728
5729 NullFields []string `json:"-"`
5730 }
5731
5732 func (s *CrossDimensionReachReportCompatibleFields) MarshalJSON() ([]byte, error) {
5733 type NoMethod CrossDimensionReachReportCompatibleFields
5734 raw := NoMethod(*s)
5735 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5736 }
5737
5738
5739 type CustomFloodlightVariable struct {
5740
5741
5742 Kind string `json:"kind,omitempty"`
5743
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
5778
5779
5780
5781
5782
5783
5784
5785
5786
5787
5788
5789
5790
5791
5792
5793
5794
5795
5796
5797
5798
5799
5800
5801
5802
5803
5804
5805
5806
5807
5808
5809
5810
5811
5812
5813
5814
5815
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825
5826
5827
5828
5829
5830
5831
5832
5833
5834
5835
5836
5837
5838
5839
5840
5841
5842
5843
5844
5845
5846
5847
5848 Type string `json:"type,omitempty"`
5849
5850
5851
5852 Value string `json:"value,omitempty"`
5853
5854
5855
5856
5857
5858
5859
5860 ForceSendFields []string `json:"-"`
5861
5862
5863
5864
5865
5866
5867
5868 NullFields []string `json:"-"`
5869 }
5870
5871 func (s *CustomFloodlightVariable) MarshalJSON() ([]byte, error) {
5872 type NoMethod CustomFloodlightVariable
5873 raw := NoMethod(*s)
5874 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5875 }
5876
5877
5878 type CustomRichMediaEvents struct {
5879
5880
5881 FilteredEventIds []*DimensionValue `json:"filteredEventIds,omitempty"`
5882
5883
5884
5885 Kind string `json:"kind,omitempty"`
5886
5887
5888
5889
5890
5891
5892
5893 ForceSendFields []string `json:"-"`
5894
5895
5896
5897
5898
5899
5900
5901
5902 NullFields []string `json:"-"`
5903 }
5904
5905 func (s *CustomRichMediaEvents) MarshalJSON() ([]byte, error) {
5906 type NoMethod CustomRichMediaEvents
5907 raw := NoMethod(*s)
5908 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5909 }
5910
5911
5912 type DateRange struct {
5913
5914
5915 EndDate string `json:"endDate,omitempty"`
5916
5917
5918
5919 Kind string `json:"kind,omitempty"`
5920
5921
5922
5923
5924
5925
5926
5927
5928
5929
5930
5931
5932
5933
5934
5935
5936
5937
5938
5939
5940
5941
5942 RelativeDateRange string `json:"relativeDateRange,omitempty"`
5943
5944
5945
5946 StartDate string `json:"startDate,omitempty"`
5947
5948
5949
5950
5951
5952
5953
5954 ForceSendFields []string `json:"-"`
5955
5956
5957
5958
5959
5960
5961
5962 NullFields []string `json:"-"`
5963 }
5964
5965 func (s *DateRange) MarshalJSON() ([]byte, error) {
5966 type NoMethod DateRange
5967 raw := NoMethod(*s)
5968 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5969 }
5970
5971
5972 type DayPartTargeting struct {
5973
5974
5975
5976
5977
5978
5979
5980
5981
5982
5983
5984
5985
5986
5987
5988
5989
5990
5991
5992 DaysOfWeek []string `json:"daysOfWeek,omitempty"`
5993
5994
5995
5996
5997
5998
5999
6000
6001 HoursOfDay []int64 `json:"hoursOfDay,omitempty"`
6002
6003
6004
6005 UserLocalTime bool `json:"userLocalTime,omitempty"`
6006
6007
6008
6009
6010
6011
6012
6013 ForceSendFields []string `json:"-"`
6014
6015
6016
6017
6018
6019
6020
6021 NullFields []string `json:"-"`
6022 }
6023
6024 func (s *DayPartTargeting) MarshalJSON() ([]byte, error) {
6025 type NoMethod DayPartTargeting
6026 raw := NoMethod(*s)
6027 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6028 }
6029
6030
6031 type DeepLink struct {
6032
6033 AppUrl string `json:"appUrl,omitempty"`
6034
6035
6036
6037 FallbackUrl string `json:"fallbackUrl,omitempty"`
6038
6039
6040
6041 Kind string `json:"kind,omitempty"`
6042
6043
6044 MobileApp *MobileApp `json:"mobileApp,omitempty"`
6045
6046
6047
6048
6049 RemarketingListIds googleapi.Int64s `json:"remarketingListIds,omitempty"`
6050
6051
6052
6053
6054
6055
6056
6057 ForceSendFields []string `json:"-"`
6058
6059
6060
6061
6062
6063
6064
6065 NullFields []string `json:"-"`
6066 }
6067
6068 func (s *DeepLink) MarshalJSON() ([]byte, error) {
6069 type NoMethod DeepLink
6070 raw := NoMethod(*s)
6071 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6072 }
6073
6074
6075
6076
6077
6078 type DefaultClickThroughEventTagProperties struct {
6079
6080
6081 DefaultClickThroughEventTagId int64 `json:"defaultClickThroughEventTagId,omitempty,string"`
6082
6083
6084
6085 OverrideInheritedEventTag bool `json:"overrideInheritedEventTag,omitempty"`
6086
6087
6088
6089
6090
6091
6092
6093
6094 ForceSendFields []string `json:"-"`
6095
6096
6097
6098
6099
6100
6101
6102
6103 NullFields []string `json:"-"`
6104 }
6105
6106 func (s *DefaultClickThroughEventTagProperties) MarshalJSON() ([]byte, error) {
6107 type NoMethod DefaultClickThroughEventTagProperties
6108 raw := NoMethod(*s)
6109 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6110 }
6111
6112
6113 type DeliverySchedule struct {
6114
6115
6116 FrequencyCap *FrequencyCap `json:"frequencyCap,omitempty"`
6117
6118
6119
6120
6121 HardCutoff bool `json:"hardCutoff,omitempty"`
6122
6123
6124
6125
6126
6127
6128 ImpressionRatio int64 `json:"impressionRatio,omitempty,string"`
6129
6130
6131
6132
6133
6134
6135
6136
6137
6138
6139
6140
6141
6142
6143
6144
6145
6146
6147
6148
6149
6150
6151 Priority string `json:"priority,omitempty"`
6152
6153
6154
6155
6156
6157
6158
6159 ForceSendFields []string `json:"-"`
6160
6161
6162
6163
6164
6165
6166
6167 NullFields []string `json:"-"`
6168 }
6169
6170 func (s *DeliverySchedule) MarshalJSON() ([]byte, error) {
6171 type NoMethod DeliverySchedule
6172 raw := NoMethod(*s)
6173 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6174 }
6175
6176
6177 type DfpSettings struct {
6178
6179 DfpNetworkCode string `json:"dfpNetworkCode,omitempty"`
6180
6181
6182 DfpNetworkName string `json:"dfpNetworkName,omitempty"`
6183
6184
6185
6186 ProgrammaticPlacementAccepted bool `json:"programmaticPlacementAccepted,omitempty"`
6187
6188
6189
6190 PubPaidPlacementAccepted bool `json:"pubPaidPlacementAccepted,omitempty"`
6191
6192
6193
6194 PublisherPortalOnly bool `json:"publisherPortalOnly,omitempty"`
6195
6196
6197
6198
6199
6200
6201
6202 ForceSendFields []string `json:"-"`
6203
6204
6205
6206
6207
6208
6209
6210
6211 NullFields []string `json:"-"`
6212 }
6213
6214 func (s *DfpSettings) MarshalJSON() ([]byte, error) {
6215 type NoMethod DfpSettings
6216 raw := NoMethod(*s)
6217 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6218 }
6219
6220
6221 type Dimension struct {
6222
6223
6224 Kind string `json:"kind,omitempty"`
6225
6226
6227 Name string `json:"name,omitempty"`
6228
6229
6230
6231
6232
6233
6234
6235 ForceSendFields []string `json:"-"`
6236
6237
6238
6239
6240
6241
6242
6243 NullFields []string `json:"-"`
6244 }
6245
6246 func (s *Dimension) MarshalJSON() ([]byte, error) {
6247 type NoMethod Dimension
6248 raw := NoMethod(*s)
6249 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6250 }
6251
6252
6253 type DimensionFilter struct {
6254
6255 DimensionName string `json:"dimensionName,omitempty"`
6256
6257
6258
6259 Kind string `json:"kind,omitempty"`
6260
6261
6262 Value string `json:"value,omitempty"`
6263
6264
6265
6266
6267
6268
6269
6270 ForceSendFields []string `json:"-"`
6271
6272
6273
6274
6275
6276
6277
6278 NullFields []string `json:"-"`
6279 }
6280
6281 func (s *DimensionFilter) MarshalJSON() ([]byte, error) {
6282 type NoMethod DimensionFilter
6283 raw := NoMethod(*s)
6284 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6285 }
6286
6287
6288 type DimensionValue struct {
6289
6290 DimensionName string `json:"dimensionName,omitempty"`
6291
6292
6293 Etag string `json:"etag,omitempty"`
6294
6295
6296 Id string `json:"id,omitempty"`
6297
6298
6299
6300 Kind string `json:"kind,omitempty"`
6301
6302
6303
6304
6305
6306
6307
6308
6309
6310
6311
6312
6313
6314 MatchType string `json:"matchType,omitempty"`
6315
6316
6317 Value string `json:"value,omitempty"`
6318
6319
6320
6321
6322
6323
6324
6325 ForceSendFields []string `json:"-"`
6326
6327
6328
6329
6330
6331
6332
6333 NullFields []string `json:"-"`
6334 }
6335
6336 func (s *DimensionValue) MarshalJSON() ([]byte, error) {
6337 type NoMethod DimensionValue
6338 raw := NoMethod(*s)
6339 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6340 }
6341
6342
6343 type DimensionValueList struct {
6344
6345 Etag string `json:"etag,omitempty"`
6346
6347
6348 Items []*DimensionValue `json:"items,omitempty"`
6349
6350
6351
6352 Kind string `json:"kind,omitempty"`
6353
6354
6355
6356
6357
6358 NextPageToken string `json:"nextPageToken,omitempty"`
6359
6360
6361
6362 googleapi.ServerResponse `json:"-"`
6363
6364
6365
6366
6367
6368
6369
6370 ForceSendFields []string `json:"-"`
6371
6372
6373
6374
6375
6376
6377
6378 NullFields []string `json:"-"`
6379 }
6380
6381 func (s *DimensionValueList) MarshalJSON() ([]byte, error) {
6382 type NoMethod DimensionValueList
6383 raw := NoMethod(*s)
6384 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6385 }
6386
6387
6388 type DimensionValueRequest struct {
6389
6390
6391 DimensionName string `json:"dimensionName,omitempty"`
6392
6393
6394
6395 EndDate string `json:"endDate,omitempty"`
6396
6397
6398
6399 Filters []*DimensionFilter `json:"filters,omitempty"`
6400
6401
6402
6403 Kind string `json:"kind,omitempty"`
6404
6405
6406
6407 StartDate string `json:"startDate,omitempty"`
6408
6409
6410
6411
6412
6413
6414
6415 ForceSendFields []string `json:"-"`
6416
6417
6418
6419
6420
6421
6422
6423 NullFields []string `json:"-"`
6424 }
6425
6426 func (s *DimensionValueRequest) MarshalJSON() ([]byte, error) {
6427 type NoMethod DimensionValueRequest
6428 raw := NoMethod(*s)
6429 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6430 }
6431
6432
6433
6434
6435 type DirectorySite struct {
6436
6437 Active bool `json:"active,omitempty"`
6438
6439
6440
6441 Id int64 `json:"id,omitempty,string"`
6442
6443
6444
6445 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
6446
6447
6448
6449
6450
6451
6452
6453
6454
6455
6456
6457
6458
6459
6460 InpageTagFormats []string `json:"inpageTagFormats,omitempty"`
6461
6462
6463
6464
6465
6466
6467
6468
6469
6470
6471
6472
6473
6474 InterstitialTagFormats []string `json:"interstitialTagFormats,omitempty"`
6475
6476
6477
6478 Kind string `json:"kind,omitempty"`
6479
6480
6481 Name string `json:"name,omitempty"`
6482
6483
6484 Settings *DirectorySiteSettings `json:"settings,omitempty"`
6485
6486
6487 Url string `json:"url,omitempty"`
6488
6489
6490
6491 googleapi.ServerResponse `json:"-"`
6492
6493
6494
6495
6496
6497
6498
6499 ForceSendFields []string `json:"-"`
6500
6501
6502
6503
6504
6505
6506
6507 NullFields []string `json:"-"`
6508 }
6509
6510 func (s *DirectorySite) MarshalJSON() ([]byte, error) {
6511 type NoMethod DirectorySite
6512 raw := NoMethod(*s)
6513 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6514 }
6515
6516
6517 type DirectorySiteSettings struct {
6518
6519
6520 ActiveViewOptOut bool `json:"activeViewOptOut,omitempty"`
6521
6522
6523 DfpSettings *DfpSettings `json:"dfpSettings,omitempty"`
6524
6525
6526
6527 InstreamVideoPlacementAccepted bool `json:"instreamVideoPlacementAccepted,omitempty"`
6528
6529
6530
6531 InterstitialPlacementAccepted bool `json:"interstitialPlacementAccepted,omitempty"`
6532
6533
6534
6535
6536
6537
6538
6539 ForceSendFields []string `json:"-"`
6540
6541
6542
6543
6544
6545
6546
6547
6548 NullFields []string `json:"-"`
6549 }
6550
6551 func (s *DirectorySiteSettings) MarshalJSON() ([]byte, error) {
6552 type NoMethod DirectorySiteSettings
6553 raw := NoMethod(*s)
6554 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6555 }
6556
6557
6558 type DirectorySitesListResponse struct {
6559
6560 DirectorySites []*DirectorySite `json:"directorySites,omitempty"`
6561
6562
6563
6564 Kind string `json:"kind,omitempty"`
6565
6566
6567
6568 NextPageToken string `json:"nextPageToken,omitempty"`
6569
6570
6571
6572 googleapi.ServerResponse `json:"-"`
6573
6574
6575
6576
6577
6578
6579
6580 ForceSendFields []string `json:"-"`
6581
6582
6583
6584
6585
6586
6587
6588
6589 NullFields []string `json:"-"`
6590 }
6591
6592 func (s *DirectorySitesListResponse) MarshalJSON() ([]byte, error) {
6593 type NoMethod DirectorySitesListResponse
6594 raw := NoMethod(*s)
6595 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6596 }
6597
6598
6599
6600
6601
6602
6603
6604 type DynamicTargetingKey struct {
6605
6606
6607 Kind string `json:"kind,omitempty"`
6608
6609
6610
6611
6612 Name string `json:"name,omitempty"`
6613
6614
6615
6616 ObjectId int64 `json:"objectId,omitempty,string"`
6617
6618
6619
6620
6621
6622
6623
6624
6625
6626 ObjectType string `json:"objectType,omitempty"`
6627
6628
6629
6630 googleapi.ServerResponse `json:"-"`
6631
6632
6633
6634
6635
6636
6637
6638 ForceSendFields []string `json:"-"`
6639
6640
6641
6642
6643
6644
6645
6646 NullFields []string `json:"-"`
6647 }
6648
6649 func (s *DynamicTargetingKey) MarshalJSON() ([]byte, error) {
6650 type NoMethod DynamicTargetingKey
6651 raw := NoMethod(*s)
6652 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6653 }
6654
6655
6656 type DynamicTargetingKeysListResponse struct {
6657
6658 DynamicTargetingKeys []*DynamicTargetingKey `json:"dynamicTargetingKeys,omitempty"`
6659
6660
6661
6662 Kind string `json:"kind,omitempty"`
6663
6664
6665
6666 googleapi.ServerResponse `json:"-"`
6667
6668
6669
6670
6671
6672
6673
6674
6675 ForceSendFields []string `json:"-"`
6676
6677
6678
6679
6680
6681
6682
6683
6684 NullFields []string `json:"-"`
6685 }
6686
6687 func (s *DynamicTargetingKeysListResponse) MarshalJSON() ([]byte, error) {
6688 type NoMethod DynamicTargetingKeysListResponse
6689 raw := NoMethod(*s)
6690 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6691 }
6692
6693
6694 type EncryptionInfo struct {
6695
6696
6697 EncryptionEntityId int64 `json:"encryptionEntityId,omitempty,string"`
6698
6699
6700
6701
6702
6703
6704
6705
6706
6707
6708
6709
6710 EncryptionEntityType string `json:"encryptionEntityType,omitempty"`
6711
6712
6713
6714
6715
6716
6717
6718
6719 EncryptionSource string `json:"encryptionSource,omitempty"`
6720
6721
6722
6723 Kind string `json:"kind,omitempty"`
6724
6725
6726
6727
6728
6729
6730
6731 ForceSendFields []string `json:"-"`
6732
6733
6734
6735
6736
6737
6738
6739
6740 NullFields []string `json:"-"`
6741 }
6742
6743 func (s *EncryptionInfo) MarshalJSON() ([]byte, error) {
6744 type NoMethod EncryptionInfo
6745 raw := NoMethod(*s)
6746 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6747 }
6748
6749
6750 type EventTag struct {
6751
6752
6753 AccountId int64 `json:"accountId,omitempty,string"`
6754
6755
6756
6757 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
6758
6759
6760
6761 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
6762
6763
6764
6765 CampaignId int64 `json:"campaignId,omitempty,string"`
6766
6767
6768
6769 CampaignIdDimensionValue *DimensionValue `json:"campaignIdDimensionValue,omitempty"`
6770
6771
6772
6773 EnabledByDefault bool `json:"enabledByDefault,omitempty"`
6774
6775
6776
6777
6778
6779
6780 ExcludeFromAdxRequests bool `json:"excludeFromAdxRequests,omitempty"`
6781
6782
6783 Id int64 `json:"id,omitempty,string"`
6784
6785
6786
6787 Kind string `json:"kind,omitempty"`
6788
6789
6790
6791 Name string `json:"name,omitempty"`
6792
6793
6794
6795
6796
6797
6798
6799 SiteFilterType string `json:"siteFilterType,omitempty"`
6800
6801
6802
6803
6804 SiteIds googleapi.Int64s `json:"siteIds,omitempty"`
6805
6806
6807
6808 SslCompliant bool `json:"sslCompliant,omitempty"`
6809
6810
6811
6812
6813
6814
6815
6816 Status string `json:"status,omitempty"`
6817
6818
6819
6820 SubaccountId int64 `json:"subaccountId,omitempty,string"`
6821
6822
6823
6824
6825
6826
6827
6828
6829
6830
6831 Type string `json:"type,omitempty"`
6832
6833
6834
6835
6836 Url string `json:"url,omitempty"`
6837
6838
6839
6840
6841
6842 UrlEscapeLevels int64 `json:"urlEscapeLevels,omitempty"`
6843
6844
6845
6846 googleapi.ServerResponse `json:"-"`
6847
6848
6849
6850
6851
6852
6853
6854 ForceSendFields []string `json:"-"`
6855
6856
6857
6858
6859
6860
6861
6862 NullFields []string `json:"-"`
6863 }
6864
6865 func (s *EventTag) MarshalJSON() ([]byte, error) {
6866 type NoMethod EventTag
6867 raw := NoMethod(*s)
6868 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6869 }
6870
6871
6872 type EventTagOverride struct {
6873
6874 Enabled bool `json:"enabled,omitempty"`
6875
6876
6877
6878 Id int64 `json:"id,omitempty,string"`
6879
6880
6881
6882
6883
6884
6885
6886 ForceSendFields []string `json:"-"`
6887
6888
6889
6890
6891
6892
6893
6894 NullFields []string `json:"-"`
6895 }
6896
6897 func (s *EventTagOverride) MarshalJSON() ([]byte, error) {
6898 type NoMethod EventTagOverride
6899 raw := NoMethod(*s)
6900 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6901 }
6902
6903
6904 type EventTagsListResponse struct {
6905
6906 EventTags []*EventTag `json:"eventTags,omitempty"`
6907
6908
6909
6910 Kind string `json:"kind,omitempty"`
6911
6912
6913
6914 googleapi.ServerResponse `json:"-"`
6915
6916
6917
6918
6919
6920
6921
6922 ForceSendFields []string `json:"-"`
6923
6924
6925
6926
6927
6928
6929
6930 NullFields []string `json:"-"`
6931 }
6932
6933 func (s *EventTagsListResponse) MarshalJSON() ([]byte, error) {
6934 type NoMethod EventTagsListResponse
6935 raw := NoMethod(*s)
6936 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6937 }
6938
6939
6940
6941
6942
6943 type File struct {
6944
6945
6946
6947 DateRange *DateRange `json:"dateRange,omitempty"`
6948
6949
6950 Etag string `json:"etag,omitempty"`
6951
6952
6953 FileName string `json:"fileName,omitempty"`
6954
6955
6956
6957
6958
6959
6960
6961 Format string `json:"format,omitempty"`
6962
6963
6964 Id int64 `json:"id,omitempty,string"`
6965
6966
6967 Kind string `json:"kind,omitempty"`
6968
6969
6970
6971 LastModifiedTime int64 `json:"lastModifiedTime,omitempty,string"`
6972
6973
6974 ReportId int64 `json:"reportId,omitempty,string"`
6975
6976
6977
6978
6979
6980
6981
6982
6983 Status string `json:"status,omitempty"`
6984
6985
6986 Urls *FileUrls `json:"urls,omitempty"`
6987
6988
6989
6990 googleapi.ServerResponse `json:"-"`
6991
6992
6993
6994
6995
6996
6997
6998 ForceSendFields []string `json:"-"`
6999
7000
7001
7002
7003
7004
7005
7006 NullFields []string `json:"-"`
7007 }
7008
7009 func (s *File) MarshalJSON() ([]byte, error) {
7010 type NoMethod File
7011 raw := NoMethod(*s)
7012 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7013 }
7014
7015
7016 type FileUrls struct {
7017
7018 ApiUrl string `json:"apiUrl,omitempty"`
7019
7020
7021
7022 BrowserUrl string `json:"browserUrl,omitempty"`
7023
7024
7025
7026
7027
7028
7029
7030 ForceSendFields []string `json:"-"`
7031
7032
7033
7034
7035
7036
7037
7038 NullFields []string `json:"-"`
7039 }
7040
7041 func (s *FileUrls) MarshalJSON() ([]byte, error) {
7042 type NoMethod FileUrls
7043 raw := NoMethod(*s)
7044 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7045 }
7046
7047
7048 type FileList struct {
7049
7050 Etag string `json:"etag,omitempty"`
7051
7052
7053 Items []*File `json:"items,omitempty"`
7054
7055
7056 Kind string `json:"kind,omitempty"`
7057
7058
7059
7060
7061
7062 NextPageToken string `json:"nextPageToken,omitempty"`
7063
7064
7065
7066 googleapi.ServerResponse `json:"-"`
7067
7068
7069
7070
7071
7072
7073
7074 ForceSendFields []string `json:"-"`
7075
7076
7077
7078
7079
7080
7081
7082 NullFields []string `json:"-"`
7083 }
7084
7085 func (s *FileList) MarshalJSON() ([]byte, error) {
7086 type NoMethod FileList
7087 raw := NoMethod(*s)
7088 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7089 }
7090
7091
7092 type Flight struct {
7093
7094 EndDate string `json:"endDate,omitempty"`
7095
7096
7097 RateOrCost int64 `json:"rateOrCost,omitempty,string"`
7098
7099
7100 StartDate string `json:"startDate,omitempty"`
7101
7102
7103 Units int64 `json:"units,omitempty,string"`
7104
7105
7106
7107
7108
7109
7110
7111 ForceSendFields []string `json:"-"`
7112
7113
7114
7115
7116
7117
7118
7119 NullFields []string `json:"-"`
7120 }
7121
7122 func (s *Flight) MarshalJSON() ([]byte, error) {
7123 type NoMethod Flight
7124 raw := NoMethod(*s)
7125 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7126 }
7127
7128
7129
7130 type FloodlightActivitiesGenerateTagResponse struct {
7131
7132
7133 FloodlightActivityTag string `json:"floodlightActivityTag,omitempty"`
7134
7135
7136
7137
7138
7139 GlobalSiteTagGlobalSnippet string `json:"globalSiteTagGlobalSnippet,omitempty"`
7140
7141
7142
7143 Kind string `json:"kind,omitempty"`
7144
7145
7146
7147 googleapi.ServerResponse `json:"-"`
7148
7149
7150
7151
7152
7153
7154
7155
7156 ForceSendFields []string `json:"-"`
7157
7158
7159
7160
7161
7162
7163
7164
7165 NullFields []string `json:"-"`
7166 }
7167
7168 func (s *FloodlightActivitiesGenerateTagResponse) MarshalJSON() ([]byte, error) {
7169 type NoMethod FloodlightActivitiesGenerateTagResponse
7170 raw := NoMethod(*s)
7171 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7172 }
7173
7174
7175 type FloodlightActivitiesListResponse struct {
7176
7177 FloodlightActivities []*FloodlightActivity `json:"floodlightActivities,omitempty"`
7178
7179
7180
7181 Kind string `json:"kind,omitempty"`
7182
7183
7184
7185 NextPageToken string `json:"nextPageToken,omitempty"`
7186
7187
7188
7189 googleapi.ServerResponse `json:"-"`
7190
7191
7192
7193
7194
7195
7196
7197
7198 ForceSendFields []string `json:"-"`
7199
7200
7201
7202
7203
7204
7205
7206
7207 NullFields []string `json:"-"`
7208 }
7209
7210 func (s *FloodlightActivitiesListResponse) MarshalJSON() ([]byte, error) {
7211 type NoMethod FloodlightActivitiesListResponse
7212 raw := NoMethod(*s)
7213 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7214 }
7215
7216
7217 type FloodlightActivity struct {
7218
7219
7220 AccountId int64 `json:"accountId,omitempty,string"`
7221
7222
7223
7224
7225 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
7226
7227
7228
7229 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
7230
7231
7232
7233
7234
7235
7236
7237
7238
7239
7240
7241 CacheBustingType string `json:"cacheBustingType,omitempty"`
7242
7243
7244
7245
7246
7247
7248
7249
7250
7251
7252 CountingMethod string `json:"countingMethod,omitempty"`
7253
7254
7255 DefaultTags []*FloodlightActivityDynamicTag `json:"defaultTags,omitempty"`
7256
7257
7258
7259 ExpectedUrl string `json:"expectedUrl,omitempty"`
7260
7261
7262
7263 FloodlightActivityGroupId int64 `json:"floodlightActivityGroupId,omitempty,string"`
7264
7265
7266
7267 FloodlightActivityGroupName string `json:"floodlightActivityGroupName,omitempty"`
7268
7269
7270
7271 FloodlightActivityGroupTagString string `json:"floodlightActivityGroupTagString,omitempty"`
7272
7273
7274
7275
7276
7277
7278
7279 FloodlightActivityGroupType string `json:"floodlightActivityGroupType,omitempty"`
7280
7281
7282
7283
7284
7285 FloodlightConfigurationId int64 `json:"floodlightConfigurationId,omitempty,string"`
7286
7287
7288
7289
7290 FloodlightConfigurationIdDimensionValue *DimensionValue `json:"floodlightConfigurationIdDimensionValue,omitempty"`
7291
7292
7293
7294
7295
7296
7297
7298
7299 FloodlightTagType string `json:"floodlightTagType,omitempty"`
7300
7301
7302
7303 Id int64 `json:"id,omitempty,string"`
7304
7305
7306
7307 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
7308
7309
7310
7311 Kind string `json:"kind,omitempty"`
7312
7313
7314
7315 Name string `json:"name,omitempty"`
7316
7317
7318 Notes string `json:"notes,omitempty"`
7319
7320
7321 PublisherTags []*FloodlightActivityPublisherDynamicTag `json:"publisherTags,omitempty"`
7322
7323
7324 Secure bool `json:"secure,omitempty"`
7325
7326
7327
7328
7329 SslCompliant bool `json:"sslCompliant,omitempty"`
7330
7331
7332 SslRequired bool `json:"sslRequired,omitempty"`
7333
7334
7335
7336 SubaccountId int64 `json:"subaccountId,omitempty,string"`
7337
7338
7339
7340
7341
7342
7343
7344 TagFormat string `json:"tagFormat,omitempty"`
7345
7346
7347
7348
7349
7350
7351
7352
7353 TagString string `json:"tagString,omitempty"`
7354
7355
7356
7357
7358
7359
7360
7361
7362
7363
7364
7365
7366
7367
7368
7369
7370
7371
7372
7373
7374
7375
7376
7377
7378
7379
7380
7381
7382
7383
7384
7385
7386
7387
7388
7389
7390
7391
7392
7393
7394
7395
7396
7397
7398
7399
7400
7401
7402
7403
7404
7405
7406
7407
7408
7409
7410
7411
7412
7413
7414
7415
7416
7417
7418
7419
7420
7421
7422
7423
7424
7425
7426
7427
7428
7429
7430
7431
7432
7433
7434
7435
7436
7437
7438
7439
7440
7441
7442
7443
7444
7445
7446
7447
7448
7449
7450
7451
7452
7453
7454
7455
7456
7457
7458
7459
7460
7461 UserDefinedVariableTypes []string `json:"userDefinedVariableTypes,omitempty"`
7462
7463
7464
7465 googleapi.ServerResponse `json:"-"`
7466
7467
7468
7469
7470
7471
7472
7473 ForceSendFields []string `json:"-"`
7474
7475
7476
7477
7478
7479
7480
7481 NullFields []string `json:"-"`
7482 }
7483
7484 func (s *FloodlightActivity) MarshalJSON() ([]byte, error) {
7485 type NoMethod FloodlightActivity
7486 raw := NoMethod(*s)
7487 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7488 }
7489
7490
7491 type FloodlightActivityDynamicTag struct {
7492
7493
7494 Id int64 `json:"id,omitempty,string"`
7495
7496
7497 Name string `json:"name,omitempty"`
7498
7499
7500 Tag string `json:"tag,omitempty"`
7501
7502
7503
7504
7505
7506
7507
7508 ForceSendFields []string `json:"-"`
7509
7510
7511
7512
7513
7514
7515
7516 NullFields []string `json:"-"`
7517 }
7518
7519 func (s *FloodlightActivityDynamicTag) MarshalJSON() ([]byte, error) {
7520 type NoMethod FloodlightActivityDynamicTag
7521 raw := NoMethod(*s)
7522 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7523 }
7524
7525
7526
7527 type FloodlightActivityGroup struct {
7528
7529
7530 AccountId int64 `json:"accountId,omitempty,string"`
7531
7532
7533
7534
7535
7536 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
7537
7538
7539
7540 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
7541
7542
7543
7544 FloodlightConfigurationId int64 `json:"floodlightConfigurationId,omitempty,string"`
7545
7546
7547
7548
7549 FloodlightConfigurationIdDimensionValue *DimensionValue `json:"floodlightConfigurationIdDimensionValue,omitempty"`
7550
7551
7552
7553 Id int64 `json:"id,omitempty,string"`
7554
7555
7556
7557 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
7558
7559
7560
7561 Kind string `json:"kind,omitempty"`
7562
7563
7564
7565
7566 Name string `json:"name,omitempty"`
7567
7568
7569
7570 SubaccountId int64 `json:"subaccountId,omitempty,string"`
7571
7572
7573
7574
7575
7576
7577
7578
7579 TagString string `json:"tagString,omitempty"`
7580
7581
7582
7583
7584
7585
7586
7587 Type string `json:"type,omitempty"`
7588
7589
7590
7591 googleapi.ServerResponse `json:"-"`
7592
7593
7594
7595
7596
7597
7598
7599 ForceSendFields []string `json:"-"`
7600
7601
7602
7603
7604
7605
7606
7607 NullFields []string `json:"-"`
7608 }
7609
7610 func (s *FloodlightActivityGroup) MarshalJSON() ([]byte, error) {
7611 type NoMethod FloodlightActivityGroup
7612 raw := NoMethod(*s)
7613 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7614 }
7615
7616
7617
7618 type FloodlightActivityGroupsListResponse struct {
7619
7620 FloodlightActivityGroups []*FloodlightActivityGroup `json:"floodlightActivityGroups,omitempty"`
7621
7622
7623
7624 Kind string `json:"kind,omitempty"`
7625
7626
7627
7628 NextPageToken string `json:"nextPageToken,omitempty"`
7629
7630
7631
7632 googleapi.ServerResponse `json:"-"`
7633
7634
7635
7636
7637
7638
7639
7640
7641 ForceSendFields []string `json:"-"`
7642
7643
7644
7645
7646
7647
7648
7649
7650 NullFields []string `json:"-"`
7651 }
7652
7653 func (s *FloodlightActivityGroupsListResponse) MarshalJSON() ([]byte, error) {
7654 type NoMethod FloodlightActivityGroupsListResponse
7655 raw := NoMethod(*s)
7656 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7657 }
7658
7659
7660 type FloodlightActivityPublisherDynamicTag struct {
7661
7662 ClickThrough bool `json:"clickThrough,omitempty"`
7663
7664
7665
7666
7667
7668 DirectorySiteId int64 `json:"directorySiteId,omitempty,string"`
7669
7670
7671 DynamicTag *FloodlightActivityDynamicTag `json:"dynamicTag,omitempty"`
7672
7673
7674 SiteId int64 `json:"siteId,omitempty,string"`
7675
7676
7677
7678 SiteIdDimensionValue *DimensionValue `json:"siteIdDimensionValue,omitempty"`
7679
7680
7681 ViewThrough bool `json:"viewThrough,omitempty"`
7682
7683
7684
7685
7686
7687
7688
7689 ForceSendFields []string `json:"-"`
7690
7691
7692
7693
7694
7695
7696
7697 NullFields []string `json:"-"`
7698 }
7699
7700 func (s *FloodlightActivityPublisherDynamicTag) MarshalJSON() ([]byte, error) {
7701 type NoMethod FloodlightActivityPublisherDynamicTag
7702 raw := NoMethod(*s)
7703 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7704 }
7705
7706
7707
7708 type FloodlightConfiguration struct {
7709
7710
7711 AccountId int64 `json:"accountId,omitempty,string"`
7712
7713
7714
7715 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
7716
7717
7718
7719 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
7720
7721
7722
7723 AnalyticsDataSharingEnabled bool `json:"analyticsDataSharingEnabled,omitempty"`
7724
7725
7726
7727
7728
7729 ExposureToConversionEnabled bool `json:"exposureToConversionEnabled,omitempty"`
7730
7731
7732
7733
7734
7735
7736
7737 FirstDayOfWeek string `json:"firstDayOfWeek,omitempty"`
7738
7739
7740
7741 Id int64 `json:"id,omitempty,string"`
7742
7743
7744
7745 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
7746
7747
7748
7749 InAppAttributionTrackingEnabled bool `json:"inAppAttributionTrackingEnabled,omitempty"`
7750
7751
7752
7753 Kind string `json:"kind,omitempty"`
7754
7755
7756
7757 LookbackConfiguration *LookbackConfiguration `json:"lookbackConfiguration,omitempty"`
7758
7759
7760
7761
7762
7763
7764
7765
7766 NaturalSearchConversionAttributionOption string `json:"naturalSearchConversionAttributionOption,omitempty"`
7767
7768
7769 OmnitureSettings *OmnitureSettings `json:"omnitureSettings,omitempty"`
7770
7771
7772
7773 SubaccountId int64 `json:"subaccountId,omitempty,string"`
7774
7775
7776
7777 TagSettings *TagSettings `json:"tagSettings,omitempty"`
7778
7779
7780
7781 ThirdPartyAuthenticationTokens []*ThirdPartyAuthenticationToken `json:"thirdPartyAuthenticationTokens,omitempty"`
7782
7783
7784
7785 UserDefinedVariableConfigurations []*UserDefinedVariableConfiguration `json:"userDefinedVariableConfigurations,omitempty"`
7786
7787
7788
7789 googleapi.ServerResponse `json:"-"`
7790
7791
7792
7793
7794
7795
7796
7797 ForceSendFields []string `json:"-"`
7798
7799
7800
7801
7802
7803
7804
7805 NullFields []string `json:"-"`
7806 }
7807
7808 func (s *FloodlightConfiguration) MarshalJSON() ([]byte, error) {
7809 type NoMethod FloodlightConfiguration
7810 raw := NoMethod(*s)
7811 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7812 }
7813
7814
7815
7816 type FloodlightConfigurationsListResponse struct {
7817
7818 FloodlightConfigurations []*FloodlightConfiguration `json:"floodlightConfigurations,omitempty"`
7819
7820
7821
7822 Kind string `json:"kind,omitempty"`
7823
7824
7825
7826 googleapi.ServerResponse `json:"-"`
7827
7828
7829
7830
7831
7832
7833
7834
7835 ForceSendFields []string `json:"-"`
7836
7837
7838
7839
7840
7841
7842
7843
7844 NullFields []string `json:"-"`
7845 }
7846
7847 func (s *FloodlightConfigurationsListResponse) MarshalJSON() ([]byte, error) {
7848 type NoMethod FloodlightConfigurationsListResponse
7849 raw := NoMethod(*s)
7850 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7851 }
7852
7853
7854
7855 type FloodlightReportCompatibleFields struct {
7856
7857
7858 DimensionFilters []*Dimension `json:"dimensionFilters,omitempty"`
7859
7860
7861
7862 Dimensions []*Dimension `json:"dimensions,omitempty"`
7863
7864
7865
7866 Kind string `json:"kind,omitempty"`
7867
7868
7869
7870 Metrics []*Metric `json:"metrics,omitempty"`
7871
7872
7873
7874
7875
7876
7877
7878 ForceSendFields []string `json:"-"`
7879
7880
7881
7882
7883
7884
7885
7886
7887 NullFields []string `json:"-"`
7888 }
7889
7890 func (s *FloodlightReportCompatibleFields) MarshalJSON() ([]byte, error) {
7891 type NoMethod FloodlightReportCompatibleFields
7892 raw := NoMethod(*s)
7893 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7894 }
7895
7896
7897 type FrequencyCap struct {
7898
7899
7900
7901 Duration int64 `json:"duration,omitempty,string"`
7902
7903
7904
7905
7906 Impressions int64 `json:"impressions,omitempty,string"`
7907
7908
7909
7910
7911
7912
7913
7914 ForceSendFields []string `json:"-"`
7915
7916
7917
7918
7919
7920
7921
7922 NullFields []string `json:"-"`
7923 }
7924
7925 func (s *FrequencyCap) MarshalJSON() ([]byte, error) {
7926 type NoMethod FrequencyCap
7927 raw := NoMethod(*s)
7928 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7929 }
7930
7931
7932 type FsCommand struct {
7933
7934
7935 Left int64 `json:"left,omitempty"`
7936
7937
7938
7939
7940
7941
7942 PositionOption string `json:"positionOption,omitempty"`
7943
7944
7945
7946 Top int64 `json:"top,omitempty"`
7947
7948
7949 WindowHeight int64 `json:"windowHeight,omitempty"`
7950
7951
7952 WindowWidth int64 `json:"windowWidth,omitempty"`
7953
7954
7955
7956
7957
7958
7959
7960 ForceSendFields []string `json:"-"`
7961
7962
7963
7964
7965
7966
7967
7968 NullFields []string `json:"-"`
7969 }
7970
7971 func (s *FsCommand) MarshalJSON() ([]byte, error) {
7972 type NoMethod FsCommand
7973 raw := NoMethod(*s)
7974 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7975 }
7976
7977
7978 type GeoTargeting struct {
7979
7980
7981
7982
7983 Cities []*City `json:"cities,omitempty"`
7984
7985
7986
7987
7988
7989
7990
7991 Countries []*Country `json:"countries,omitempty"`
7992
7993
7994
7995
7996 ExcludeCountries bool `json:"excludeCountries,omitempty"`
7997
7998
7999
8000
8001
8002 Metros []*Metro `json:"metros,omitempty"`
8003
8004
8005
8006
8007
8008 PostalCodes []*PostalCode `json:"postalCodes,omitempty"`
8009
8010
8011
8012
8013
8014 Regions []*Region `json:"regions,omitempty"`
8015
8016
8017
8018
8019
8020
8021
8022 ForceSendFields []string `json:"-"`
8023
8024
8025
8026
8027
8028
8029
8030 NullFields []string `json:"-"`
8031 }
8032
8033 func (s *GeoTargeting) MarshalJSON() ([]byte, error) {
8034 type NoMethod GeoTargeting
8035 raw := NoMethod(*s)
8036 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8037 }
8038
8039
8040 type InventoryItem struct {
8041
8042 AccountId int64 `json:"accountId,omitempty,string"`
8043
8044
8045
8046
8047
8048
8049 AdSlots []*AdSlot `json:"adSlots,omitempty"`
8050
8051
8052 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
8053
8054
8055 ContentCategoryId int64 `json:"contentCategoryId,omitempty,string"`
8056
8057
8058
8059 EstimatedClickThroughRate int64 `json:"estimatedClickThroughRate,omitempty,string"`
8060
8061
8062
8063 EstimatedConversionRate int64 `json:"estimatedConversionRate,omitempty,string"`
8064
8065
8066 Id int64 `json:"id,omitempty,string"`
8067
8068
8069 InPlan bool `json:"inPlan,omitempty"`
8070
8071
8072
8073 Kind string `json:"kind,omitempty"`
8074
8075
8076
8077 LastModifiedInfo *LastModifiedInfo `json:"lastModifiedInfo,omitempty"`
8078
8079
8080
8081
8082
8083 Name string `json:"name,omitempty"`
8084
8085
8086 NegotiationChannelId int64 `json:"negotiationChannelId,omitempty,string"`
8087
8088
8089 OrderId int64 `json:"orderId,omitempty,string"`
8090
8091
8092 PlacementStrategyId int64 `json:"placementStrategyId,omitempty,string"`
8093
8094
8095 Pricing *Pricing `json:"pricing,omitempty"`
8096
8097
8098 ProjectId int64 `json:"projectId,omitempty,string"`
8099
8100
8101 RfpId int64 `json:"rfpId,omitempty,string"`
8102
8103
8104 SiteId int64 `json:"siteId,omitempty,string"`
8105
8106
8107 SubaccountId int64 `json:"subaccountId,omitempty,string"`
8108
8109
8110
8111
8112
8113
8114 Type string `json:"type,omitempty"`
8115
8116
8117
8118 googleapi.ServerResponse `json:"-"`
8119
8120
8121
8122
8123
8124
8125
8126 ForceSendFields []string `json:"-"`
8127
8128
8129
8130
8131
8132
8133
8134 NullFields []string `json:"-"`
8135 }
8136
8137 func (s *InventoryItem) MarshalJSON() ([]byte, error) {
8138 type NoMethod InventoryItem
8139 raw := NoMethod(*s)
8140 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8141 }
8142
8143
8144 type InventoryItemsListResponse struct {
8145
8146 InventoryItems []*InventoryItem `json:"inventoryItems,omitempty"`
8147
8148
8149
8150 Kind string `json:"kind,omitempty"`
8151
8152
8153
8154 NextPageToken string `json:"nextPageToken,omitempty"`
8155
8156
8157
8158 googleapi.ServerResponse `json:"-"`
8159
8160
8161
8162
8163
8164
8165
8166 ForceSendFields []string `json:"-"`
8167
8168
8169
8170
8171
8172
8173
8174
8175 NullFields []string `json:"-"`
8176 }
8177
8178 func (s *InventoryItemsListResponse) MarshalJSON() ([]byte, error) {
8179 type NoMethod InventoryItemsListResponse
8180 raw := NoMethod(*s)
8181 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8182 }
8183
8184
8185 type KeyValueTargetingExpression struct {
8186
8187 Expression string `json:"expression,omitempty"`
8188
8189
8190
8191
8192
8193
8194
8195 ForceSendFields []string `json:"-"`
8196
8197
8198
8199
8200
8201
8202
8203 NullFields []string `json:"-"`
8204 }
8205
8206 func (s *KeyValueTargetingExpression) MarshalJSON() ([]byte, error) {
8207 type NoMethod KeyValueTargetingExpression
8208 raw := NoMethod(*s)
8209 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8210 }
8211
8212
8213
8214 type LandingPage struct {
8215
8216
8217 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
8218
8219
8220 Archived bool `json:"archived,omitempty"`
8221
8222
8223
8224 DeepLinks []*DeepLink `json:"deepLinks,omitempty"`
8225
8226
8227
8228 Id int64 `json:"id,omitempty,string"`
8229
8230
8231
8232 Kind string `json:"kind,omitempty"`
8233
8234
8235
8236 Name string `json:"name,omitempty"`
8237
8238
8239 Url string `json:"url,omitempty"`
8240
8241
8242
8243 googleapi.ServerResponse `json:"-"`
8244
8245
8246
8247
8248
8249
8250
8251 ForceSendFields []string `json:"-"`
8252
8253
8254
8255
8256
8257
8258
8259 NullFields []string `json:"-"`
8260 }
8261
8262 func (s *LandingPage) MarshalJSON() ([]byte, error) {
8263 type NoMethod LandingPage
8264 raw := NoMethod(*s)
8265 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8266 }
8267
8268
8269
8270 type Language struct {
8271
8272
8273 Id int64 `json:"id,omitempty,string"`
8274
8275
8276
8277 Kind string `json:"kind,omitempty"`
8278
8279
8280
8281
8282
8283 LanguageCode string `json:"languageCode,omitempty"`
8284
8285
8286 Name string `json:"name,omitempty"`
8287
8288
8289
8290
8291
8292
8293
8294 ForceSendFields []string `json:"-"`
8295
8296
8297
8298
8299
8300
8301
8302 NullFields []string `json:"-"`
8303 }
8304
8305 func (s *Language) MarshalJSON() ([]byte, error) {
8306 type NoMethod Language
8307 raw := NoMethod(*s)
8308 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8309 }
8310
8311
8312 type LanguageTargeting struct {
8313
8314
8315
8316 Languages []*Language `json:"languages,omitempty"`
8317
8318
8319
8320
8321
8322
8323
8324 ForceSendFields []string `json:"-"`
8325
8326
8327
8328
8329
8330
8331
8332 NullFields []string `json:"-"`
8333 }
8334
8335 func (s *LanguageTargeting) MarshalJSON() ([]byte, error) {
8336 type NoMethod LanguageTargeting
8337 raw := NoMethod(*s)
8338 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8339 }
8340
8341
8342 type LanguagesListResponse struct {
8343
8344
8345 Kind string `json:"kind,omitempty"`
8346
8347
8348 Languages []*Language `json:"languages,omitempty"`
8349
8350
8351
8352 googleapi.ServerResponse `json:"-"`
8353
8354
8355
8356
8357
8358
8359
8360 ForceSendFields []string `json:"-"`
8361
8362
8363
8364
8365
8366
8367
8368 NullFields []string `json:"-"`
8369 }
8370
8371 func (s *LanguagesListResponse) MarshalJSON() ([]byte, error) {
8372 type NoMethod LanguagesListResponse
8373 raw := NoMethod(*s)
8374 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8375 }
8376
8377
8378 type LastModifiedInfo struct {
8379
8380 Time int64 `json:"time,omitempty,string"`
8381
8382
8383
8384
8385
8386
8387
8388 ForceSendFields []string `json:"-"`
8389
8390
8391
8392
8393
8394
8395
8396 NullFields []string `json:"-"`
8397 }
8398
8399 func (s *LastModifiedInfo) MarshalJSON() ([]byte, error) {
8400 type NoMethod LastModifiedInfo
8401 raw := NoMethod(*s)
8402 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8403 }
8404
8405
8406
8407 type ListPopulationClause struct {
8408
8409
8410
8411 Terms []*ListPopulationTerm `json:"terms,omitempty"`
8412
8413
8414
8415
8416
8417
8418
8419 ForceSendFields []string `json:"-"`
8420
8421
8422
8423
8424
8425
8426
8427 NullFields []string `json:"-"`
8428 }
8429
8430 func (s *ListPopulationClause) MarshalJSON() ([]byte, error) {
8431 type NoMethod ListPopulationClause
8432 raw := NoMethod(*s)
8433 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8434 }
8435
8436
8437 type ListPopulationRule struct {
8438
8439
8440 FloodlightActivityId int64 `json:"floodlightActivityId,omitempty,string"`
8441
8442
8443
8444 FloodlightActivityName string `json:"floodlightActivityName,omitempty"`
8445
8446
8447
8448
8449 ListPopulationClauses []*ListPopulationClause `json:"listPopulationClauses,omitempty"`
8450
8451
8452
8453
8454
8455
8456
8457
8458 ForceSendFields []string `json:"-"`
8459
8460
8461
8462
8463
8464
8465
8466
8467 NullFields []string `json:"-"`
8468 }
8469
8470 func (s *ListPopulationRule) MarshalJSON() ([]byte, error) {
8471 type NoMethod ListPopulationRule
8472 raw := NoMethod(*s)
8473 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8474 }
8475
8476
8477 type ListPopulationTerm struct {
8478
8479
8480
8481
8482 Contains bool `json:"contains,omitempty"`
8483
8484
8485
8486
8487 Negation bool `json:"negation,omitempty"`
8488
8489
8490
8491
8492
8493
8494
8495
8496
8497
8498
8499
8500
8501 Operator string `json:"operator,omitempty"`
8502
8503
8504
8505 RemarketingListId int64 `json:"remarketingListId,omitempty,string"`
8506
8507
8508
8509
8510
8511
8512
8513
8514
8515
8516
8517
8518 Type string `json:"type,omitempty"`
8519
8520
8521
8522
8523 Value string `json:"value,omitempty"`
8524
8525
8526
8527
8528 VariableFriendlyName string `json:"variableFriendlyName,omitempty"`
8529
8530
8531
8532
8533 VariableName string `json:"variableName,omitempty"`
8534
8535
8536
8537
8538
8539
8540
8541 ForceSendFields []string `json:"-"`
8542
8543
8544
8545
8546
8547
8548
8549 NullFields []string `json:"-"`
8550 }
8551
8552 func (s *ListPopulationTerm) MarshalJSON() ([]byte, error) {
8553 type NoMethod ListPopulationTerm
8554 raw := NoMethod(*s)
8555 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8556 }
8557
8558
8559 type ListTargetingExpression struct {
8560
8561
8562 Expression string `json:"expression,omitempty"`
8563
8564
8565
8566
8567
8568
8569
8570 ForceSendFields []string `json:"-"`
8571
8572
8573
8574
8575
8576
8577
8578 NullFields []string `json:"-"`
8579 }
8580
8581 func (s *ListTargetingExpression) MarshalJSON() ([]byte, error) {
8582 type NoMethod ListTargetingExpression
8583 raw := NoMethod(*s)
8584 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8585 }
8586
8587
8588 type LookbackConfiguration struct {
8589
8590
8591
8592
8593
8594 ClickDuration int64 `json:"clickDuration,omitempty"`
8595
8596
8597
8598
8599
8600
8601
8602 PostImpressionActivitiesDuration int64 `json:"postImpressionActivitiesDuration,omitempty"`
8603
8604
8605
8606
8607
8608
8609
8610 ForceSendFields []string `json:"-"`
8611
8612
8613
8614
8615
8616
8617
8618 NullFields []string `json:"-"`
8619 }
8620
8621 func (s *LookbackConfiguration) MarshalJSON() ([]byte, error) {
8622 type NoMethod LookbackConfiguration
8623 raw := NoMethod(*s)
8624 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8625 }
8626
8627
8628 type Metric struct {
8629
8630 Kind string `json:"kind,omitempty"`
8631
8632
8633 Name string `json:"name,omitempty"`
8634
8635
8636
8637
8638
8639
8640
8641 ForceSendFields []string `json:"-"`
8642
8643
8644
8645
8646
8647
8648
8649 NullFields []string `json:"-"`
8650 }
8651
8652 func (s *Metric) MarshalJSON() ([]byte, error) {
8653 type NoMethod Metric
8654 raw := NoMethod(*s)
8655 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8656 }
8657
8658
8659
8660 type Metro struct {
8661
8662
8663 CountryCode string `json:"countryCode,omitempty"`
8664
8665
8666
8667 CountryDartId int64 `json:"countryDartId,omitempty,string"`
8668
8669
8670 DartId int64 `json:"dartId,omitempty,string"`
8671
8672
8673
8674 DmaId int64 `json:"dmaId,omitempty,string"`
8675
8676
8677
8678 Kind string `json:"kind,omitempty"`
8679
8680
8681
8682 MetroCode string `json:"metroCode,omitempty"`
8683
8684
8685 Name string `json:"name,omitempty"`
8686
8687
8688
8689
8690
8691
8692
8693 ForceSendFields []string `json:"-"`
8694
8695
8696
8697
8698
8699
8700
8701 NullFields []string `json:"-"`
8702 }
8703
8704 func (s *Metro) MarshalJSON() ([]byte, error) {
8705 type NoMethod Metro
8706 raw := NoMethod(*s)
8707 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8708 }
8709
8710
8711 type MetrosListResponse struct {
8712
8713
8714 Kind string `json:"kind,omitempty"`
8715
8716
8717 Metros []*Metro `json:"metros,omitempty"`
8718
8719
8720
8721 googleapi.ServerResponse `json:"-"`
8722
8723
8724
8725
8726
8727
8728
8729 ForceSendFields []string `json:"-"`
8730
8731
8732
8733
8734
8735
8736
8737 NullFields []string `json:"-"`
8738 }
8739
8740 func (s *MetrosListResponse) MarshalJSON() ([]byte, error) {
8741 type NoMethod MetrosListResponse
8742 raw := NoMethod(*s)
8743 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8744 }
8745
8746
8747
8748 type MobileApp struct {
8749
8750
8751
8752
8753
8754
8755 Directory string `json:"directory,omitempty"`
8756
8757
8758 Id string `json:"id,omitempty"`
8759
8760
8761
8762 Kind string `json:"kind,omitempty"`
8763
8764
8765 PublisherName string `json:"publisherName,omitempty"`
8766
8767
8768 Title string `json:"title,omitempty"`
8769
8770
8771
8772 googleapi.ServerResponse `json:"-"`
8773
8774
8775
8776
8777
8778
8779
8780 ForceSendFields []string `json:"-"`
8781
8782
8783
8784
8785
8786
8787
8788 NullFields []string `json:"-"`
8789 }
8790
8791 func (s *MobileApp) MarshalJSON() ([]byte, error) {
8792 type NoMethod MobileApp
8793 raw := NoMethod(*s)
8794 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8795 }
8796
8797
8798 type MobileAppsListResponse struct {
8799
8800
8801 Kind string `json:"kind,omitempty"`
8802
8803
8804 MobileApps []*MobileApp `json:"mobileApps,omitempty"`
8805
8806
8807
8808 NextPageToken string `json:"nextPageToken,omitempty"`
8809
8810
8811
8812 googleapi.ServerResponse `json:"-"`
8813
8814
8815
8816
8817
8818
8819
8820 ForceSendFields []string `json:"-"`
8821
8822
8823
8824
8825
8826
8827
8828 NullFields []string `json:"-"`
8829 }
8830
8831 func (s *MobileAppsListResponse) MarshalJSON() ([]byte, error) {
8832 type NoMethod MobileAppsListResponse
8833 raw := NoMethod(*s)
8834 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8835 }
8836
8837
8838
8839 type MobileCarrier struct {
8840
8841
8842 CountryCode string `json:"countryCode,omitempty"`
8843
8844
8845
8846 CountryDartId int64 `json:"countryDartId,omitempty,string"`
8847
8848
8849 Id int64 `json:"id,omitempty,string"`
8850
8851
8852
8853 Kind string `json:"kind,omitempty"`
8854
8855
8856 Name string `json:"name,omitempty"`
8857
8858
8859
8860 googleapi.ServerResponse `json:"-"`
8861
8862
8863
8864
8865
8866
8867
8868 ForceSendFields []string `json:"-"`
8869
8870
8871
8872
8873
8874
8875
8876 NullFields []string `json:"-"`
8877 }
8878
8879 func (s *MobileCarrier) MarshalJSON() ([]byte, error) {
8880 type NoMethod MobileCarrier
8881 raw := NoMethod(*s)
8882 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8883 }
8884
8885
8886 type MobileCarriersListResponse struct {
8887
8888
8889 Kind string `json:"kind,omitempty"`
8890
8891
8892 MobileCarriers []*MobileCarrier `json:"mobileCarriers,omitempty"`
8893
8894
8895
8896 googleapi.ServerResponse `json:"-"`
8897
8898
8899
8900
8901
8902
8903
8904 ForceSendFields []string `json:"-"`
8905
8906
8907
8908
8909
8910
8911
8912 NullFields []string `json:"-"`
8913 }
8914
8915 func (s *MobileCarriersListResponse) MarshalJSON() ([]byte, error) {
8916 type NoMethod MobileCarriersListResponse
8917 raw := NoMethod(*s)
8918 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8919 }
8920
8921
8922 type ObjectFilter struct {
8923
8924
8925 Kind string `json:"kind,omitempty"`
8926
8927
8928
8929 ObjectIds googleapi.Int64s `json:"objectIds,omitempty"`
8930
8931
8932
8933
8934
8935
8936
8937
8938
8939
8940 Status string `json:"status,omitempty"`
8941
8942
8943
8944
8945
8946
8947
8948 ForceSendFields []string `json:"-"`
8949
8950
8951
8952
8953
8954
8955
8956 NullFields []string `json:"-"`
8957 }
8958
8959 func (s *ObjectFilter) MarshalJSON() ([]byte, error) {
8960 type NoMethod ObjectFilter
8961 raw := NoMethod(*s)
8962 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8963 }
8964
8965
8966 type OffsetPosition struct {
8967
8968 Left int64 `json:"left,omitempty"`
8969
8970
8971 Top int64 `json:"top,omitempty"`
8972
8973
8974
8975
8976
8977
8978
8979 ForceSendFields []string `json:"-"`
8980
8981
8982
8983
8984
8985
8986
8987 NullFields []string `json:"-"`
8988 }
8989
8990 func (s *OffsetPosition) MarshalJSON() ([]byte, error) {
8991 type NoMethod OffsetPosition
8992 raw := NoMethod(*s)
8993 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8994 }
8995
8996
8997 type OmnitureSettings struct {
8998
8999
9000
9001 OmnitureCostDataEnabled bool `json:"omnitureCostDataEnabled,omitempty"`
9002
9003
9004
9005
9006 OmnitureIntegrationEnabled bool `json:"omnitureIntegrationEnabled,omitempty"`
9007
9008
9009
9010
9011
9012
9013
9014
9015 ForceSendFields []string `json:"-"`
9016
9017
9018
9019
9020
9021
9022
9023
9024 NullFields []string `json:"-"`
9025 }
9026
9027 func (s *OmnitureSettings) MarshalJSON() ([]byte, error) {
9028 type NoMethod OmnitureSettings
9029 raw := NoMethod(*s)
9030 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9031 }
9032
9033
9034
9035 type OperatingSystem struct {
9036
9037
9038 DartId int64 `json:"dartId,omitempty,string"`
9039
9040
9041 Desktop bool `json:"desktop,omitempty"`
9042
9043
9044
9045 Kind string `json:"kind,omitempty"`
9046
9047
9048 Mobile bool `json:"mobile,omitempty"`
9049
9050
9051 Name string `json:"name,omitempty"`
9052
9053
9054
9055 googleapi.ServerResponse `json:"-"`
9056
9057
9058
9059
9060
9061
9062
9063 ForceSendFields []string `json:"-"`
9064
9065
9066
9067
9068
9069
9070
9071 NullFields []string `json:"-"`
9072 }
9073
9074 func (s *OperatingSystem) MarshalJSON() ([]byte, error) {
9075 type NoMethod OperatingSystem
9076 raw := NoMethod(*s)
9077 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9078 }
9079
9080
9081
9082 type OperatingSystemVersion struct {
9083
9084 Id int64 `json:"id,omitempty,string"`
9085
9086
9087
9088 Kind string `json:"kind,omitempty"`
9089
9090
9091
9092 MajorVersion string `json:"majorVersion,omitempty"`
9093
9094
9095
9096 MinorVersion string `json:"minorVersion,omitempty"`
9097
9098
9099 Name string `json:"name,omitempty"`
9100
9101
9102 OperatingSystem *OperatingSystem `json:"operatingSystem,omitempty"`
9103
9104
9105
9106 googleapi.ServerResponse `json:"-"`
9107
9108
9109
9110
9111
9112
9113
9114 ForceSendFields []string `json:"-"`
9115
9116
9117
9118
9119
9120
9121
9122 NullFields []string `json:"-"`
9123 }
9124
9125 func (s *OperatingSystemVersion) MarshalJSON() ([]byte, error) {
9126 type NoMethod OperatingSystemVersion
9127 raw := NoMethod(*s)
9128 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9129 }
9130
9131
9132
9133 type OperatingSystemVersionsListResponse struct {
9134
9135
9136 Kind string `json:"kind,omitempty"`
9137
9138
9139 OperatingSystemVersions []*OperatingSystemVersion `json:"operatingSystemVersions,omitempty"`
9140
9141
9142
9143 googleapi.ServerResponse `json:"-"`
9144
9145
9146
9147
9148
9149
9150
9151 ForceSendFields []string `json:"-"`
9152
9153
9154
9155
9156
9157
9158
9159 NullFields []string `json:"-"`
9160 }
9161
9162 func (s *OperatingSystemVersionsListResponse) MarshalJSON() ([]byte, error) {
9163 type NoMethod OperatingSystemVersionsListResponse
9164 raw := NoMethod(*s)
9165 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9166 }
9167
9168
9169 type OperatingSystemsListResponse struct {
9170
9171
9172 Kind string `json:"kind,omitempty"`
9173
9174
9175 OperatingSystems []*OperatingSystem `json:"operatingSystems,omitempty"`
9176
9177
9178
9179 googleapi.ServerResponse `json:"-"`
9180
9181
9182
9183
9184
9185
9186
9187 ForceSendFields []string `json:"-"`
9188
9189
9190
9191
9192
9193
9194
9195 NullFields []string `json:"-"`
9196 }
9197
9198 func (s *OperatingSystemsListResponse) MarshalJSON() ([]byte, error) {
9199 type NoMethod OperatingSystemsListResponse
9200 raw := NoMethod(*s)
9201 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9202 }
9203
9204
9205 type OptimizationActivity struct {
9206
9207
9208 FloodlightActivityId int64 `json:"floodlightActivityId,omitempty,string"`
9209
9210
9211
9212 FloodlightActivityIdDimensionValue *DimensionValue `json:"floodlightActivityIdDimensionValue,omitempty"`
9213
9214
9215
9216
9217 Weight int64 `json:"weight,omitempty"`
9218
9219
9220
9221
9222
9223
9224
9225
9226 ForceSendFields []string `json:"-"`
9227
9228
9229
9230
9231
9232
9233
9234
9235 NullFields []string `json:"-"`
9236 }
9237
9238 func (s *OptimizationActivity) MarshalJSON() ([]byte, error) {
9239 type NoMethod OptimizationActivity
9240 raw := NoMethod(*s)
9241 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9242 }
9243
9244
9245 type Order struct {
9246
9247 AccountId int64 `json:"accountId,omitempty,string"`
9248
9249
9250 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
9251
9252
9253
9254 ApproverUserProfileIds googleapi.Int64s `json:"approverUserProfileIds,omitempty"`
9255
9256
9257 BuyerInvoiceId string `json:"buyerInvoiceId,omitempty"`
9258
9259
9260 BuyerOrganizationName string `json:"buyerOrganizationName,omitempty"`
9261
9262
9263 Comments string `json:"comments,omitempty"`
9264
9265
9266 Contacts []*OrderContact `json:"contacts,omitempty"`
9267
9268
9269 Id int64 `json:"id,omitempty,string"`
9270
9271
9272
9273 Kind string `json:"kind,omitempty"`
9274
9275
9276
9277 LastModifiedInfo *LastModifiedInfo `json:"lastModifiedInfo,omitempty"`
9278
9279
9280 Name string `json:"name,omitempty"`
9281
9282
9283 Notes string `json:"notes,omitempty"`
9284
9285
9286
9287 PlanningTermId int64 `json:"planningTermId,omitempty,string"`
9288
9289
9290 ProjectId int64 `json:"projectId,omitempty,string"`
9291
9292
9293 SellerOrderId string `json:"sellerOrderId,omitempty"`
9294
9295
9296 SellerOrganizationName string `json:"sellerOrganizationName,omitempty"`
9297
9298
9299 SiteId googleapi.Int64s `json:"siteId,omitempty"`
9300
9301
9302 SiteNames []string `json:"siteNames,omitempty"`
9303
9304
9305 SubaccountId int64 `json:"subaccountId,omitempty,string"`
9306
9307
9308 TermsAndConditions string `json:"termsAndConditions,omitempty"`
9309
9310
9311
9312 googleapi.ServerResponse `json:"-"`
9313
9314
9315
9316
9317
9318
9319
9320 ForceSendFields []string `json:"-"`
9321
9322
9323
9324
9325
9326
9327
9328 NullFields []string `json:"-"`
9329 }
9330
9331 func (s *Order) MarshalJSON() ([]byte, error) {
9332 type NoMethod Order
9333 raw := NoMethod(*s)
9334 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9335 }
9336
9337
9338 type OrderContact struct {
9339
9340
9341
9342 ContactInfo string `json:"contactInfo,omitempty"`
9343
9344
9345 ContactName string `json:"contactName,omitempty"`
9346
9347
9348 ContactTitle string `json:"contactTitle,omitempty"`
9349
9350
9351
9352
9353
9354
9355
9356 ContactType string `json:"contactType,omitempty"`
9357
9358
9359
9360 SignatureUserProfileId int64 `json:"signatureUserProfileId,omitempty,string"`
9361
9362
9363
9364
9365
9366
9367
9368 ForceSendFields []string `json:"-"`
9369
9370
9371
9372
9373
9374
9375
9376 NullFields []string `json:"-"`
9377 }
9378
9379 func (s *OrderContact) MarshalJSON() ([]byte, error) {
9380 type NoMethod OrderContact
9381 raw := NoMethod(*s)
9382 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9383 }
9384
9385
9386 type OrderDocument struct {
9387
9388 AccountId int64 `json:"accountId,omitempty,string"`
9389
9390
9391 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
9392
9393
9394
9395
9396 AmendedOrderDocumentId int64 `json:"amendedOrderDocumentId,omitempty,string"`
9397
9398
9399
9400 ApprovedByUserProfileIds googleapi.Int64s `json:"approvedByUserProfileIds,omitempty"`
9401
9402
9403 Cancelled bool `json:"cancelled,omitempty"`
9404
9405
9406 CreatedInfo *LastModifiedInfo `json:"createdInfo,omitempty"`
9407
9408
9409 EffectiveDate string `json:"effectiveDate,omitempty"`
9410
9411
9412 Id int64 `json:"id,omitempty,string"`
9413
9414
9415
9416 Kind string `json:"kind,omitempty"`
9417
9418
9419
9420 LastSentRecipients []string `json:"lastSentRecipients,omitempty"`
9421
9422
9423
9424 LastSentTime string `json:"lastSentTime,omitempty"`
9425
9426
9427 OrderId int64 `json:"orderId,omitempty,string"`
9428
9429
9430 ProjectId int64 `json:"projectId,omitempty,string"`
9431
9432
9433 Signed bool `json:"signed,omitempty"`
9434
9435
9436 SubaccountId int64 `json:"subaccountId,omitempty,string"`
9437
9438
9439 Title string `json:"title,omitempty"`
9440
9441
9442
9443
9444
9445
9446 Type string `json:"type,omitempty"`
9447
9448
9449
9450 googleapi.ServerResponse `json:"-"`
9451
9452
9453
9454
9455
9456
9457
9458 ForceSendFields []string `json:"-"`
9459
9460
9461
9462
9463
9464
9465
9466 NullFields []string `json:"-"`
9467 }
9468
9469 func (s *OrderDocument) MarshalJSON() ([]byte, error) {
9470 type NoMethod OrderDocument
9471 raw := NoMethod(*s)
9472 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9473 }
9474
9475
9476 type OrderDocumentsListResponse struct {
9477
9478
9479 Kind string `json:"kind,omitempty"`
9480
9481
9482
9483 NextPageToken string `json:"nextPageToken,omitempty"`
9484
9485
9486 OrderDocuments []*OrderDocument `json:"orderDocuments,omitempty"`
9487
9488
9489
9490 googleapi.ServerResponse `json:"-"`
9491
9492
9493
9494
9495
9496
9497
9498 ForceSendFields []string `json:"-"`
9499
9500
9501
9502
9503
9504
9505
9506 NullFields []string `json:"-"`
9507 }
9508
9509 func (s *OrderDocumentsListResponse) MarshalJSON() ([]byte, error) {
9510 type NoMethod OrderDocumentsListResponse
9511 raw := NoMethod(*s)
9512 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9513 }
9514
9515
9516 type OrdersListResponse struct {
9517
9518
9519 Kind string `json:"kind,omitempty"`
9520
9521
9522
9523 NextPageToken string `json:"nextPageToken,omitempty"`
9524
9525
9526 Orders []*Order `json:"orders,omitempty"`
9527
9528
9529
9530 googleapi.ServerResponse `json:"-"`
9531
9532
9533
9534
9535
9536
9537
9538 ForceSendFields []string `json:"-"`
9539
9540
9541
9542
9543
9544
9545
9546 NullFields []string `json:"-"`
9547 }
9548
9549 func (s *OrdersListResponse) MarshalJSON() ([]byte, error) {
9550 type NoMethod OrdersListResponse
9551 raw := NoMethod(*s)
9552 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9553 }
9554
9555
9556
9557 type PathToConversionReportCompatibleFields struct {
9558
9559
9560 ConversionDimensions []*Dimension `json:"conversionDimensions,omitempty"`
9561
9562
9563
9564
9565 CustomFloodlightVariables []*Dimension `json:"customFloodlightVariables,omitempty"`
9566
9567
9568
9569 Kind string `json:"kind,omitempty"`
9570
9571
9572
9573 Metrics []*Metric `json:"metrics,omitempty"`
9574
9575
9576
9577
9578 PerInteractionDimensions []*Dimension `json:"perInteractionDimensions,omitempty"`
9579
9580
9581
9582
9583
9584
9585
9586
9587 ForceSendFields []string `json:"-"`
9588
9589
9590
9591
9592
9593
9594
9595
9596 NullFields []string `json:"-"`
9597 }
9598
9599 func (s *PathToConversionReportCompatibleFields) MarshalJSON() ([]byte, error) {
9600 type NoMethod PathToConversionReportCompatibleFields
9601 raw := NoMethod(*s)
9602 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9603 }
9604
9605
9606 type Placement struct {
9607
9608
9609 AccountId int64 `json:"accountId,omitempty,string"`
9610
9611
9612
9613
9614 AdBlockingOptOut bool `json:"adBlockingOptOut,omitempty"`
9615
9616
9617
9618
9619 AdditionalSizes []*Size `json:"additionalSizes,omitempty"`
9620
9621
9622
9623 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
9624
9625
9626
9627 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
9628
9629
9630 Archived bool `json:"archived,omitempty"`
9631
9632
9633
9634 CampaignId int64 `json:"campaignId,omitempty,string"`
9635
9636
9637
9638 CampaignIdDimensionValue *DimensionValue `json:"campaignIdDimensionValue,omitempty"`
9639
9640
9641 Comment string `json:"comment,omitempty"`
9642
9643
9644
9645
9646
9647
9648
9649
9650
9651
9652
9653
9654
9655
9656
9657
9658 Compatibility string `json:"compatibility,omitempty"`
9659
9660
9661
9662 ContentCategoryId int64 `json:"contentCategoryId,omitempty,string"`
9663
9664
9665
9666 CreateInfo *LastModifiedInfo `json:"createInfo,omitempty"`
9667
9668
9669
9670
9671
9672 DirectorySiteId int64 `json:"directorySiteId,omitempty,string"`
9673
9674
9675
9676 DirectorySiteIdDimensionValue *DimensionValue `json:"directorySiteIdDimensionValue,omitempty"`
9677
9678
9679 ExternalId string `json:"externalId,omitempty"`
9680
9681
9682 Id int64 `json:"id,omitempty,string"`
9683
9684
9685
9686 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
9687
9688
9689
9690 KeyName string `json:"keyName,omitempty"`
9691
9692
9693
9694 Kind string `json:"kind,omitempty"`
9695
9696
9697
9698 LastModifiedInfo *LastModifiedInfo `json:"lastModifiedInfo,omitempty"`
9699
9700
9701 LookbackConfiguration *LookbackConfiguration `json:"lookbackConfiguration,omitempty"`
9702
9703
9704
9705 Name string `json:"name,omitempty"`
9706
9707
9708
9709 PaymentApproved bool `json:"paymentApproved,omitempty"`
9710
9711
9712
9713
9714
9715
9716
9717 PaymentSource string `json:"paymentSource,omitempty"`
9718
9719
9720 PlacementGroupId int64 `json:"placementGroupId,omitempty,string"`
9721
9722
9723
9724 PlacementGroupIdDimensionValue *DimensionValue `json:"placementGroupIdDimensionValue,omitempty"`
9725
9726
9727
9728 PlacementStrategyId int64 `json:"placementStrategyId,omitempty,string"`
9729
9730
9731
9732
9733 PricingSchedule *PricingSchedule `json:"pricingSchedule,omitempty"`
9734
9735
9736
9737
9738
9739
9740
9741 Primary bool `json:"primary,omitempty"`
9742
9743
9744
9745 PublisherUpdateInfo *LastModifiedInfo `json:"publisherUpdateInfo,omitempty"`
9746
9747
9748
9749
9750
9751 SiteId int64 `json:"siteId,omitempty,string"`
9752
9753
9754
9755 SiteIdDimensionValue *DimensionValue `json:"siteIdDimensionValue,omitempty"`
9756
9757
9758
9759
9760 Size *Size `json:"size,omitempty"`
9761
9762
9763
9764 SslRequired bool `json:"sslRequired,omitempty"`
9765
9766
9767
9768
9769
9770
9771
9772
9773
9774
9775 Status string `json:"status,omitempty"`
9776
9777
9778
9779 SubaccountId int64 `json:"subaccountId,omitempty,string"`
9780
9781
9782
9783
9784
9785
9786
9787
9788
9789
9790
9791
9792
9793
9794
9795
9796
9797
9798
9799
9800
9801
9802
9803
9804
9805
9806
9807
9808
9809
9810
9811
9812
9813
9814
9815
9816
9817
9818
9819
9820 TagFormats []string `json:"tagFormats,omitempty"`
9821
9822
9823 TagSetting *TagSetting `json:"tagSetting,omitempty"`
9824
9825
9826
9827
9828
9829
9830
9831
9832
9833 VideoActiveViewOptOut bool `json:"videoActiveViewOptOut,omitempty"`
9834
9835
9836
9837
9838 VideoSettings *VideoSettings `json:"videoSettings,omitempty"`
9839
9840
9841
9842
9843
9844
9845
9846
9847
9848
9849
9850
9851
9852 VpaidAdapterChoice string `json:"vpaidAdapterChoice,omitempty"`
9853
9854
9855
9856 googleapi.ServerResponse `json:"-"`
9857
9858
9859
9860
9861
9862
9863
9864 ForceSendFields []string `json:"-"`
9865
9866
9867
9868
9869
9870
9871
9872 NullFields []string `json:"-"`
9873 }
9874
9875 func (s *Placement) MarshalJSON() ([]byte, error) {
9876 type NoMethod Placement
9877 raw := NoMethod(*s)
9878 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9879 }
9880
9881
9882 type PlacementAssignment struct {
9883
9884
9885 Active bool `json:"active,omitempty"`
9886
9887
9888
9889 PlacementId int64 `json:"placementId,omitempty,string"`
9890
9891
9892
9893 PlacementIdDimensionValue *DimensionValue `json:"placementIdDimensionValue,omitempty"`
9894
9895
9896
9897
9898 SslRequired bool `json:"sslRequired,omitempty"`
9899
9900
9901
9902
9903
9904
9905
9906 ForceSendFields []string `json:"-"`
9907
9908
9909
9910
9911
9912
9913
9914 NullFields []string `json:"-"`
9915 }
9916
9917 func (s *PlacementAssignment) MarshalJSON() ([]byte, error) {
9918 type NoMethod PlacementAssignment
9919 raw := NoMethod(*s)
9920 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9921 }
9922
9923
9924 type PlacementGroup struct {
9925
9926
9927 AccountId int64 `json:"accountId,omitempty,string"`
9928
9929
9930
9931 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
9932
9933
9934
9935 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
9936
9937
9938 Archived bool `json:"archived,omitempty"`
9939
9940
9941
9942 CampaignId int64 `json:"campaignId,omitempty,string"`
9943
9944
9945
9946 CampaignIdDimensionValue *DimensionValue `json:"campaignIdDimensionValue,omitempty"`
9947
9948
9949
9950 ChildPlacementIds googleapi.Int64s `json:"childPlacementIds,omitempty"`
9951
9952
9953 Comment string `json:"comment,omitempty"`
9954
9955
9956
9957 ContentCategoryId int64 `json:"contentCategoryId,omitempty,string"`
9958
9959
9960
9961 CreateInfo *LastModifiedInfo `json:"createInfo,omitempty"`
9962
9963
9964
9965
9966
9967 DirectorySiteId int64 `json:"directorySiteId,omitempty,string"`
9968
9969
9970
9971 DirectorySiteIdDimensionValue *DimensionValue `json:"directorySiteIdDimensionValue,omitempty"`
9972
9973
9974 ExternalId string `json:"externalId,omitempty"`
9975
9976
9977
9978 Id int64 `json:"id,omitempty,string"`
9979
9980
9981
9982 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
9983
9984
9985
9986 Kind string `json:"kind,omitempty"`
9987
9988
9989
9990 LastModifiedInfo *LastModifiedInfo `json:"lastModifiedInfo,omitempty"`
9991
9992
9993
9994 Name string `json:"name,omitempty"`
9995
9996
9997
9998
9999
10000
10001
10002
10003
10004
10005
10006
10007 PlacementGroupType string `json:"placementGroupType,omitempty"`
10008
10009
10010
10011 PlacementStrategyId int64 `json:"placementStrategyId,omitempty,string"`
10012
10013
10014
10015 PricingSchedule *PricingSchedule `json:"pricingSchedule,omitempty"`
10016
10017
10018
10019
10020
10021 PrimaryPlacementId int64 `json:"primaryPlacementId,omitempty,string"`
10022
10023
10024
10025 PrimaryPlacementIdDimensionValue *DimensionValue `json:"primaryPlacementIdDimensionValue,omitempty"`
10026
10027
10028
10029
10030
10031 SiteId int64 `json:"siteId,omitempty,string"`
10032
10033
10034
10035 SiteIdDimensionValue *DimensionValue `json:"siteIdDimensionValue,omitempty"`
10036
10037
10038
10039 SubaccountId int64 `json:"subaccountId,omitempty,string"`
10040
10041
10042
10043 googleapi.ServerResponse `json:"-"`
10044
10045
10046
10047
10048
10049
10050
10051 ForceSendFields []string `json:"-"`
10052
10053
10054
10055
10056
10057
10058
10059 NullFields []string `json:"-"`
10060 }
10061
10062 func (s *PlacementGroup) MarshalJSON() ([]byte, error) {
10063 type NoMethod PlacementGroup
10064 raw := NoMethod(*s)
10065 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10066 }
10067
10068
10069 type PlacementGroupsListResponse struct {
10070
10071
10072 Kind string `json:"kind,omitempty"`
10073
10074
10075
10076 NextPageToken string `json:"nextPageToken,omitempty"`
10077
10078
10079 PlacementGroups []*PlacementGroup `json:"placementGroups,omitempty"`
10080
10081
10082
10083 googleapi.ServerResponse `json:"-"`
10084
10085
10086
10087
10088
10089
10090
10091 ForceSendFields []string `json:"-"`
10092
10093
10094
10095
10096
10097
10098
10099 NullFields []string `json:"-"`
10100 }
10101
10102 func (s *PlacementGroupsListResponse) MarshalJSON() ([]byte, error) {
10103 type NoMethod PlacementGroupsListResponse
10104 raw := NoMethod(*s)
10105 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10106 }
10107
10108
10109 type PlacementStrategiesListResponse struct {
10110
10111
10112 Kind string `json:"kind,omitempty"`
10113
10114
10115
10116 NextPageToken string `json:"nextPageToken,omitempty"`
10117
10118
10119 PlacementStrategies []*PlacementStrategy `json:"placementStrategies,omitempty"`
10120
10121
10122
10123 googleapi.ServerResponse `json:"-"`
10124
10125
10126
10127
10128
10129
10130
10131 ForceSendFields []string `json:"-"`
10132
10133
10134
10135
10136
10137
10138
10139 NullFields []string `json:"-"`
10140 }
10141
10142 func (s *PlacementStrategiesListResponse) MarshalJSON() ([]byte, error) {
10143 type NoMethod PlacementStrategiesListResponse
10144 raw := NoMethod(*s)
10145 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10146 }
10147
10148
10149 type PlacementStrategy struct {
10150
10151
10152 AccountId int64 `json:"accountId,omitempty,string"`
10153
10154
10155
10156 Id int64 `json:"id,omitempty,string"`
10157
10158
10159
10160 Kind string `json:"kind,omitempty"`
10161
10162
10163
10164
10165 Name string `json:"name,omitempty"`
10166
10167
10168
10169 googleapi.ServerResponse `json:"-"`
10170
10171
10172
10173
10174
10175
10176
10177 ForceSendFields []string `json:"-"`
10178
10179
10180
10181
10182
10183
10184
10185 NullFields []string `json:"-"`
10186 }
10187
10188 func (s *PlacementStrategy) MarshalJSON() ([]byte, error) {
10189 type NoMethod PlacementStrategy
10190 raw := NoMethod(*s)
10191 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10192 }
10193
10194
10195 type PlacementTag struct {
10196
10197 PlacementId int64 `json:"placementId,omitempty,string"`
10198
10199
10200 TagDatas []*TagData `json:"tagDatas,omitempty"`
10201
10202
10203
10204
10205
10206
10207
10208 ForceSendFields []string `json:"-"`
10209
10210
10211
10212
10213
10214
10215
10216 NullFields []string `json:"-"`
10217 }
10218
10219 func (s *PlacementTag) MarshalJSON() ([]byte, error) {
10220 type NoMethod PlacementTag
10221 raw := NoMethod(*s)
10222 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10223 }
10224
10225
10226 type PlacementsGenerateTagsResponse struct {
10227
10228
10229 Kind string `json:"kind,omitempty"`
10230
10231
10232 PlacementTags []*PlacementTag `json:"placementTags,omitempty"`
10233
10234
10235
10236 googleapi.ServerResponse `json:"-"`
10237
10238
10239
10240
10241
10242
10243
10244 ForceSendFields []string `json:"-"`
10245
10246
10247
10248
10249
10250
10251
10252 NullFields []string `json:"-"`
10253 }
10254
10255 func (s *PlacementsGenerateTagsResponse) MarshalJSON() ([]byte, error) {
10256 type NoMethod PlacementsGenerateTagsResponse
10257 raw := NoMethod(*s)
10258 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10259 }
10260
10261
10262 type PlacementsListResponse struct {
10263
10264
10265 Kind string `json:"kind,omitempty"`
10266
10267
10268
10269 NextPageToken string `json:"nextPageToken,omitempty"`
10270
10271
10272 Placements []*Placement `json:"placements,omitempty"`
10273
10274
10275
10276 googleapi.ServerResponse `json:"-"`
10277
10278
10279
10280
10281
10282
10283
10284 ForceSendFields []string `json:"-"`
10285
10286
10287
10288
10289
10290
10291
10292 NullFields []string `json:"-"`
10293 }
10294
10295 func (s *PlacementsListResponse) MarshalJSON() ([]byte, error) {
10296 type NoMethod PlacementsListResponse
10297 raw := NoMethod(*s)
10298 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10299 }
10300
10301
10302
10303 type PlatformType struct {
10304
10305 Id int64 `json:"id,omitempty,string"`
10306
10307
10308
10309 Kind string `json:"kind,omitempty"`
10310
10311
10312 Name string `json:"name,omitempty"`
10313
10314
10315
10316 googleapi.ServerResponse `json:"-"`
10317
10318
10319
10320
10321
10322
10323
10324 ForceSendFields []string `json:"-"`
10325
10326
10327
10328
10329
10330
10331
10332 NullFields []string `json:"-"`
10333 }
10334
10335 func (s *PlatformType) MarshalJSON() ([]byte, error) {
10336 type NoMethod PlatformType
10337 raw := NoMethod(*s)
10338 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10339 }
10340
10341
10342 type PlatformTypesListResponse struct {
10343
10344
10345 Kind string `json:"kind,omitempty"`
10346
10347
10348 PlatformTypes []*PlatformType `json:"platformTypes,omitempty"`
10349
10350
10351
10352 googleapi.ServerResponse `json:"-"`
10353
10354
10355
10356
10357
10358
10359
10360 ForceSendFields []string `json:"-"`
10361
10362
10363
10364
10365
10366
10367
10368 NullFields []string `json:"-"`
10369 }
10370
10371 func (s *PlatformTypesListResponse) MarshalJSON() ([]byte, error) {
10372 type NoMethod PlatformTypesListResponse
10373 raw := NoMethod(*s)
10374 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10375 }
10376
10377
10378 type PopupWindowProperties struct {
10379
10380
10381
10382 Dimension *Size `json:"dimension,omitempty"`
10383
10384
10385
10386 Offset *OffsetPosition `json:"offset,omitempty"`
10387
10388
10389
10390
10391
10392
10393
10394 PositionType string `json:"positionType,omitempty"`
10395
10396
10397 ShowAddressBar bool `json:"showAddressBar,omitempty"`
10398
10399
10400 ShowMenuBar bool `json:"showMenuBar,omitempty"`
10401
10402
10403 ShowScrollBar bool `json:"showScrollBar,omitempty"`
10404
10405
10406 ShowStatusBar bool `json:"showStatusBar,omitempty"`
10407
10408
10409 ShowToolBar bool `json:"showToolBar,omitempty"`
10410
10411
10412 Title string `json:"title,omitempty"`
10413
10414
10415
10416
10417
10418
10419
10420 ForceSendFields []string `json:"-"`
10421
10422
10423
10424
10425
10426
10427
10428 NullFields []string `json:"-"`
10429 }
10430
10431 func (s *PopupWindowProperties) MarshalJSON() ([]byte, error) {
10432 type NoMethod PopupWindowProperties
10433 raw := NoMethod(*s)
10434 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10435 }
10436
10437
10438
10439 type PostalCode struct {
10440
10441 Code string `json:"code,omitempty"`
10442
10443
10444
10445 CountryCode string `json:"countryCode,omitempty"`
10446
10447
10448
10449 CountryDartId int64 `json:"countryDartId,omitempty,string"`
10450
10451
10452 Id string `json:"id,omitempty"`
10453
10454
10455
10456 Kind string `json:"kind,omitempty"`
10457
10458
10459
10460 googleapi.ServerResponse `json:"-"`
10461
10462
10463
10464
10465
10466
10467
10468 ForceSendFields []string `json:"-"`
10469
10470
10471
10472
10473
10474
10475
10476 NullFields []string `json:"-"`
10477 }
10478
10479 func (s *PostalCode) MarshalJSON() ([]byte, error) {
10480 type NoMethod PostalCode
10481 raw := NoMethod(*s)
10482 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10483 }
10484
10485
10486 type PostalCodesListResponse struct {
10487
10488
10489 Kind string `json:"kind,omitempty"`
10490
10491
10492 PostalCodes []*PostalCode `json:"postalCodes,omitempty"`
10493
10494
10495
10496 googleapi.ServerResponse `json:"-"`
10497
10498
10499
10500
10501
10502
10503
10504 ForceSendFields []string `json:"-"`
10505
10506
10507
10508
10509
10510
10511
10512 NullFields []string `json:"-"`
10513 }
10514
10515 func (s *PostalCodesListResponse) MarshalJSON() ([]byte, error) {
10516 type NoMethod PostalCodesListResponse
10517 raw := NoMethod(*s)
10518 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10519 }
10520
10521
10522 type Pricing struct {
10523
10524
10525
10526
10527
10528
10529 CapCostType string `json:"capCostType,omitempty"`
10530
10531
10532 EndDate string `json:"endDate,omitempty"`
10533
10534
10535
10536
10537 Flights []*Flight `json:"flights,omitempty"`
10538
10539
10540
10541
10542
10543
10544
10545
10546
10547
10548
10549
10550
10551 GroupType string `json:"groupType,omitempty"`
10552
10553
10554
10555
10556
10557
10558
10559
10560
10561
10562
10563
10564 PricingType string `json:"pricingType,omitempty"`
10565
10566
10567 StartDate string `json:"startDate,omitempty"`
10568
10569
10570
10571
10572
10573
10574
10575 ForceSendFields []string `json:"-"`
10576
10577
10578
10579
10580
10581
10582
10583 NullFields []string `json:"-"`
10584 }
10585
10586 func (s *Pricing) MarshalJSON() ([]byte, error) {
10587 type NoMethod Pricing
10588 raw := NoMethod(*s)
10589 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10590 }
10591
10592
10593 type PricingSchedule struct {
10594
10595
10596
10597
10598
10599
10600 CapCostOption string `json:"capCostOption,omitempty"`
10601
10602
10603
10604
10605
10606
10607
10608
10609 EndDate string `json:"endDate,omitempty"`
10610
10611
10612
10613 Flighted bool `json:"flighted,omitempty"`
10614
10615
10616
10617
10618 FloodlightActivityId int64 `json:"floodlightActivityId,omitempty,string"`
10619
10620
10621 PricingPeriods []*PricingSchedulePricingPeriod `json:"pricingPeriods,omitempty"`
10622
10623
10624
10625
10626
10627
10628
10629
10630
10631
10632
10633 PricingType string `json:"pricingType,omitempty"`
10634
10635
10636
10637
10638
10639 StartDate string `json:"startDate,omitempty"`
10640
10641
10642
10643
10644 TestingStartDate string `json:"testingStartDate,omitempty"`
10645
10646
10647
10648
10649
10650
10651
10652 ForceSendFields []string `json:"-"`
10653
10654
10655
10656
10657
10658
10659
10660 NullFields []string `json:"-"`
10661 }
10662
10663 func (s *PricingSchedule) MarshalJSON() ([]byte, error) {
10664 type NoMethod PricingSchedule
10665 raw := NoMethod(*s)
10666 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10667 }
10668
10669
10670 type PricingSchedulePricingPeriod struct {
10671
10672
10673
10674
10675
10676
10677
10678 EndDate string `json:"endDate,omitempty"`
10679
10680
10681 PricingComment string `json:"pricingComment,omitempty"`
10682
10683
10684
10685
10686 RateOrCostNanos int64 `json:"rateOrCostNanos,omitempty,string"`
10687
10688
10689
10690
10691
10692 StartDate string `json:"startDate,omitempty"`
10693
10694
10695
10696 Units int64 `json:"units,omitempty,string"`
10697
10698
10699
10700
10701
10702
10703
10704 ForceSendFields []string `json:"-"`
10705
10706
10707
10708
10709
10710
10711
10712 NullFields []string `json:"-"`
10713 }
10714
10715 func (s *PricingSchedulePricingPeriod) MarshalJSON() ([]byte, error) {
10716 type NoMethod PricingSchedulePricingPeriod
10717 raw := NoMethod(*s)
10718 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10719 }
10720
10721
10722 type Project struct {
10723
10724 AccountId int64 `json:"accountId,omitempty,string"`
10725
10726
10727 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
10728
10729
10730
10731
10732
10733
10734
10735
10736
10737
10738
10739 AudienceAgeGroup string `json:"audienceAgeGroup,omitempty"`
10740
10741
10742
10743
10744
10745
10746 AudienceGender string `json:"audienceGender,omitempty"`
10747
10748
10749
10750
10751
10752 Budget int64 `json:"budget,omitempty,string"`
10753
10754
10755 ClientBillingCode string `json:"clientBillingCode,omitempty"`
10756
10757
10758 ClientName string `json:"clientName,omitempty"`
10759
10760
10761 EndDate string `json:"endDate,omitempty"`
10762
10763
10764 Id int64 `json:"id,omitempty,string"`
10765
10766
10767
10768 Kind string `json:"kind,omitempty"`
10769
10770
10771
10772 LastModifiedInfo *LastModifiedInfo `json:"lastModifiedInfo,omitempty"`
10773
10774
10775 Name string `json:"name,omitempty"`
10776
10777
10778 Overview string `json:"overview,omitempty"`
10779
10780
10781 StartDate string `json:"startDate,omitempty"`
10782
10783
10784 SubaccountId int64 `json:"subaccountId,omitempty,string"`
10785
10786
10787 TargetClicks int64 `json:"targetClicks,omitempty,string"`
10788
10789
10790
10791 TargetConversions int64 `json:"targetConversions,omitempty,string"`
10792
10793
10794 TargetCpaNanos int64 `json:"targetCpaNanos,omitempty,string"`
10795
10796
10797 TargetCpcNanos int64 `json:"targetCpcNanos,omitempty,string"`
10798
10799
10800
10801 TargetCpmActiveViewNanos int64 `json:"targetCpmActiveViewNanos,omitempty,string"`
10802
10803
10804 TargetCpmNanos int64 `json:"targetCpmNanos,omitempty,string"`
10805
10806
10807
10808 TargetImpressions int64 `json:"targetImpressions,omitempty,string"`
10809
10810
10811
10812 googleapi.ServerResponse `json:"-"`
10813
10814
10815
10816
10817
10818
10819
10820 ForceSendFields []string `json:"-"`
10821
10822
10823
10824
10825
10826
10827
10828 NullFields []string `json:"-"`
10829 }
10830
10831 func (s *Project) MarshalJSON() ([]byte, error) {
10832 type NoMethod Project
10833 raw := NoMethod(*s)
10834 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10835 }
10836
10837
10838 type ProjectsListResponse struct {
10839
10840
10841 Kind string `json:"kind,omitempty"`
10842
10843
10844
10845 NextPageToken string `json:"nextPageToken,omitempty"`
10846
10847
10848 Projects []*Project `json:"projects,omitempty"`
10849
10850
10851
10852 googleapi.ServerResponse `json:"-"`
10853
10854
10855
10856
10857
10858
10859
10860 ForceSendFields []string `json:"-"`
10861
10862
10863
10864
10865
10866
10867
10868 NullFields []string `json:"-"`
10869 }
10870
10871 func (s *ProjectsListResponse) MarshalJSON() ([]byte, error) {
10872 type NoMethod ProjectsListResponse
10873 raw := NoMethod(*s)
10874 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10875 }
10876
10877
10878
10879 type ReachReportCompatibleFields struct {
10880
10881
10882 DimensionFilters []*Dimension `json:"dimensionFilters,omitempty"`
10883
10884
10885
10886 Dimensions []*Dimension `json:"dimensions,omitempty"`
10887
10888
10889
10890 Kind string `json:"kind,omitempty"`
10891
10892
10893
10894 Metrics []*Metric `json:"metrics,omitempty"`
10895
10896
10897
10898
10899 PivotedActivityMetrics []*Metric `json:"pivotedActivityMetrics,omitempty"`
10900
10901
10902
10903 ReachByFrequencyMetrics []*Metric `json:"reachByFrequencyMetrics,omitempty"`
10904
10905
10906
10907
10908
10909
10910
10911 ForceSendFields []string `json:"-"`
10912
10913
10914
10915
10916
10917
10918
10919
10920 NullFields []string `json:"-"`
10921 }
10922
10923 func (s *ReachReportCompatibleFields) MarshalJSON() ([]byte, error) {
10924 type NoMethod ReachReportCompatibleFields
10925 raw := NoMethod(*s)
10926 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10927 }
10928
10929
10930 type Recipient struct {
10931
10932
10933
10934
10935
10936 DeliveryType string `json:"deliveryType,omitempty"`
10937
10938
10939 Email string `json:"email,omitempty"`
10940
10941
10942
10943 Kind string `json:"kind,omitempty"`
10944
10945
10946
10947
10948
10949
10950
10951 ForceSendFields []string `json:"-"`
10952
10953
10954
10955
10956
10957
10958
10959 NullFields []string `json:"-"`
10960 }
10961
10962 func (s *Recipient) MarshalJSON() ([]byte, error) {
10963 type NoMethod Recipient
10964 raw := NoMethod(*s)
10965 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10966 }
10967
10968
10969
10970 type Region struct {
10971
10972
10973 CountryCode string `json:"countryCode,omitempty"`
10974
10975
10976 CountryDartId int64 `json:"countryDartId,omitempty,string"`
10977
10978
10979 DartId int64 `json:"dartId,omitempty,string"`
10980
10981
10982
10983 Kind string `json:"kind,omitempty"`
10984
10985
10986 Name string `json:"name,omitempty"`
10987
10988
10989 RegionCode string `json:"regionCode,omitempty"`
10990
10991
10992
10993
10994
10995
10996
10997 ForceSendFields []string `json:"-"`
10998
10999
11000
11001
11002
11003
11004
11005 NullFields []string `json:"-"`
11006 }
11007
11008 func (s *Region) MarshalJSON() ([]byte, error) {
11009 type NoMethod Region
11010 raw := NoMethod(*s)
11011 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11012 }
11013
11014
11015 type RegionsListResponse struct {
11016
11017
11018 Kind string `json:"kind,omitempty"`
11019
11020
11021 Regions []*Region `json:"regions,omitempty"`
11022
11023
11024
11025 googleapi.ServerResponse `json:"-"`
11026
11027
11028
11029
11030
11031
11032
11033 ForceSendFields []string `json:"-"`
11034
11035
11036
11037
11038
11039
11040
11041 NullFields []string `json:"-"`
11042 }
11043
11044 func (s *RegionsListResponse) MarshalJSON() ([]byte, error) {
11045 type NoMethod RegionsListResponse
11046 raw := NoMethod(*s)
11047 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11048 }
11049
11050
11051
11052
11053
11054
11055
11056
11057 type RemarketingList struct {
11058
11059
11060 AccountId int64 `json:"accountId,omitempty,string"`
11061
11062
11063 Active bool `json:"active,omitempty"`
11064
11065
11066
11067 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
11068
11069
11070
11071 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
11072
11073
11074 Description string `json:"description,omitempty"`
11075
11076
11077 Id int64 `json:"id,omitempty,string"`
11078
11079
11080
11081 Kind string `json:"kind,omitempty"`
11082
11083
11084
11085
11086 LifeSpan int64 `json:"lifeSpan,omitempty,string"`
11087
11088
11089
11090 ListPopulationRule *ListPopulationRule `json:"listPopulationRule,omitempty"`
11091
11092
11093
11094 ListSize int64 `json:"listSize,omitempty,string"`
11095
11096
11097
11098
11099
11100
11101
11102
11103
11104
11105
11106
11107
11108
11109
11110 ListSource string `json:"listSource,omitempty"`
11111
11112
11113
11114 Name string `json:"name,omitempty"`
11115
11116
11117
11118
11119 SubaccountId int64 `json:"subaccountId,omitempty,string"`
11120
11121
11122
11123 googleapi.ServerResponse `json:"-"`
11124
11125
11126
11127
11128
11129
11130
11131 ForceSendFields []string `json:"-"`
11132
11133
11134
11135
11136
11137
11138
11139 NullFields []string `json:"-"`
11140 }
11141
11142 func (s *RemarketingList) MarshalJSON() ([]byte, error) {
11143 type NoMethod RemarketingList
11144 raw := NoMethod(*s)
11145 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11146 }
11147
11148
11149
11150
11151
11152 type RemarketingListShare struct {
11153
11154
11155 Kind string `json:"kind,omitempty"`
11156
11157
11158
11159 RemarketingListId int64 `json:"remarketingListId,omitempty,string"`
11160
11161
11162 SharedAccountIds googleapi.Int64s `json:"sharedAccountIds,omitempty"`
11163
11164
11165
11166 SharedAdvertiserIds googleapi.Int64s `json:"sharedAdvertiserIds,omitempty"`
11167
11168
11169
11170 googleapi.ServerResponse `json:"-"`
11171
11172
11173
11174
11175
11176
11177
11178 ForceSendFields []string `json:"-"`
11179
11180
11181
11182
11183
11184
11185
11186 NullFields []string `json:"-"`
11187 }
11188
11189 func (s *RemarketingListShare) MarshalJSON() ([]byte, error) {
11190 type NoMethod RemarketingListShare
11191 raw := NoMethod(*s)
11192 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11193 }
11194
11195
11196 type RemarketingListsListResponse struct {
11197
11198
11199 Kind string `json:"kind,omitempty"`
11200
11201
11202
11203 NextPageToken string `json:"nextPageToken,omitempty"`
11204
11205
11206 RemarketingLists []*RemarketingList `json:"remarketingLists,omitempty"`
11207
11208
11209
11210 googleapi.ServerResponse `json:"-"`
11211
11212
11213
11214
11215
11216
11217
11218 ForceSendFields []string `json:"-"`
11219
11220
11221
11222
11223
11224
11225
11226 NullFields []string `json:"-"`
11227 }
11228
11229 func (s *RemarketingListsListResponse) MarshalJSON() ([]byte, error) {
11230 type NoMethod RemarketingListsListResponse
11231 raw := NoMethod(*s)
11232 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11233 }
11234
11235
11236 type Report struct {
11237
11238 AccountId int64 `json:"accountId,omitempty,string"`
11239
11240
11241 Criteria *ReportCriteria `json:"criteria,omitempty"`
11242
11243
11244
11245 CrossDimensionReachCriteria *ReportCrossDimensionReachCriteria `json:"crossDimensionReachCriteria,omitempty"`
11246
11247
11248 Delivery *ReportDelivery `json:"delivery,omitempty"`
11249
11250
11251 Etag string `json:"etag,omitempty"`
11252
11253
11254
11255 FileName string `json:"fileName,omitempty"`
11256
11257
11258
11259 FloodlightCriteria *ReportFloodlightCriteria `json:"floodlightCriteria,omitempty"`
11260
11261
11262
11263
11264
11265
11266
11267
11268
11269 Format string `json:"format,omitempty"`
11270
11271
11272 Id int64 `json:"id,omitempty,string"`
11273
11274
11275 Kind string `json:"kind,omitempty"`
11276
11277
11278
11279 LastModifiedTime uint64 `json:"lastModifiedTime,omitempty,string"`
11280
11281
11282 Name string `json:"name,omitempty"`
11283
11284
11285 OwnerProfileId int64 `json:"ownerProfileId,omitempty,string"`
11286
11287
11288
11289 PathToConversionCriteria *ReportPathToConversionCriteria `json:"pathToConversionCriteria,omitempty"`
11290
11291
11292 ReachCriteria *ReportReachCriteria `json:"reachCriteria,omitempty"`
11293
11294
11295
11296
11297 Schedule *ReportSchedule `json:"schedule,omitempty"`
11298
11299
11300
11301 SubAccountId int64 `json:"subAccountId,omitempty,string"`
11302
11303
11304
11305
11306
11307
11308
11309
11310
11311 Type string `json:"type,omitempty"`
11312
11313
11314
11315 googleapi.ServerResponse `json:"-"`
11316
11317
11318
11319
11320
11321
11322
11323 ForceSendFields []string `json:"-"`
11324
11325
11326
11327
11328
11329
11330
11331 NullFields []string `json:"-"`
11332 }
11333
11334 func (s *Report) MarshalJSON() ([]byte, error) {
11335 type NoMethod Report
11336 raw := NoMethod(*s)
11337 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11338 }
11339
11340
11341 type ReportCriteria struct {
11342
11343 Activities *Activities `json:"activities,omitempty"`
11344
11345
11346 CustomRichMediaEvents *CustomRichMediaEvents `json:"customRichMediaEvents,omitempty"`
11347
11348
11349 DateRange *DateRange `json:"dateRange,omitempty"`
11350
11351
11352
11353
11354
11355 DimensionFilters []*DimensionValue `json:"dimensionFilters,omitempty"`
11356
11357
11358
11359 Dimensions []*SortedDimension `json:"dimensions,omitempty"`
11360
11361
11362 MetricNames []string `json:"metricNames,omitempty"`
11363
11364
11365
11366
11367
11368
11369
11370 ForceSendFields []string `json:"-"`
11371
11372
11373
11374
11375
11376
11377
11378 NullFields []string `json:"-"`
11379 }
11380
11381 func (s *ReportCriteria) MarshalJSON() ([]byte, error) {
11382 type NoMethod ReportCriteria
11383 raw := NoMethod(*s)
11384 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11385 }
11386
11387
11388
11389 type ReportCrossDimensionReachCriteria struct {
11390
11391 Breakdown []*SortedDimension `json:"breakdown,omitempty"`
11392
11393
11394 DateRange *DateRange `json:"dateRange,omitempty"`
11395
11396
11397
11398
11399
11400
11401
11402
11403 Dimension string `json:"dimension,omitempty"`
11404
11405
11406
11407 DimensionFilters []*DimensionValue `json:"dimensionFilters,omitempty"`
11408
11409
11410 MetricNames []string `json:"metricNames,omitempty"`
11411
11412
11413
11414 OverlapMetricNames []string `json:"overlapMetricNames,omitempty"`
11415
11416
11417 Pivoted bool `json:"pivoted,omitempty"`
11418
11419
11420
11421
11422
11423
11424
11425 ForceSendFields []string `json:"-"`
11426
11427
11428
11429
11430
11431
11432
11433 NullFields []string `json:"-"`
11434 }
11435
11436 func (s *ReportCrossDimensionReachCriteria) MarshalJSON() ([]byte, error) {
11437 type NoMethod ReportCrossDimensionReachCriteria
11438 raw := NoMethod(*s)
11439 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11440 }
11441
11442
11443 type ReportDelivery struct {
11444
11445 EmailOwner bool `json:"emailOwner,omitempty"`
11446
11447
11448
11449
11450
11451
11452
11453 EmailOwnerDeliveryType string `json:"emailOwnerDeliveryType,omitempty"`
11454
11455
11456 Message string `json:"message,omitempty"`
11457
11458
11459 Recipients []*Recipient `json:"recipients,omitempty"`
11460
11461
11462
11463
11464
11465
11466
11467 ForceSendFields []string `json:"-"`
11468
11469
11470
11471
11472
11473
11474
11475 NullFields []string `json:"-"`
11476 }
11477
11478 func (s *ReportDelivery) MarshalJSON() ([]byte, error) {
11479 type NoMethod ReportDelivery
11480 raw := NoMethod(*s)
11481 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11482 }
11483
11484
11485
11486 type ReportFloodlightCriteria struct {
11487
11488
11489 CustomRichMediaEvents []*DimensionValue `json:"customRichMediaEvents,omitempty"`
11490
11491
11492 DateRange *DateRange `json:"dateRange,omitempty"`
11493
11494
11495
11496
11497
11498 DimensionFilters []*DimensionValue `json:"dimensionFilters,omitempty"`
11499
11500
11501 Dimensions []*SortedDimension `json:"dimensions,omitempty"`
11502
11503
11504
11505
11506
11507 FloodlightConfigId *DimensionValue `json:"floodlightConfigId,omitempty"`
11508
11509
11510 MetricNames []string `json:"metricNames,omitempty"`
11511
11512
11513 ReportProperties *ReportFloodlightCriteriaReportProperties `json:"reportProperties,omitempty"`
11514
11515
11516
11517
11518
11519
11520
11521
11522 ForceSendFields []string `json:"-"`
11523
11524
11525
11526
11527
11528
11529
11530
11531 NullFields []string `json:"-"`
11532 }
11533
11534 func (s *ReportFloodlightCriteria) MarshalJSON() ([]byte, error) {
11535 type NoMethod ReportFloodlightCriteria
11536 raw := NoMethod(*s)
11537 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11538 }
11539
11540
11541
11542 type ReportFloodlightCriteriaReportProperties struct {
11543
11544
11545 IncludeAttributedIPConversions bool `json:"includeAttributedIPConversions,omitempty"`
11546
11547
11548
11549
11550
11551
11552 IncludeUnattributedCookieConversions bool `json:"includeUnattributedCookieConversions,omitempty"`
11553
11554
11555
11556
11557
11558 IncludeUnattributedIPConversions bool `json:"includeUnattributedIPConversions,omitempty"`
11559
11560
11561
11562
11563
11564
11565
11566
11567 ForceSendFields []string `json:"-"`
11568
11569
11570
11571
11572
11573
11574
11575
11576 NullFields []string `json:"-"`
11577 }
11578
11579 func (s *ReportFloodlightCriteriaReportProperties) MarshalJSON() ([]byte, error) {
11580 type NoMethod ReportFloodlightCriteriaReportProperties
11581 raw := NoMethod(*s)
11582 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11583 }
11584
11585
11586
11587 type ReportPathToConversionCriteria struct {
11588
11589 ActivityFilters []*DimensionValue `json:"activityFilters,omitempty"`
11590
11591
11592
11593 ConversionDimensions []*SortedDimension `json:"conversionDimensions,omitempty"`
11594
11595
11596
11597 CustomFloodlightVariables []*SortedDimension `json:"customFloodlightVariables,omitempty"`
11598
11599
11600
11601 CustomRichMediaEvents []*DimensionValue `json:"customRichMediaEvents,omitempty"`
11602
11603
11604 DateRange *DateRange `json:"dateRange,omitempty"`
11605
11606
11607
11608
11609
11610 FloodlightConfigId *DimensionValue `json:"floodlightConfigId,omitempty"`
11611
11612
11613 MetricNames []string `json:"metricNames,omitempty"`
11614
11615
11616
11617 PerInteractionDimensions []*SortedDimension `json:"perInteractionDimensions,omitempty"`
11618
11619
11620 ReportProperties *ReportPathToConversionCriteriaReportProperties `json:"reportProperties,omitempty"`
11621
11622
11623
11624
11625
11626
11627
11628 ForceSendFields []string `json:"-"`
11629
11630
11631
11632
11633
11634
11635
11636
11637 NullFields []string `json:"-"`
11638 }
11639
11640 func (s *ReportPathToConversionCriteria) MarshalJSON() ([]byte, error) {
11641 type NoMethod ReportPathToConversionCriteria
11642 raw := NoMethod(*s)
11643 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11644 }
11645
11646
11647
11648 type ReportPathToConversionCriteriaReportProperties struct {
11649
11650
11651
11652
11653 ClicksLookbackWindow int64 `json:"clicksLookbackWindow,omitempty"`
11654
11655
11656
11657
11658
11659 ImpressionsLookbackWindow int64 `json:"impressionsLookbackWindow,omitempty"`
11660
11661
11662 IncludeAttributedIPConversions bool `json:"includeAttributedIPConversions,omitempty"`
11663
11664
11665
11666
11667
11668
11669 IncludeUnattributedCookieConversions bool `json:"includeUnattributedCookieConversions,omitempty"`
11670
11671
11672
11673
11674
11675 IncludeUnattributedIPConversions bool `json:"includeUnattributedIPConversions,omitempty"`
11676
11677
11678
11679
11680
11681
11682 MaximumClickInteractions int64 `json:"maximumClickInteractions,omitempty"`
11683
11684
11685
11686
11687
11688
11689 MaximumImpressionInteractions int64 `json:"maximumImpressionInteractions,omitempty"`
11690
11691
11692
11693
11694 MaximumInteractionGap int64 `json:"maximumInteractionGap,omitempty"`
11695
11696
11697 PivotOnInteractionPath bool `json:"pivotOnInteractionPath,omitempty"`
11698
11699
11700
11701
11702
11703
11704
11705
11706 ForceSendFields []string `json:"-"`
11707
11708
11709
11710
11711
11712
11713
11714
11715 NullFields []string `json:"-"`
11716 }
11717
11718 func (s *ReportPathToConversionCriteriaReportProperties) MarshalJSON() ([]byte, error) {
11719 type NoMethod ReportPathToConversionCriteriaReportProperties
11720 raw := NoMethod(*s)
11721 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11722 }
11723
11724
11725
11726 type ReportReachCriteria struct {
11727
11728 Activities *Activities `json:"activities,omitempty"`
11729
11730
11731 CustomRichMediaEvents *CustomRichMediaEvents `json:"customRichMediaEvents,omitempty"`
11732
11733
11734 DateRange *DateRange `json:"dateRange,omitempty"`
11735
11736
11737
11738
11739
11740 DimensionFilters []*DimensionValue `json:"dimensionFilters,omitempty"`
11741
11742
11743 Dimensions []*SortedDimension `json:"dimensions,omitempty"`
11744
11745
11746
11747
11748 EnableAllDimensionCombinations bool `json:"enableAllDimensionCombinations,omitempty"`
11749
11750
11751 MetricNames []string `json:"metricNames,omitempty"`
11752
11753
11754
11755 ReachByFrequencyMetricNames []string `json:"reachByFrequencyMetricNames,omitempty"`
11756
11757
11758
11759
11760
11761
11762
11763 ForceSendFields []string `json:"-"`
11764
11765
11766
11767
11768
11769
11770
11771 NullFields []string `json:"-"`
11772 }
11773
11774 func (s *ReportReachCriteria) MarshalJSON() ([]byte, error) {
11775 type NoMethod ReportReachCriteria
11776 raw := NoMethod(*s)
11777 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11778 }
11779
11780
11781
11782
11783 type ReportSchedule struct {
11784
11785
11786 Active bool `json:"active,omitempty"`
11787
11788
11789
11790
11791 Every int64 `json:"every,omitempty"`
11792
11793
11794
11795 ExpirationDate string `json:"expirationDate,omitempty"`
11796
11797
11798
11799
11800
11801
11802
11803 Repeats string `json:"repeats,omitempty"`
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
11815
11816 RepeatsOnWeekDays []string `json:"repeatsOnWeekDays,omitempty"`
11817
11818
11819
11820
11821
11822
11823
11824
11825
11826
11827
11828
11829 RunsOnDayOfMonth string `json:"runsOnDayOfMonth,omitempty"`
11830
11831
11832
11833 StartDate string `json:"startDate,omitempty"`
11834
11835
11836
11837
11838
11839
11840
11841 ForceSendFields []string `json:"-"`
11842
11843
11844
11845
11846
11847
11848
11849 NullFields []string `json:"-"`
11850 }
11851
11852 func (s *ReportSchedule) MarshalJSON() ([]byte, error) {
11853 type NoMethod ReportSchedule
11854 raw := NoMethod(*s)
11855 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11856 }
11857
11858
11859
11860 type ReportCompatibleFields struct {
11861
11862
11863 DimensionFilters []*Dimension `json:"dimensionFilters,omitempty"`
11864
11865
11866
11867 Dimensions []*Dimension `json:"dimensions,omitempty"`
11868
11869
11870
11871 Kind string `json:"kind,omitempty"`
11872
11873
11874
11875 Metrics []*Metric `json:"metrics,omitempty"`
11876
11877
11878
11879
11880 PivotedActivityMetrics []*Metric `json:"pivotedActivityMetrics,omitempty"`
11881
11882
11883
11884
11885
11886
11887
11888 ForceSendFields []string `json:"-"`
11889
11890
11891
11892
11893
11894
11895
11896
11897 NullFields []string `json:"-"`
11898 }
11899
11900 func (s *ReportCompatibleFields) MarshalJSON() ([]byte, error) {
11901 type NoMethod ReportCompatibleFields
11902 raw := NoMethod(*s)
11903 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11904 }
11905
11906
11907 type ReportList struct {
11908
11909 Etag string `json:"etag,omitempty"`
11910
11911
11912 Items []*Report `json:"items,omitempty"`
11913
11914
11915 Kind string `json:"kind,omitempty"`
11916
11917
11918
11919
11920
11921 NextPageToken string `json:"nextPageToken,omitempty"`
11922
11923
11924
11925 googleapi.ServerResponse `json:"-"`
11926
11927
11928
11929
11930
11931
11932
11933 ForceSendFields []string `json:"-"`
11934
11935
11936
11937
11938
11939
11940
11941 NullFields []string `json:"-"`
11942 }
11943
11944 func (s *ReportList) MarshalJSON() ([]byte, error) {
11945 type NoMethod ReportList
11946 raw := NoMethod(*s)
11947 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11948 }
11949
11950
11951 type ReportsConfiguration struct {
11952
11953
11954
11955
11956 ExposureToConversionEnabled bool `json:"exposureToConversionEnabled,omitempty"`
11957
11958
11959
11960 LookbackConfiguration *LookbackConfiguration `json:"lookbackConfiguration,omitempty"`
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971
11972
11973
11974
11975
11976
11977
11978
11979
11980 ReportGenerationTimeZoneId int64 `json:"reportGenerationTimeZoneId,omitempty,string"`
11981
11982
11983
11984
11985
11986
11987
11988
11989 ForceSendFields []string `json:"-"`
11990
11991
11992
11993
11994
11995
11996
11997
11998 NullFields []string `json:"-"`
11999 }
12000
12001 func (s *ReportsConfiguration) MarshalJSON() ([]byte, error) {
12002 type NoMethod ReportsConfiguration
12003 raw := NoMethod(*s)
12004 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12005 }
12006
12007
12008 type RichMediaExitOverride struct {
12009
12010
12011 ClickThroughUrl *ClickThroughUrl `json:"clickThroughUrl,omitempty"`
12012
12013
12014
12015 Enabled bool `json:"enabled,omitempty"`
12016
12017
12018
12019 ExitId int64 `json:"exitId,omitempty,string"`
12020
12021
12022
12023
12024
12025
12026
12027 ForceSendFields []string `json:"-"`
12028
12029
12030
12031
12032
12033
12034
12035
12036 NullFields []string `json:"-"`
12037 }
12038
12039 func (s *RichMediaExitOverride) MarshalJSON() ([]byte, error) {
12040 type NoMethod RichMediaExitOverride
12041 raw := NoMethod(*s)
12042 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12043 }
12044
12045
12046
12047 type Rule struct {
12048
12049
12050 AssetId int64 `json:"assetId,omitempty,string"`
12051
12052
12053 Name string `json:"name,omitempty"`
12054
12055
12056
12057
12058 TargetingTemplateId int64 `json:"targetingTemplateId,omitempty,string"`
12059
12060
12061
12062
12063
12064
12065
12066 ForceSendFields []string `json:"-"`
12067
12068
12069
12070
12071
12072
12073
12074 NullFields []string `json:"-"`
12075 }
12076
12077 func (s *Rule) MarshalJSON() ([]byte, error) {
12078 type NoMethod Rule
12079 raw := NoMethod(*s)
12080 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12081 }
12082
12083
12084 type Site struct {
12085
12086
12087 AccountId int64 `json:"accountId,omitempty,string"`
12088
12089
12090 Approved bool `json:"approved,omitempty"`
12091
12092
12093
12094 DirectorySiteId int64 `json:"directorySiteId,omitempty,string"`
12095
12096
12097
12098 DirectorySiteIdDimensionValue *DimensionValue `json:"directorySiteIdDimensionValue,omitempty"`
12099
12100
12101 Id int64 `json:"id,omitempty,string"`
12102
12103
12104
12105 IdDimensionValue *DimensionValue `json:"idDimensionValue,omitempty"`
12106
12107
12108
12109 KeyName string `json:"keyName,omitempty"`
12110
12111
12112
12113 Kind string `json:"kind,omitempty"`
12114
12115
12116
12117
12118
12119
12120 Name string `json:"name,omitempty"`
12121
12122
12123 SiteContacts []*SiteContact `json:"siteContacts,omitempty"`
12124
12125
12126 SiteSettings *SiteSettings `json:"siteSettings,omitempty"`
12127
12128
12129
12130 SubaccountId int64 `json:"subaccountId,omitempty,string"`
12131
12132
12133
12134 googleapi.ServerResponse `json:"-"`
12135
12136
12137
12138
12139
12140
12141
12142 ForceSendFields []string `json:"-"`
12143
12144
12145
12146
12147
12148
12149
12150 NullFields []string `json:"-"`
12151 }
12152
12153 func (s *Site) MarshalJSON() ([]byte, error) {
12154 type NoMethod Site
12155 raw := NoMethod(*s)
12156 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12157 }
12158
12159
12160 type SiteContact struct {
12161
12162 Address string `json:"address,omitempty"`
12163
12164
12165
12166
12167
12168
12169 ContactType string `json:"contactType,omitempty"`
12170
12171
12172 Email string `json:"email,omitempty"`
12173
12174
12175 FirstName string `json:"firstName,omitempty"`
12176
12177
12178
12179 Id int64 `json:"id,omitempty,string"`
12180
12181
12182 LastName string `json:"lastName,omitempty"`
12183
12184
12185 Phone string `json:"phone,omitempty"`
12186
12187
12188 Title string `json:"title,omitempty"`
12189
12190
12191
12192
12193
12194
12195
12196 ForceSendFields []string `json:"-"`
12197
12198
12199
12200
12201
12202
12203
12204 NullFields []string `json:"-"`
12205 }
12206
12207 func (s *SiteContact) MarshalJSON() ([]byte, error) {
12208 type NoMethod SiteContact
12209 raw := NoMethod(*s)
12210 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12211 }
12212
12213
12214 type SiteSettings struct {
12215
12216
12217 ActiveViewOptOut bool `json:"activeViewOptOut,omitempty"`
12218
12219
12220
12221
12222
12223 AdBlockingOptOut bool `json:"adBlockingOptOut,omitempty"`
12224
12225
12226 DisableNewCookie bool `json:"disableNewCookie,omitempty"`
12227
12228
12229
12230 TagSetting *TagSetting `json:"tagSetting,omitempty"`
12231
12232
12233
12234
12235
12236
12237 VideoActiveViewOptOutTemplate bool `json:"videoActiveViewOptOutTemplate,omitempty"`
12238
12239
12240
12241
12242
12243
12244
12245
12246
12247
12248
12249
12250
12251
12252
12253
12254
12255
12256
12257 VpaidAdapterChoiceTemplate string `json:"vpaidAdapterChoiceTemplate,omitempty"`
12258
12259
12260
12261
12262
12263
12264
12265 ForceSendFields []string `json:"-"`
12266
12267
12268
12269
12270
12271
12272
12273
12274 NullFields []string `json:"-"`
12275 }
12276
12277 func (s *SiteSettings) MarshalJSON() ([]byte, error) {
12278 type NoMethod SiteSettings
12279 raw := NoMethod(*s)
12280 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12281 }
12282
12283
12284 type SitesListResponse struct {
12285
12286
12287 Kind string `json:"kind,omitempty"`
12288
12289
12290
12291 NextPageToken string `json:"nextPageToken,omitempty"`
12292
12293
12294 Sites []*Site `json:"sites,omitempty"`
12295
12296
12297
12298 googleapi.ServerResponse `json:"-"`
12299
12300
12301
12302
12303
12304
12305
12306 ForceSendFields []string `json:"-"`
12307
12308
12309
12310
12311
12312
12313
12314 NullFields []string `json:"-"`
12315 }
12316
12317 func (s *SitesListResponse) MarshalJSON() ([]byte, error) {
12318 type NoMethod SitesListResponse
12319 raw := NoMethod(*s)
12320 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12321 }
12322
12323
12324
12325 type Size struct {
12326
12327
12328 Height int64 `json:"height,omitempty"`
12329
12330
12331 Iab bool `json:"iab,omitempty"`
12332
12333
12334 Id int64 `json:"id,omitempty,string"`
12335
12336
12337
12338 Kind string `json:"kind,omitempty"`
12339
12340
12341
12342 Width int64 `json:"width,omitempty"`
12343
12344
12345
12346 googleapi.ServerResponse `json:"-"`
12347
12348
12349
12350
12351
12352
12353
12354 ForceSendFields []string `json:"-"`
12355
12356
12357
12358
12359
12360
12361
12362 NullFields []string `json:"-"`
12363 }
12364
12365 func (s *Size) MarshalJSON() ([]byte, error) {
12366 type NoMethod Size
12367 raw := NoMethod(*s)
12368 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12369 }
12370
12371
12372 type SizesListResponse struct {
12373
12374
12375 Kind string `json:"kind,omitempty"`
12376
12377
12378 Sizes []*Size `json:"sizes,omitempty"`
12379
12380
12381
12382 googleapi.ServerResponse `json:"-"`
12383
12384
12385
12386
12387
12388
12389
12390 ForceSendFields []string `json:"-"`
12391
12392
12393
12394
12395
12396
12397
12398 NullFields []string `json:"-"`
12399 }
12400
12401 func (s *SizesListResponse) MarshalJSON() ([]byte, error) {
12402 type NoMethod SizesListResponse
12403 raw := NoMethod(*s)
12404 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12405 }
12406
12407
12408 type SkippableSetting struct {
12409
12410
12411 Kind string `json:"kind,omitempty"`
12412
12413
12414
12415 ProgressOffset *VideoOffset `json:"progressOffset,omitempty"`
12416
12417
12418
12419
12420 SkipOffset *VideoOffset `json:"skipOffset,omitempty"`
12421
12422
12423
12424 Skippable bool `json:"skippable,omitempty"`
12425
12426
12427
12428
12429
12430
12431
12432 ForceSendFields []string `json:"-"`
12433
12434
12435
12436
12437
12438
12439
12440 NullFields []string `json:"-"`
12441 }
12442
12443 func (s *SkippableSetting) MarshalJSON() ([]byte, error) {
12444 type NoMethod SkippableSetting
12445 raw := NoMethod(*s)
12446 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12447 }
12448
12449
12450 type SortedDimension struct {
12451
12452
12453 Kind string `json:"kind,omitempty"`
12454
12455
12456 Name string `json:"name,omitempty"`
12457
12458
12459
12460
12461
12462
12463 SortOrder string `json:"sortOrder,omitempty"`
12464
12465
12466
12467
12468
12469
12470
12471 ForceSendFields []string `json:"-"`
12472
12473
12474
12475
12476
12477
12478
12479 NullFields []string `json:"-"`
12480 }
12481
12482 func (s *SortedDimension) MarshalJSON() ([]byte, error) {
12483 type NoMethod SortedDimension
12484 raw := NoMethod(*s)
12485 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12486 }
12487
12488
12489 type Subaccount struct {
12490
12491
12492 AccountId int64 `json:"accountId,omitempty,string"`
12493
12494
12495
12496 AvailablePermissionIds googleapi.Int64s `json:"availablePermissionIds,omitempty"`
12497
12498
12499 Id int64 `json:"id,omitempty,string"`
12500
12501
12502
12503 Kind string `json:"kind,omitempty"`
12504
12505
12506
12507
12508 Name string `json:"name,omitempty"`
12509
12510
12511
12512 googleapi.ServerResponse `json:"-"`
12513
12514
12515
12516
12517
12518
12519
12520 ForceSendFields []string `json:"-"`
12521
12522
12523
12524
12525
12526
12527
12528 NullFields []string `json:"-"`
12529 }
12530
12531 func (s *Subaccount) MarshalJSON() ([]byte, error) {
12532 type NoMethod Subaccount
12533 raw := NoMethod(*s)
12534 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12535 }
12536
12537
12538 type SubaccountsListResponse struct {
12539
12540
12541 Kind string `json:"kind,omitempty"`
12542
12543
12544
12545 NextPageToken string `json:"nextPageToken,omitempty"`
12546
12547
12548 Subaccounts []*Subaccount `json:"subaccounts,omitempty"`
12549
12550
12551
12552 googleapi.ServerResponse `json:"-"`
12553
12554
12555
12556
12557
12558
12559
12560 ForceSendFields []string `json:"-"`
12561
12562
12563
12564
12565
12566
12567
12568 NullFields []string `json:"-"`
12569 }
12570
12571 func (s *SubaccountsListResponse) MarshalJSON() ([]byte, error) {
12572 type NoMethod SubaccountsListResponse
12573 raw := NoMethod(*s)
12574 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12575 }
12576
12577
12578 type TagData struct {
12579
12580
12581 AdId int64 `json:"adId,omitempty,string"`
12582
12583
12584 ClickTag string `json:"clickTag,omitempty"`
12585
12586
12587
12588 CreativeId int64 `json:"creativeId,omitempty,string"`
12589
12590
12591
12592
12593
12594
12595
12596
12597
12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611
12612 Format string `json:"format,omitempty"`
12613
12614
12615 ImpressionTag string `json:"impressionTag,omitempty"`
12616
12617
12618
12619
12620
12621
12622
12623 ForceSendFields []string `json:"-"`
12624
12625
12626
12627
12628
12629
12630
12631 NullFields []string `json:"-"`
12632 }
12633
12634 func (s *TagData) MarshalJSON() ([]byte, error) {
12635 type NoMethod TagData
12636 raw := NoMethod(*s)
12637 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12638 }
12639
12640
12641 type TagSetting struct {
12642
12643
12644
12645
12646 AdditionalKeyValues string `json:"additionalKeyValues,omitempty"`
12647
12648
12649
12650 IncludeClickThroughUrls bool `json:"includeClickThroughUrls,omitempty"`
12651
12652
12653
12654 IncludeClickTracking bool `json:"includeClickTracking,omitempty"`
12655
12656
12657
12658
12659
12660
12661
12662
12663
12664
12665 KeywordOption string `json:"keywordOption,omitempty"`
12666
12667
12668
12669
12670
12671
12672
12673 ForceSendFields []string `json:"-"`
12674
12675
12676
12677
12678
12679
12680
12681
12682 NullFields []string `json:"-"`
12683 }
12684
12685 func (s *TagSetting) MarshalJSON() ([]byte, error) {
12686 type NoMethod TagSetting
12687 raw := NoMethod(*s)
12688 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12689 }
12690
12691
12692 type TagSettings struct {
12693
12694 DynamicTagEnabled bool `json:"dynamicTagEnabled,omitempty"`
12695
12696
12697 ImageTagEnabled bool `json:"imageTagEnabled,omitempty"`
12698
12699
12700
12701
12702
12703
12704
12705 ForceSendFields []string `json:"-"`
12706
12707
12708
12709
12710
12711
12712
12713
12714 NullFields []string `json:"-"`
12715 }
12716
12717 func (s *TagSettings) MarshalJSON() ([]byte, error) {
12718 type NoMethod TagSettings
12719 raw := NoMethod(*s)
12720 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12721 }
12722
12723
12724 type TargetWindow struct {
12725
12726 CustomHtml string `json:"customHtml,omitempty"`
12727
12728
12729
12730
12731
12732
12733
12734
12735 TargetWindowOption string `json:"targetWindowOption,omitempty"`
12736
12737
12738
12739
12740
12741
12742
12743 ForceSendFields []string `json:"-"`
12744
12745
12746
12747
12748
12749
12750
12751 NullFields []string `json:"-"`
12752 }
12753
12754 func (s *TargetWindow) MarshalJSON() ([]byte, error) {
12755 type NoMethod TargetWindow
12756 raw := NoMethod(*s)
12757 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12758 }
12759
12760
12761
12762
12763
12764
12765
12766
12767
12768
12769 type TargetableRemarketingList struct {
12770
12771
12772 AccountId int64 `json:"accountId,omitempty,string"`
12773
12774
12775 Active bool `json:"active,omitempty"`
12776
12777
12778
12779 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
12780
12781
12782
12783 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
12784
12785
12786 Description string `json:"description,omitempty"`
12787
12788
12789 Id int64 `json:"id,omitempty,string"`
12790
12791
12792
12793 Kind string `json:"kind,omitempty"`
12794
12795
12796
12797 LifeSpan int64 `json:"lifeSpan,omitempty,string"`
12798
12799
12800
12801 ListSize int64 `json:"listSize,omitempty,string"`
12802
12803
12804
12805
12806
12807
12808
12809
12810
12811
12812
12813
12814
12815
12816
12817
12818 ListSource string `json:"listSource,omitempty"`
12819
12820
12821
12822 Name string `json:"name,omitempty"`
12823
12824
12825
12826
12827 SubaccountId int64 `json:"subaccountId,omitempty,string"`
12828
12829
12830
12831 googleapi.ServerResponse `json:"-"`
12832
12833
12834
12835
12836
12837
12838
12839 ForceSendFields []string `json:"-"`
12840
12841
12842
12843
12844
12845
12846
12847 NullFields []string `json:"-"`
12848 }
12849
12850 func (s *TargetableRemarketingList) MarshalJSON() ([]byte, error) {
12851 type NoMethod TargetableRemarketingList
12852 raw := NoMethod(*s)
12853 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12854 }
12855
12856
12857
12858 type TargetableRemarketingListsListResponse struct {
12859
12860
12861 Kind string `json:"kind,omitempty"`
12862
12863
12864
12865 NextPageToken string `json:"nextPageToken,omitempty"`
12866
12867
12868 TargetableRemarketingLists []*TargetableRemarketingList `json:"targetableRemarketingLists,omitempty"`
12869
12870
12871
12872 googleapi.ServerResponse `json:"-"`
12873
12874
12875
12876
12877
12878
12879
12880 ForceSendFields []string `json:"-"`
12881
12882
12883
12884
12885
12886
12887
12888 NullFields []string `json:"-"`
12889 }
12890
12891 func (s *TargetableRemarketingListsListResponse) MarshalJSON() ([]byte, error) {
12892 type NoMethod TargetableRemarketingListsListResponse
12893 raw := NoMethod(*s)
12894 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12895 }
12896
12897
12898
12899
12900 type TargetingTemplate struct {
12901
12902
12903
12904 AccountId int64 `json:"accountId,omitempty,string"`
12905
12906
12907
12908 AdvertiserId int64 `json:"advertiserId,omitempty,string"`
12909
12910
12911
12912 AdvertiserIdDimensionValue *DimensionValue `json:"advertiserIdDimensionValue,omitempty"`
12913
12914
12915 DayPartTargeting *DayPartTargeting `json:"dayPartTargeting,omitempty"`
12916
12917
12918 GeoTargeting *GeoTargeting `json:"geoTargeting,omitempty"`
12919
12920
12921
12922 Id int64 `json:"id,omitempty,string"`
12923
12924
12925 KeyValueTargetingExpression *KeyValueTargetingExpression `json:"keyValueTargetingExpression,omitempty"`
12926
12927
12928
12929 Kind string `json:"kind,omitempty"`
12930
12931
12932 LanguageTargeting *LanguageTargeting `json:"languageTargeting,omitempty"`
12933
12934
12935 ListTargetingExpression *ListTargetingExpression `json:"listTargetingExpression,omitempty"`
12936
12937
12938
12939
12940 Name string `json:"name,omitempty"`
12941
12942
12943
12944
12945 SubaccountId int64 `json:"subaccountId,omitempty,string"`
12946
12947
12948 TechnologyTargeting *TechnologyTargeting `json:"technologyTargeting,omitempty"`
12949
12950
12951
12952 googleapi.ServerResponse `json:"-"`
12953
12954
12955
12956
12957
12958
12959
12960 ForceSendFields []string `json:"-"`
12961
12962
12963
12964
12965
12966
12967
12968 NullFields []string `json:"-"`
12969 }
12970
12971 func (s *TargetingTemplate) MarshalJSON() ([]byte, error) {
12972 type NoMethod TargetingTemplate
12973 raw := NoMethod(*s)
12974 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
12975 }
12976
12977
12978 type TargetingTemplatesListResponse struct {
12979
12980
12981 Kind string `json:"kind,omitempty"`
12982
12983
12984
12985 NextPageToken string `json:"nextPageToken,omitempty"`
12986
12987
12988 TargetingTemplates []*TargetingTemplate `json:"targetingTemplates,omitempty"`
12989
12990
12991
12992 googleapi.ServerResponse `json:"-"`
12993
12994
12995
12996
12997
12998
12999
13000 ForceSendFields []string `json:"-"`
13001
13002
13003
13004
13005
13006
13007
13008 NullFields []string `json:"-"`
13009 }
13010
13011 func (s *TargetingTemplatesListResponse) MarshalJSON() ([]byte, error) {
13012 type NoMethod TargetingTemplatesListResponse
13013 raw := NoMethod(*s)
13014 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13015 }
13016
13017
13018 type TechnologyTargeting struct {
13019
13020
13021
13022
13023 Browsers []*Browser `json:"browsers,omitempty"`
13024
13025
13026
13027
13028 ConnectionTypes []*ConnectionType `json:"connectionTypes,omitempty"`
13029
13030
13031
13032
13033
13034 MobileCarriers []*MobileCarrier `json:"mobileCarriers,omitempty"`
13035
13036
13037
13038
13039
13040
13041
13042 OperatingSystemVersions []*OperatingSystemVersion `json:"operatingSystemVersions,omitempty"`
13043
13044
13045
13046
13047
13048
13049
13050 OperatingSystems []*OperatingSystem `json:"operatingSystems,omitempty"`
13051
13052
13053
13054
13055
13056 PlatformTypes []*PlatformType `json:"platformTypes,omitempty"`
13057
13058
13059
13060
13061
13062
13063
13064 ForceSendFields []string `json:"-"`
13065
13066
13067
13068
13069
13070
13071
13072 NullFields []string `json:"-"`
13073 }
13074
13075 func (s *TechnologyTargeting) MarshalJSON() ([]byte, error) {
13076 type NoMethod TechnologyTargeting
13077 raw := NoMethod(*s)
13078 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13079 }
13080
13081
13082 type ThirdPartyAuthenticationToken struct {
13083
13084 Name string `json:"name,omitempty"`
13085
13086
13087
13088 Value string `json:"value,omitempty"`
13089
13090
13091
13092
13093
13094
13095
13096 ForceSendFields []string `json:"-"`
13097
13098
13099
13100
13101
13102
13103
13104 NullFields []string `json:"-"`
13105 }
13106
13107 func (s *ThirdPartyAuthenticationToken) MarshalJSON() ([]byte, error) {
13108 type NoMethod ThirdPartyAuthenticationToken
13109 raw := NoMethod(*s)
13110 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13111 }
13112
13113
13114 type ThirdPartyTrackingUrl struct {
13115
13116
13117
13118
13119
13120
13121
13122
13123
13124
13125
13126
13127
13128
13129
13130
13131
13132
13133
13134
13135
13136
13137
13138 ThirdPartyUrlType string `json:"thirdPartyUrlType,omitempty"`
13139
13140
13141 Url string `json:"url,omitempty"`
13142
13143
13144
13145
13146
13147
13148
13149 ForceSendFields []string `json:"-"`
13150
13151
13152
13153
13154
13155
13156
13157
13158 NullFields []string `json:"-"`
13159 }
13160
13161 func (s *ThirdPartyTrackingUrl) MarshalJSON() ([]byte, error) {
13162 type NoMethod ThirdPartyTrackingUrl
13163 raw := NoMethod(*s)
13164 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13165 }
13166
13167
13168 type TranscodeSetting struct {
13169
13170
13171 EnabledVideoFormats []int64 `json:"enabledVideoFormats,omitempty"`
13172
13173
13174
13175 Kind string `json:"kind,omitempty"`
13176
13177
13178
13179
13180
13181
13182
13183 ForceSendFields []string `json:"-"`
13184
13185
13186
13187
13188
13189
13190
13191
13192 NullFields []string `json:"-"`
13193 }
13194
13195 func (s *TranscodeSetting) MarshalJSON() ([]byte, error) {
13196 type NoMethod TranscodeSetting
13197 raw := NoMethod(*s)
13198 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13199 }
13200
13201
13202
13203
13204 type UniversalAdId struct {
13205
13206
13207
13208
13209
13210
13211
13212 Registry string `json:"registry,omitempty"`
13213
13214
13215
13216
13217 Value string `json:"value,omitempty"`
13218
13219
13220
13221
13222
13223
13224
13225 ForceSendFields []string `json:"-"`
13226
13227
13228
13229
13230
13231
13232
13233 NullFields []string `json:"-"`
13234 }
13235
13236 func (s *UniversalAdId) MarshalJSON() ([]byte, error) {
13237 type NoMethod UniversalAdId
13238 raw := NoMethod(*s)
13239 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13240 }
13241
13242
13243
13244 type UserDefinedVariableConfiguration struct {
13245
13246
13247
13248
13249
13250 DataType string `json:"dataType,omitempty"`
13251
13252
13253
13254
13255 ReportName string `json:"reportName,omitempty"`
13256
13257
13258
13259
13260
13261
13262
13263
13264
13265
13266
13267
13268
13269
13270
13271
13272
13273
13274
13275
13276
13277
13278
13279
13280
13281
13282
13283
13284
13285
13286
13287
13288
13289
13290
13291
13292
13293
13294
13295
13296
13297
13298
13299
13300
13301
13302
13303
13304
13305
13306
13307
13308
13309
13310
13311
13312
13313
13314
13315
13316
13317
13318
13319
13320
13321
13322
13323
13324
13325
13326
13327
13328
13329
13330
13331
13332
13333
13334
13335
13336
13337
13338
13339
13340
13341
13342
13343
13344
13345
13346
13347
13348
13349
13350
13351
13352
13353
13354
13355
13356
13357
13358
13359
13360 VariableType string `json:"variableType,omitempty"`
13361
13362
13363
13364
13365
13366
13367
13368 ForceSendFields []string `json:"-"`
13369
13370
13371
13372
13373
13374
13375
13376 NullFields []string `json:"-"`
13377 }
13378
13379 func (s *UserDefinedVariableConfiguration) MarshalJSON() ([]byte, error) {
13380 type NoMethod UserDefinedVariableConfiguration
13381 raw := NoMethod(*s)
13382 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13383 }
13384
13385
13386 type UserProfile struct {
13387
13388 AccountId int64 `json:"accountId,omitempty,string"`
13389
13390
13391 AccountName string `json:"accountName,omitempty"`
13392
13393
13394 Etag string `json:"etag,omitempty"`
13395
13396
13397
13398 Kind string `json:"kind,omitempty"`
13399
13400
13401 ProfileId int64 `json:"profileId,omitempty,string"`
13402
13403
13404
13405 SubAccountId int64 `json:"subAccountId,omitempty,string"`
13406
13407
13408
13409 SubAccountName string `json:"subAccountName,omitempty"`
13410
13411
13412 UserName string `json:"userName,omitempty"`
13413
13414
13415
13416 googleapi.ServerResponse `json:"-"`
13417
13418
13419
13420
13421
13422
13423
13424 ForceSendFields []string `json:"-"`
13425
13426
13427
13428
13429
13430
13431
13432 NullFields []string `json:"-"`
13433 }
13434
13435 func (s *UserProfile) MarshalJSON() ([]byte, error) {
13436 type NoMethod UserProfile
13437 raw := NoMethod(*s)
13438 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13439 }
13440
13441
13442 type UserProfileList struct {
13443
13444 Etag string `json:"etag,omitempty"`
13445
13446
13447 Items []*UserProfile `json:"items,omitempty"`
13448
13449
13450
13451 Kind string `json:"kind,omitempty"`
13452
13453
13454
13455 googleapi.ServerResponse `json:"-"`
13456
13457
13458
13459
13460
13461
13462
13463 ForceSendFields []string `json:"-"`
13464
13465
13466
13467
13468
13469
13470
13471 NullFields []string `json:"-"`
13472 }
13473
13474 func (s *UserProfileList) MarshalJSON() ([]byte, error) {
13475 type NoMethod UserProfileList
13476 raw := NoMethod(*s)
13477 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13478 }
13479
13480
13481
13482 type UserRole struct {
13483
13484
13485 AccountId int64 `json:"accountId,omitempty,string"`
13486
13487
13488
13489
13490
13491 DefaultUserRole bool `json:"defaultUserRole,omitempty"`
13492
13493
13494 Id int64 `json:"id,omitempty,string"`
13495
13496
13497
13498 Kind string `json:"kind,omitempty"`
13499
13500
13501
13502
13503
13504
13505 Name string `json:"name,omitempty"`
13506
13507
13508
13509 ParentUserRoleId int64 `json:"parentUserRoleId,omitempty,string"`
13510
13511
13512 Permissions []*UserRolePermission `json:"permissions,omitempty"`
13513
13514
13515
13516 SubaccountId int64 `json:"subaccountId,omitempty,string"`
13517
13518
13519
13520 googleapi.ServerResponse `json:"-"`
13521
13522
13523
13524
13525
13526
13527
13528 ForceSendFields []string `json:"-"`
13529
13530
13531
13532
13533
13534
13535
13536 NullFields []string `json:"-"`
13537 }
13538
13539 func (s *UserRole) MarshalJSON() ([]byte, error) {
13540 type NoMethod UserRole
13541 raw := NoMethod(*s)
13542 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13543 }
13544
13545
13546 type UserRolePermission struct {
13547
13548
13549
13550
13551
13552
13553
13554
13555 Availability string `json:"availability,omitempty"`
13556
13557
13558 Id int64 `json:"id,omitempty,string"`
13559
13560
13561
13562 Kind string `json:"kind,omitempty"`
13563
13564
13565 Name string `json:"name,omitempty"`
13566
13567
13568
13569 PermissionGroupId int64 `json:"permissionGroupId,omitempty,string"`
13570
13571
13572
13573 googleapi.ServerResponse `json:"-"`
13574
13575
13576
13577
13578
13579
13580
13581 ForceSendFields []string `json:"-"`
13582
13583
13584
13585
13586
13587
13588
13589 NullFields []string `json:"-"`
13590 }
13591
13592 func (s *UserRolePermission) MarshalJSON() ([]byte, error) {
13593 type NoMethod UserRolePermission
13594 raw := NoMethod(*s)
13595 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13596 }
13597
13598
13599
13600 type UserRolePermissionGroup struct {
13601
13602 Id int64 `json:"id,omitempty,string"`
13603
13604
13605
13606 Kind string `json:"kind,omitempty"`
13607
13608
13609 Name string `json:"name,omitempty"`
13610
13611
13612
13613 googleapi.ServerResponse `json:"-"`
13614
13615
13616
13617
13618
13619
13620
13621 ForceSendFields []string `json:"-"`
13622
13623
13624
13625
13626
13627
13628
13629 NullFields []string `json:"-"`
13630 }
13631
13632 func (s *UserRolePermissionGroup) MarshalJSON() ([]byte, error) {
13633 type NoMethod UserRolePermissionGroup
13634 raw := NoMethod(*s)
13635 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13636 }
13637
13638
13639
13640 type UserRolePermissionGroupsListResponse struct {
13641
13642
13643 Kind string `json:"kind,omitempty"`
13644
13645
13646 UserRolePermissionGroups []*UserRolePermissionGroup `json:"userRolePermissionGroups,omitempty"`
13647
13648
13649
13650 googleapi.ServerResponse `json:"-"`
13651
13652
13653
13654
13655
13656
13657
13658 ForceSendFields []string `json:"-"`
13659
13660
13661
13662
13663
13664
13665
13666 NullFields []string `json:"-"`
13667 }
13668
13669 func (s *UserRolePermissionGroupsListResponse) MarshalJSON() ([]byte, error) {
13670 type NoMethod UserRolePermissionGroupsListResponse
13671 raw := NoMethod(*s)
13672 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13673 }
13674
13675
13676 type UserRolePermissionsListResponse struct {
13677
13678
13679 Kind string `json:"kind,omitempty"`
13680
13681
13682 UserRolePermissions []*UserRolePermission `json:"userRolePermissions,omitempty"`
13683
13684
13685
13686 googleapi.ServerResponse `json:"-"`
13687
13688
13689
13690
13691
13692
13693
13694 ForceSendFields []string `json:"-"`
13695
13696
13697
13698
13699
13700
13701
13702 NullFields []string `json:"-"`
13703 }
13704
13705 func (s *UserRolePermissionsListResponse) MarshalJSON() ([]byte, error) {
13706 type NoMethod UserRolePermissionsListResponse
13707 raw := NoMethod(*s)
13708 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13709 }
13710
13711
13712 type UserRolesListResponse struct {
13713
13714
13715 Kind string `json:"kind,omitempty"`
13716
13717
13718
13719 NextPageToken string `json:"nextPageToken,omitempty"`
13720
13721
13722 UserRoles []*UserRole `json:"userRoles,omitempty"`
13723
13724
13725
13726 googleapi.ServerResponse `json:"-"`
13727
13728
13729
13730
13731
13732
13733
13734 ForceSendFields []string `json:"-"`
13735
13736
13737
13738
13739
13740
13741
13742 NullFields []string `json:"-"`
13743 }
13744
13745 func (s *UserRolesListResponse) MarshalJSON() ([]byte, error) {
13746 type NoMethod UserRolesListResponse
13747 raw := NoMethod(*s)
13748 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13749 }
13750
13751
13752 type VideoFormat struct {
13753
13754
13755
13756
13757
13758
13759
13760
13761 FileType string `json:"fileType,omitempty"`
13762
13763
13764 Id int64 `json:"id,omitempty"`
13765
13766
13767
13768 Kind string `json:"kind,omitempty"`
13769
13770
13771 Resolution *Size `json:"resolution,omitempty"`
13772
13773
13774 TargetBitRate int64 `json:"targetBitRate,omitempty"`
13775
13776
13777
13778 googleapi.ServerResponse `json:"-"`
13779
13780
13781
13782
13783
13784
13785
13786 ForceSendFields []string `json:"-"`
13787
13788
13789
13790
13791
13792
13793
13794 NullFields []string `json:"-"`
13795 }
13796
13797 func (s *VideoFormat) MarshalJSON() ([]byte, error) {
13798 type NoMethod VideoFormat
13799 raw := NoMethod(*s)
13800 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13801 }
13802
13803
13804 type VideoFormatsListResponse struct {
13805
13806
13807 Kind string `json:"kind,omitempty"`
13808
13809
13810 VideoFormats []*VideoFormat `json:"videoFormats,omitempty"`
13811
13812
13813
13814 googleapi.ServerResponse `json:"-"`
13815
13816
13817
13818
13819
13820
13821
13822 ForceSendFields []string `json:"-"`
13823
13824
13825
13826
13827
13828
13829
13830 NullFields []string `json:"-"`
13831 }
13832
13833 func (s *VideoFormatsListResponse) MarshalJSON() ([]byte, error) {
13834 type NoMethod VideoFormatsListResponse
13835 raw := NoMethod(*s)
13836 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13837 }
13838
13839
13840 type VideoOffset struct {
13841
13842
13843
13844 OffsetPercentage int64 `json:"offsetPercentage,omitempty"`
13845
13846
13847
13848 OffsetSeconds int64 `json:"offsetSeconds,omitempty"`
13849
13850
13851
13852
13853
13854
13855
13856 ForceSendFields []string `json:"-"`
13857
13858
13859
13860
13861
13862
13863
13864
13865 NullFields []string `json:"-"`
13866 }
13867
13868 func (s *VideoOffset) MarshalJSON() ([]byte, error) {
13869 type NoMethod VideoOffset
13870 raw := NoMethod(*s)
13871 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13872 }
13873
13874
13875 type VideoSettings struct {
13876
13877
13878 CompanionSettings *CompanionSetting `json:"companionSettings,omitempty"`
13879
13880
13881
13882 Kind string `json:"kind,omitempty"`
13883
13884
13885
13886
13887
13888
13889
13890
13891 Orientation string `json:"orientation,omitempty"`
13892
13893
13894
13895
13896 SkippableSettings *SkippableSetting `json:"skippableSettings,omitempty"`
13897
13898
13899
13900
13901 TranscodeSettings *TranscodeSetting `json:"transcodeSettings,omitempty"`
13902
13903
13904
13905
13906
13907
13908
13909 ForceSendFields []string `json:"-"`
13910
13911
13912
13913
13914
13915
13916
13917
13918 NullFields []string `json:"-"`
13919 }
13920
13921 func (s *VideoSettings) MarshalJSON() ([]byte, error) {
13922 type NoMethod VideoSettings
13923 raw := NoMethod(*s)
13924 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
13925 }
13926
13927
13928
13929 type AccountActiveAdSummariesGetCall struct {
13930 s *Service
13931 profileId int64
13932 summaryAccountId int64
13933 urlParams_ gensupport.URLParams
13934 ifNoneMatch_ string
13935 ctx_ context.Context
13936 header_ http.Header
13937 }
13938
13939
13940 func (r *AccountActiveAdSummariesService) Get(profileId int64, summaryAccountId int64) *AccountActiveAdSummariesGetCall {
13941 c := &AccountActiveAdSummariesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13942 c.profileId = profileId
13943 c.summaryAccountId = summaryAccountId
13944 return c
13945 }
13946
13947
13948
13949
13950 func (c *AccountActiveAdSummariesGetCall) Fields(s ...googleapi.Field) *AccountActiveAdSummariesGetCall {
13951 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13952 return c
13953 }
13954
13955
13956
13957
13958
13959
13960 func (c *AccountActiveAdSummariesGetCall) IfNoneMatch(entityTag string) *AccountActiveAdSummariesGetCall {
13961 c.ifNoneMatch_ = entityTag
13962 return c
13963 }
13964
13965
13966
13967
13968 func (c *AccountActiveAdSummariesGetCall) Context(ctx context.Context) *AccountActiveAdSummariesGetCall {
13969 c.ctx_ = ctx
13970 return c
13971 }
13972
13973
13974
13975 func (c *AccountActiveAdSummariesGetCall) Header() http.Header {
13976 if c.header_ == nil {
13977 c.header_ = make(http.Header)
13978 }
13979 return c.header_
13980 }
13981
13982 func (c *AccountActiveAdSummariesGetCall) doRequest(alt string) (*http.Response, error) {
13983 reqHeaders := make(http.Header)
13984 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
13985 for k, v := range c.header_ {
13986 reqHeaders[k] = v
13987 }
13988 reqHeaders.Set("User-Agent", c.s.userAgent())
13989 if c.ifNoneMatch_ != "" {
13990 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13991 }
13992 var body io.Reader = nil
13993 c.urlParams_.Set("alt", alt)
13994 c.urlParams_.Set("prettyPrint", "false")
13995 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountActiveAdSummaries/{summaryAccountId}")
13996 urls += "?" + c.urlParams_.Encode()
13997 req, err := http.NewRequest("GET", urls, body)
13998 if err != nil {
13999 return nil, err
14000 }
14001 req.Header = reqHeaders
14002 googleapi.Expand(req.URL, map[string]string{
14003 "profileId": strconv.FormatInt(c.profileId, 10),
14004 "summaryAccountId": strconv.FormatInt(c.summaryAccountId, 10),
14005 })
14006 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14007 }
14008
14009
14010
14011
14012
14013
14014
14015
14016 func (c *AccountActiveAdSummariesGetCall) Do(opts ...googleapi.CallOption) (*AccountActiveAdSummary, error) {
14017 gensupport.SetOptions(c.urlParams_, opts...)
14018 res, err := c.doRequest("json")
14019 if res != nil && res.StatusCode == http.StatusNotModified {
14020 if res.Body != nil {
14021 res.Body.Close()
14022 }
14023 return nil, &googleapi.Error{
14024 Code: res.StatusCode,
14025 Header: res.Header,
14026 }
14027 }
14028 if err != nil {
14029 return nil, err
14030 }
14031 defer googleapi.CloseBody(res)
14032 if err := googleapi.CheckResponse(res); err != nil {
14033 return nil, err
14034 }
14035 ret := &AccountActiveAdSummary{
14036 ServerResponse: googleapi.ServerResponse{
14037 Header: res.Header,
14038 HTTPStatusCode: res.StatusCode,
14039 },
14040 }
14041 target := &ret
14042 if err := gensupport.DecodeResponse(target, res); err != nil {
14043 return nil, err
14044 }
14045 return ret, nil
14046
14047
14048
14049
14050
14051
14052
14053
14054
14055
14056
14057
14058
14059
14060
14061
14062
14063
14064
14065
14066
14067
14068
14069
14070
14071
14072
14073
14074
14075
14076
14077
14078
14079 }
14080
14081
14082
14083 type AccountPermissionGroupsGetCall struct {
14084 s *Service
14085 profileId int64
14086 id int64
14087 urlParams_ gensupport.URLParams
14088 ifNoneMatch_ string
14089 ctx_ context.Context
14090 header_ http.Header
14091 }
14092
14093
14094 func (r *AccountPermissionGroupsService) Get(profileId int64, id int64) *AccountPermissionGroupsGetCall {
14095 c := &AccountPermissionGroupsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14096 c.profileId = profileId
14097 c.id = id
14098 return c
14099 }
14100
14101
14102
14103
14104 func (c *AccountPermissionGroupsGetCall) Fields(s ...googleapi.Field) *AccountPermissionGroupsGetCall {
14105 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14106 return c
14107 }
14108
14109
14110
14111
14112
14113
14114 func (c *AccountPermissionGroupsGetCall) IfNoneMatch(entityTag string) *AccountPermissionGroupsGetCall {
14115 c.ifNoneMatch_ = entityTag
14116 return c
14117 }
14118
14119
14120
14121
14122 func (c *AccountPermissionGroupsGetCall) Context(ctx context.Context) *AccountPermissionGroupsGetCall {
14123 c.ctx_ = ctx
14124 return c
14125 }
14126
14127
14128
14129 func (c *AccountPermissionGroupsGetCall) Header() http.Header {
14130 if c.header_ == nil {
14131 c.header_ = make(http.Header)
14132 }
14133 return c.header_
14134 }
14135
14136 func (c *AccountPermissionGroupsGetCall) doRequest(alt string) (*http.Response, error) {
14137 reqHeaders := make(http.Header)
14138 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
14139 for k, v := range c.header_ {
14140 reqHeaders[k] = v
14141 }
14142 reqHeaders.Set("User-Agent", c.s.userAgent())
14143 if c.ifNoneMatch_ != "" {
14144 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14145 }
14146 var body io.Reader = nil
14147 c.urlParams_.Set("alt", alt)
14148 c.urlParams_.Set("prettyPrint", "false")
14149 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountPermissionGroups/{id}")
14150 urls += "?" + c.urlParams_.Encode()
14151 req, err := http.NewRequest("GET", urls, body)
14152 if err != nil {
14153 return nil, err
14154 }
14155 req.Header = reqHeaders
14156 googleapi.Expand(req.URL, map[string]string{
14157 "profileId": strconv.FormatInt(c.profileId, 10),
14158 "id": strconv.FormatInt(c.id, 10),
14159 })
14160 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14161 }
14162
14163
14164
14165
14166
14167
14168
14169
14170 func (c *AccountPermissionGroupsGetCall) Do(opts ...googleapi.CallOption) (*AccountPermissionGroup, error) {
14171 gensupport.SetOptions(c.urlParams_, opts...)
14172 res, err := c.doRequest("json")
14173 if res != nil && res.StatusCode == http.StatusNotModified {
14174 if res.Body != nil {
14175 res.Body.Close()
14176 }
14177 return nil, &googleapi.Error{
14178 Code: res.StatusCode,
14179 Header: res.Header,
14180 }
14181 }
14182 if err != nil {
14183 return nil, err
14184 }
14185 defer googleapi.CloseBody(res)
14186 if err := googleapi.CheckResponse(res); err != nil {
14187 return nil, err
14188 }
14189 ret := &AccountPermissionGroup{
14190 ServerResponse: googleapi.ServerResponse{
14191 Header: res.Header,
14192 HTTPStatusCode: res.StatusCode,
14193 },
14194 }
14195 target := &ret
14196 if err := gensupport.DecodeResponse(target, res); err != nil {
14197 return nil, err
14198 }
14199 return ret, nil
14200
14201
14202
14203
14204
14205
14206
14207
14208
14209
14210
14211
14212
14213
14214
14215
14216
14217
14218
14219
14220
14221
14222
14223
14224
14225
14226
14227
14228
14229
14230
14231
14232
14233 }
14234
14235
14236
14237 type AccountPermissionGroupsListCall struct {
14238 s *Service
14239 profileId int64
14240 urlParams_ gensupport.URLParams
14241 ifNoneMatch_ string
14242 ctx_ context.Context
14243 header_ http.Header
14244 }
14245
14246
14247 func (r *AccountPermissionGroupsService) List(profileId int64) *AccountPermissionGroupsListCall {
14248 c := &AccountPermissionGroupsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14249 c.profileId = profileId
14250 return c
14251 }
14252
14253
14254
14255
14256 func (c *AccountPermissionGroupsListCall) Fields(s ...googleapi.Field) *AccountPermissionGroupsListCall {
14257 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14258 return c
14259 }
14260
14261
14262
14263
14264
14265
14266 func (c *AccountPermissionGroupsListCall) IfNoneMatch(entityTag string) *AccountPermissionGroupsListCall {
14267 c.ifNoneMatch_ = entityTag
14268 return c
14269 }
14270
14271
14272
14273
14274 func (c *AccountPermissionGroupsListCall) Context(ctx context.Context) *AccountPermissionGroupsListCall {
14275 c.ctx_ = ctx
14276 return c
14277 }
14278
14279
14280
14281 func (c *AccountPermissionGroupsListCall) Header() http.Header {
14282 if c.header_ == nil {
14283 c.header_ = make(http.Header)
14284 }
14285 return c.header_
14286 }
14287
14288 func (c *AccountPermissionGroupsListCall) doRequest(alt string) (*http.Response, error) {
14289 reqHeaders := make(http.Header)
14290 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
14291 for k, v := range c.header_ {
14292 reqHeaders[k] = v
14293 }
14294 reqHeaders.Set("User-Agent", c.s.userAgent())
14295 if c.ifNoneMatch_ != "" {
14296 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14297 }
14298 var body io.Reader = nil
14299 c.urlParams_.Set("alt", alt)
14300 c.urlParams_.Set("prettyPrint", "false")
14301 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountPermissionGroups")
14302 urls += "?" + c.urlParams_.Encode()
14303 req, err := http.NewRequest("GET", urls, body)
14304 if err != nil {
14305 return nil, err
14306 }
14307 req.Header = reqHeaders
14308 googleapi.Expand(req.URL, map[string]string{
14309 "profileId": strconv.FormatInt(c.profileId, 10),
14310 })
14311 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14312 }
14313
14314
14315
14316
14317
14318
14319
14320
14321
14322 func (c *AccountPermissionGroupsListCall) Do(opts ...googleapi.CallOption) (*AccountPermissionGroupsListResponse, error) {
14323 gensupport.SetOptions(c.urlParams_, opts...)
14324 res, err := c.doRequest("json")
14325 if res != nil && res.StatusCode == http.StatusNotModified {
14326 if res.Body != nil {
14327 res.Body.Close()
14328 }
14329 return nil, &googleapi.Error{
14330 Code: res.StatusCode,
14331 Header: res.Header,
14332 }
14333 }
14334 if err != nil {
14335 return nil, err
14336 }
14337 defer googleapi.CloseBody(res)
14338 if err := googleapi.CheckResponse(res); err != nil {
14339 return nil, err
14340 }
14341 ret := &AccountPermissionGroupsListResponse{
14342 ServerResponse: googleapi.ServerResponse{
14343 Header: res.Header,
14344 HTTPStatusCode: res.StatusCode,
14345 },
14346 }
14347 target := &ret
14348 if err := gensupport.DecodeResponse(target, res); err != nil {
14349 return nil, err
14350 }
14351 return ret, nil
14352
14353
14354
14355
14356
14357
14358
14359
14360
14361
14362
14363
14364
14365
14366
14367
14368
14369
14370
14371
14372
14373
14374
14375
14376
14377 }
14378
14379
14380
14381 type AccountPermissionsGetCall struct {
14382 s *Service
14383 profileId int64
14384 id int64
14385 urlParams_ gensupport.URLParams
14386 ifNoneMatch_ string
14387 ctx_ context.Context
14388 header_ http.Header
14389 }
14390
14391
14392 func (r *AccountPermissionsService) Get(profileId int64, id int64) *AccountPermissionsGetCall {
14393 c := &AccountPermissionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14394 c.profileId = profileId
14395 c.id = id
14396 return c
14397 }
14398
14399
14400
14401
14402 func (c *AccountPermissionsGetCall) Fields(s ...googleapi.Field) *AccountPermissionsGetCall {
14403 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14404 return c
14405 }
14406
14407
14408
14409
14410
14411
14412 func (c *AccountPermissionsGetCall) IfNoneMatch(entityTag string) *AccountPermissionsGetCall {
14413 c.ifNoneMatch_ = entityTag
14414 return c
14415 }
14416
14417
14418
14419
14420 func (c *AccountPermissionsGetCall) Context(ctx context.Context) *AccountPermissionsGetCall {
14421 c.ctx_ = ctx
14422 return c
14423 }
14424
14425
14426
14427 func (c *AccountPermissionsGetCall) Header() http.Header {
14428 if c.header_ == nil {
14429 c.header_ = make(http.Header)
14430 }
14431 return c.header_
14432 }
14433
14434 func (c *AccountPermissionsGetCall) doRequest(alt string) (*http.Response, error) {
14435 reqHeaders := make(http.Header)
14436 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
14437 for k, v := range c.header_ {
14438 reqHeaders[k] = v
14439 }
14440 reqHeaders.Set("User-Agent", c.s.userAgent())
14441 if c.ifNoneMatch_ != "" {
14442 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14443 }
14444 var body io.Reader = nil
14445 c.urlParams_.Set("alt", alt)
14446 c.urlParams_.Set("prettyPrint", "false")
14447 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountPermissions/{id}")
14448 urls += "?" + c.urlParams_.Encode()
14449 req, err := http.NewRequest("GET", urls, body)
14450 if err != nil {
14451 return nil, err
14452 }
14453 req.Header = reqHeaders
14454 googleapi.Expand(req.URL, map[string]string{
14455 "profileId": strconv.FormatInt(c.profileId, 10),
14456 "id": strconv.FormatInt(c.id, 10),
14457 })
14458 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14459 }
14460
14461
14462
14463
14464
14465
14466
14467
14468 func (c *AccountPermissionsGetCall) Do(opts ...googleapi.CallOption) (*AccountPermission, error) {
14469 gensupport.SetOptions(c.urlParams_, opts...)
14470 res, err := c.doRequest("json")
14471 if res != nil && res.StatusCode == http.StatusNotModified {
14472 if res.Body != nil {
14473 res.Body.Close()
14474 }
14475 return nil, &googleapi.Error{
14476 Code: res.StatusCode,
14477 Header: res.Header,
14478 }
14479 }
14480 if err != nil {
14481 return nil, err
14482 }
14483 defer googleapi.CloseBody(res)
14484 if err := googleapi.CheckResponse(res); err != nil {
14485 return nil, err
14486 }
14487 ret := &AccountPermission{
14488 ServerResponse: googleapi.ServerResponse{
14489 Header: res.Header,
14490 HTTPStatusCode: res.StatusCode,
14491 },
14492 }
14493 target := &ret
14494 if err := gensupport.DecodeResponse(target, res); err != nil {
14495 return nil, err
14496 }
14497 return ret, nil
14498
14499
14500
14501
14502
14503
14504
14505
14506
14507
14508
14509
14510
14511
14512
14513
14514
14515
14516
14517
14518
14519
14520
14521
14522
14523
14524
14525
14526
14527
14528
14529
14530
14531 }
14532
14533
14534
14535 type AccountPermissionsListCall struct {
14536 s *Service
14537 profileId int64
14538 urlParams_ gensupport.URLParams
14539 ifNoneMatch_ string
14540 ctx_ context.Context
14541 header_ http.Header
14542 }
14543
14544
14545 func (r *AccountPermissionsService) List(profileId int64) *AccountPermissionsListCall {
14546 c := &AccountPermissionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14547 c.profileId = profileId
14548 return c
14549 }
14550
14551
14552
14553
14554 func (c *AccountPermissionsListCall) Fields(s ...googleapi.Field) *AccountPermissionsListCall {
14555 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14556 return c
14557 }
14558
14559
14560
14561
14562
14563
14564 func (c *AccountPermissionsListCall) IfNoneMatch(entityTag string) *AccountPermissionsListCall {
14565 c.ifNoneMatch_ = entityTag
14566 return c
14567 }
14568
14569
14570
14571
14572 func (c *AccountPermissionsListCall) Context(ctx context.Context) *AccountPermissionsListCall {
14573 c.ctx_ = ctx
14574 return c
14575 }
14576
14577
14578
14579 func (c *AccountPermissionsListCall) Header() http.Header {
14580 if c.header_ == nil {
14581 c.header_ = make(http.Header)
14582 }
14583 return c.header_
14584 }
14585
14586 func (c *AccountPermissionsListCall) doRequest(alt string) (*http.Response, error) {
14587 reqHeaders := make(http.Header)
14588 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
14589 for k, v := range c.header_ {
14590 reqHeaders[k] = v
14591 }
14592 reqHeaders.Set("User-Agent", c.s.userAgent())
14593 if c.ifNoneMatch_ != "" {
14594 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14595 }
14596 var body io.Reader = nil
14597 c.urlParams_.Set("alt", alt)
14598 c.urlParams_.Set("prettyPrint", "false")
14599 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountPermissions")
14600 urls += "?" + c.urlParams_.Encode()
14601 req, err := http.NewRequest("GET", urls, body)
14602 if err != nil {
14603 return nil, err
14604 }
14605 req.Header = reqHeaders
14606 googleapi.Expand(req.URL, map[string]string{
14607 "profileId": strconv.FormatInt(c.profileId, 10),
14608 })
14609 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14610 }
14611
14612
14613
14614
14615
14616
14617
14618
14619 func (c *AccountPermissionsListCall) Do(opts ...googleapi.CallOption) (*AccountPermissionsListResponse, error) {
14620 gensupport.SetOptions(c.urlParams_, opts...)
14621 res, err := c.doRequest("json")
14622 if res != nil && res.StatusCode == http.StatusNotModified {
14623 if res.Body != nil {
14624 res.Body.Close()
14625 }
14626 return nil, &googleapi.Error{
14627 Code: res.StatusCode,
14628 Header: res.Header,
14629 }
14630 }
14631 if err != nil {
14632 return nil, err
14633 }
14634 defer googleapi.CloseBody(res)
14635 if err := googleapi.CheckResponse(res); err != nil {
14636 return nil, err
14637 }
14638 ret := &AccountPermissionsListResponse{
14639 ServerResponse: googleapi.ServerResponse{
14640 Header: res.Header,
14641 HTTPStatusCode: res.StatusCode,
14642 },
14643 }
14644 target := &ret
14645 if err := gensupport.DecodeResponse(target, res); err != nil {
14646 return nil, err
14647 }
14648 return ret, nil
14649
14650
14651
14652
14653
14654
14655
14656
14657
14658
14659
14660
14661
14662
14663
14664
14665
14666
14667
14668
14669
14670
14671
14672
14673
14674 }
14675
14676
14677
14678 type AccountUserProfilesGetCall struct {
14679 s *Service
14680 profileId int64
14681 id int64
14682 urlParams_ gensupport.URLParams
14683 ifNoneMatch_ string
14684 ctx_ context.Context
14685 header_ http.Header
14686 }
14687
14688
14689 func (r *AccountUserProfilesService) Get(profileId int64, id int64) *AccountUserProfilesGetCall {
14690 c := &AccountUserProfilesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14691 c.profileId = profileId
14692 c.id = id
14693 return c
14694 }
14695
14696
14697
14698
14699 func (c *AccountUserProfilesGetCall) Fields(s ...googleapi.Field) *AccountUserProfilesGetCall {
14700 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14701 return c
14702 }
14703
14704
14705
14706
14707
14708
14709 func (c *AccountUserProfilesGetCall) IfNoneMatch(entityTag string) *AccountUserProfilesGetCall {
14710 c.ifNoneMatch_ = entityTag
14711 return c
14712 }
14713
14714
14715
14716
14717 func (c *AccountUserProfilesGetCall) Context(ctx context.Context) *AccountUserProfilesGetCall {
14718 c.ctx_ = ctx
14719 return c
14720 }
14721
14722
14723
14724 func (c *AccountUserProfilesGetCall) Header() http.Header {
14725 if c.header_ == nil {
14726 c.header_ = make(http.Header)
14727 }
14728 return c.header_
14729 }
14730
14731 func (c *AccountUserProfilesGetCall) doRequest(alt string) (*http.Response, error) {
14732 reqHeaders := make(http.Header)
14733 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
14734 for k, v := range c.header_ {
14735 reqHeaders[k] = v
14736 }
14737 reqHeaders.Set("User-Agent", c.s.userAgent())
14738 if c.ifNoneMatch_ != "" {
14739 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14740 }
14741 var body io.Reader = nil
14742 c.urlParams_.Set("alt", alt)
14743 c.urlParams_.Set("prettyPrint", "false")
14744 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountUserProfiles/{id}")
14745 urls += "?" + c.urlParams_.Encode()
14746 req, err := http.NewRequest("GET", urls, body)
14747 if err != nil {
14748 return nil, err
14749 }
14750 req.Header = reqHeaders
14751 googleapi.Expand(req.URL, map[string]string{
14752 "profileId": strconv.FormatInt(c.profileId, 10),
14753 "id": strconv.FormatInt(c.id, 10),
14754 })
14755 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14756 }
14757
14758
14759
14760
14761
14762
14763
14764
14765 func (c *AccountUserProfilesGetCall) Do(opts ...googleapi.CallOption) (*AccountUserProfile, error) {
14766 gensupport.SetOptions(c.urlParams_, opts...)
14767 res, err := c.doRequest("json")
14768 if res != nil && res.StatusCode == http.StatusNotModified {
14769 if res.Body != nil {
14770 res.Body.Close()
14771 }
14772 return nil, &googleapi.Error{
14773 Code: res.StatusCode,
14774 Header: res.Header,
14775 }
14776 }
14777 if err != nil {
14778 return nil, err
14779 }
14780 defer googleapi.CloseBody(res)
14781 if err := googleapi.CheckResponse(res); err != nil {
14782 return nil, err
14783 }
14784 ret := &AccountUserProfile{
14785 ServerResponse: googleapi.ServerResponse{
14786 Header: res.Header,
14787 HTTPStatusCode: res.StatusCode,
14788 },
14789 }
14790 target := &ret
14791 if err := gensupport.DecodeResponse(target, res); err != nil {
14792 return nil, err
14793 }
14794 return ret, nil
14795
14796
14797
14798
14799
14800
14801
14802
14803
14804
14805
14806
14807
14808
14809
14810
14811
14812
14813
14814
14815
14816
14817
14818
14819
14820
14821
14822
14823
14824
14825
14826
14827
14828 }
14829
14830
14831
14832 type AccountUserProfilesInsertCall struct {
14833 s *Service
14834 profileId int64
14835 accountuserprofile *AccountUserProfile
14836 urlParams_ gensupport.URLParams
14837 ctx_ context.Context
14838 header_ http.Header
14839 }
14840
14841
14842 func (r *AccountUserProfilesService) Insert(profileId int64, accountuserprofile *AccountUserProfile) *AccountUserProfilesInsertCall {
14843 c := &AccountUserProfilesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14844 c.profileId = profileId
14845 c.accountuserprofile = accountuserprofile
14846 return c
14847 }
14848
14849
14850
14851
14852 func (c *AccountUserProfilesInsertCall) Fields(s ...googleapi.Field) *AccountUserProfilesInsertCall {
14853 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14854 return c
14855 }
14856
14857
14858
14859
14860 func (c *AccountUserProfilesInsertCall) Context(ctx context.Context) *AccountUserProfilesInsertCall {
14861 c.ctx_ = ctx
14862 return c
14863 }
14864
14865
14866
14867 func (c *AccountUserProfilesInsertCall) Header() http.Header {
14868 if c.header_ == nil {
14869 c.header_ = make(http.Header)
14870 }
14871 return c.header_
14872 }
14873
14874 func (c *AccountUserProfilesInsertCall) doRequest(alt string) (*http.Response, error) {
14875 reqHeaders := make(http.Header)
14876 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
14877 for k, v := range c.header_ {
14878 reqHeaders[k] = v
14879 }
14880 reqHeaders.Set("User-Agent", c.s.userAgent())
14881 var body io.Reader = nil
14882 body, err := googleapi.WithoutDataWrapper.JSONReader(c.accountuserprofile)
14883 if err != nil {
14884 return nil, err
14885 }
14886 reqHeaders.Set("Content-Type", "application/json")
14887 c.urlParams_.Set("alt", alt)
14888 c.urlParams_.Set("prettyPrint", "false")
14889 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountUserProfiles")
14890 urls += "?" + c.urlParams_.Encode()
14891 req, err := http.NewRequest("POST", urls, body)
14892 if err != nil {
14893 return nil, err
14894 }
14895 req.Header = reqHeaders
14896 googleapi.Expand(req.URL, map[string]string{
14897 "profileId": strconv.FormatInt(c.profileId, 10),
14898 })
14899 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14900 }
14901
14902
14903
14904
14905
14906
14907
14908
14909 func (c *AccountUserProfilesInsertCall) Do(opts ...googleapi.CallOption) (*AccountUserProfile, error) {
14910 gensupport.SetOptions(c.urlParams_, opts...)
14911 res, err := c.doRequest("json")
14912 if res != nil && res.StatusCode == http.StatusNotModified {
14913 if res.Body != nil {
14914 res.Body.Close()
14915 }
14916 return nil, &googleapi.Error{
14917 Code: res.StatusCode,
14918 Header: res.Header,
14919 }
14920 }
14921 if err != nil {
14922 return nil, err
14923 }
14924 defer googleapi.CloseBody(res)
14925 if err := googleapi.CheckResponse(res); err != nil {
14926 return nil, err
14927 }
14928 ret := &AccountUserProfile{
14929 ServerResponse: googleapi.ServerResponse{
14930 Header: res.Header,
14931 HTTPStatusCode: res.StatusCode,
14932 },
14933 }
14934 target := &ret
14935 if err := gensupport.DecodeResponse(target, res); err != nil {
14936 return nil, err
14937 }
14938 return ret, nil
14939
14940
14941
14942
14943
14944
14945
14946
14947
14948
14949
14950
14951
14952
14953
14954
14955
14956
14957
14958
14959
14960
14961
14962
14963
14964
14965
14966
14967 }
14968
14969
14970
14971 type AccountUserProfilesListCall struct {
14972 s *Service
14973 profileId int64
14974 urlParams_ gensupport.URLParams
14975 ifNoneMatch_ string
14976 ctx_ context.Context
14977 header_ http.Header
14978 }
14979
14980
14981
14982 func (r *AccountUserProfilesService) List(profileId int64) *AccountUserProfilesListCall {
14983 c := &AccountUserProfilesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14984 c.profileId = profileId
14985 return c
14986 }
14987
14988
14989
14990 func (c *AccountUserProfilesListCall) Active(active bool) *AccountUserProfilesListCall {
14991 c.urlParams_.Set("active", fmt.Sprint(active))
14992 return c
14993 }
14994
14995
14996
14997 func (c *AccountUserProfilesListCall) Ids(ids ...int64) *AccountUserProfilesListCall {
14998 var ids_ []string
14999 for _, v := range ids {
15000 ids_ = append(ids_, fmt.Sprint(v))
15001 }
15002 c.urlParams_.SetMulti("ids", ids_)
15003 return c
15004 }
15005
15006
15007
15008 func (c *AccountUserProfilesListCall) MaxResults(maxResults int64) *AccountUserProfilesListCall {
15009 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
15010 return c
15011 }
15012
15013
15014
15015 func (c *AccountUserProfilesListCall) PageToken(pageToken string) *AccountUserProfilesListCall {
15016 c.urlParams_.Set("pageToken", pageToken)
15017 return c
15018 }
15019
15020
15021
15022
15023
15024
15025
15026
15027
15028
15029 func (c *AccountUserProfilesListCall) SearchString(searchString string) *AccountUserProfilesListCall {
15030 c.urlParams_.Set("searchString", searchString)
15031 return c
15032 }
15033
15034
15035
15036
15037
15038
15039
15040
15041 func (c *AccountUserProfilesListCall) SortField(sortField string) *AccountUserProfilesListCall {
15042 c.urlParams_.Set("sortField", sortField)
15043 return c
15044 }
15045
15046
15047
15048
15049
15050
15051
15052
15053 func (c *AccountUserProfilesListCall) SortOrder(sortOrder string) *AccountUserProfilesListCall {
15054 c.urlParams_.Set("sortOrder", sortOrder)
15055 return c
15056 }
15057
15058
15059
15060 func (c *AccountUserProfilesListCall) SubaccountId(subaccountId int64) *AccountUserProfilesListCall {
15061 c.urlParams_.Set("subaccountId", fmt.Sprint(subaccountId))
15062 return c
15063 }
15064
15065
15066
15067 func (c *AccountUserProfilesListCall) UserRoleId(userRoleId int64) *AccountUserProfilesListCall {
15068 c.urlParams_.Set("userRoleId", fmt.Sprint(userRoleId))
15069 return c
15070 }
15071
15072
15073
15074
15075 func (c *AccountUserProfilesListCall) Fields(s ...googleapi.Field) *AccountUserProfilesListCall {
15076 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15077 return c
15078 }
15079
15080
15081
15082
15083
15084
15085 func (c *AccountUserProfilesListCall) IfNoneMatch(entityTag string) *AccountUserProfilesListCall {
15086 c.ifNoneMatch_ = entityTag
15087 return c
15088 }
15089
15090
15091
15092
15093 func (c *AccountUserProfilesListCall) Context(ctx context.Context) *AccountUserProfilesListCall {
15094 c.ctx_ = ctx
15095 return c
15096 }
15097
15098
15099
15100 func (c *AccountUserProfilesListCall) Header() http.Header {
15101 if c.header_ == nil {
15102 c.header_ = make(http.Header)
15103 }
15104 return c.header_
15105 }
15106
15107 func (c *AccountUserProfilesListCall) doRequest(alt string) (*http.Response, error) {
15108 reqHeaders := make(http.Header)
15109 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
15110 for k, v := range c.header_ {
15111 reqHeaders[k] = v
15112 }
15113 reqHeaders.Set("User-Agent", c.s.userAgent())
15114 if c.ifNoneMatch_ != "" {
15115 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15116 }
15117 var body io.Reader = nil
15118 c.urlParams_.Set("alt", alt)
15119 c.urlParams_.Set("prettyPrint", "false")
15120 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountUserProfiles")
15121 urls += "?" + c.urlParams_.Encode()
15122 req, err := http.NewRequest("GET", urls, body)
15123 if err != nil {
15124 return nil, err
15125 }
15126 req.Header = reqHeaders
15127 googleapi.Expand(req.URL, map[string]string{
15128 "profileId": strconv.FormatInt(c.profileId, 10),
15129 })
15130 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15131 }
15132
15133
15134
15135
15136
15137
15138
15139
15140 func (c *AccountUserProfilesListCall) Do(opts ...googleapi.CallOption) (*AccountUserProfilesListResponse, error) {
15141 gensupport.SetOptions(c.urlParams_, opts...)
15142 res, err := c.doRequest("json")
15143 if res != nil && res.StatusCode == http.StatusNotModified {
15144 if res.Body != nil {
15145 res.Body.Close()
15146 }
15147 return nil, &googleapi.Error{
15148 Code: res.StatusCode,
15149 Header: res.Header,
15150 }
15151 }
15152 if err != nil {
15153 return nil, err
15154 }
15155 defer googleapi.CloseBody(res)
15156 if err := googleapi.CheckResponse(res); err != nil {
15157 return nil, err
15158 }
15159 ret := &AccountUserProfilesListResponse{
15160 ServerResponse: googleapi.ServerResponse{
15161 Header: res.Header,
15162 HTTPStatusCode: res.StatusCode,
15163 },
15164 }
15165 target := &ret
15166 if err := gensupport.DecodeResponse(target, res); err != nil {
15167 return nil, err
15168 }
15169 return ret, nil
15170
15171
15172
15173
15174
15175
15176
15177
15178
15179
15180
15181
15182
15183
15184
15185
15186
15187
15188
15189
15190
15191
15192
15193
15194
15195
15196
15197
15198
15199
15200
15201
15202
15203
15204
15205
15206
15207
15208
15209
15210
15211
15212
15213
15214
15215
15216
15217
15218
15219
15220
15221
15222
15223
15224
15225
15226
15227
15228
15229
15230
15231
15232
15233
15234
15235
15236
15237
15238
15239
15240
15241
15242
15243
15244
15245
15246
15247
15248
15249
15250
15251
15252
15253
15254
15255
15256
15257
15258
15259
15260
15261
15262
15263
15264
15265
15266 }
15267
15268
15269
15270
15271 func (c *AccountUserProfilesListCall) Pages(ctx context.Context, f func(*AccountUserProfilesListResponse) error) error {
15272 c.ctx_ = ctx
15273 defer c.PageToken(c.urlParams_.Get("pageToken"))
15274 for {
15275 x, err := c.Do()
15276 if err != nil {
15277 return err
15278 }
15279 if err := f(x); err != nil {
15280 return err
15281 }
15282 if x.NextPageToken == "" {
15283 return nil
15284 }
15285 c.PageToken(x.NextPageToken)
15286 }
15287 }
15288
15289
15290
15291 type AccountUserProfilesPatchCall struct {
15292 s *Service
15293 profileId int64
15294 accountuserprofile *AccountUserProfile
15295 urlParams_ gensupport.URLParams
15296 ctx_ context.Context
15297 header_ http.Header
15298 }
15299
15300
15301
15302 func (r *AccountUserProfilesService) Patch(profileId int64, id int64, accountuserprofile *AccountUserProfile) *AccountUserProfilesPatchCall {
15303 c := &AccountUserProfilesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15304 c.profileId = profileId
15305 c.urlParams_.Set("id", fmt.Sprint(id))
15306 c.accountuserprofile = accountuserprofile
15307 return c
15308 }
15309
15310
15311
15312
15313 func (c *AccountUserProfilesPatchCall) Fields(s ...googleapi.Field) *AccountUserProfilesPatchCall {
15314 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15315 return c
15316 }
15317
15318
15319
15320
15321 func (c *AccountUserProfilesPatchCall) Context(ctx context.Context) *AccountUserProfilesPatchCall {
15322 c.ctx_ = ctx
15323 return c
15324 }
15325
15326
15327
15328 func (c *AccountUserProfilesPatchCall) Header() http.Header {
15329 if c.header_ == nil {
15330 c.header_ = make(http.Header)
15331 }
15332 return c.header_
15333 }
15334
15335 func (c *AccountUserProfilesPatchCall) doRequest(alt string) (*http.Response, error) {
15336 reqHeaders := make(http.Header)
15337 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
15338 for k, v := range c.header_ {
15339 reqHeaders[k] = v
15340 }
15341 reqHeaders.Set("User-Agent", c.s.userAgent())
15342 var body io.Reader = nil
15343 body, err := googleapi.WithoutDataWrapper.JSONReader(c.accountuserprofile)
15344 if err != nil {
15345 return nil, err
15346 }
15347 reqHeaders.Set("Content-Type", "application/json")
15348 c.urlParams_.Set("alt", alt)
15349 c.urlParams_.Set("prettyPrint", "false")
15350 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountUserProfiles")
15351 urls += "?" + c.urlParams_.Encode()
15352 req, err := http.NewRequest("PATCH", urls, body)
15353 if err != nil {
15354 return nil, err
15355 }
15356 req.Header = reqHeaders
15357 googleapi.Expand(req.URL, map[string]string{
15358 "profileId": strconv.FormatInt(c.profileId, 10),
15359 })
15360 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15361 }
15362
15363
15364
15365
15366
15367
15368
15369
15370 func (c *AccountUserProfilesPatchCall) Do(opts ...googleapi.CallOption) (*AccountUserProfile, error) {
15371 gensupport.SetOptions(c.urlParams_, opts...)
15372 res, err := c.doRequest("json")
15373 if res != nil && res.StatusCode == http.StatusNotModified {
15374 if res.Body != nil {
15375 res.Body.Close()
15376 }
15377 return nil, &googleapi.Error{
15378 Code: res.StatusCode,
15379 Header: res.Header,
15380 }
15381 }
15382 if err != nil {
15383 return nil, err
15384 }
15385 defer googleapi.CloseBody(res)
15386 if err := googleapi.CheckResponse(res); err != nil {
15387 return nil, err
15388 }
15389 ret := &AccountUserProfile{
15390 ServerResponse: googleapi.ServerResponse{
15391 Header: res.Header,
15392 HTTPStatusCode: res.StatusCode,
15393 },
15394 }
15395 target := &ret
15396 if err := gensupport.DecodeResponse(target, res); err != nil {
15397 return nil, err
15398 }
15399 return ret, nil
15400
15401
15402
15403
15404
15405
15406
15407
15408
15409
15410
15411
15412
15413
15414
15415
15416
15417
15418
15419
15420
15421
15422
15423
15424
15425
15426
15427
15428
15429
15430
15431
15432
15433
15434
15435
15436 }
15437
15438
15439
15440 type AccountUserProfilesUpdateCall struct {
15441 s *Service
15442 profileId int64
15443 accountuserprofile *AccountUserProfile
15444 urlParams_ gensupport.URLParams
15445 ctx_ context.Context
15446 header_ http.Header
15447 }
15448
15449
15450 func (r *AccountUserProfilesService) Update(profileId int64, accountuserprofile *AccountUserProfile) *AccountUserProfilesUpdateCall {
15451 c := &AccountUserProfilesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15452 c.profileId = profileId
15453 c.accountuserprofile = accountuserprofile
15454 return c
15455 }
15456
15457
15458
15459
15460 func (c *AccountUserProfilesUpdateCall) Fields(s ...googleapi.Field) *AccountUserProfilesUpdateCall {
15461 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15462 return c
15463 }
15464
15465
15466
15467
15468 func (c *AccountUserProfilesUpdateCall) Context(ctx context.Context) *AccountUserProfilesUpdateCall {
15469 c.ctx_ = ctx
15470 return c
15471 }
15472
15473
15474
15475 func (c *AccountUserProfilesUpdateCall) Header() http.Header {
15476 if c.header_ == nil {
15477 c.header_ = make(http.Header)
15478 }
15479 return c.header_
15480 }
15481
15482 func (c *AccountUserProfilesUpdateCall) doRequest(alt string) (*http.Response, error) {
15483 reqHeaders := make(http.Header)
15484 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
15485 for k, v := range c.header_ {
15486 reqHeaders[k] = v
15487 }
15488 reqHeaders.Set("User-Agent", c.s.userAgent())
15489 var body io.Reader = nil
15490 body, err := googleapi.WithoutDataWrapper.JSONReader(c.accountuserprofile)
15491 if err != nil {
15492 return nil, err
15493 }
15494 reqHeaders.Set("Content-Type", "application/json")
15495 c.urlParams_.Set("alt", alt)
15496 c.urlParams_.Set("prettyPrint", "false")
15497 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accountUserProfiles")
15498 urls += "?" + c.urlParams_.Encode()
15499 req, err := http.NewRequest("PUT", urls, body)
15500 if err != nil {
15501 return nil, err
15502 }
15503 req.Header = reqHeaders
15504 googleapi.Expand(req.URL, map[string]string{
15505 "profileId": strconv.FormatInt(c.profileId, 10),
15506 })
15507 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15508 }
15509
15510
15511
15512
15513
15514
15515
15516
15517 func (c *AccountUserProfilesUpdateCall) Do(opts ...googleapi.CallOption) (*AccountUserProfile, error) {
15518 gensupport.SetOptions(c.urlParams_, opts...)
15519 res, err := c.doRequest("json")
15520 if res != nil && res.StatusCode == http.StatusNotModified {
15521 if res.Body != nil {
15522 res.Body.Close()
15523 }
15524 return nil, &googleapi.Error{
15525 Code: res.StatusCode,
15526 Header: res.Header,
15527 }
15528 }
15529 if err != nil {
15530 return nil, err
15531 }
15532 defer googleapi.CloseBody(res)
15533 if err := googleapi.CheckResponse(res); err != nil {
15534 return nil, err
15535 }
15536 ret := &AccountUserProfile{
15537 ServerResponse: googleapi.ServerResponse{
15538 Header: res.Header,
15539 HTTPStatusCode: res.StatusCode,
15540 },
15541 }
15542 target := &ret
15543 if err := gensupport.DecodeResponse(target, res); err != nil {
15544 return nil, err
15545 }
15546 return ret, nil
15547
15548
15549
15550
15551
15552
15553
15554
15555
15556
15557
15558
15559
15560
15561
15562
15563
15564
15565
15566
15567
15568
15569
15570
15571
15572
15573
15574
15575 }
15576
15577
15578
15579 type AccountsGetCall struct {
15580 s *Service
15581 profileId int64
15582 id int64
15583 urlParams_ gensupport.URLParams
15584 ifNoneMatch_ string
15585 ctx_ context.Context
15586 header_ http.Header
15587 }
15588
15589
15590 func (r *AccountsService) Get(profileId int64, id int64) *AccountsGetCall {
15591 c := &AccountsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15592 c.profileId = profileId
15593 c.id = id
15594 return c
15595 }
15596
15597
15598
15599
15600 func (c *AccountsGetCall) Fields(s ...googleapi.Field) *AccountsGetCall {
15601 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15602 return c
15603 }
15604
15605
15606
15607
15608
15609
15610 func (c *AccountsGetCall) IfNoneMatch(entityTag string) *AccountsGetCall {
15611 c.ifNoneMatch_ = entityTag
15612 return c
15613 }
15614
15615
15616
15617
15618 func (c *AccountsGetCall) Context(ctx context.Context) *AccountsGetCall {
15619 c.ctx_ = ctx
15620 return c
15621 }
15622
15623
15624
15625 func (c *AccountsGetCall) Header() http.Header {
15626 if c.header_ == nil {
15627 c.header_ = make(http.Header)
15628 }
15629 return c.header_
15630 }
15631
15632 func (c *AccountsGetCall) doRequest(alt string) (*http.Response, error) {
15633 reqHeaders := make(http.Header)
15634 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
15635 for k, v := range c.header_ {
15636 reqHeaders[k] = v
15637 }
15638 reqHeaders.Set("User-Agent", c.s.userAgent())
15639 if c.ifNoneMatch_ != "" {
15640 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15641 }
15642 var body io.Reader = nil
15643 c.urlParams_.Set("alt", alt)
15644 c.urlParams_.Set("prettyPrint", "false")
15645 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accounts/{id}")
15646 urls += "?" + c.urlParams_.Encode()
15647 req, err := http.NewRequest("GET", urls, body)
15648 if err != nil {
15649 return nil, err
15650 }
15651 req.Header = reqHeaders
15652 googleapi.Expand(req.URL, map[string]string{
15653 "profileId": strconv.FormatInt(c.profileId, 10),
15654 "id": strconv.FormatInt(c.id, 10),
15655 })
15656 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15657 }
15658
15659
15660
15661
15662
15663
15664
15665
15666 func (c *AccountsGetCall) Do(opts ...googleapi.CallOption) (*Account, error) {
15667 gensupport.SetOptions(c.urlParams_, opts...)
15668 res, err := c.doRequest("json")
15669 if res != nil && res.StatusCode == http.StatusNotModified {
15670 if res.Body != nil {
15671 res.Body.Close()
15672 }
15673 return nil, &googleapi.Error{
15674 Code: res.StatusCode,
15675 Header: res.Header,
15676 }
15677 }
15678 if err != nil {
15679 return nil, err
15680 }
15681 defer googleapi.CloseBody(res)
15682 if err := googleapi.CheckResponse(res); err != nil {
15683 return nil, err
15684 }
15685 ret := &Account{
15686 ServerResponse: googleapi.ServerResponse{
15687 Header: res.Header,
15688 HTTPStatusCode: res.StatusCode,
15689 },
15690 }
15691 target := &ret
15692 if err := gensupport.DecodeResponse(target, res); err != nil {
15693 return nil, err
15694 }
15695 return ret, nil
15696
15697
15698
15699
15700
15701
15702
15703
15704
15705
15706
15707
15708
15709
15710
15711
15712
15713
15714
15715
15716
15717
15718
15719
15720
15721
15722
15723
15724
15725
15726
15727
15728
15729 }
15730
15731
15732
15733 type AccountsListCall struct {
15734 s *Service
15735 profileId int64
15736 urlParams_ gensupport.URLParams
15737 ifNoneMatch_ string
15738 ctx_ context.Context
15739 header_ http.Header
15740 }
15741
15742
15743
15744 func (r *AccountsService) List(profileId int64) *AccountsListCall {
15745 c := &AccountsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15746 c.profileId = profileId
15747 return c
15748 }
15749
15750
15751
15752
15753 func (c *AccountsListCall) Active(active bool) *AccountsListCall {
15754 c.urlParams_.Set("active", fmt.Sprint(active))
15755 return c
15756 }
15757
15758
15759
15760 func (c *AccountsListCall) Ids(ids ...int64) *AccountsListCall {
15761 var ids_ []string
15762 for _, v := range ids {
15763 ids_ = append(ids_, fmt.Sprint(v))
15764 }
15765 c.urlParams_.SetMulti("ids", ids_)
15766 return c
15767 }
15768
15769
15770
15771 func (c *AccountsListCall) MaxResults(maxResults int64) *AccountsListCall {
15772 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
15773 return c
15774 }
15775
15776
15777
15778 func (c *AccountsListCall) PageToken(pageToken string) *AccountsListCall {
15779 c.urlParams_.Set("pageToken", pageToken)
15780 return c
15781 }
15782
15783
15784
15785
15786
15787
15788
15789
15790
15791 func (c *AccountsListCall) SearchString(searchString string) *AccountsListCall {
15792 c.urlParams_.Set("searchString", searchString)
15793 return c
15794 }
15795
15796
15797
15798
15799
15800
15801
15802
15803 func (c *AccountsListCall) SortField(sortField string) *AccountsListCall {
15804 c.urlParams_.Set("sortField", sortField)
15805 return c
15806 }
15807
15808
15809
15810
15811
15812
15813
15814
15815 func (c *AccountsListCall) SortOrder(sortOrder string) *AccountsListCall {
15816 c.urlParams_.Set("sortOrder", sortOrder)
15817 return c
15818 }
15819
15820
15821
15822
15823 func (c *AccountsListCall) Fields(s ...googleapi.Field) *AccountsListCall {
15824 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15825 return c
15826 }
15827
15828
15829
15830
15831
15832
15833 func (c *AccountsListCall) IfNoneMatch(entityTag string) *AccountsListCall {
15834 c.ifNoneMatch_ = entityTag
15835 return c
15836 }
15837
15838
15839
15840
15841 func (c *AccountsListCall) Context(ctx context.Context) *AccountsListCall {
15842 c.ctx_ = ctx
15843 return c
15844 }
15845
15846
15847
15848 func (c *AccountsListCall) Header() http.Header {
15849 if c.header_ == nil {
15850 c.header_ = make(http.Header)
15851 }
15852 return c.header_
15853 }
15854
15855 func (c *AccountsListCall) doRequest(alt string) (*http.Response, error) {
15856 reqHeaders := make(http.Header)
15857 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
15858 for k, v := range c.header_ {
15859 reqHeaders[k] = v
15860 }
15861 reqHeaders.Set("User-Agent", c.s.userAgent())
15862 if c.ifNoneMatch_ != "" {
15863 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15864 }
15865 var body io.Reader = nil
15866 c.urlParams_.Set("alt", alt)
15867 c.urlParams_.Set("prettyPrint", "false")
15868 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accounts")
15869 urls += "?" + c.urlParams_.Encode()
15870 req, err := http.NewRequest("GET", urls, body)
15871 if err != nil {
15872 return nil, err
15873 }
15874 req.Header = reqHeaders
15875 googleapi.Expand(req.URL, map[string]string{
15876 "profileId": strconv.FormatInt(c.profileId, 10),
15877 })
15878 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15879 }
15880
15881
15882
15883
15884
15885
15886
15887
15888 func (c *AccountsListCall) Do(opts ...googleapi.CallOption) (*AccountsListResponse, error) {
15889 gensupport.SetOptions(c.urlParams_, opts...)
15890 res, err := c.doRequest("json")
15891 if res != nil && res.StatusCode == http.StatusNotModified {
15892 if res.Body != nil {
15893 res.Body.Close()
15894 }
15895 return nil, &googleapi.Error{
15896 Code: res.StatusCode,
15897 Header: res.Header,
15898 }
15899 }
15900 if err != nil {
15901 return nil, err
15902 }
15903 defer googleapi.CloseBody(res)
15904 if err := googleapi.CheckResponse(res); err != nil {
15905 return nil, err
15906 }
15907 ret := &AccountsListResponse{
15908 ServerResponse: googleapi.ServerResponse{
15909 Header: res.Header,
15910 HTTPStatusCode: res.StatusCode,
15911 },
15912 }
15913 target := &ret
15914 if err := gensupport.DecodeResponse(target, res); err != nil {
15915 return nil, err
15916 }
15917 return ret, nil
15918
15919
15920
15921
15922
15923
15924
15925
15926
15927
15928
15929
15930
15931
15932
15933
15934
15935
15936
15937
15938
15939
15940
15941
15942
15943
15944
15945
15946
15947
15948
15949
15950
15951
15952
15953
15954
15955
15956
15957
15958
15959
15960
15961
15962
15963
15964
15965
15966
15967
15968
15969
15970
15971
15972
15973
15974
15975
15976
15977
15978
15979
15980
15981
15982
15983
15984
15985
15986
15987
15988
15989
15990
15991
15992
15993
15994
15995
15996
15997
15998
15999
16000
16001
16002 }
16003
16004
16005
16006
16007 func (c *AccountsListCall) Pages(ctx context.Context, f func(*AccountsListResponse) error) error {
16008 c.ctx_ = ctx
16009 defer c.PageToken(c.urlParams_.Get("pageToken"))
16010 for {
16011 x, err := c.Do()
16012 if err != nil {
16013 return err
16014 }
16015 if err := f(x); err != nil {
16016 return err
16017 }
16018 if x.NextPageToken == "" {
16019 return nil
16020 }
16021 c.PageToken(x.NextPageToken)
16022 }
16023 }
16024
16025
16026
16027 type AccountsPatchCall struct {
16028 s *Service
16029 profileId int64
16030 account *Account
16031 urlParams_ gensupport.URLParams
16032 ctx_ context.Context
16033 header_ http.Header
16034 }
16035
16036
16037
16038 func (r *AccountsService) Patch(profileId int64, id int64, account *Account) *AccountsPatchCall {
16039 c := &AccountsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16040 c.profileId = profileId
16041 c.urlParams_.Set("id", fmt.Sprint(id))
16042 c.account = account
16043 return c
16044 }
16045
16046
16047
16048
16049 func (c *AccountsPatchCall) Fields(s ...googleapi.Field) *AccountsPatchCall {
16050 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16051 return c
16052 }
16053
16054
16055
16056
16057 func (c *AccountsPatchCall) Context(ctx context.Context) *AccountsPatchCall {
16058 c.ctx_ = ctx
16059 return c
16060 }
16061
16062
16063
16064 func (c *AccountsPatchCall) Header() http.Header {
16065 if c.header_ == nil {
16066 c.header_ = make(http.Header)
16067 }
16068 return c.header_
16069 }
16070
16071 func (c *AccountsPatchCall) doRequest(alt string) (*http.Response, error) {
16072 reqHeaders := make(http.Header)
16073 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
16074 for k, v := range c.header_ {
16075 reqHeaders[k] = v
16076 }
16077 reqHeaders.Set("User-Agent", c.s.userAgent())
16078 var body io.Reader = nil
16079 body, err := googleapi.WithoutDataWrapper.JSONReader(c.account)
16080 if err != nil {
16081 return nil, err
16082 }
16083 reqHeaders.Set("Content-Type", "application/json")
16084 c.urlParams_.Set("alt", alt)
16085 c.urlParams_.Set("prettyPrint", "false")
16086 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accounts")
16087 urls += "?" + c.urlParams_.Encode()
16088 req, err := http.NewRequest("PATCH", urls, body)
16089 if err != nil {
16090 return nil, err
16091 }
16092 req.Header = reqHeaders
16093 googleapi.Expand(req.URL, map[string]string{
16094 "profileId": strconv.FormatInt(c.profileId, 10),
16095 })
16096 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16097 }
16098
16099
16100
16101
16102
16103
16104
16105
16106 func (c *AccountsPatchCall) Do(opts ...googleapi.CallOption) (*Account, error) {
16107 gensupport.SetOptions(c.urlParams_, opts...)
16108 res, err := c.doRequest("json")
16109 if res != nil && res.StatusCode == http.StatusNotModified {
16110 if res.Body != nil {
16111 res.Body.Close()
16112 }
16113 return nil, &googleapi.Error{
16114 Code: res.StatusCode,
16115 Header: res.Header,
16116 }
16117 }
16118 if err != nil {
16119 return nil, err
16120 }
16121 defer googleapi.CloseBody(res)
16122 if err := googleapi.CheckResponse(res); err != nil {
16123 return nil, err
16124 }
16125 ret := &Account{
16126 ServerResponse: googleapi.ServerResponse{
16127 Header: res.Header,
16128 HTTPStatusCode: res.StatusCode,
16129 },
16130 }
16131 target := &ret
16132 if err := gensupport.DecodeResponse(target, res); err != nil {
16133 return nil, err
16134 }
16135 return ret, nil
16136
16137
16138
16139
16140
16141
16142
16143
16144
16145
16146
16147
16148
16149
16150
16151
16152
16153
16154
16155
16156
16157
16158
16159
16160
16161
16162
16163
16164
16165
16166
16167
16168
16169
16170
16171
16172 }
16173
16174
16175
16176 type AccountsUpdateCall struct {
16177 s *Service
16178 profileId int64
16179 account *Account
16180 urlParams_ gensupport.URLParams
16181 ctx_ context.Context
16182 header_ http.Header
16183 }
16184
16185
16186 func (r *AccountsService) Update(profileId int64, account *Account) *AccountsUpdateCall {
16187 c := &AccountsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16188 c.profileId = profileId
16189 c.account = account
16190 return c
16191 }
16192
16193
16194
16195
16196 func (c *AccountsUpdateCall) Fields(s ...googleapi.Field) *AccountsUpdateCall {
16197 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16198 return c
16199 }
16200
16201
16202
16203
16204 func (c *AccountsUpdateCall) Context(ctx context.Context) *AccountsUpdateCall {
16205 c.ctx_ = ctx
16206 return c
16207 }
16208
16209
16210
16211 func (c *AccountsUpdateCall) Header() http.Header {
16212 if c.header_ == nil {
16213 c.header_ = make(http.Header)
16214 }
16215 return c.header_
16216 }
16217
16218 func (c *AccountsUpdateCall) doRequest(alt string) (*http.Response, error) {
16219 reqHeaders := make(http.Header)
16220 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
16221 for k, v := range c.header_ {
16222 reqHeaders[k] = v
16223 }
16224 reqHeaders.Set("User-Agent", c.s.userAgent())
16225 var body io.Reader = nil
16226 body, err := googleapi.WithoutDataWrapper.JSONReader(c.account)
16227 if err != nil {
16228 return nil, err
16229 }
16230 reqHeaders.Set("Content-Type", "application/json")
16231 c.urlParams_.Set("alt", alt)
16232 c.urlParams_.Set("prettyPrint", "false")
16233 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/accounts")
16234 urls += "?" + c.urlParams_.Encode()
16235 req, err := http.NewRequest("PUT", urls, body)
16236 if err != nil {
16237 return nil, err
16238 }
16239 req.Header = reqHeaders
16240 googleapi.Expand(req.URL, map[string]string{
16241 "profileId": strconv.FormatInt(c.profileId, 10),
16242 })
16243 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16244 }
16245
16246
16247
16248
16249
16250
16251
16252
16253 func (c *AccountsUpdateCall) Do(opts ...googleapi.CallOption) (*Account, error) {
16254 gensupport.SetOptions(c.urlParams_, opts...)
16255 res, err := c.doRequest("json")
16256 if res != nil && res.StatusCode == http.StatusNotModified {
16257 if res.Body != nil {
16258 res.Body.Close()
16259 }
16260 return nil, &googleapi.Error{
16261 Code: res.StatusCode,
16262 Header: res.Header,
16263 }
16264 }
16265 if err != nil {
16266 return nil, err
16267 }
16268 defer googleapi.CloseBody(res)
16269 if err := googleapi.CheckResponse(res); err != nil {
16270 return nil, err
16271 }
16272 ret := &Account{
16273 ServerResponse: googleapi.ServerResponse{
16274 Header: res.Header,
16275 HTTPStatusCode: res.StatusCode,
16276 },
16277 }
16278 target := &ret
16279 if err := gensupport.DecodeResponse(target, res); err != nil {
16280 return nil, err
16281 }
16282 return ret, nil
16283
16284
16285
16286
16287
16288
16289
16290
16291
16292
16293
16294
16295
16296
16297
16298
16299
16300
16301
16302
16303
16304
16305
16306
16307
16308
16309
16310
16311 }
16312
16313
16314
16315 type AdsGetCall struct {
16316 s *Service
16317 profileId int64
16318 id int64
16319 urlParams_ gensupport.URLParams
16320 ifNoneMatch_ string
16321 ctx_ context.Context
16322 header_ http.Header
16323 }
16324
16325
16326 func (r *AdsService) Get(profileId int64, id int64) *AdsGetCall {
16327 c := &AdsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16328 c.profileId = profileId
16329 c.id = id
16330 return c
16331 }
16332
16333
16334
16335
16336 func (c *AdsGetCall) Fields(s ...googleapi.Field) *AdsGetCall {
16337 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16338 return c
16339 }
16340
16341
16342
16343
16344
16345
16346 func (c *AdsGetCall) IfNoneMatch(entityTag string) *AdsGetCall {
16347 c.ifNoneMatch_ = entityTag
16348 return c
16349 }
16350
16351
16352
16353
16354 func (c *AdsGetCall) Context(ctx context.Context) *AdsGetCall {
16355 c.ctx_ = ctx
16356 return c
16357 }
16358
16359
16360
16361 func (c *AdsGetCall) Header() http.Header {
16362 if c.header_ == nil {
16363 c.header_ = make(http.Header)
16364 }
16365 return c.header_
16366 }
16367
16368 func (c *AdsGetCall) doRequest(alt string) (*http.Response, error) {
16369 reqHeaders := make(http.Header)
16370 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
16371 for k, v := range c.header_ {
16372 reqHeaders[k] = v
16373 }
16374 reqHeaders.Set("User-Agent", c.s.userAgent())
16375 if c.ifNoneMatch_ != "" {
16376 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16377 }
16378 var body io.Reader = nil
16379 c.urlParams_.Set("alt", alt)
16380 c.urlParams_.Set("prettyPrint", "false")
16381 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/ads/{id}")
16382 urls += "?" + c.urlParams_.Encode()
16383 req, err := http.NewRequest("GET", urls, body)
16384 if err != nil {
16385 return nil, err
16386 }
16387 req.Header = reqHeaders
16388 googleapi.Expand(req.URL, map[string]string{
16389 "profileId": strconv.FormatInt(c.profileId, 10),
16390 "id": strconv.FormatInt(c.id, 10),
16391 })
16392 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16393 }
16394
16395
16396
16397
16398
16399
16400
16401
16402 func (c *AdsGetCall) Do(opts ...googleapi.CallOption) (*Ad, error) {
16403 gensupport.SetOptions(c.urlParams_, opts...)
16404 res, err := c.doRequest("json")
16405 if res != nil && res.StatusCode == http.StatusNotModified {
16406 if res.Body != nil {
16407 res.Body.Close()
16408 }
16409 return nil, &googleapi.Error{
16410 Code: res.StatusCode,
16411 Header: res.Header,
16412 }
16413 }
16414 if err != nil {
16415 return nil, err
16416 }
16417 defer googleapi.CloseBody(res)
16418 if err := googleapi.CheckResponse(res); err != nil {
16419 return nil, err
16420 }
16421 ret := &Ad{
16422 ServerResponse: googleapi.ServerResponse{
16423 Header: res.Header,
16424 HTTPStatusCode: res.StatusCode,
16425 },
16426 }
16427 target := &ret
16428 if err := gensupport.DecodeResponse(target, res); err != nil {
16429 return nil, err
16430 }
16431 return ret, nil
16432
16433
16434
16435
16436
16437
16438
16439
16440
16441
16442
16443
16444
16445
16446
16447
16448
16449
16450
16451
16452
16453
16454
16455
16456
16457
16458
16459
16460
16461
16462
16463
16464
16465 }
16466
16467
16468
16469 type AdsInsertCall struct {
16470 s *Service
16471 profileId int64
16472 ad *Ad
16473 urlParams_ gensupport.URLParams
16474 ctx_ context.Context
16475 header_ http.Header
16476 }
16477
16478
16479 func (r *AdsService) Insert(profileId int64, ad *Ad) *AdsInsertCall {
16480 c := &AdsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16481 c.profileId = profileId
16482 c.ad = ad
16483 return c
16484 }
16485
16486
16487
16488
16489 func (c *AdsInsertCall) Fields(s ...googleapi.Field) *AdsInsertCall {
16490 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16491 return c
16492 }
16493
16494
16495
16496
16497 func (c *AdsInsertCall) Context(ctx context.Context) *AdsInsertCall {
16498 c.ctx_ = ctx
16499 return c
16500 }
16501
16502
16503
16504 func (c *AdsInsertCall) Header() http.Header {
16505 if c.header_ == nil {
16506 c.header_ = make(http.Header)
16507 }
16508 return c.header_
16509 }
16510
16511 func (c *AdsInsertCall) doRequest(alt string) (*http.Response, error) {
16512 reqHeaders := make(http.Header)
16513 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
16514 for k, v := range c.header_ {
16515 reqHeaders[k] = v
16516 }
16517 reqHeaders.Set("User-Agent", c.s.userAgent())
16518 var body io.Reader = nil
16519 body, err := googleapi.WithoutDataWrapper.JSONReader(c.ad)
16520 if err != nil {
16521 return nil, err
16522 }
16523 reqHeaders.Set("Content-Type", "application/json")
16524 c.urlParams_.Set("alt", alt)
16525 c.urlParams_.Set("prettyPrint", "false")
16526 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/ads")
16527 urls += "?" + c.urlParams_.Encode()
16528 req, err := http.NewRequest("POST", urls, body)
16529 if err != nil {
16530 return nil, err
16531 }
16532 req.Header = reqHeaders
16533 googleapi.Expand(req.URL, map[string]string{
16534 "profileId": strconv.FormatInt(c.profileId, 10),
16535 })
16536 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16537 }
16538
16539
16540
16541
16542
16543
16544
16545
16546 func (c *AdsInsertCall) Do(opts ...googleapi.CallOption) (*Ad, error) {
16547 gensupport.SetOptions(c.urlParams_, opts...)
16548 res, err := c.doRequest("json")
16549 if res != nil && res.StatusCode == http.StatusNotModified {
16550 if res.Body != nil {
16551 res.Body.Close()
16552 }
16553 return nil, &googleapi.Error{
16554 Code: res.StatusCode,
16555 Header: res.Header,
16556 }
16557 }
16558 if err != nil {
16559 return nil, err
16560 }
16561 defer googleapi.CloseBody(res)
16562 if err := googleapi.CheckResponse(res); err != nil {
16563 return nil, err
16564 }
16565 ret := &Ad{
16566 ServerResponse: googleapi.ServerResponse{
16567 Header: res.Header,
16568 HTTPStatusCode: res.StatusCode,
16569 },
16570 }
16571 target := &ret
16572 if err := gensupport.DecodeResponse(target, res); err != nil {
16573 return nil, err
16574 }
16575 return ret, nil
16576
16577
16578
16579
16580
16581
16582
16583
16584
16585
16586
16587
16588
16589
16590
16591
16592
16593
16594
16595
16596
16597
16598
16599
16600
16601
16602
16603
16604 }
16605
16606
16607
16608 type AdsListCall struct {
16609 s *Service
16610 profileId int64
16611 urlParams_ gensupport.URLParams
16612 ifNoneMatch_ string
16613 ctx_ context.Context
16614 header_ http.Header
16615 }
16616
16617
16618
16619 func (r *AdsService) List(profileId int64) *AdsListCall {
16620 c := &AdsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16621 c.profileId = profileId
16622 return c
16623 }
16624
16625
16626 func (c *AdsListCall) Active(active bool) *AdsListCall {
16627 c.urlParams_.Set("active", fmt.Sprint(active))
16628 return c
16629 }
16630
16631
16632
16633 func (c *AdsListCall) AdvertiserId(advertiserId int64) *AdsListCall {
16634 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
16635 return c
16636 }
16637
16638
16639
16640 func (c *AdsListCall) Archived(archived bool) *AdsListCall {
16641 c.urlParams_.Set("archived", fmt.Sprint(archived))
16642 return c
16643 }
16644
16645
16646
16647 func (c *AdsListCall) AudienceSegmentIds(audienceSegmentIds ...int64) *AdsListCall {
16648 var audienceSegmentIds_ []string
16649 for _, v := range audienceSegmentIds {
16650 audienceSegmentIds_ = append(audienceSegmentIds_, fmt.Sprint(v))
16651 }
16652 c.urlParams_.SetMulti("audienceSegmentIds", audienceSegmentIds_)
16653 return c
16654 }
16655
16656
16657
16658 func (c *AdsListCall) CampaignIds(campaignIds ...int64) *AdsListCall {
16659 var campaignIds_ []string
16660 for _, v := range campaignIds {
16661 campaignIds_ = append(campaignIds_, fmt.Sprint(v))
16662 }
16663 c.urlParams_.SetMulti("campaignIds", campaignIds_)
16664 return c
16665 }
16666
16667
16668
16669
16670
16671
16672
16673
16674
16675
16676
16677
16678
16679
16680
16681
16682
16683 func (c *AdsListCall) Compatibility(compatibility string) *AdsListCall {
16684 c.urlParams_.Set("compatibility", compatibility)
16685 return c
16686 }
16687
16688
16689
16690 func (c *AdsListCall) CreativeIds(creativeIds ...int64) *AdsListCall {
16691 var creativeIds_ []string
16692 for _, v := range creativeIds {
16693 creativeIds_ = append(creativeIds_, fmt.Sprint(v))
16694 }
16695 c.urlParams_.SetMulti("creativeIds", creativeIds_)
16696 return c
16697 }
16698
16699
16700
16701
16702 func (c *AdsListCall) CreativeOptimizationConfigurationIds(creativeOptimizationConfigurationIds ...int64) *AdsListCall {
16703 var creativeOptimizationConfigurationIds_ []string
16704 for _, v := range creativeOptimizationConfigurationIds {
16705 creativeOptimizationConfigurationIds_ = append(creativeOptimizationConfigurationIds_, fmt.Sprint(v))
16706 }
16707 c.urlParams_.SetMulti("creativeOptimizationConfigurationIds", creativeOptimizationConfigurationIds_)
16708 return c
16709 }
16710
16711
16712
16713
16714
16715
16716 func (c *AdsListCall) DynamicClickTracker(dynamicClickTracker bool) *AdsListCall {
16717 c.urlParams_.Set("dynamicClickTracker", fmt.Sprint(dynamicClickTracker))
16718 return c
16719 }
16720
16721
16722
16723 func (c *AdsListCall) Ids(ids ...int64) *AdsListCall {
16724 var ids_ []string
16725 for _, v := range ids {
16726 ids_ = append(ids_, fmt.Sprint(v))
16727 }
16728 c.urlParams_.SetMulti("ids", ids_)
16729 return c
16730 }
16731
16732
16733
16734 func (c *AdsListCall) LandingPageIds(landingPageIds ...int64) *AdsListCall {
16735 var landingPageIds_ []string
16736 for _, v := range landingPageIds {
16737 landingPageIds_ = append(landingPageIds_, fmt.Sprint(v))
16738 }
16739 c.urlParams_.SetMulti("landingPageIds", landingPageIds_)
16740 return c
16741 }
16742
16743
16744
16745 func (c *AdsListCall) MaxResults(maxResults int64) *AdsListCall {
16746 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
16747 return c
16748 }
16749
16750
16751
16752
16753 func (c *AdsListCall) OverriddenEventTagId(overriddenEventTagId int64) *AdsListCall {
16754 c.urlParams_.Set("overriddenEventTagId", fmt.Sprint(overriddenEventTagId))
16755 return c
16756 }
16757
16758
16759
16760 func (c *AdsListCall) PageToken(pageToken string) *AdsListCall {
16761 c.urlParams_.Set("pageToken", pageToken)
16762 return c
16763 }
16764
16765
16766
16767 func (c *AdsListCall) PlacementIds(placementIds ...int64) *AdsListCall {
16768 var placementIds_ []string
16769 for _, v := range placementIds {
16770 placementIds_ = append(placementIds_, fmt.Sprint(v))
16771 }
16772 c.urlParams_.SetMulti("placementIds", placementIds_)
16773 return c
16774 }
16775
16776
16777
16778
16779 func (c *AdsListCall) RemarketingListIds(remarketingListIds ...int64) *AdsListCall {
16780 var remarketingListIds_ []string
16781 for _, v := range remarketingListIds {
16782 remarketingListIds_ = append(remarketingListIds_, fmt.Sprint(v))
16783 }
16784 c.urlParams_.SetMulti("remarketingListIds", remarketingListIds_)
16785 return c
16786 }
16787
16788
16789
16790
16791
16792
16793
16794
16795 func (c *AdsListCall) SearchString(searchString string) *AdsListCall {
16796 c.urlParams_.Set("searchString", searchString)
16797 return c
16798 }
16799
16800
16801
16802 func (c *AdsListCall) SizeIds(sizeIds ...int64) *AdsListCall {
16803 var sizeIds_ []string
16804 for _, v := range sizeIds {
16805 sizeIds_ = append(sizeIds_, fmt.Sprint(v))
16806 }
16807 c.urlParams_.SetMulti("sizeIds", sizeIds_)
16808 return c
16809 }
16810
16811
16812
16813
16814
16815
16816
16817
16818 func (c *AdsListCall) SortField(sortField string) *AdsListCall {
16819 c.urlParams_.Set("sortField", sortField)
16820 return c
16821 }
16822
16823
16824
16825
16826
16827
16828
16829
16830 func (c *AdsListCall) SortOrder(sortOrder string) *AdsListCall {
16831 c.urlParams_.Set("sortOrder", sortOrder)
16832 return c
16833 }
16834
16835
16836
16837 func (c *AdsListCall) SslCompliant(sslCompliant bool) *AdsListCall {
16838 c.urlParams_.Set("sslCompliant", fmt.Sprint(sslCompliant))
16839 return c
16840 }
16841
16842
16843
16844 func (c *AdsListCall) SslRequired(sslRequired bool) *AdsListCall {
16845 c.urlParams_.Set("sslRequired", fmt.Sprint(sslRequired))
16846 return c
16847 }
16848
16849
16850
16851
16852
16853
16854
16855
16856
16857
16858 func (c *AdsListCall) Type(type_ ...string) *AdsListCall {
16859 c.urlParams_.SetMulti("type", append([]string{}, type_...))
16860 return c
16861 }
16862
16863
16864
16865
16866 func (c *AdsListCall) Fields(s ...googleapi.Field) *AdsListCall {
16867 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16868 return c
16869 }
16870
16871
16872
16873
16874
16875
16876 func (c *AdsListCall) IfNoneMatch(entityTag string) *AdsListCall {
16877 c.ifNoneMatch_ = entityTag
16878 return c
16879 }
16880
16881
16882
16883
16884 func (c *AdsListCall) Context(ctx context.Context) *AdsListCall {
16885 c.ctx_ = ctx
16886 return c
16887 }
16888
16889
16890
16891 func (c *AdsListCall) Header() http.Header {
16892 if c.header_ == nil {
16893 c.header_ = make(http.Header)
16894 }
16895 return c.header_
16896 }
16897
16898 func (c *AdsListCall) doRequest(alt string) (*http.Response, error) {
16899 reqHeaders := make(http.Header)
16900 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
16901 for k, v := range c.header_ {
16902 reqHeaders[k] = v
16903 }
16904 reqHeaders.Set("User-Agent", c.s.userAgent())
16905 if c.ifNoneMatch_ != "" {
16906 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16907 }
16908 var body io.Reader = nil
16909 c.urlParams_.Set("alt", alt)
16910 c.urlParams_.Set("prettyPrint", "false")
16911 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/ads")
16912 urls += "?" + c.urlParams_.Encode()
16913 req, err := http.NewRequest("GET", urls, body)
16914 if err != nil {
16915 return nil, err
16916 }
16917 req.Header = reqHeaders
16918 googleapi.Expand(req.URL, map[string]string{
16919 "profileId": strconv.FormatInt(c.profileId, 10),
16920 })
16921 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16922 }
16923
16924
16925
16926
16927
16928
16929
16930
16931 func (c *AdsListCall) Do(opts ...googleapi.CallOption) (*AdsListResponse, error) {
16932 gensupport.SetOptions(c.urlParams_, opts...)
16933 res, err := c.doRequest("json")
16934 if res != nil && res.StatusCode == http.StatusNotModified {
16935 if res.Body != nil {
16936 res.Body.Close()
16937 }
16938 return nil, &googleapi.Error{
16939 Code: res.StatusCode,
16940 Header: res.Header,
16941 }
16942 }
16943 if err != nil {
16944 return nil, err
16945 }
16946 defer googleapi.CloseBody(res)
16947 if err := googleapi.CheckResponse(res); err != nil {
16948 return nil, err
16949 }
16950 ret := &AdsListResponse{
16951 ServerResponse: googleapi.ServerResponse{
16952 Header: res.Header,
16953 HTTPStatusCode: res.StatusCode,
16954 },
16955 }
16956 target := &ret
16957 if err := gensupport.DecodeResponse(target, res); err != nil {
16958 return nil, err
16959 }
16960 return ret, nil
16961
16962
16963
16964
16965
16966
16967
16968
16969
16970
16971
16972
16973
16974
16975
16976
16977
16978
16979
16980
16981
16982
16983
16984
16985
16986
16987
16988
16989
16990
16991
16992
16993
16994
16995
16996
16997
16998
16999
17000
17001
17002
17003
17004
17005
17006
17007
17008
17009
17010
17011
17012
17013
17014
17015
17016
17017
17018
17019
17020
17021
17022
17023
17024
17025
17026
17027
17028
17029
17030
17031
17032
17033
17034
17035
17036
17037
17038
17039
17040
17041
17042
17043
17044
17045
17046
17047
17048
17049
17050
17051
17052
17053
17054
17055
17056
17057
17058
17059
17060
17061
17062
17063
17064
17065
17066
17067
17068
17069
17070
17071
17072
17073
17074
17075
17076
17077
17078
17079
17080
17081
17082
17083
17084
17085
17086
17087
17088
17089
17090
17091
17092
17093
17094
17095
17096
17097
17098
17099
17100
17101
17102
17103
17104
17105
17106
17107
17108
17109
17110
17111
17112
17113
17114
17115
17116
17117
17118
17119
17120
17121
17122
17123
17124
17125
17126
17127
17128
17129
17130
17131
17132
17133
17134
17135
17136
17137
17138
17139
17140
17141
17142
17143
17144
17145
17146
17147
17148
17149
17150
17151
17152
17153
17154
17155
17156
17157
17158
17159
17160
17161
17162
17163
17164
17165
17166
17167
17168
17169
17170
17171
17172 }
17173
17174
17175
17176
17177 func (c *AdsListCall) Pages(ctx context.Context, f func(*AdsListResponse) error) error {
17178 c.ctx_ = ctx
17179 defer c.PageToken(c.urlParams_.Get("pageToken"))
17180 for {
17181 x, err := c.Do()
17182 if err != nil {
17183 return err
17184 }
17185 if err := f(x); err != nil {
17186 return err
17187 }
17188 if x.NextPageToken == "" {
17189 return nil
17190 }
17191 c.PageToken(x.NextPageToken)
17192 }
17193 }
17194
17195
17196
17197 type AdsPatchCall struct {
17198 s *Service
17199 profileId int64
17200 ad *Ad
17201 urlParams_ gensupport.URLParams
17202 ctx_ context.Context
17203 header_ http.Header
17204 }
17205
17206
17207 func (r *AdsService) Patch(profileId int64, id int64, ad *Ad) *AdsPatchCall {
17208 c := &AdsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17209 c.profileId = profileId
17210 c.urlParams_.Set("id", fmt.Sprint(id))
17211 c.ad = ad
17212 return c
17213 }
17214
17215
17216
17217
17218 func (c *AdsPatchCall) Fields(s ...googleapi.Field) *AdsPatchCall {
17219 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17220 return c
17221 }
17222
17223
17224
17225
17226 func (c *AdsPatchCall) Context(ctx context.Context) *AdsPatchCall {
17227 c.ctx_ = ctx
17228 return c
17229 }
17230
17231
17232
17233 func (c *AdsPatchCall) Header() http.Header {
17234 if c.header_ == nil {
17235 c.header_ = make(http.Header)
17236 }
17237 return c.header_
17238 }
17239
17240 func (c *AdsPatchCall) doRequest(alt string) (*http.Response, error) {
17241 reqHeaders := make(http.Header)
17242 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
17243 for k, v := range c.header_ {
17244 reqHeaders[k] = v
17245 }
17246 reqHeaders.Set("User-Agent", c.s.userAgent())
17247 var body io.Reader = nil
17248 body, err := googleapi.WithoutDataWrapper.JSONReader(c.ad)
17249 if err != nil {
17250 return nil, err
17251 }
17252 reqHeaders.Set("Content-Type", "application/json")
17253 c.urlParams_.Set("alt", alt)
17254 c.urlParams_.Set("prettyPrint", "false")
17255 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/ads")
17256 urls += "?" + c.urlParams_.Encode()
17257 req, err := http.NewRequest("PATCH", urls, body)
17258 if err != nil {
17259 return nil, err
17260 }
17261 req.Header = reqHeaders
17262 googleapi.Expand(req.URL, map[string]string{
17263 "profileId": strconv.FormatInt(c.profileId, 10),
17264 })
17265 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17266 }
17267
17268
17269
17270
17271
17272
17273
17274
17275 func (c *AdsPatchCall) Do(opts ...googleapi.CallOption) (*Ad, error) {
17276 gensupport.SetOptions(c.urlParams_, opts...)
17277 res, err := c.doRequest("json")
17278 if res != nil && res.StatusCode == http.StatusNotModified {
17279 if res.Body != nil {
17280 res.Body.Close()
17281 }
17282 return nil, &googleapi.Error{
17283 Code: res.StatusCode,
17284 Header: res.Header,
17285 }
17286 }
17287 if err != nil {
17288 return nil, err
17289 }
17290 defer googleapi.CloseBody(res)
17291 if err := googleapi.CheckResponse(res); err != nil {
17292 return nil, err
17293 }
17294 ret := &Ad{
17295 ServerResponse: googleapi.ServerResponse{
17296 Header: res.Header,
17297 HTTPStatusCode: res.StatusCode,
17298 },
17299 }
17300 target := &ret
17301 if err := gensupport.DecodeResponse(target, res); err != nil {
17302 return nil, err
17303 }
17304 return ret, nil
17305
17306
17307
17308
17309
17310
17311
17312
17313
17314
17315
17316
17317
17318
17319
17320
17321
17322
17323
17324
17325
17326
17327
17328
17329
17330
17331
17332
17333
17334
17335
17336
17337
17338
17339
17340
17341 }
17342
17343
17344
17345 type AdsUpdateCall struct {
17346 s *Service
17347 profileId int64
17348 ad *Ad
17349 urlParams_ gensupport.URLParams
17350 ctx_ context.Context
17351 header_ http.Header
17352 }
17353
17354
17355 func (r *AdsService) Update(profileId int64, ad *Ad) *AdsUpdateCall {
17356 c := &AdsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17357 c.profileId = profileId
17358 c.ad = ad
17359 return c
17360 }
17361
17362
17363
17364
17365 func (c *AdsUpdateCall) Fields(s ...googleapi.Field) *AdsUpdateCall {
17366 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17367 return c
17368 }
17369
17370
17371
17372
17373 func (c *AdsUpdateCall) Context(ctx context.Context) *AdsUpdateCall {
17374 c.ctx_ = ctx
17375 return c
17376 }
17377
17378
17379
17380 func (c *AdsUpdateCall) Header() http.Header {
17381 if c.header_ == nil {
17382 c.header_ = make(http.Header)
17383 }
17384 return c.header_
17385 }
17386
17387 func (c *AdsUpdateCall) doRequest(alt string) (*http.Response, error) {
17388 reqHeaders := make(http.Header)
17389 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
17390 for k, v := range c.header_ {
17391 reqHeaders[k] = v
17392 }
17393 reqHeaders.Set("User-Agent", c.s.userAgent())
17394 var body io.Reader = nil
17395 body, err := googleapi.WithoutDataWrapper.JSONReader(c.ad)
17396 if err != nil {
17397 return nil, err
17398 }
17399 reqHeaders.Set("Content-Type", "application/json")
17400 c.urlParams_.Set("alt", alt)
17401 c.urlParams_.Set("prettyPrint", "false")
17402 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/ads")
17403 urls += "?" + c.urlParams_.Encode()
17404 req, err := http.NewRequest("PUT", urls, body)
17405 if err != nil {
17406 return nil, err
17407 }
17408 req.Header = reqHeaders
17409 googleapi.Expand(req.URL, map[string]string{
17410 "profileId": strconv.FormatInt(c.profileId, 10),
17411 })
17412 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17413 }
17414
17415
17416
17417
17418
17419
17420
17421
17422 func (c *AdsUpdateCall) Do(opts ...googleapi.CallOption) (*Ad, error) {
17423 gensupport.SetOptions(c.urlParams_, opts...)
17424 res, err := c.doRequest("json")
17425 if res != nil && res.StatusCode == http.StatusNotModified {
17426 if res.Body != nil {
17427 res.Body.Close()
17428 }
17429 return nil, &googleapi.Error{
17430 Code: res.StatusCode,
17431 Header: res.Header,
17432 }
17433 }
17434 if err != nil {
17435 return nil, err
17436 }
17437 defer googleapi.CloseBody(res)
17438 if err := googleapi.CheckResponse(res); err != nil {
17439 return nil, err
17440 }
17441 ret := &Ad{
17442 ServerResponse: googleapi.ServerResponse{
17443 Header: res.Header,
17444 HTTPStatusCode: res.StatusCode,
17445 },
17446 }
17447 target := &ret
17448 if err := gensupport.DecodeResponse(target, res); err != nil {
17449 return nil, err
17450 }
17451 return ret, nil
17452
17453
17454
17455
17456
17457
17458
17459
17460
17461
17462
17463
17464
17465
17466
17467
17468
17469
17470
17471
17472
17473
17474
17475
17476
17477
17478
17479
17480 }
17481
17482
17483
17484 type AdvertiserGroupsDeleteCall struct {
17485 s *Service
17486 profileId int64
17487 id int64
17488 urlParams_ gensupport.URLParams
17489 ctx_ context.Context
17490 header_ http.Header
17491 }
17492
17493
17494 func (r *AdvertiserGroupsService) Delete(profileId int64, id int64) *AdvertiserGroupsDeleteCall {
17495 c := &AdvertiserGroupsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17496 c.profileId = profileId
17497 c.id = id
17498 return c
17499 }
17500
17501
17502
17503
17504 func (c *AdvertiserGroupsDeleteCall) Fields(s ...googleapi.Field) *AdvertiserGroupsDeleteCall {
17505 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17506 return c
17507 }
17508
17509
17510
17511
17512 func (c *AdvertiserGroupsDeleteCall) Context(ctx context.Context) *AdvertiserGroupsDeleteCall {
17513 c.ctx_ = ctx
17514 return c
17515 }
17516
17517
17518
17519 func (c *AdvertiserGroupsDeleteCall) Header() http.Header {
17520 if c.header_ == nil {
17521 c.header_ = make(http.Header)
17522 }
17523 return c.header_
17524 }
17525
17526 func (c *AdvertiserGroupsDeleteCall) doRequest(alt string) (*http.Response, error) {
17527 reqHeaders := make(http.Header)
17528 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
17529 for k, v := range c.header_ {
17530 reqHeaders[k] = v
17531 }
17532 reqHeaders.Set("User-Agent", c.s.userAgent())
17533 var body io.Reader = nil
17534 c.urlParams_.Set("alt", alt)
17535 c.urlParams_.Set("prettyPrint", "false")
17536 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserGroups/{id}")
17537 urls += "?" + c.urlParams_.Encode()
17538 req, err := http.NewRequest("DELETE", urls, body)
17539 if err != nil {
17540 return nil, err
17541 }
17542 req.Header = reqHeaders
17543 googleapi.Expand(req.URL, map[string]string{
17544 "profileId": strconv.FormatInt(c.profileId, 10),
17545 "id": strconv.FormatInt(c.id, 10),
17546 })
17547 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17548 }
17549
17550
17551 func (c *AdvertiserGroupsDeleteCall) Do(opts ...googleapi.CallOption) error {
17552 gensupport.SetOptions(c.urlParams_, opts...)
17553 res, err := c.doRequest("json")
17554 if err != nil {
17555 return err
17556 }
17557 defer googleapi.CloseBody(res)
17558 if err := googleapi.CheckResponse(res); err != nil {
17559 return err
17560 }
17561 return nil
17562
17563
17564
17565
17566
17567
17568
17569
17570
17571
17572
17573
17574
17575
17576
17577
17578
17579
17580
17581
17582
17583
17584
17585
17586
17587
17588
17589
17590
17591
17592 }
17593
17594
17595
17596 type AdvertiserGroupsGetCall struct {
17597 s *Service
17598 profileId int64
17599 id int64
17600 urlParams_ gensupport.URLParams
17601 ifNoneMatch_ string
17602 ctx_ context.Context
17603 header_ http.Header
17604 }
17605
17606
17607 func (r *AdvertiserGroupsService) Get(profileId int64, id int64) *AdvertiserGroupsGetCall {
17608 c := &AdvertiserGroupsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17609 c.profileId = profileId
17610 c.id = id
17611 return c
17612 }
17613
17614
17615
17616
17617 func (c *AdvertiserGroupsGetCall) Fields(s ...googleapi.Field) *AdvertiserGroupsGetCall {
17618 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17619 return c
17620 }
17621
17622
17623
17624
17625
17626
17627 func (c *AdvertiserGroupsGetCall) IfNoneMatch(entityTag string) *AdvertiserGroupsGetCall {
17628 c.ifNoneMatch_ = entityTag
17629 return c
17630 }
17631
17632
17633
17634
17635 func (c *AdvertiserGroupsGetCall) Context(ctx context.Context) *AdvertiserGroupsGetCall {
17636 c.ctx_ = ctx
17637 return c
17638 }
17639
17640
17641
17642 func (c *AdvertiserGroupsGetCall) Header() http.Header {
17643 if c.header_ == nil {
17644 c.header_ = make(http.Header)
17645 }
17646 return c.header_
17647 }
17648
17649 func (c *AdvertiserGroupsGetCall) doRequest(alt string) (*http.Response, error) {
17650 reqHeaders := make(http.Header)
17651 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
17652 for k, v := range c.header_ {
17653 reqHeaders[k] = v
17654 }
17655 reqHeaders.Set("User-Agent", c.s.userAgent())
17656 if c.ifNoneMatch_ != "" {
17657 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17658 }
17659 var body io.Reader = nil
17660 c.urlParams_.Set("alt", alt)
17661 c.urlParams_.Set("prettyPrint", "false")
17662 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserGroups/{id}")
17663 urls += "?" + c.urlParams_.Encode()
17664 req, err := http.NewRequest("GET", urls, body)
17665 if err != nil {
17666 return nil, err
17667 }
17668 req.Header = reqHeaders
17669 googleapi.Expand(req.URL, map[string]string{
17670 "profileId": strconv.FormatInt(c.profileId, 10),
17671 "id": strconv.FormatInt(c.id, 10),
17672 })
17673 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17674 }
17675
17676
17677
17678
17679
17680
17681
17682
17683 func (c *AdvertiserGroupsGetCall) Do(opts ...googleapi.CallOption) (*AdvertiserGroup, error) {
17684 gensupport.SetOptions(c.urlParams_, opts...)
17685 res, err := c.doRequest("json")
17686 if res != nil && res.StatusCode == http.StatusNotModified {
17687 if res.Body != nil {
17688 res.Body.Close()
17689 }
17690 return nil, &googleapi.Error{
17691 Code: res.StatusCode,
17692 Header: res.Header,
17693 }
17694 }
17695 if err != nil {
17696 return nil, err
17697 }
17698 defer googleapi.CloseBody(res)
17699 if err := googleapi.CheckResponse(res); err != nil {
17700 return nil, err
17701 }
17702 ret := &AdvertiserGroup{
17703 ServerResponse: googleapi.ServerResponse{
17704 Header: res.Header,
17705 HTTPStatusCode: res.StatusCode,
17706 },
17707 }
17708 target := &ret
17709 if err := gensupport.DecodeResponse(target, res); err != nil {
17710 return nil, err
17711 }
17712 return ret, nil
17713
17714
17715
17716
17717
17718
17719
17720
17721
17722
17723
17724
17725
17726
17727
17728
17729
17730
17731
17732
17733
17734
17735
17736
17737
17738
17739
17740
17741
17742
17743
17744
17745
17746 }
17747
17748
17749
17750 type AdvertiserGroupsInsertCall struct {
17751 s *Service
17752 profileId int64
17753 advertisergroup *AdvertiserGroup
17754 urlParams_ gensupport.URLParams
17755 ctx_ context.Context
17756 header_ http.Header
17757 }
17758
17759
17760 func (r *AdvertiserGroupsService) Insert(profileId int64, advertisergroup *AdvertiserGroup) *AdvertiserGroupsInsertCall {
17761 c := &AdvertiserGroupsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17762 c.profileId = profileId
17763 c.advertisergroup = advertisergroup
17764 return c
17765 }
17766
17767
17768
17769
17770 func (c *AdvertiserGroupsInsertCall) Fields(s ...googleapi.Field) *AdvertiserGroupsInsertCall {
17771 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17772 return c
17773 }
17774
17775
17776
17777
17778 func (c *AdvertiserGroupsInsertCall) Context(ctx context.Context) *AdvertiserGroupsInsertCall {
17779 c.ctx_ = ctx
17780 return c
17781 }
17782
17783
17784
17785 func (c *AdvertiserGroupsInsertCall) Header() http.Header {
17786 if c.header_ == nil {
17787 c.header_ = make(http.Header)
17788 }
17789 return c.header_
17790 }
17791
17792 func (c *AdvertiserGroupsInsertCall) doRequest(alt string) (*http.Response, error) {
17793 reqHeaders := make(http.Header)
17794 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
17795 for k, v := range c.header_ {
17796 reqHeaders[k] = v
17797 }
17798 reqHeaders.Set("User-Agent", c.s.userAgent())
17799 var body io.Reader = nil
17800 body, err := googleapi.WithoutDataWrapper.JSONReader(c.advertisergroup)
17801 if err != nil {
17802 return nil, err
17803 }
17804 reqHeaders.Set("Content-Type", "application/json")
17805 c.urlParams_.Set("alt", alt)
17806 c.urlParams_.Set("prettyPrint", "false")
17807 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserGroups")
17808 urls += "?" + c.urlParams_.Encode()
17809 req, err := http.NewRequest("POST", urls, body)
17810 if err != nil {
17811 return nil, err
17812 }
17813 req.Header = reqHeaders
17814 googleapi.Expand(req.URL, map[string]string{
17815 "profileId": strconv.FormatInt(c.profileId, 10),
17816 })
17817 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17818 }
17819
17820
17821
17822
17823
17824
17825
17826
17827 func (c *AdvertiserGroupsInsertCall) Do(opts ...googleapi.CallOption) (*AdvertiserGroup, error) {
17828 gensupport.SetOptions(c.urlParams_, opts...)
17829 res, err := c.doRequest("json")
17830 if res != nil && res.StatusCode == http.StatusNotModified {
17831 if res.Body != nil {
17832 res.Body.Close()
17833 }
17834 return nil, &googleapi.Error{
17835 Code: res.StatusCode,
17836 Header: res.Header,
17837 }
17838 }
17839 if err != nil {
17840 return nil, err
17841 }
17842 defer googleapi.CloseBody(res)
17843 if err := googleapi.CheckResponse(res); err != nil {
17844 return nil, err
17845 }
17846 ret := &AdvertiserGroup{
17847 ServerResponse: googleapi.ServerResponse{
17848 Header: res.Header,
17849 HTTPStatusCode: res.StatusCode,
17850 },
17851 }
17852 target := &ret
17853 if err := gensupport.DecodeResponse(target, res); err != nil {
17854 return nil, err
17855 }
17856 return ret, nil
17857
17858
17859
17860
17861
17862
17863
17864
17865
17866
17867
17868
17869
17870
17871
17872
17873
17874
17875
17876
17877
17878
17879
17880
17881
17882
17883
17884
17885 }
17886
17887
17888
17889 type AdvertiserGroupsListCall struct {
17890 s *Service
17891 profileId int64
17892 urlParams_ gensupport.URLParams
17893 ifNoneMatch_ string
17894 ctx_ context.Context
17895 header_ http.Header
17896 }
17897
17898
17899
17900 func (r *AdvertiserGroupsService) List(profileId int64) *AdvertiserGroupsListCall {
17901 c := &AdvertiserGroupsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17902 c.profileId = profileId
17903 return c
17904 }
17905
17906
17907
17908 func (c *AdvertiserGroupsListCall) Ids(ids ...int64) *AdvertiserGroupsListCall {
17909 var ids_ []string
17910 for _, v := range ids {
17911 ids_ = append(ids_, fmt.Sprint(v))
17912 }
17913 c.urlParams_.SetMulti("ids", ids_)
17914 return c
17915 }
17916
17917
17918
17919 func (c *AdvertiserGroupsListCall) MaxResults(maxResults int64) *AdvertiserGroupsListCall {
17920 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
17921 return c
17922 }
17923
17924
17925
17926 func (c *AdvertiserGroupsListCall) PageToken(pageToken string) *AdvertiserGroupsListCall {
17927 c.urlParams_.Set("pageToken", pageToken)
17928 return c
17929 }
17930
17931
17932
17933
17934
17935
17936
17937
17938
17939
17940 func (c *AdvertiserGroupsListCall) SearchString(searchString string) *AdvertiserGroupsListCall {
17941 c.urlParams_.Set("searchString", searchString)
17942 return c
17943 }
17944
17945
17946
17947
17948
17949
17950
17951
17952 func (c *AdvertiserGroupsListCall) SortField(sortField string) *AdvertiserGroupsListCall {
17953 c.urlParams_.Set("sortField", sortField)
17954 return c
17955 }
17956
17957
17958
17959
17960
17961
17962
17963
17964 func (c *AdvertiserGroupsListCall) SortOrder(sortOrder string) *AdvertiserGroupsListCall {
17965 c.urlParams_.Set("sortOrder", sortOrder)
17966 return c
17967 }
17968
17969
17970
17971
17972 func (c *AdvertiserGroupsListCall) Fields(s ...googleapi.Field) *AdvertiserGroupsListCall {
17973 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17974 return c
17975 }
17976
17977
17978
17979
17980
17981
17982 func (c *AdvertiserGroupsListCall) IfNoneMatch(entityTag string) *AdvertiserGroupsListCall {
17983 c.ifNoneMatch_ = entityTag
17984 return c
17985 }
17986
17987
17988
17989
17990 func (c *AdvertiserGroupsListCall) Context(ctx context.Context) *AdvertiserGroupsListCall {
17991 c.ctx_ = ctx
17992 return c
17993 }
17994
17995
17996
17997 func (c *AdvertiserGroupsListCall) Header() http.Header {
17998 if c.header_ == nil {
17999 c.header_ = make(http.Header)
18000 }
18001 return c.header_
18002 }
18003
18004 func (c *AdvertiserGroupsListCall) doRequest(alt string) (*http.Response, error) {
18005 reqHeaders := make(http.Header)
18006 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
18007 for k, v := range c.header_ {
18008 reqHeaders[k] = v
18009 }
18010 reqHeaders.Set("User-Agent", c.s.userAgent())
18011 if c.ifNoneMatch_ != "" {
18012 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18013 }
18014 var body io.Reader = nil
18015 c.urlParams_.Set("alt", alt)
18016 c.urlParams_.Set("prettyPrint", "false")
18017 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserGroups")
18018 urls += "?" + c.urlParams_.Encode()
18019 req, err := http.NewRequest("GET", urls, body)
18020 if err != nil {
18021 return nil, err
18022 }
18023 req.Header = reqHeaders
18024 googleapi.Expand(req.URL, map[string]string{
18025 "profileId": strconv.FormatInt(c.profileId, 10),
18026 })
18027 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18028 }
18029
18030
18031
18032
18033
18034
18035
18036
18037 func (c *AdvertiserGroupsListCall) Do(opts ...googleapi.CallOption) (*AdvertiserGroupsListResponse, error) {
18038 gensupport.SetOptions(c.urlParams_, opts...)
18039 res, err := c.doRequest("json")
18040 if res != nil && res.StatusCode == http.StatusNotModified {
18041 if res.Body != nil {
18042 res.Body.Close()
18043 }
18044 return nil, &googleapi.Error{
18045 Code: res.StatusCode,
18046 Header: res.Header,
18047 }
18048 }
18049 if err != nil {
18050 return nil, err
18051 }
18052 defer googleapi.CloseBody(res)
18053 if err := googleapi.CheckResponse(res); err != nil {
18054 return nil, err
18055 }
18056 ret := &AdvertiserGroupsListResponse{
18057 ServerResponse: googleapi.ServerResponse{
18058 Header: res.Header,
18059 HTTPStatusCode: res.StatusCode,
18060 },
18061 }
18062 target := &ret
18063 if err := gensupport.DecodeResponse(target, res); err != nil {
18064 return nil, err
18065 }
18066 return ret, nil
18067
18068
18069
18070
18071
18072
18073
18074
18075
18076
18077
18078
18079
18080
18081
18082
18083
18084
18085
18086
18087
18088
18089
18090
18091
18092
18093
18094
18095
18096
18097
18098
18099
18100
18101
18102
18103
18104
18105
18106
18107
18108
18109
18110
18111
18112
18113
18114
18115
18116
18117
18118
18119
18120
18121
18122
18123
18124
18125
18126
18127
18128
18129
18130
18131
18132
18133
18134
18135
18136
18137
18138
18139
18140
18141
18142
18143
18144
18145
18146 }
18147
18148
18149
18150
18151 func (c *AdvertiserGroupsListCall) Pages(ctx context.Context, f func(*AdvertiserGroupsListResponse) error) error {
18152 c.ctx_ = ctx
18153 defer c.PageToken(c.urlParams_.Get("pageToken"))
18154 for {
18155 x, err := c.Do()
18156 if err != nil {
18157 return err
18158 }
18159 if err := f(x); err != nil {
18160 return err
18161 }
18162 if x.NextPageToken == "" {
18163 return nil
18164 }
18165 c.PageToken(x.NextPageToken)
18166 }
18167 }
18168
18169
18170
18171 type AdvertiserGroupsPatchCall struct {
18172 s *Service
18173 profileId int64
18174 advertisergroup *AdvertiserGroup
18175 urlParams_ gensupport.URLParams
18176 ctx_ context.Context
18177 header_ http.Header
18178 }
18179
18180
18181
18182 func (r *AdvertiserGroupsService) Patch(profileId int64, id int64, advertisergroup *AdvertiserGroup) *AdvertiserGroupsPatchCall {
18183 c := &AdvertiserGroupsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18184 c.profileId = profileId
18185 c.urlParams_.Set("id", fmt.Sprint(id))
18186 c.advertisergroup = advertisergroup
18187 return c
18188 }
18189
18190
18191
18192
18193 func (c *AdvertiserGroupsPatchCall) Fields(s ...googleapi.Field) *AdvertiserGroupsPatchCall {
18194 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18195 return c
18196 }
18197
18198
18199
18200
18201 func (c *AdvertiserGroupsPatchCall) Context(ctx context.Context) *AdvertiserGroupsPatchCall {
18202 c.ctx_ = ctx
18203 return c
18204 }
18205
18206
18207
18208 func (c *AdvertiserGroupsPatchCall) Header() http.Header {
18209 if c.header_ == nil {
18210 c.header_ = make(http.Header)
18211 }
18212 return c.header_
18213 }
18214
18215 func (c *AdvertiserGroupsPatchCall) doRequest(alt string) (*http.Response, error) {
18216 reqHeaders := make(http.Header)
18217 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
18218 for k, v := range c.header_ {
18219 reqHeaders[k] = v
18220 }
18221 reqHeaders.Set("User-Agent", c.s.userAgent())
18222 var body io.Reader = nil
18223 body, err := googleapi.WithoutDataWrapper.JSONReader(c.advertisergroup)
18224 if err != nil {
18225 return nil, err
18226 }
18227 reqHeaders.Set("Content-Type", "application/json")
18228 c.urlParams_.Set("alt", alt)
18229 c.urlParams_.Set("prettyPrint", "false")
18230 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserGroups")
18231 urls += "?" + c.urlParams_.Encode()
18232 req, err := http.NewRequest("PATCH", urls, body)
18233 if err != nil {
18234 return nil, err
18235 }
18236 req.Header = reqHeaders
18237 googleapi.Expand(req.URL, map[string]string{
18238 "profileId": strconv.FormatInt(c.profileId, 10),
18239 })
18240 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18241 }
18242
18243
18244
18245
18246
18247
18248
18249
18250 func (c *AdvertiserGroupsPatchCall) Do(opts ...googleapi.CallOption) (*AdvertiserGroup, 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, &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, err
18268 }
18269 ret := &AdvertiserGroup{
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
18286
18287
18288
18289
18290
18291
18292
18293
18294
18295
18296
18297
18298
18299
18300
18301
18302
18303
18304
18305
18306
18307
18308
18309
18310
18311
18312
18313
18314
18315
18316 }
18317
18318
18319
18320 type AdvertiserGroupsUpdateCall struct {
18321 s *Service
18322 profileId int64
18323 advertisergroup *AdvertiserGroup
18324 urlParams_ gensupport.URLParams
18325 ctx_ context.Context
18326 header_ http.Header
18327 }
18328
18329
18330 func (r *AdvertiserGroupsService) Update(profileId int64, advertisergroup *AdvertiserGroup) *AdvertiserGroupsUpdateCall {
18331 c := &AdvertiserGroupsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18332 c.profileId = profileId
18333 c.advertisergroup = advertisergroup
18334 return c
18335 }
18336
18337
18338
18339
18340 func (c *AdvertiserGroupsUpdateCall) Fields(s ...googleapi.Field) *AdvertiserGroupsUpdateCall {
18341 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18342 return c
18343 }
18344
18345
18346
18347
18348 func (c *AdvertiserGroupsUpdateCall) Context(ctx context.Context) *AdvertiserGroupsUpdateCall {
18349 c.ctx_ = ctx
18350 return c
18351 }
18352
18353
18354
18355 func (c *AdvertiserGroupsUpdateCall) Header() http.Header {
18356 if c.header_ == nil {
18357 c.header_ = make(http.Header)
18358 }
18359 return c.header_
18360 }
18361
18362 func (c *AdvertiserGroupsUpdateCall) doRequest(alt string) (*http.Response, error) {
18363 reqHeaders := make(http.Header)
18364 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
18365 for k, v := range c.header_ {
18366 reqHeaders[k] = v
18367 }
18368 reqHeaders.Set("User-Agent", c.s.userAgent())
18369 var body io.Reader = nil
18370 body, err := googleapi.WithoutDataWrapper.JSONReader(c.advertisergroup)
18371 if err != nil {
18372 return nil, err
18373 }
18374 reqHeaders.Set("Content-Type", "application/json")
18375 c.urlParams_.Set("alt", alt)
18376 c.urlParams_.Set("prettyPrint", "false")
18377 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserGroups")
18378 urls += "?" + c.urlParams_.Encode()
18379 req, err := http.NewRequest("PUT", urls, body)
18380 if err != nil {
18381 return nil, err
18382 }
18383 req.Header = reqHeaders
18384 googleapi.Expand(req.URL, map[string]string{
18385 "profileId": strconv.FormatInt(c.profileId, 10),
18386 })
18387 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18388 }
18389
18390
18391
18392
18393
18394
18395
18396
18397 func (c *AdvertiserGroupsUpdateCall) Do(opts ...googleapi.CallOption) (*AdvertiserGroup, error) {
18398 gensupport.SetOptions(c.urlParams_, opts...)
18399 res, err := c.doRequest("json")
18400 if res != nil && res.StatusCode == http.StatusNotModified {
18401 if res.Body != nil {
18402 res.Body.Close()
18403 }
18404 return nil, &googleapi.Error{
18405 Code: res.StatusCode,
18406 Header: res.Header,
18407 }
18408 }
18409 if err != nil {
18410 return nil, err
18411 }
18412 defer googleapi.CloseBody(res)
18413 if err := googleapi.CheckResponse(res); err != nil {
18414 return nil, err
18415 }
18416 ret := &AdvertiserGroup{
18417 ServerResponse: googleapi.ServerResponse{
18418 Header: res.Header,
18419 HTTPStatusCode: res.StatusCode,
18420 },
18421 }
18422 target := &ret
18423 if err := gensupport.DecodeResponse(target, res); err != nil {
18424 return nil, err
18425 }
18426 return ret, nil
18427
18428
18429
18430
18431
18432
18433
18434
18435
18436
18437
18438
18439
18440
18441
18442
18443
18444
18445
18446
18447
18448
18449
18450
18451
18452
18453
18454
18455 }
18456
18457
18458
18459 type AdvertiserLandingPagesGetCall struct {
18460 s *Service
18461 profileId int64
18462 id int64
18463 urlParams_ gensupport.URLParams
18464 ifNoneMatch_ string
18465 ctx_ context.Context
18466 header_ http.Header
18467 }
18468
18469
18470 func (r *AdvertiserLandingPagesService) Get(profileId int64, id int64) *AdvertiserLandingPagesGetCall {
18471 c := &AdvertiserLandingPagesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18472 c.profileId = profileId
18473 c.id = id
18474 return c
18475 }
18476
18477
18478
18479
18480 func (c *AdvertiserLandingPagesGetCall) Fields(s ...googleapi.Field) *AdvertiserLandingPagesGetCall {
18481 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18482 return c
18483 }
18484
18485
18486
18487
18488
18489
18490 func (c *AdvertiserLandingPagesGetCall) IfNoneMatch(entityTag string) *AdvertiserLandingPagesGetCall {
18491 c.ifNoneMatch_ = entityTag
18492 return c
18493 }
18494
18495
18496
18497
18498 func (c *AdvertiserLandingPagesGetCall) Context(ctx context.Context) *AdvertiserLandingPagesGetCall {
18499 c.ctx_ = ctx
18500 return c
18501 }
18502
18503
18504
18505 func (c *AdvertiserLandingPagesGetCall) Header() http.Header {
18506 if c.header_ == nil {
18507 c.header_ = make(http.Header)
18508 }
18509 return c.header_
18510 }
18511
18512 func (c *AdvertiserLandingPagesGetCall) doRequest(alt string) (*http.Response, error) {
18513 reqHeaders := make(http.Header)
18514 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
18515 for k, v := range c.header_ {
18516 reqHeaders[k] = v
18517 }
18518 reqHeaders.Set("User-Agent", c.s.userAgent())
18519 if c.ifNoneMatch_ != "" {
18520 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18521 }
18522 var body io.Reader = nil
18523 c.urlParams_.Set("alt", alt)
18524 c.urlParams_.Set("prettyPrint", "false")
18525 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserLandingPages/{id}")
18526 urls += "?" + c.urlParams_.Encode()
18527 req, err := http.NewRequest("GET", urls, body)
18528 if err != nil {
18529 return nil, err
18530 }
18531 req.Header = reqHeaders
18532 googleapi.Expand(req.URL, map[string]string{
18533 "profileId": strconv.FormatInt(c.profileId, 10),
18534 "id": strconv.FormatInt(c.id, 10),
18535 })
18536 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18537 }
18538
18539
18540
18541
18542
18543
18544
18545
18546 func (c *AdvertiserLandingPagesGetCall) Do(opts ...googleapi.CallOption) (*LandingPage, error) {
18547 gensupport.SetOptions(c.urlParams_, opts...)
18548 res, err := c.doRequest("json")
18549 if res != nil && res.StatusCode == http.StatusNotModified {
18550 if res.Body != nil {
18551 res.Body.Close()
18552 }
18553 return nil, &googleapi.Error{
18554 Code: res.StatusCode,
18555 Header: res.Header,
18556 }
18557 }
18558 if err != nil {
18559 return nil, err
18560 }
18561 defer googleapi.CloseBody(res)
18562 if err := googleapi.CheckResponse(res); err != nil {
18563 return nil, err
18564 }
18565 ret := &LandingPage{
18566 ServerResponse: googleapi.ServerResponse{
18567 Header: res.Header,
18568 HTTPStatusCode: res.StatusCode,
18569 },
18570 }
18571 target := &ret
18572 if err := gensupport.DecodeResponse(target, res); err != nil {
18573 return nil, err
18574 }
18575 return ret, nil
18576
18577
18578
18579
18580
18581
18582
18583
18584
18585
18586
18587
18588
18589
18590
18591
18592
18593
18594
18595
18596
18597
18598
18599
18600
18601
18602
18603
18604
18605
18606
18607
18608
18609 }
18610
18611
18612
18613 type AdvertiserLandingPagesInsertCall struct {
18614 s *Service
18615 profileId int64
18616 landingpage *LandingPage
18617 urlParams_ gensupport.URLParams
18618 ctx_ context.Context
18619 header_ http.Header
18620 }
18621
18622
18623 func (r *AdvertiserLandingPagesService) Insert(profileId int64, landingpage *LandingPage) *AdvertiserLandingPagesInsertCall {
18624 c := &AdvertiserLandingPagesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18625 c.profileId = profileId
18626 c.landingpage = landingpage
18627 return c
18628 }
18629
18630
18631
18632
18633 func (c *AdvertiserLandingPagesInsertCall) Fields(s ...googleapi.Field) *AdvertiserLandingPagesInsertCall {
18634 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18635 return c
18636 }
18637
18638
18639
18640
18641 func (c *AdvertiserLandingPagesInsertCall) Context(ctx context.Context) *AdvertiserLandingPagesInsertCall {
18642 c.ctx_ = ctx
18643 return c
18644 }
18645
18646
18647
18648 func (c *AdvertiserLandingPagesInsertCall) Header() http.Header {
18649 if c.header_ == nil {
18650 c.header_ = make(http.Header)
18651 }
18652 return c.header_
18653 }
18654
18655 func (c *AdvertiserLandingPagesInsertCall) doRequest(alt string) (*http.Response, error) {
18656 reqHeaders := make(http.Header)
18657 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
18658 for k, v := range c.header_ {
18659 reqHeaders[k] = v
18660 }
18661 reqHeaders.Set("User-Agent", c.s.userAgent())
18662 var body io.Reader = nil
18663 body, err := googleapi.WithoutDataWrapper.JSONReader(c.landingpage)
18664 if err != nil {
18665 return nil, err
18666 }
18667 reqHeaders.Set("Content-Type", "application/json")
18668 c.urlParams_.Set("alt", alt)
18669 c.urlParams_.Set("prettyPrint", "false")
18670 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserLandingPages")
18671 urls += "?" + c.urlParams_.Encode()
18672 req, err := http.NewRequest("POST", urls, body)
18673 if err != nil {
18674 return nil, err
18675 }
18676 req.Header = reqHeaders
18677 googleapi.Expand(req.URL, map[string]string{
18678 "profileId": strconv.FormatInt(c.profileId, 10),
18679 })
18680 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18681 }
18682
18683
18684
18685
18686
18687
18688
18689
18690 func (c *AdvertiserLandingPagesInsertCall) Do(opts ...googleapi.CallOption) (*LandingPage, error) {
18691 gensupport.SetOptions(c.urlParams_, opts...)
18692 res, err := c.doRequest("json")
18693 if res != nil && res.StatusCode == http.StatusNotModified {
18694 if res.Body != nil {
18695 res.Body.Close()
18696 }
18697 return nil, &googleapi.Error{
18698 Code: res.StatusCode,
18699 Header: res.Header,
18700 }
18701 }
18702 if err != nil {
18703 return nil, err
18704 }
18705 defer googleapi.CloseBody(res)
18706 if err := googleapi.CheckResponse(res); err != nil {
18707 return nil, err
18708 }
18709 ret := &LandingPage{
18710 ServerResponse: googleapi.ServerResponse{
18711 Header: res.Header,
18712 HTTPStatusCode: res.StatusCode,
18713 },
18714 }
18715 target := &ret
18716 if err := gensupport.DecodeResponse(target, res); err != nil {
18717 return nil, err
18718 }
18719 return ret, nil
18720
18721
18722
18723
18724
18725
18726
18727
18728
18729
18730
18731
18732
18733
18734
18735
18736
18737
18738
18739
18740
18741
18742
18743
18744
18745
18746
18747
18748 }
18749
18750
18751
18752 type AdvertiserLandingPagesListCall struct {
18753 s *Service
18754 profileId int64
18755 urlParams_ gensupport.URLParams
18756 ifNoneMatch_ string
18757 ctx_ context.Context
18758 header_ http.Header
18759 }
18760
18761
18762 func (r *AdvertiserLandingPagesService) List(profileId int64) *AdvertiserLandingPagesListCall {
18763 c := &AdvertiserLandingPagesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18764 c.profileId = profileId
18765 return c
18766 }
18767
18768
18769
18770 func (c *AdvertiserLandingPagesListCall) AdvertiserIds(advertiserIds ...int64) *AdvertiserLandingPagesListCall {
18771 var advertiserIds_ []string
18772 for _, v := range advertiserIds {
18773 advertiserIds_ = append(advertiserIds_, fmt.Sprint(v))
18774 }
18775 c.urlParams_.SetMulti("advertiserIds", advertiserIds_)
18776 return c
18777 }
18778
18779
18780
18781
18782 func (c *AdvertiserLandingPagesListCall) Archived(archived bool) *AdvertiserLandingPagesListCall {
18783 c.urlParams_.Set("archived", fmt.Sprint(archived))
18784 return c
18785 }
18786
18787
18788
18789 func (c *AdvertiserLandingPagesListCall) CampaignIds(campaignIds ...int64) *AdvertiserLandingPagesListCall {
18790 var campaignIds_ []string
18791 for _, v := range campaignIds {
18792 campaignIds_ = append(campaignIds_, fmt.Sprint(v))
18793 }
18794 c.urlParams_.SetMulti("campaignIds", campaignIds_)
18795 return c
18796 }
18797
18798
18799
18800 func (c *AdvertiserLandingPagesListCall) Ids(ids ...int64) *AdvertiserLandingPagesListCall {
18801 var ids_ []string
18802 for _, v := range ids {
18803 ids_ = append(ids_, fmt.Sprint(v))
18804 }
18805 c.urlParams_.SetMulti("ids", ids_)
18806 return c
18807 }
18808
18809
18810
18811 func (c *AdvertiserLandingPagesListCall) MaxResults(maxResults int64) *AdvertiserLandingPagesListCall {
18812 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
18813 return c
18814 }
18815
18816
18817
18818 func (c *AdvertiserLandingPagesListCall) PageToken(pageToken string) *AdvertiserLandingPagesListCall {
18819 c.urlParams_.Set("pageToken", pageToken)
18820 return c
18821 }
18822
18823
18824
18825
18826
18827
18828
18829
18830
18831 func (c *AdvertiserLandingPagesListCall) SearchString(searchString string) *AdvertiserLandingPagesListCall {
18832 c.urlParams_.Set("searchString", searchString)
18833 return c
18834 }
18835
18836
18837
18838
18839
18840
18841
18842
18843 func (c *AdvertiserLandingPagesListCall) SortField(sortField string) *AdvertiserLandingPagesListCall {
18844 c.urlParams_.Set("sortField", sortField)
18845 return c
18846 }
18847
18848
18849
18850
18851
18852
18853
18854
18855 func (c *AdvertiserLandingPagesListCall) SortOrder(sortOrder string) *AdvertiserLandingPagesListCall {
18856 c.urlParams_.Set("sortOrder", sortOrder)
18857 return c
18858 }
18859
18860
18861
18862 func (c *AdvertiserLandingPagesListCall) SubaccountId(subaccountId int64) *AdvertiserLandingPagesListCall {
18863 c.urlParams_.Set("subaccountId", fmt.Sprint(subaccountId))
18864 return c
18865 }
18866
18867
18868
18869
18870 func (c *AdvertiserLandingPagesListCall) Fields(s ...googleapi.Field) *AdvertiserLandingPagesListCall {
18871 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18872 return c
18873 }
18874
18875
18876
18877
18878
18879
18880 func (c *AdvertiserLandingPagesListCall) IfNoneMatch(entityTag string) *AdvertiserLandingPagesListCall {
18881 c.ifNoneMatch_ = entityTag
18882 return c
18883 }
18884
18885
18886
18887
18888 func (c *AdvertiserLandingPagesListCall) Context(ctx context.Context) *AdvertiserLandingPagesListCall {
18889 c.ctx_ = ctx
18890 return c
18891 }
18892
18893
18894
18895 func (c *AdvertiserLandingPagesListCall) Header() http.Header {
18896 if c.header_ == nil {
18897 c.header_ = make(http.Header)
18898 }
18899 return c.header_
18900 }
18901
18902 func (c *AdvertiserLandingPagesListCall) doRequest(alt string) (*http.Response, error) {
18903 reqHeaders := make(http.Header)
18904 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
18905 for k, v := range c.header_ {
18906 reqHeaders[k] = v
18907 }
18908 reqHeaders.Set("User-Agent", c.s.userAgent())
18909 if c.ifNoneMatch_ != "" {
18910 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18911 }
18912 var body io.Reader = nil
18913 c.urlParams_.Set("alt", alt)
18914 c.urlParams_.Set("prettyPrint", "false")
18915 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserLandingPages")
18916 urls += "?" + c.urlParams_.Encode()
18917 req, err := http.NewRequest("GET", urls, body)
18918 if err != nil {
18919 return nil, err
18920 }
18921 req.Header = reqHeaders
18922 googleapi.Expand(req.URL, map[string]string{
18923 "profileId": strconv.FormatInt(c.profileId, 10),
18924 })
18925 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18926 }
18927
18928
18929
18930
18931
18932
18933
18934
18935
18936 func (c *AdvertiserLandingPagesListCall) Do(opts ...googleapi.CallOption) (*AdvertiserLandingPagesListResponse, error) {
18937 gensupport.SetOptions(c.urlParams_, opts...)
18938 res, err := c.doRequest("json")
18939 if res != nil && res.StatusCode == http.StatusNotModified {
18940 if res.Body != nil {
18941 res.Body.Close()
18942 }
18943 return nil, &googleapi.Error{
18944 Code: res.StatusCode,
18945 Header: res.Header,
18946 }
18947 }
18948 if err != nil {
18949 return nil, err
18950 }
18951 defer googleapi.CloseBody(res)
18952 if err := googleapi.CheckResponse(res); err != nil {
18953 return nil, err
18954 }
18955 ret := &AdvertiserLandingPagesListResponse{
18956 ServerResponse: googleapi.ServerResponse{
18957 Header: res.Header,
18958 HTTPStatusCode: res.StatusCode,
18959 },
18960 }
18961 target := &ret
18962 if err := gensupport.DecodeResponse(target, res); err != nil {
18963 return nil, err
18964 }
18965 return ret, nil
18966
18967
18968
18969
18970
18971
18972
18973
18974
18975
18976
18977
18978
18979
18980
18981
18982
18983
18984
18985
18986
18987
18988
18989
18990
18991
18992
18993
18994
18995
18996
18997
18998
18999
19000
19001
19002
19003
19004
19005
19006
19007
19008
19009
19010
19011
19012
19013
19014
19015
19016
19017
19018
19019
19020
19021
19022
19023
19024
19025
19026
19027
19028
19029
19030
19031
19032
19033
19034
19035
19036
19037
19038
19039
19040
19041
19042
19043
19044
19045
19046
19047
19048
19049
19050
19051
19052
19053
19054
19055
19056
19057
19058
19059
19060
19061
19062
19063
19064
19065
19066
19067
19068
19069
19070 }
19071
19072
19073
19074
19075 func (c *AdvertiserLandingPagesListCall) Pages(ctx context.Context, f func(*AdvertiserLandingPagesListResponse) error) error {
19076 c.ctx_ = ctx
19077 defer c.PageToken(c.urlParams_.Get("pageToken"))
19078 for {
19079 x, err := c.Do()
19080 if err != nil {
19081 return err
19082 }
19083 if err := f(x); err != nil {
19084 return err
19085 }
19086 if x.NextPageToken == "" {
19087 return nil
19088 }
19089 c.PageToken(x.NextPageToken)
19090 }
19091 }
19092
19093
19094
19095 type AdvertiserLandingPagesPatchCall struct {
19096 s *Service
19097 profileId int64
19098 landingpage *LandingPage
19099 urlParams_ gensupport.URLParams
19100 ctx_ context.Context
19101 header_ http.Header
19102 }
19103
19104
19105
19106 func (r *AdvertiserLandingPagesService) Patch(profileId int64, id int64, landingpage *LandingPage) *AdvertiserLandingPagesPatchCall {
19107 c := &AdvertiserLandingPagesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19108 c.profileId = profileId
19109 c.urlParams_.Set("id", fmt.Sprint(id))
19110 c.landingpage = landingpage
19111 return c
19112 }
19113
19114
19115
19116
19117 func (c *AdvertiserLandingPagesPatchCall) Fields(s ...googleapi.Field) *AdvertiserLandingPagesPatchCall {
19118 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19119 return c
19120 }
19121
19122
19123
19124
19125 func (c *AdvertiserLandingPagesPatchCall) Context(ctx context.Context) *AdvertiserLandingPagesPatchCall {
19126 c.ctx_ = ctx
19127 return c
19128 }
19129
19130
19131
19132 func (c *AdvertiserLandingPagesPatchCall) Header() http.Header {
19133 if c.header_ == nil {
19134 c.header_ = make(http.Header)
19135 }
19136 return c.header_
19137 }
19138
19139 func (c *AdvertiserLandingPagesPatchCall) doRequest(alt string) (*http.Response, error) {
19140 reqHeaders := make(http.Header)
19141 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
19142 for k, v := range c.header_ {
19143 reqHeaders[k] = v
19144 }
19145 reqHeaders.Set("User-Agent", c.s.userAgent())
19146 var body io.Reader = nil
19147 body, err := googleapi.WithoutDataWrapper.JSONReader(c.landingpage)
19148 if err != nil {
19149 return nil, err
19150 }
19151 reqHeaders.Set("Content-Type", "application/json")
19152 c.urlParams_.Set("alt", alt)
19153 c.urlParams_.Set("prettyPrint", "false")
19154 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserLandingPages")
19155 urls += "?" + c.urlParams_.Encode()
19156 req, err := http.NewRequest("PATCH", urls, body)
19157 if err != nil {
19158 return nil, err
19159 }
19160 req.Header = reqHeaders
19161 googleapi.Expand(req.URL, map[string]string{
19162 "profileId": strconv.FormatInt(c.profileId, 10),
19163 })
19164 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19165 }
19166
19167
19168
19169
19170
19171
19172
19173
19174 func (c *AdvertiserLandingPagesPatchCall) Do(opts ...googleapi.CallOption) (*LandingPage, error) {
19175 gensupport.SetOptions(c.urlParams_, opts...)
19176 res, err := c.doRequest("json")
19177 if res != nil && res.StatusCode == http.StatusNotModified {
19178 if res.Body != nil {
19179 res.Body.Close()
19180 }
19181 return nil, &googleapi.Error{
19182 Code: res.StatusCode,
19183 Header: res.Header,
19184 }
19185 }
19186 if err != nil {
19187 return nil, err
19188 }
19189 defer googleapi.CloseBody(res)
19190 if err := googleapi.CheckResponse(res); err != nil {
19191 return nil, err
19192 }
19193 ret := &LandingPage{
19194 ServerResponse: googleapi.ServerResponse{
19195 Header: res.Header,
19196 HTTPStatusCode: res.StatusCode,
19197 },
19198 }
19199 target := &ret
19200 if err := gensupport.DecodeResponse(target, res); err != nil {
19201 return nil, err
19202 }
19203 return ret, nil
19204
19205
19206
19207
19208
19209
19210
19211
19212
19213
19214
19215
19216
19217
19218
19219
19220
19221
19222
19223
19224
19225
19226
19227
19228
19229
19230
19231
19232
19233
19234
19235
19236
19237
19238
19239
19240 }
19241
19242
19243
19244 type AdvertiserLandingPagesUpdateCall struct {
19245 s *Service
19246 profileId int64
19247 landingpage *LandingPage
19248 urlParams_ gensupport.URLParams
19249 ctx_ context.Context
19250 header_ http.Header
19251 }
19252
19253
19254 func (r *AdvertiserLandingPagesService) Update(profileId int64, landingpage *LandingPage) *AdvertiserLandingPagesUpdateCall {
19255 c := &AdvertiserLandingPagesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19256 c.profileId = profileId
19257 c.landingpage = landingpage
19258 return c
19259 }
19260
19261
19262
19263
19264 func (c *AdvertiserLandingPagesUpdateCall) Fields(s ...googleapi.Field) *AdvertiserLandingPagesUpdateCall {
19265 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19266 return c
19267 }
19268
19269
19270
19271
19272 func (c *AdvertiserLandingPagesUpdateCall) Context(ctx context.Context) *AdvertiserLandingPagesUpdateCall {
19273 c.ctx_ = ctx
19274 return c
19275 }
19276
19277
19278
19279 func (c *AdvertiserLandingPagesUpdateCall) Header() http.Header {
19280 if c.header_ == nil {
19281 c.header_ = make(http.Header)
19282 }
19283 return c.header_
19284 }
19285
19286 func (c *AdvertiserLandingPagesUpdateCall) doRequest(alt string) (*http.Response, error) {
19287 reqHeaders := make(http.Header)
19288 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
19289 for k, v := range c.header_ {
19290 reqHeaders[k] = v
19291 }
19292 reqHeaders.Set("User-Agent", c.s.userAgent())
19293 var body io.Reader = nil
19294 body, err := googleapi.WithoutDataWrapper.JSONReader(c.landingpage)
19295 if err != nil {
19296 return nil, err
19297 }
19298 reqHeaders.Set("Content-Type", "application/json")
19299 c.urlParams_.Set("alt", alt)
19300 c.urlParams_.Set("prettyPrint", "false")
19301 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertiserLandingPages")
19302 urls += "?" + c.urlParams_.Encode()
19303 req, err := http.NewRequest("PUT", urls, body)
19304 if err != nil {
19305 return nil, err
19306 }
19307 req.Header = reqHeaders
19308 googleapi.Expand(req.URL, map[string]string{
19309 "profileId": strconv.FormatInt(c.profileId, 10),
19310 })
19311 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19312 }
19313
19314
19315
19316
19317
19318
19319
19320
19321 func (c *AdvertiserLandingPagesUpdateCall) Do(opts ...googleapi.CallOption) (*LandingPage, error) {
19322 gensupport.SetOptions(c.urlParams_, opts...)
19323 res, err := c.doRequest("json")
19324 if res != nil && res.StatusCode == http.StatusNotModified {
19325 if res.Body != nil {
19326 res.Body.Close()
19327 }
19328 return nil, &googleapi.Error{
19329 Code: res.StatusCode,
19330 Header: res.Header,
19331 }
19332 }
19333 if err != nil {
19334 return nil, err
19335 }
19336 defer googleapi.CloseBody(res)
19337 if err := googleapi.CheckResponse(res); err != nil {
19338 return nil, err
19339 }
19340 ret := &LandingPage{
19341 ServerResponse: googleapi.ServerResponse{
19342 Header: res.Header,
19343 HTTPStatusCode: res.StatusCode,
19344 },
19345 }
19346 target := &ret
19347 if err := gensupport.DecodeResponse(target, res); err != nil {
19348 return nil, err
19349 }
19350 return ret, nil
19351
19352
19353
19354
19355
19356
19357
19358
19359
19360
19361
19362
19363
19364
19365
19366
19367
19368
19369
19370
19371
19372
19373
19374
19375
19376
19377
19378
19379 }
19380
19381
19382
19383 type AdvertisersGetCall struct {
19384 s *Service
19385 profileId int64
19386 id int64
19387 urlParams_ gensupport.URLParams
19388 ifNoneMatch_ string
19389 ctx_ context.Context
19390 header_ http.Header
19391 }
19392
19393
19394 func (r *AdvertisersService) Get(profileId int64, id int64) *AdvertisersGetCall {
19395 c := &AdvertisersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19396 c.profileId = profileId
19397 c.id = id
19398 return c
19399 }
19400
19401
19402
19403
19404 func (c *AdvertisersGetCall) Fields(s ...googleapi.Field) *AdvertisersGetCall {
19405 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19406 return c
19407 }
19408
19409
19410
19411
19412
19413
19414 func (c *AdvertisersGetCall) IfNoneMatch(entityTag string) *AdvertisersGetCall {
19415 c.ifNoneMatch_ = entityTag
19416 return c
19417 }
19418
19419
19420
19421
19422 func (c *AdvertisersGetCall) Context(ctx context.Context) *AdvertisersGetCall {
19423 c.ctx_ = ctx
19424 return c
19425 }
19426
19427
19428
19429 func (c *AdvertisersGetCall) Header() http.Header {
19430 if c.header_ == nil {
19431 c.header_ = make(http.Header)
19432 }
19433 return c.header_
19434 }
19435
19436 func (c *AdvertisersGetCall) doRequest(alt string) (*http.Response, error) {
19437 reqHeaders := make(http.Header)
19438 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
19439 for k, v := range c.header_ {
19440 reqHeaders[k] = v
19441 }
19442 reqHeaders.Set("User-Agent", c.s.userAgent())
19443 if c.ifNoneMatch_ != "" {
19444 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
19445 }
19446 var body io.Reader = nil
19447 c.urlParams_.Set("alt", alt)
19448 c.urlParams_.Set("prettyPrint", "false")
19449 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertisers/{id}")
19450 urls += "?" + c.urlParams_.Encode()
19451 req, err := http.NewRequest("GET", urls, body)
19452 if err != nil {
19453 return nil, err
19454 }
19455 req.Header = reqHeaders
19456 googleapi.Expand(req.URL, map[string]string{
19457 "profileId": strconv.FormatInt(c.profileId, 10),
19458 "id": strconv.FormatInt(c.id, 10),
19459 })
19460 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19461 }
19462
19463
19464
19465
19466
19467
19468
19469
19470 func (c *AdvertisersGetCall) Do(opts ...googleapi.CallOption) (*Advertiser, error) {
19471 gensupport.SetOptions(c.urlParams_, opts...)
19472 res, err := c.doRequest("json")
19473 if res != nil && res.StatusCode == http.StatusNotModified {
19474 if res.Body != nil {
19475 res.Body.Close()
19476 }
19477 return nil, &googleapi.Error{
19478 Code: res.StatusCode,
19479 Header: res.Header,
19480 }
19481 }
19482 if err != nil {
19483 return nil, err
19484 }
19485 defer googleapi.CloseBody(res)
19486 if err := googleapi.CheckResponse(res); err != nil {
19487 return nil, err
19488 }
19489 ret := &Advertiser{
19490 ServerResponse: googleapi.ServerResponse{
19491 Header: res.Header,
19492 HTTPStatusCode: res.StatusCode,
19493 },
19494 }
19495 target := &ret
19496 if err := gensupport.DecodeResponse(target, res); err != nil {
19497 return nil, err
19498 }
19499 return ret, nil
19500
19501
19502
19503
19504
19505
19506
19507
19508
19509
19510
19511
19512
19513
19514
19515
19516
19517
19518
19519
19520
19521
19522
19523
19524
19525
19526
19527
19528
19529
19530
19531
19532
19533 }
19534
19535
19536
19537 type AdvertisersInsertCall struct {
19538 s *Service
19539 profileId int64
19540 advertiser *Advertiser
19541 urlParams_ gensupport.URLParams
19542 ctx_ context.Context
19543 header_ http.Header
19544 }
19545
19546
19547 func (r *AdvertisersService) Insert(profileId int64, advertiser *Advertiser) *AdvertisersInsertCall {
19548 c := &AdvertisersInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19549 c.profileId = profileId
19550 c.advertiser = advertiser
19551 return c
19552 }
19553
19554
19555
19556
19557 func (c *AdvertisersInsertCall) Fields(s ...googleapi.Field) *AdvertisersInsertCall {
19558 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19559 return c
19560 }
19561
19562
19563
19564
19565 func (c *AdvertisersInsertCall) Context(ctx context.Context) *AdvertisersInsertCall {
19566 c.ctx_ = ctx
19567 return c
19568 }
19569
19570
19571
19572 func (c *AdvertisersInsertCall) Header() http.Header {
19573 if c.header_ == nil {
19574 c.header_ = make(http.Header)
19575 }
19576 return c.header_
19577 }
19578
19579 func (c *AdvertisersInsertCall) doRequest(alt string) (*http.Response, error) {
19580 reqHeaders := make(http.Header)
19581 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
19582 for k, v := range c.header_ {
19583 reqHeaders[k] = v
19584 }
19585 reqHeaders.Set("User-Agent", c.s.userAgent())
19586 var body io.Reader = nil
19587 body, err := googleapi.WithoutDataWrapper.JSONReader(c.advertiser)
19588 if err != nil {
19589 return nil, err
19590 }
19591 reqHeaders.Set("Content-Type", "application/json")
19592 c.urlParams_.Set("alt", alt)
19593 c.urlParams_.Set("prettyPrint", "false")
19594 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertisers")
19595 urls += "?" + c.urlParams_.Encode()
19596 req, err := http.NewRequest("POST", urls, body)
19597 if err != nil {
19598 return nil, err
19599 }
19600 req.Header = reqHeaders
19601 googleapi.Expand(req.URL, map[string]string{
19602 "profileId": strconv.FormatInt(c.profileId, 10),
19603 })
19604 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19605 }
19606
19607
19608
19609
19610
19611
19612
19613
19614 func (c *AdvertisersInsertCall) Do(opts ...googleapi.CallOption) (*Advertiser, error) {
19615 gensupport.SetOptions(c.urlParams_, opts...)
19616 res, err := c.doRequest("json")
19617 if res != nil && res.StatusCode == http.StatusNotModified {
19618 if res.Body != nil {
19619 res.Body.Close()
19620 }
19621 return nil, &googleapi.Error{
19622 Code: res.StatusCode,
19623 Header: res.Header,
19624 }
19625 }
19626 if err != nil {
19627 return nil, err
19628 }
19629 defer googleapi.CloseBody(res)
19630 if err := googleapi.CheckResponse(res); err != nil {
19631 return nil, err
19632 }
19633 ret := &Advertiser{
19634 ServerResponse: googleapi.ServerResponse{
19635 Header: res.Header,
19636 HTTPStatusCode: res.StatusCode,
19637 },
19638 }
19639 target := &ret
19640 if err := gensupport.DecodeResponse(target, res); err != nil {
19641 return nil, err
19642 }
19643 return ret, nil
19644
19645
19646
19647
19648
19649
19650
19651
19652
19653
19654
19655
19656
19657
19658
19659
19660
19661
19662
19663
19664
19665
19666
19667
19668
19669
19670
19671
19672 }
19673
19674
19675
19676 type AdvertisersListCall struct {
19677 s *Service
19678 profileId int64
19679 urlParams_ gensupport.URLParams
19680 ifNoneMatch_ string
19681 ctx_ context.Context
19682 header_ http.Header
19683 }
19684
19685
19686
19687 func (r *AdvertisersService) List(profileId int64) *AdvertisersListCall {
19688 c := &AdvertisersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19689 c.profileId = profileId
19690 return c
19691 }
19692
19693
19694
19695 func (c *AdvertisersListCall) AdvertiserGroupIds(advertiserGroupIds ...int64) *AdvertisersListCall {
19696 var advertiserGroupIds_ []string
19697 for _, v := range advertiserGroupIds {
19698 advertiserGroupIds_ = append(advertiserGroupIds_, fmt.Sprint(v))
19699 }
19700 c.urlParams_.SetMulti("advertiserGroupIds", advertiserGroupIds_)
19701 return c
19702 }
19703
19704
19705
19706
19707 func (c *AdvertisersListCall) FloodlightConfigurationIds(floodlightConfigurationIds ...int64) *AdvertisersListCall {
19708 var floodlightConfigurationIds_ []string
19709 for _, v := range floodlightConfigurationIds {
19710 floodlightConfigurationIds_ = append(floodlightConfigurationIds_, fmt.Sprint(v))
19711 }
19712 c.urlParams_.SetMulti("floodlightConfigurationIds", floodlightConfigurationIds_)
19713 return c
19714 }
19715
19716
19717
19718 func (c *AdvertisersListCall) Ids(ids ...int64) *AdvertisersListCall {
19719 var ids_ []string
19720 for _, v := range ids {
19721 ids_ = append(ids_, fmt.Sprint(v))
19722 }
19723 c.urlParams_.SetMulti("ids", ids_)
19724 return c
19725 }
19726
19727
19728
19729
19730 func (c *AdvertisersListCall) IncludeAdvertisersWithoutGroupsOnly(includeAdvertisersWithoutGroupsOnly bool) *AdvertisersListCall {
19731 c.urlParams_.Set("includeAdvertisersWithoutGroupsOnly", fmt.Sprint(includeAdvertisersWithoutGroupsOnly))
19732 return c
19733 }
19734
19735
19736
19737 func (c *AdvertisersListCall) MaxResults(maxResults int64) *AdvertisersListCall {
19738 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
19739 return c
19740 }
19741
19742
19743
19744 func (c *AdvertisersListCall) OnlyParent(onlyParent bool) *AdvertisersListCall {
19745 c.urlParams_.Set("onlyParent", fmt.Sprint(onlyParent))
19746 return c
19747 }
19748
19749
19750
19751 func (c *AdvertisersListCall) PageToken(pageToken string) *AdvertisersListCall {
19752 c.urlParams_.Set("pageToken", pageToken)
19753 return c
19754 }
19755
19756
19757
19758
19759
19760
19761
19762
19763
19764 func (c *AdvertisersListCall) SearchString(searchString string) *AdvertisersListCall {
19765 c.urlParams_.Set("searchString", searchString)
19766 return c
19767 }
19768
19769
19770
19771
19772
19773
19774
19775
19776 func (c *AdvertisersListCall) SortField(sortField string) *AdvertisersListCall {
19777 c.urlParams_.Set("sortField", sortField)
19778 return c
19779 }
19780
19781
19782
19783
19784
19785
19786
19787
19788 func (c *AdvertisersListCall) SortOrder(sortOrder string) *AdvertisersListCall {
19789 c.urlParams_.Set("sortOrder", sortOrder)
19790 return c
19791 }
19792
19793
19794
19795
19796
19797
19798
19799
19800 func (c *AdvertisersListCall) Status(status string) *AdvertisersListCall {
19801 c.urlParams_.Set("status", status)
19802 return c
19803 }
19804
19805
19806
19807 func (c *AdvertisersListCall) SubaccountId(subaccountId int64) *AdvertisersListCall {
19808 c.urlParams_.Set("subaccountId", fmt.Sprint(subaccountId))
19809 return c
19810 }
19811
19812
19813
19814
19815 func (c *AdvertisersListCall) Fields(s ...googleapi.Field) *AdvertisersListCall {
19816 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19817 return c
19818 }
19819
19820
19821
19822
19823
19824
19825 func (c *AdvertisersListCall) IfNoneMatch(entityTag string) *AdvertisersListCall {
19826 c.ifNoneMatch_ = entityTag
19827 return c
19828 }
19829
19830
19831
19832
19833 func (c *AdvertisersListCall) Context(ctx context.Context) *AdvertisersListCall {
19834 c.ctx_ = ctx
19835 return c
19836 }
19837
19838
19839
19840 func (c *AdvertisersListCall) Header() http.Header {
19841 if c.header_ == nil {
19842 c.header_ = make(http.Header)
19843 }
19844 return c.header_
19845 }
19846
19847 func (c *AdvertisersListCall) doRequest(alt string) (*http.Response, error) {
19848 reqHeaders := make(http.Header)
19849 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
19850 for k, v := range c.header_ {
19851 reqHeaders[k] = v
19852 }
19853 reqHeaders.Set("User-Agent", c.s.userAgent())
19854 if c.ifNoneMatch_ != "" {
19855 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
19856 }
19857 var body io.Reader = nil
19858 c.urlParams_.Set("alt", alt)
19859 c.urlParams_.Set("prettyPrint", "false")
19860 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertisers")
19861 urls += "?" + c.urlParams_.Encode()
19862 req, err := http.NewRequest("GET", urls, body)
19863 if err != nil {
19864 return nil, err
19865 }
19866 req.Header = reqHeaders
19867 googleapi.Expand(req.URL, map[string]string{
19868 "profileId": strconv.FormatInt(c.profileId, 10),
19869 })
19870 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19871 }
19872
19873
19874
19875
19876
19877
19878
19879
19880 func (c *AdvertisersListCall) Do(opts ...googleapi.CallOption) (*AdvertisersListResponse, error) {
19881 gensupport.SetOptions(c.urlParams_, opts...)
19882 res, err := c.doRequest("json")
19883 if res != nil && res.StatusCode == http.StatusNotModified {
19884 if res.Body != nil {
19885 res.Body.Close()
19886 }
19887 return nil, &googleapi.Error{
19888 Code: res.StatusCode,
19889 Header: res.Header,
19890 }
19891 }
19892 if err != nil {
19893 return nil, err
19894 }
19895 defer googleapi.CloseBody(res)
19896 if err := googleapi.CheckResponse(res); err != nil {
19897 return nil, err
19898 }
19899 ret := &AdvertisersListResponse{
19900 ServerResponse: googleapi.ServerResponse{
19901 Header: res.Header,
19902 HTTPStatusCode: res.StatusCode,
19903 },
19904 }
19905 target := &ret
19906 if err := gensupport.DecodeResponse(target, res); err != nil {
19907 return nil, err
19908 }
19909 return ret, nil
19910
19911
19912
19913
19914
19915
19916
19917
19918
19919
19920
19921
19922
19923
19924
19925
19926
19927
19928
19929
19930
19931
19932
19933
19934
19935
19936
19937
19938
19939
19940
19941
19942
19943
19944
19945
19946
19947
19948
19949
19950
19951
19952
19953
19954
19955
19956
19957
19958
19959
19960
19961
19962
19963
19964
19965
19966
19967
19968
19969
19970
19971
19972
19973
19974
19975
19976
19977
19978
19979
19980
19981
19982
19983
19984
19985
19986
19987
19988
19989
19990
19991
19992
19993
19994
19995
19996
19997
19998
19999
20000
20001
20002
20003
20004
20005
20006
20007
20008
20009
20010
20011
20012
20013
20014
20015
20016
20017
20018
20019
20020
20021
20022
20023
20024
20025
20026
20027
20028
20029
20030
20031
20032 }
20033
20034
20035
20036
20037 func (c *AdvertisersListCall) Pages(ctx context.Context, f func(*AdvertisersListResponse) error) error {
20038 c.ctx_ = ctx
20039 defer c.PageToken(c.urlParams_.Get("pageToken"))
20040 for {
20041 x, err := c.Do()
20042 if err != nil {
20043 return err
20044 }
20045 if err := f(x); err != nil {
20046 return err
20047 }
20048 if x.NextPageToken == "" {
20049 return nil
20050 }
20051 c.PageToken(x.NextPageToken)
20052 }
20053 }
20054
20055
20056
20057 type AdvertisersPatchCall struct {
20058 s *Service
20059 profileId int64
20060 advertiser *Advertiser
20061 urlParams_ gensupport.URLParams
20062 ctx_ context.Context
20063 header_ http.Header
20064 }
20065
20066
20067
20068 func (r *AdvertisersService) Patch(profileId int64, id int64, advertiser *Advertiser) *AdvertisersPatchCall {
20069 c := &AdvertisersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20070 c.profileId = profileId
20071 c.urlParams_.Set("id", fmt.Sprint(id))
20072 c.advertiser = advertiser
20073 return c
20074 }
20075
20076
20077
20078
20079 func (c *AdvertisersPatchCall) Fields(s ...googleapi.Field) *AdvertisersPatchCall {
20080 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20081 return c
20082 }
20083
20084
20085
20086
20087 func (c *AdvertisersPatchCall) Context(ctx context.Context) *AdvertisersPatchCall {
20088 c.ctx_ = ctx
20089 return c
20090 }
20091
20092
20093
20094 func (c *AdvertisersPatchCall) Header() http.Header {
20095 if c.header_ == nil {
20096 c.header_ = make(http.Header)
20097 }
20098 return c.header_
20099 }
20100
20101 func (c *AdvertisersPatchCall) doRequest(alt string) (*http.Response, error) {
20102 reqHeaders := make(http.Header)
20103 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
20104 for k, v := range c.header_ {
20105 reqHeaders[k] = v
20106 }
20107 reqHeaders.Set("User-Agent", c.s.userAgent())
20108 var body io.Reader = nil
20109 body, err := googleapi.WithoutDataWrapper.JSONReader(c.advertiser)
20110 if err != nil {
20111 return nil, err
20112 }
20113 reqHeaders.Set("Content-Type", "application/json")
20114 c.urlParams_.Set("alt", alt)
20115 c.urlParams_.Set("prettyPrint", "false")
20116 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertisers")
20117 urls += "?" + c.urlParams_.Encode()
20118 req, err := http.NewRequest("PATCH", urls, body)
20119 if err != nil {
20120 return nil, err
20121 }
20122 req.Header = reqHeaders
20123 googleapi.Expand(req.URL, map[string]string{
20124 "profileId": strconv.FormatInt(c.profileId, 10),
20125 })
20126 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20127 }
20128
20129
20130
20131
20132
20133
20134
20135
20136 func (c *AdvertisersPatchCall) Do(opts ...googleapi.CallOption) (*Advertiser, error) {
20137 gensupport.SetOptions(c.urlParams_, opts...)
20138 res, err := c.doRequest("json")
20139 if res != nil && res.StatusCode == http.StatusNotModified {
20140 if res.Body != nil {
20141 res.Body.Close()
20142 }
20143 return nil, &googleapi.Error{
20144 Code: res.StatusCode,
20145 Header: res.Header,
20146 }
20147 }
20148 if err != nil {
20149 return nil, err
20150 }
20151 defer googleapi.CloseBody(res)
20152 if err := googleapi.CheckResponse(res); err != nil {
20153 return nil, err
20154 }
20155 ret := &Advertiser{
20156 ServerResponse: googleapi.ServerResponse{
20157 Header: res.Header,
20158 HTTPStatusCode: res.StatusCode,
20159 },
20160 }
20161 target := &ret
20162 if err := gensupport.DecodeResponse(target, res); err != nil {
20163 return nil, err
20164 }
20165 return ret, nil
20166
20167
20168
20169
20170
20171
20172
20173
20174
20175
20176
20177
20178
20179
20180
20181
20182
20183
20184
20185
20186
20187
20188
20189
20190
20191
20192
20193
20194
20195
20196
20197
20198
20199
20200
20201
20202 }
20203
20204
20205
20206 type AdvertisersUpdateCall struct {
20207 s *Service
20208 profileId int64
20209 advertiser *Advertiser
20210 urlParams_ gensupport.URLParams
20211 ctx_ context.Context
20212 header_ http.Header
20213 }
20214
20215
20216 func (r *AdvertisersService) Update(profileId int64, advertiser *Advertiser) *AdvertisersUpdateCall {
20217 c := &AdvertisersUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20218 c.profileId = profileId
20219 c.advertiser = advertiser
20220 return c
20221 }
20222
20223
20224
20225
20226 func (c *AdvertisersUpdateCall) Fields(s ...googleapi.Field) *AdvertisersUpdateCall {
20227 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20228 return c
20229 }
20230
20231
20232
20233
20234 func (c *AdvertisersUpdateCall) Context(ctx context.Context) *AdvertisersUpdateCall {
20235 c.ctx_ = ctx
20236 return c
20237 }
20238
20239
20240
20241 func (c *AdvertisersUpdateCall) Header() http.Header {
20242 if c.header_ == nil {
20243 c.header_ = make(http.Header)
20244 }
20245 return c.header_
20246 }
20247
20248 func (c *AdvertisersUpdateCall) doRequest(alt string) (*http.Response, error) {
20249 reqHeaders := make(http.Header)
20250 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
20251 for k, v := range c.header_ {
20252 reqHeaders[k] = v
20253 }
20254 reqHeaders.Set("User-Agent", c.s.userAgent())
20255 var body io.Reader = nil
20256 body, err := googleapi.WithoutDataWrapper.JSONReader(c.advertiser)
20257 if err != nil {
20258 return nil, err
20259 }
20260 reqHeaders.Set("Content-Type", "application/json")
20261 c.urlParams_.Set("alt", alt)
20262 c.urlParams_.Set("prettyPrint", "false")
20263 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/advertisers")
20264 urls += "?" + c.urlParams_.Encode()
20265 req, err := http.NewRequest("PUT", urls, body)
20266 if err != nil {
20267 return nil, err
20268 }
20269 req.Header = reqHeaders
20270 googleapi.Expand(req.URL, map[string]string{
20271 "profileId": strconv.FormatInt(c.profileId, 10),
20272 })
20273 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20274 }
20275
20276
20277
20278
20279
20280
20281
20282
20283 func (c *AdvertisersUpdateCall) Do(opts ...googleapi.CallOption) (*Advertiser, error) {
20284 gensupport.SetOptions(c.urlParams_, opts...)
20285 res, err := c.doRequest("json")
20286 if res != nil && res.StatusCode == http.StatusNotModified {
20287 if res.Body != nil {
20288 res.Body.Close()
20289 }
20290 return nil, &googleapi.Error{
20291 Code: res.StatusCode,
20292 Header: res.Header,
20293 }
20294 }
20295 if err != nil {
20296 return nil, err
20297 }
20298 defer googleapi.CloseBody(res)
20299 if err := googleapi.CheckResponse(res); err != nil {
20300 return nil, err
20301 }
20302 ret := &Advertiser{
20303 ServerResponse: googleapi.ServerResponse{
20304 Header: res.Header,
20305 HTTPStatusCode: res.StatusCode,
20306 },
20307 }
20308 target := &ret
20309 if err := gensupport.DecodeResponse(target, res); err != nil {
20310 return nil, err
20311 }
20312 return ret, nil
20313
20314
20315
20316
20317
20318
20319
20320
20321
20322
20323
20324
20325
20326
20327
20328
20329
20330
20331
20332
20333
20334
20335
20336
20337
20338
20339
20340
20341 }
20342
20343
20344
20345 type BrowsersListCall struct {
20346 s *Service
20347 profileId int64
20348 urlParams_ gensupport.URLParams
20349 ifNoneMatch_ string
20350 ctx_ context.Context
20351 header_ http.Header
20352 }
20353
20354
20355 func (r *BrowsersService) List(profileId int64) *BrowsersListCall {
20356 c := &BrowsersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20357 c.profileId = profileId
20358 return c
20359 }
20360
20361
20362
20363
20364 func (c *BrowsersListCall) Fields(s ...googleapi.Field) *BrowsersListCall {
20365 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20366 return c
20367 }
20368
20369
20370
20371
20372
20373
20374 func (c *BrowsersListCall) IfNoneMatch(entityTag string) *BrowsersListCall {
20375 c.ifNoneMatch_ = entityTag
20376 return c
20377 }
20378
20379
20380
20381
20382 func (c *BrowsersListCall) Context(ctx context.Context) *BrowsersListCall {
20383 c.ctx_ = ctx
20384 return c
20385 }
20386
20387
20388
20389 func (c *BrowsersListCall) Header() http.Header {
20390 if c.header_ == nil {
20391 c.header_ = make(http.Header)
20392 }
20393 return c.header_
20394 }
20395
20396 func (c *BrowsersListCall) doRequest(alt string) (*http.Response, error) {
20397 reqHeaders := make(http.Header)
20398 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
20399 for k, v := range c.header_ {
20400 reqHeaders[k] = v
20401 }
20402 reqHeaders.Set("User-Agent", c.s.userAgent())
20403 if c.ifNoneMatch_ != "" {
20404 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20405 }
20406 var body io.Reader = nil
20407 c.urlParams_.Set("alt", alt)
20408 c.urlParams_.Set("prettyPrint", "false")
20409 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/browsers")
20410 urls += "?" + c.urlParams_.Encode()
20411 req, err := http.NewRequest("GET", urls, body)
20412 if err != nil {
20413 return nil, err
20414 }
20415 req.Header = reqHeaders
20416 googleapi.Expand(req.URL, map[string]string{
20417 "profileId": strconv.FormatInt(c.profileId, 10),
20418 })
20419 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20420 }
20421
20422
20423
20424
20425
20426
20427
20428
20429 func (c *BrowsersListCall) Do(opts ...googleapi.CallOption) (*BrowsersListResponse, error) {
20430 gensupport.SetOptions(c.urlParams_, opts...)
20431 res, err := c.doRequest("json")
20432 if res != nil && res.StatusCode == http.StatusNotModified {
20433 if res.Body != nil {
20434 res.Body.Close()
20435 }
20436 return nil, &googleapi.Error{
20437 Code: res.StatusCode,
20438 Header: res.Header,
20439 }
20440 }
20441 if err != nil {
20442 return nil, err
20443 }
20444 defer googleapi.CloseBody(res)
20445 if err := googleapi.CheckResponse(res); err != nil {
20446 return nil, err
20447 }
20448 ret := &BrowsersListResponse{
20449 ServerResponse: googleapi.ServerResponse{
20450 Header: res.Header,
20451 HTTPStatusCode: res.StatusCode,
20452 },
20453 }
20454 target := &ret
20455 if err := gensupport.DecodeResponse(target, res); err != nil {
20456 return nil, err
20457 }
20458 return ret, nil
20459
20460
20461
20462
20463
20464
20465
20466
20467
20468
20469
20470
20471
20472
20473
20474
20475
20476
20477
20478
20479
20480
20481
20482
20483
20484 }
20485
20486
20487
20488 type CampaignCreativeAssociationsInsertCall struct {
20489 s *Service
20490 profileId int64
20491 campaignId int64
20492 campaigncreativeassociation *CampaignCreativeAssociation
20493 urlParams_ gensupport.URLParams
20494 ctx_ context.Context
20495 header_ http.Header
20496 }
20497
20498
20499
20500
20501 func (r *CampaignCreativeAssociationsService) Insert(profileId int64, campaignId int64, campaigncreativeassociation *CampaignCreativeAssociation) *CampaignCreativeAssociationsInsertCall {
20502 c := &CampaignCreativeAssociationsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20503 c.profileId = profileId
20504 c.campaignId = campaignId
20505 c.campaigncreativeassociation = campaigncreativeassociation
20506 return c
20507 }
20508
20509
20510
20511
20512 func (c *CampaignCreativeAssociationsInsertCall) Fields(s ...googleapi.Field) *CampaignCreativeAssociationsInsertCall {
20513 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20514 return c
20515 }
20516
20517
20518
20519
20520 func (c *CampaignCreativeAssociationsInsertCall) Context(ctx context.Context) *CampaignCreativeAssociationsInsertCall {
20521 c.ctx_ = ctx
20522 return c
20523 }
20524
20525
20526
20527 func (c *CampaignCreativeAssociationsInsertCall) Header() http.Header {
20528 if c.header_ == nil {
20529 c.header_ = make(http.Header)
20530 }
20531 return c.header_
20532 }
20533
20534 func (c *CampaignCreativeAssociationsInsertCall) doRequest(alt string) (*http.Response, error) {
20535 reqHeaders := make(http.Header)
20536 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
20537 for k, v := range c.header_ {
20538 reqHeaders[k] = v
20539 }
20540 reqHeaders.Set("User-Agent", c.s.userAgent())
20541 var body io.Reader = nil
20542 body, err := googleapi.WithoutDataWrapper.JSONReader(c.campaigncreativeassociation)
20543 if err != nil {
20544 return nil, err
20545 }
20546 reqHeaders.Set("Content-Type", "application/json")
20547 c.urlParams_.Set("alt", alt)
20548 c.urlParams_.Set("prettyPrint", "false")
20549 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/campaigns/{campaignId}/campaignCreativeAssociations")
20550 urls += "?" + c.urlParams_.Encode()
20551 req, err := http.NewRequest("POST", urls, body)
20552 if err != nil {
20553 return nil, err
20554 }
20555 req.Header = reqHeaders
20556 googleapi.Expand(req.URL, map[string]string{
20557 "profileId": strconv.FormatInt(c.profileId, 10),
20558 "campaignId": strconv.FormatInt(c.campaignId, 10),
20559 })
20560 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20561 }
20562
20563
20564
20565
20566
20567
20568
20569
20570 func (c *CampaignCreativeAssociationsInsertCall) Do(opts ...googleapi.CallOption) (*CampaignCreativeAssociation, error) {
20571 gensupport.SetOptions(c.urlParams_, opts...)
20572 res, err := c.doRequest("json")
20573 if res != nil && res.StatusCode == http.StatusNotModified {
20574 if res.Body != nil {
20575 res.Body.Close()
20576 }
20577 return nil, &googleapi.Error{
20578 Code: res.StatusCode,
20579 Header: res.Header,
20580 }
20581 }
20582 if err != nil {
20583 return nil, err
20584 }
20585 defer googleapi.CloseBody(res)
20586 if err := googleapi.CheckResponse(res); err != nil {
20587 return nil, err
20588 }
20589 ret := &CampaignCreativeAssociation{
20590 ServerResponse: googleapi.ServerResponse{
20591 Header: res.Header,
20592 HTTPStatusCode: res.StatusCode,
20593 },
20594 }
20595 target := &ret
20596 if err := gensupport.DecodeResponse(target, res); err != nil {
20597 return nil, err
20598 }
20599 return ret, nil
20600
20601
20602
20603
20604
20605
20606
20607
20608
20609
20610
20611
20612
20613
20614
20615
20616
20617
20618
20619
20620
20621
20622
20623
20624
20625
20626
20627
20628
20629
20630
20631
20632
20633
20634
20635
20636 }
20637
20638
20639
20640 type CampaignCreativeAssociationsListCall struct {
20641 s *Service
20642 profileId int64
20643 campaignId int64
20644 urlParams_ gensupport.URLParams
20645 ifNoneMatch_ string
20646 ctx_ context.Context
20647 header_ http.Header
20648 }
20649
20650
20651
20652 func (r *CampaignCreativeAssociationsService) List(profileId int64, campaignId int64) *CampaignCreativeAssociationsListCall {
20653 c := &CampaignCreativeAssociationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20654 c.profileId = profileId
20655 c.campaignId = campaignId
20656 return c
20657 }
20658
20659
20660
20661 func (c *CampaignCreativeAssociationsListCall) MaxResults(maxResults int64) *CampaignCreativeAssociationsListCall {
20662 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
20663 return c
20664 }
20665
20666
20667
20668 func (c *CampaignCreativeAssociationsListCall) PageToken(pageToken string) *CampaignCreativeAssociationsListCall {
20669 c.urlParams_.Set("pageToken", pageToken)
20670 return c
20671 }
20672
20673
20674
20675
20676
20677
20678
20679
20680 func (c *CampaignCreativeAssociationsListCall) SortOrder(sortOrder string) *CampaignCreativeAssociationsListCall {
20681 c.urlParams_.Set("sortOrder", sortOrder)
20682 return c
20683 }
20684
20685
20686
20687
20688 func (c *CampaignCreativeAssociationsListCall) Fields(s ...googleapi.Field) *CampaignCreativeAssociationsListCall {
20689 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20690 return c
20691 }
20692
20693
20694
20695
20696
20697
20698 func (c *CampaignCreativeAssociationsListCall) IfNoneMatch(entityTag string) *CampaignCreativeAssociationsListCall {
20699 c.ifNoneMatch_ = entityTag
20700 return c
20701 }
20702
20703
20704
20705
20706 func (c *CampaignCreativeAssociationsListCall) Context(ctx context.Context) *CampaignCreativeAssociationsListCall {
20707 c.ctx_ = ctx
20708 return c
20709 }
20710
20711
20712
20713 func (c *CampaignCreativeAssociationsListCall) Header() http.Header {
20714 if c.header_ == nil {
20715 c.header_ = make(http.Header)
20716 }
20717 return c.header_
20718 }
20719
20720 func (c *CampaignCreativeAssociationsListCall) doRequest(alt string) (*http.Response, error) {
20721 reqHeaders := make(http.Header)
20722 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
20723 for k, v := range c.header_ {
20724 reqHeaders[k] = v
20725 }
20726 reqHeaders.Set("User-Agent", c.s.userAgent())
20727 if c.ifNoneMatch_ != "" {
20728 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20729 }
20730 var body io.Reader = nil
20731 c.urlParams_.Set("alt", alt)
20732 c.urlParams_.Set("prettyPrint", "false")
20733 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/campaigns/{campaignId}/campaignCreativeAssociations")
20734 urls += "?" + c.urlParams_.Encode()
20735 req, err := http.NewRequest("GET", urls, body)
20736 if err != nil {
20737 return nil, err
20738 }
20739 req.Header = reqHeaders
20740 googleapi.Expand(req.URL, map[string]string{
20741 "profileId": strconv.FormatInt(c.profileId, 10),
20742 "campaignId": strconv.FormatInt(c.campaignId, 10),
20743 })
20744 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20745 }
20746
20747
20748
20749
20750
20751
20752
20753
20754
20755
20756 func (c *CampaignCreativeAssociationsListCall) Do(opts ...googleapi.CallOption) (*CampaignCreativeAssociationsListResponse, error) {
20757 gensupport.SetOptions(c.urlParams_, opts...)
20758 res, err := c.doRequest("json")
20759 if res != nil && res.StatusCode == http.StatusNotModified {
20760 if res.Body != nil {
20761 res.Body.Close()
20762 }
20763 return nil, &googleapi.Error{
20764 Code: res.StatusCode,
20765 Header: res.Header,
20766 }
20767 }
20768 if err != nil {
20769 return nil, err
20770 }
20771 defer googleapi.CloseBody(res)
20772 if err := googleapi.CheckResponse(res); err != nil {
20773 return nil, err
20774 }
20775 ret := &CampaignCreativeAssociationsListResponse{
20776 ServerResponse: googleapi.ServerResponse{
20777 Header: res.Header,
20778 HTTPStatusCode: res.StatusCode,
20779 },
20780 }
20781 target := &ret
20782 if err := gensupport.DecodeResponse(target, res); err != nil {
20783 return nil, err
20784 }
20785 return ret, nil
20786
20787
20788
20789
20790
20791
20792
20793
20794
20795
20796
20797
20798
20799
20800
20801
20802
20803
20804
20805
20806
20807
20808
20809
20810
20811
20812
20813
20814
20815
20816
20817
20818
20819
20820
20821
20822
20823
20824
20825
20826
20827
20828
20829
20830
20831
20832
20833
20834
20835
20836
20837
20838
20839
20840
20841
20842
20843
20844
20845
20846
20847 }
20848
20849
20850
20851
20852 func (c *CampaignCreativeAssociationsListCall) Pages(ctx context.Context, f func(*CampaignCreativeAssociationsListResponse) error) error {
20853 c.ctx_ = ctx
20854 defer c.PageToken(c.urlParams_.Get("pageToken"))
20855 for {
20856 x, err := c.Do()
20857 if err != nil {
20858 return err
20859 }
20860 if err := f(x); err != nil {
20861 return err
20862 }
20863 if x.NextPageToken == "" {
20864 return nil
20865 }
20866 c.PageToken(x.NextPageToken)
20867 }
20868 }
20869
20870
20871
20872 type CampaignsGetCall struct {
20873 s *Service
20874 profileId int64
20875 id int64
20876 urlParams_ gensupport.URLParams
20877 ifNoneMatch_ string
20878 ctx_ context.Context
20879 header_ http.Header
20880 }
20881
20882
20883 func (r *CampaignsService) Get(profileId int64, id int64) *CampaignsGetCall {
20884 c := &CampaignsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20885 c.profileId = profileId
20886 c.id = id
20887 return c
20888 }
20889
20890
20891
20892
20893 func (c *CampaignsGetCall) Fields(s ...googleapi.Field) *CampaignsGetCall {
20894 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20895 return c
20896 }
20897
20898
20899
20900
20901
20902
20903 func (c *CampaignsGetCall) IfNoneMatch(entityTag string) *CampaignsGetCall {
20904 c.ifNoneMatch_ = entityTag
20905 return c
20906 }
20907
20908
20909
20910
20911 func (c *CampaignsGetCall) Context(ctx context.Context) *CampaignsGetCall {
20912 c.ctx_ = ctx
20913 return c
20914 }
20915
20916
20917
20918 func (c *CampaignsGetCall) Header() http.Header {
20919 if c.header_ == nil {
20920 c.header_ = make(http.Header)
20921 }
20922 return c.header_
20923 }
20924
20925 func (c *CampaignsGetCall) doRequest(alt string) (*http.Response, error) {
20926 reqHeaders := make(http.Header)
20927 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
20928 for k, v := range c.header_ {
20929 reqHeaders[k] = v
20930 }
20931 reqHeaders.Set("User-Agent", c.s.userAgent())
20932 if c.ifNoneMatch_ != "" {
20933 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20934 }
20935 var body io.Reader = nil
20936 c.urlParams_.Set("alt", alt)
20937 c.urlParams_.Set("prettyPrint", "false")
20938 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/campaigns/{id}")
20939 urls += "?" + c.urlParams_.Encode()
20940 req, err := http.NewRequest("GET", urls, body)
20941 if err != nil {
20942 return nil, err
20943 }
20944 req.Header = reqHeaders
20945 googleapi.Expand(req.URL, map[string]string{
20946 "profileId": strconv.FormatInt(c.profileId, 10),
20947 "id": strconv.FormatInt(c.id, 10),
20948 })
20949 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20950 }
20951
20952
20953
20954
20955
20956
20957
20958
20959 func (c *CampaignsGetCall) Do(opts ...googleapi.CallOption) (*Campaign, error) {
20960 gensupport.SetOptions(c.urlParams_, opts...)
20961 res, err := c.doRequest("json")
20962 if res != nil && res.StatusCode == http.StatusNotModified {
20963 if res.Body != nil {
20964 res.Body.Close()
20965 }
20966 return nil, &googleapi.Error{
20967 Code: res.StatusCode,
20968 Header: res.Header,
20969 }
20970 }
20971 if err != nil {
20972 return nil, err
20973 }
20974 defer googleapi.CloseBody(res)
20975 if err := googleapi.CheckResponse(res); err != nil {
20976 return nil, err
20977 }
20978 ret := &Campaign{
20979 ServerResponse: googleapi.ServerResponse{
20980 Header: res.Header,
20981 HTTPStatusCode: res.StatusCode,
20982 },
20983 }
20984 target := &ret
20985 if err := gensupport.DecodeResponse(target, res); err != nil {
20986 return nil, err
20987 }
20988 return ret, nil
20989
20990
20991
20992
20993
20994
20995
20996
20997
20998
20999
21000
21001
21002
21003
21004
21005
21006
21007
21008
21009
21010
21011
21012
21013
21014
21015
21016
21017
21018
21019
21020
21021
21022 }
21023
21024
21025
21026 type CampaignsInsertCall struct {
21027 s *Service
21028 profileId int64
21029 campaign *Campaign
21030 urlParams_ gensupport.URLParams
21031 ctx_ context.Context
21032 header_ http.Header
21033 }
21034
21035
21036 func (r *CampaignsService) Insert(profileId int64, campaign *Campaign) *CampaignsInsertCall {
21037 c := &CampaignsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21038 c.profileId = profileId
21039 c.campaign = campaign
21040 return c
21041 }
21042
21043
21044
21045
21046 func (c *CampaignsInsertCall) Fields(s ...googleapi.Field) *CampaignsInsertCall {
21047 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21048 return c
21049 }
21050
21051
21052
21053
21054 func (c *CampaignsInsertCall) Context(ctx context.Context) *CampaignsInsertCall {
21055 c.ctx_ = ctx
21056 return c
21057 }
21058
21059
21060
21061 func (c *CampaignsInsertCall) Header() http.Header {
21062 if c.header_ == nil {
21063 c.header_ = make(http.Header)
21064 }
21065 return c.header_
21066 }
21067
21068 func (c *CampaignsInsertCall) doRequest(alt string) (*http.Response, error) {
21069 reqHeaders := make(http.Header)
21070 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
21071 for k, v := range c.header_ {
21072 reqHeaders[k] = v
21073 }
21074 reqHeaders.Set("User-Agent", c.s.userAgent())
21075 var body io.Reader = nil
21076 body, err := googleapi.WithoutDataWrapper.JSONReader(c.campaign)
21077 if err != nil {
21078 return nil, err
21079 }
21080 reqHeaders.Set("Content-Type", "application/json")
21081 c.urlParams_.Set("alt", alt)
21082 c.urlParams_.Set("prettyPrint", "false")
21083 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/campaigns")
21084 urls += "?" + c.urlParams_.Encode()
21085 req, err := http.NewRequest("POST", urls, body)
21086 if err != nil {
21087 return nil, err
21088 }
21089 req.Header = reqHeaders
21090 googleapi.Expand(req.URL, map[string]string{
21091 "profileId": strconv.FormatInt(c.profileId, 10),
21092 })
21093 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21094 }
21095
21096
21097
21098
21099
21100
21101
21102
21103 func (c *CampaignsInsertCall) Do(opts ...googleapi.CallOption) (*Campaign, error) {
21104 gensupport.SetOptions(c.urlParams_, opts...)
21105 res, err := c.doRequest("json")
21106 if res != nil && res.StatusCode == http.StatusNotModified {
21107 if res.Body != nil {
21108 res.Body.Close()
21109 }
21110 return nil, &googleapi.Error{
21111 Code: res.StatusCode,
21112 Header: res.Header,
21113 }
21114 }
21115 if err != nil {
21116 return nil, err
21117 }
21118 defer googleapi.CloseBody(res)
21119 if err := googleapi.CheckResponse(res); err != nil {
21120 return nil, err
21121 }
21122 ret := &Campaign{
21123 ServerResponse: googleapi.ServerResponse{
21124 Header: res.Header,
21125 HTTPStatusCode: res.StatusCode,
21126 },
21127 }
21128 target := &ret
21129 if err := gensupport.DecodeResponse(target, res); err != nil {
21130 return nil, err
21131 }
21132 return ret, nil
21133
21134
21135
21136
21137
21138
21139
21140
21141
21142
21143
21144
21145
21146
21147
21148
21149
21150
21151
21152
21153
21154
21155
21156
21157
21158
21159
21160
21161 }
21162
21163
21164
21165 type CampaignsListCall struct {
21166 s *Service
21167 profileId int64
21168 urlParams_ gensupport.URLParams
21169 ifNoneMatch_ string
21170 ctx_ context.Context
21171 header_ http.Header
21172 }
21173
21174
21175
21176 func (r *CampaignsService) List(profileId int64) *CampaignsListCall {
21177 c := &CampaignsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21178 c.profileId = profileId
21179 return c
21180 }
21181
21182
21183
21184
21185 func (c *CampaignsListCall) AdvertiserGroupIds(advertiserGroupIds ...int64) *CampaignsListCall {
21186 var advertiserGroupIds_ []string
21187 for _, v := range advertiserGroupIds {
21188 advertiserGroupIds_ = append(advertiserGroupIds_, fmt.Sprint(v))
21189 }
21190 c.urlParams_.SetMulti("advertiserGroupIds", advertiserGroupIds_)
21191 return c
21192 }
21193
21194
21195
21196 func (c *CampaignsListCall) AdvertiserIds(advertiserIds ...int64) *CampaignsListCall {
21197 var advertiserIds_ []string
21198 for _, v := range advertiserIds {
21199 advertiserIds_ = append(advertiserIds_, fmt.Sprint(v))
21200 }
21201 c.urlParams_.SetMulti("advertiserIds", advertiserIds_)
21202 return c
21203 }
21204
21205
21206
21207
21208 func (c *CampaignsListCall) Archived(archived bool) *CampaignsListCall {
21209 c.urlParams_.Set("archived", fmt.Sprint(archived))
21210 return c
21211 }
21212
21213
21214
21215
21216 func (c *CampaignsListCall) AtLeastOneOptimizationActivity(atLeastOneOptimizationActivity bool) *CampaignsListCall {
21217 c.urlParams_.Set("atLeastOneOptimizationActivity", fmt.Sprint(atLeastOneOptimizationActivity))
21218 return c
21219 }
21220
21221
21222
21223 func (c *CampaignsListCall) ExcludedIds(excludedIds ...int64) *CampaignsListCall {
21224 var excludedIds_ []string
21225 for _, v := range excludedIds {
21226 excludedIds_ = append(excludedIds_, fmt.Sprint(v))
21227 }
21228 c.urlParams_.SetMulti("excludedIds", excludedIds_)
21229 return c
21230 }
21231
21232
21233
21234 func (c *CampaignsListCall) Ids(ids ...int64) *CampaignsListCall {
21235 var ids_ []string
21236 for _, v := range ids {
21237 ids_ = append(ids_, fmt.Sprint(v))
21238 }
21239 c.urlParams_.SetMulti("ids", ids_)
21240 return c
21241 }
21242
21243
21244
21245 func (c *CampaignsListCall) MaxResults(maxResults int64) *CampaignsListCall {
21246 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
21247 return c
21248 }
21249
21250
21251
21252
21253 func (c *CampaignsListCall) OverriddenEventTagId(overriddenEventTagId int64) *CampaignsListCall {
21254 c.urlParams_.Set("overriddenEventTagId", fmt.Sprint(overriddenEventTagId))
21255 return c
21256 }
21257
21258
21259
21260 func (c *CampaignsListCall) PageToken(pageToken string) *CampaignsListCall {
21261 c.urlParams_.Set("pageToken", pageToken)
21262 return c
21263 }
21264
21265
21266
21267
21268
21269
21270
21271
21272
21273 func (c *CampaignsListCall) SearchString(searchString string) *CampaignsListCall {
21274 c.urlParams_.Set("searchString", searchString)
21275 return c
21276 }
21277
21278
21279
21280
21281
21282
21283
21284
21285 func (c *CampaignsListCall) SortField(sortField string) *CampaignsListCall {
21286 c.urlParams_.Set("sortField", sortField)
21287 return c
21288 }
21289
21290
21291
21292
21293
21294
21295
21296
21297 func (c *CampaignsListCall) SortOrder(sortOrder string) *CampaignsListCall {
21298 c.urlParams_.Set("sortOrder", sortOrder)
21299 return c
21300 }
21301
21302
21303
21304 func (c *CampaignsListCall) SubaccountId(subaccountId int64) *CampaignsListCall {
21305 c.urlParams_.Set("subaccountId", fmt.Sprint(subaccountId))
21306 return c
21307 }
21308
21309
21310
21311
21312 func (c *CampaignsListCall) Fields(s ...googleapi.Field) *CampaignsListCall {
21313 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21314 return c
21315 }
21316
21317
21318
21319
21320
21321
21322 func (c *CampaignsListCall) IfNoneMatch(entityTag string) *CampaignsListCall {
21323 c.ifNoneMatch_ = entityTag
21324 return c
21325 }
21326
21327
21328
21329
21330 func (c *CampaignsListCall) Context(ctx context.Context) *CampaignsListCall {
21331 c.ctx_ = ctx
21332 return c
21333 }
21334
21335
21336
21337 func (c *CampaignsListCall) Header() http.Header {
21338 if c.header_ == nil {
21339 c.header_ = make(http.Header)
21340 }
21341 return c.header_
21342 }
21343
21344 func (c *CampaignsListCall) doRequest(alt string) (*http.Response, error) {
21345 reqHeaders := make(http.Header)
21346 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
21347 for k, v := range c.header_ {
21348 reqHeaders[k] = v
21349 }
21350 reqHeaders.Set("User-Agent", c.s.userAgent())
21351 if c.ifNoneMatch_ != "" {
21352 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
21353 }
21354 var body io.Reader = nil
21355 c.urlParams_.Set("alt", alt)
21356 c.urlParams_.Set("prettyPrint", "false")
21357 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/campaigns")
21358 urls += "?" + c.urlParams_.Encode()
21359 req, err := http.NewRequest("GET", urls, body)
21360 if err != nil {
21361 return nil, err
21362 }
21363 req.Header = reqHeaders
21364 googleapi.Expand(req.URL, map[string]string{
21365 "profileId": strconv.FormatInt(c.profileId, 10),
21366 })
21367 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21368 }
21369
21370
21371
21372
21373
21374
21375
21376
21377 func (c *CampaignsListCall) Do(opts ...googleapi.CallOption) (*CampaignsListResponse, error) {
21378 gensupport.SetOptions(c.urlParams_, opts...)
21379 res, err := c.doRequest("json")
21380 if res != nil && res.StatusCode == http.StatusNotModified {
21381 if res.Body != nil {
21382 res.Body.Close()
21383 }
21384 return nil, &googleapi.Error{
21385 Code: res.StatusCode,
21386 Header: res.Header,
21387 }
21388 }
21389 if err != nil {
21390 return nil, err
21391 }
21392 defer googleapi.CloseBody(res)
21393 if err := googleapi.CheckResponse(res); err != nil {
21394 return nil, err
21395 }
21396 ret := &CampaignsListResponse{
21397 ServerResponse: googleapi.ServerResponse{
21398 Header: res.Header,
21399 HTTPStatusCode: res.StatusCode,
21400 },
21401 }
21402 target := &ret
21403 if err := gensupport.DecodeResponse(target, res); err != nil {
21404 return nil, err
21405 }
21406 return ret, nil
21407
21408
21409
21410
21411
21412
21413
21414
21415
21416
21417
21418
21419
21420
21421
21422
21423
21424
21425
21426
21427
21428
21429
21430
21431
21432
21433
21434
21435
21436
21437
21438
21439
21440
21441
21442
21443
21444
21445
21446
21447
21448
21449
21450
21451
21452
21453
21454
21455
21456
21457
21458
21459
21460
21461
21462
21463
21464
21465
21466
21467
21468
21469
21470
21471
21472
21473
21474
21475
21476
21477
21478
21479
21480
21481
21482
21483
21484
21485
21486
21487
21488
21489
21490
21491
21492
21493
21494
21495
21496
21497
21498
21499
21500
21501
21502
21503
21504
21505
21506
21507
21508
21509
21510
21511
21512
21513
21514
21515
21516
21517
21518
21519
21520
21521
21522
21523
21524
21525
21526
21527
21528
21529 }
21530
21531
21532
21533
21534 func (c *CampaignsListCall) Pages(ctx context.Context, f func(*CampaignsListResponse) error) error {
21535 c.ctx_ = ctx
21536 defer c.PageToken(c.urlParams_.Get("pageToken"))
21537 for {
21538 x, err := c.Do()
21539 if err != nil {
21540 return err
21541 }
21542 if err := f(x); err != nil {
21543 return err
21544 }
21545 if x.NextPageToken == "" {
21546 return nil
21547 }
21548 c.PageToken(x.NextPageToken)
21549 }
21550 }
21551
21552
21553
21554 type CampaignsPatchCall struct {
21555 s *Service
21556 profileId int64
21557 campaign *Campaign
21558 urlParams_ gensupport.URLParams
21559 ctx_ context.Context
21560 header_ http.Header
21561 }
21562
21563
21564
21565 func (r *CampaignsService) Patch(profileId int64, id int64, campaign *Campaign) *CampaignsPatchCall {
21566 c := &CampaignsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21567 c.profileId = profileId
21568 c.urlParams_.Set("id", fmt.Sprint(id))
21569 c.campaign = campaign
21570 return c
21571 }
21572
21573
21574
21575
21576 func (c *CampaignsPatchCall) Fields(s ...googleapi.Field) *CampaignsPatchCall {
21577 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21578 return c
21579 }
21580
21581
21582
21583
21584 func (c *CampaignsPatchCall) Context(ctx context.Context) *CampaignsPatchCall {
21585 c.ctx_ = ctx
21586 return c
21587 }
21588
21589
21590
21591 func (c *CampaignsPatchCall) Header() http.Header {
21592 if c.header_ == nil {
21593 c.header_ = make(http.Header)
21594 }
21595 return c.header_
21596 }
21597
21598 func (c *CampaignsPatchCall) doRequest(alt string) (*http.Response, error) {
21599 reqHeaders := make(http.Header)
21600 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
21601 for k, v := range c.header_ {
21602 reqHeaders[k] = v
21603 }
21604 reqHeaders.Set("User-Agent", c.s.userAgent())
21605 var body io.Reader = nil
21606 body, err := googleapi.WithoutDataWrapper.JSONReader(c.campaign)
21607 if err != nil {
21608 return nil, err
21609 }
21610 reqHeaders.Set("Content-Type", "application/json")
21611 c.urlParams_.Set("alt", alt)
21612 c.urlParams_.Set("prettyPrint", "false")
21613 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/campaigns")
21614 urls += "?" + c.urlParams_.Encode()
21615 req, err := http.NewRequest("PATCH", urls, body)
21616 if err != nil {
21617 return nil, err
21618 }
21619 req.Header = reqHeaders
21620 googleapi.Expand(req.URL, map[string]string{
21621 "profileId": strconv.FormatInt(c.profileId, 10),
21622 })
21623 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21624 }
21625
21626
21627
21628
21629
21630
21631
21632
21633 func (c *CampaignsPatchCall) Do(opts ...googleapi.CallOption) (*Campaign, error) {
21634 gensupport.SetOptions(c.urlParams_, opts...)
21635 res, err := c.doRequest("json")
21636 if res != nil && res.StatusCode == http.StatusNotModified {
21637 if res.Body != nil {
21638 res.Body.Close()
21639 }
21640 return nil, &googleapi.Error{
21641 Code: res.StatusCode,
21642 Header: res.Header,
21643 }
21644 }
21645 if err != nil {
21646 return nil, err
21647 }
21648 defer googleapi.CloseBody(res)
21649 if err := googleapi.CheckResponse(res); err != nil {
21650 return nil, err
21651 }
21652 ret := &Campaign{
21653 ServerResponse: googleapi.ServerResponse{
21654 Header: res.Header,
21655 HTTPStatusCode: res.StatusCode,
21656 },
21657 }
21658 target := &ret
21659 if err := gensupport.DecodeResponse(target, res); err != nil {
21660 return nil, err
21661 }
21662 return ret, nil
21663
21664
21665
21666
21667
21668
21669
21670
21671
21672
21673
21674
21675
21676
21677
21678
21679
21680
21681
21682
21683
21684
21685
21686
21687
21688
21689
21690
21691
21692
21693
21694
21695
21696
21697
21698
21699 }
21700
21701
21702
21703 type CampaignsUpdateCall struct {
21704 s *Service
21705 profileId int64
21706 campaign *Campaign
21707 urlParams_ gensupport.URLParams
21708 ctx_ context.Context
21709 header_ http.Header
21710 }
21711
21712
21713 func (r *CampaignsService) Update(profileId int64, campaign *Campaign) *CampaignsUpdateCall {
21714 c := &CampaignsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21715 c.profileId = profileId
21716 c.campaign = campaign
21717 return c
21718 }
21719
21720
21721
21722
21723 func (c *CampaignsUpdateCall) Fields(s ...googleapi.Field) *CampaignsUpdateCall {
21724 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21725 return c
21726 }
21727
21728
21729
21730
21731 func (c *CampaignsUpdateCall) Context(ctx context.Context) *CampaignsUpdateCall {
21732 c.ctx_ = ctx
21733 return c
21734 }
21735
21736
21737
21738 func (c *CampaignsUpdateCall) Header() http.Header {
21739 if c.header_ == nil {
21740 c.header_ = make(http.Header)
21741 }
21742 return c.header_
21743 }
21744
21745 func (c *CampaignsUpdateCall) doRequest(alt string) (*http.Response, error) {
21746 reqHeaders := make(http.Header)
21747 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
21748 for k, v := range c.header_ {
21749 reqHeaders[k] = v
21750 }
21751 reqHeaders.Set("User-Agent", c.s.userAgent())
21752 var body io.Reader = nil
21753 body, err := googleapi.WithoutDataWrapper.JSONReader(c.campaign)
21754 if err != nil {
21755 return nil, err
21756 }
21757 reqHeaders.Set("Content-Type", "application/json")
21758 c.urlParams_.Set("alt", alt)
21759 c.urlParams_.Set("prettyPrint", "false")
21760 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/campaigns")
21761 urls += "?" + c.urlParams_.Encode()
21762 req, err := http.NewRequest("PUT", urls, body)
21763 if err != nil {
21764 return nil, err
21765 }
21766 req.Header = reqHeaders
21767 googleapi.Expand(req.URL, map[string]string{
21768 "profileId": strconv.FormatInt(c.profileId, 10),
21769 })
21770 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21771 }
21772
21773
21774
21775
21776
21777
21778
21779
21780 func (c *CampaignsUpdateCall) Do(opts ...googleapi.CallOption) (*Campaign, error) {
21781 gensupport.SetOptions(c.urlParams_, opts...)
21782 res, err := c.doRequest("json")
21783 if res != nil && res.StatusCode == http.StatusNotModified {
21784 if res.Body != nil {
21785 res.Body.Close()
21786 }
21787 return nil, &googleapi.Error{
21788 Code: res.StatusCode,
21789 Header: res.Header,
21790 }
21791 }
21792 if err != nil {
21793 return nil, err
21794 }
21795 defer googleapi.CloseBody(res)
21796 if err := googleapi.CheckResponse(res); err != nil {
21797 return nil, err
21798 }
21799 ret := &Campaign{
21800 ServerResponse: googleapi.ServerResponse{
21801 Header: res.Header,
21802 HTTPStatusCode: res.StatusCode,
21803 },
21804 }
21805 target := &ret
21806 if err := gensupport.DecodeResponse(target, res); err != nil {
21807 return nil, err
21808 }
21809 return ret, nil
21810
21811
21812
21813
21814
21815
21816
21817
21818
21819
21820
21821
21822
21823
21824
21825
21826
21827
21828
21829
21830
21831
21832
21833
21834
21835
21836
21837
21838 }
21839
21840
21841
21842 type ChangeLogsGetCall struct {
21843 s *Service
21844 profileId int64
21845 id int64
21846 urlParams_ gensupport.URLParams
21847 ifNoneMatch_ string
21848 ctx_ context.Context
21849 header_ http.Header
21850 }
21851
21852
21853 func (r *ChangeLogsService) Get(profileId int64, id int64) *ChangeLogsGetCall {
21854 c := &ChangeLogsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21855 c.profileId = profileId
21856 c.id = id
21857 return c
21858 }
21859
21860
21861
21862
21863 func (c *ChangeLogsGetCall) Fields(s ...googleapi.Field) *ChangeLogsGetCall {
21864 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21865 return c
21866 }
21867
21868
21869
21870
21871
21872
21873 func (c *ChangeLogsGetCall) IfNoneMatch(entityTag string) *ChangeLogsGetCall {
21874 c.ifNoneMatch_ = entityTag
21875 return c
21876 }
21877
21878
21879
21880
21881 func (c *ChangeLogsGetCall) Context(ctx context.Context) *ChangeLogsGetCall {
21882 c.ctx_ = ctx
21883 return c
21884 }
21885
21886
21887
21888 func (c *ChangeLogsGetCall) Header() http.Header {
21889 if c.header_ == nil {
21890 c.header_ = make(http.Header)
21891 }
21892 return c.header_
21893 }
21894
21895 func (c *ChangeLogsGetCall) doRequest(alt string) (*http.Response, error) {
21896 reqHeaders := make(http.Header)
21897 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
21898 for k, v := range c.header_ {
21899 reqHeaders[k] = v
21900 }
21901 reqHeaders.Set("User-Agent", c.s.userAgent())
21902 if c.ifNoneMatch_ != "" {
21903 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
21904 }
21905 var body io.Reader = nil
21906 c.urlParams_.Set("alt", alt)
21907 c.urlParams_.Set("prettyPrint", "false")
21908 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/changeLogs/{id}")
21909 urls += "?" + c.urlParams_.Encode()
21910 req, err := http.NewRequest("GET", urls, body)
21911 if err != nil {
21912 return nil, err
21913 }
21914 req.Header = reqHeaders
21915 googleapi.Expand(req.URL, map[string]string{
21916 "profileId": strconv.FormatInt(c.profileId, 10),
21917 "id": strconv.FormatInt(c.id, 10),
21918 })
21919 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21920 }
21921
21922
21923
21924
21925
21926
21927
21928
21929 func (c *ChangeLogsGetCall) Do(opts ...googleapi.CallOption) (*ChangeLog, error) {
21930 gensupport.SetOptions(c.urlParams_, opts...)
21931 res, err := c.doRequest("json")
21932 if res != nil && res.StatusCode == http.StatusNotModified {
21933 if res.Body != nil {
21934 res.Body.Close()
21935 }
21936 return nil, &googleapi.Error{
21937 Code: res.StatusCode,
21938 Header: res.Header,
21939 }
21940 }
21941 if err != nil {
21942 return nil, err
21943 }
21944 defer googleapi.CloseBody(res)
21945 if err := googleapi.CheckResponse(res); err != nil {
21946 return nil, err
21947 }
21948 ret := &ChangeLog{
21949 ServerResponse: googleapi.ServerResponse{
21950 Header: res.Header,
21951 HTTPStatusCode: res.StatusCode,
21952 },
21953 }
21954 target := &ret
21955 if err := gensupport.DecodeResponse(target, res); err != nil {
21956 return nil, err
21957 }
21958 return ret, nil
21959
21960
21961
21962
21963
21964
21965
21966
21967
21968
21969
21970
21971
21972
21973
21974
21975
21976
21977
21978
21979
21980
21981
21982
21983
21984
21985
21986
21987
21988
21989
21990
21991
21992 }
21993
21994
21995
21996 type ChangeLogsListCall struct {
21997 s *Service
21998 profileId int64
21999 urlParams_ gensupport.URLParams
22000 ifNoneMatch_ string
22001 ctx_ context.Context
22002 header_ http.Header
22003 }
22004
22005
22006 func (r *ChangeLogsService) List(profileId int64) *ChangeLogsListCall {
22007 c := &ChangeLogsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22008 c.profileId = profileId
22009 return c
22010 }
22011
22012
22013
22014
22015
22016
22017
22018
22019
22020
22021
22022
22023
22024
22025
22026
22027
22028
22029
22030
22031
22032
22033
22034 func (c *ChangeLogsListCall) Action(action string) *ChangeLogsListCall {
22035 c.urlParams_.Set("action", action)
22036 return c
22037 }
22038
22039
22040
22041 func (c *ChangeLogsListCall) Ids(ids ...int64) *ChangeLogsListCall {
22042 var ids_ []string
22043 for _, v := range ids {
22044 ids_ = append(ids_, fmt.Sprint(v))
22045 }
22046 c.urlParams_.SetMulti("ids", ids_)
22047 return c
22048 }
22049
22050
22051
22052
22053
22054
22055
22056
22057
22058 func (c *ChangeLogsListCall) MaxChangeTime(maxChangeTime string) *ChangeLogsListCall {
22059 c.urlParams_.Set("maxChangeTime", maxChangeTime)
22060 return c
22061 }
22062
22063
22064
22065 func (c *ChangeLogsListCall) MaxResults(maxResults int64) *ChangeLogsListCall {
22066 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
22067 return c
22068 }
22069
22070
22071
22072
22073
22074
22075
22076
22077
22078 func (c *ChangeLogsListCall) MinChangeTime(minChangeTime string) *ChangeLogsListCall {
22079 c.urlParams_.Set("minChangeTime", minChangeTime)
22080 return c
22081 }
22082
22083
22084
22085 func (c *ChangeLogsListCall) ObjectIds(objectIds ...int64) *ChangeLogsListCall {
22086 var objectIds_ []string
22087 for _, v := range objectIds {
22088 objectIds_ = append(objectIds_, fmt.Sprint(v))
22089 }
22090 c.urlParams_.SetMulti("objectIds", objectIds_)
22091 return c
22092 }
22093
22094
22095
22096
22097
22098
22099
22100
22101
22102
22103
22104
22105
22106
22107
22108
22109
22110
22111
22112
22113
22114
22115
22116
22117
22118
22119
22120
22121
22122
22123
22124
22125
22126
22127
22128
22129
22130
22131
22132
22133
22134
22135
22136
22137
22138
22139 func (c *ChangeLogsListCall) ObjectType(objectType string) *ChangeLogsListCall {
22140 c.urlParams_.Set("objectType", objectType)
22141 return c
22142 }
22143
22144
22145
22146 func (c *ChangeLogsListCall) PageToken(pageToken string) *ChangeLogsListCall {
22147 c.urlParams_.Set("pageToken", pageToken)
22148 return c
22149 }
22150
22151
22152
22153
22154 func (c *ChangeLogsListCall) SearchString(searchString string) *ChangeLogsListCall {
22155 c.urlParams_.Set("searchString", searchString)
22156 return c
22157 }
22158
22159
22160
22161 func (c *ChangeLogsListCall) UserProfileIds(userProfileIds ...int64) *ChangeLogsListCall {
22162 var userProfileIds_ []string
22163 for _, v := range userProfileIds {
22164 userProfileIds_ = append(userProfileIds_, fmt.Sprint(v))
22165 }
22166 c.urlParams_.SetMulti("userProfileIds", userProfileIds_)
22167 return c
22168 }
22169
22170
22171
22172
22173 func (c *ChangeLogsListCall) Fields(s ...googleapi.Field) *ChangeLogsListCall {
22174 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22175 return c
22176 }
22177
22178
22179
22180
22181
22182
22183 func (c *ChangeLogsListCall) IfNoneMatch(entityTag string) *ChangeLogsListCall {
22184 c.ifNoneMatch_ = entityTag
22185 return c
22186 }
22187
22188
22189
22190
22191 func (c *ChangeLogsListCall) Context(ctx context.Context) *ChangeLogsListCall {
22192 c.ctx_ = ctx
22193 return c
22194 }
22195
22196
22197
22198 func (c *ChangeLogsListCall) Header() http.Header {
22199 if c.header_ == nil {
22200 c.header_ = make(http.Header)
22201 }
22202 return c.header_
22203 }
22204
22205 func (c *ChangeLogsListCall) doRequest(alt string) (*http.Response, error) {
22206 reqHeaders := make(http.Header)
22207 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
22208 for k, v := range c.header_ {
22209 reqHeaders[k] = v
22210 }
22211 reqHeaders.Set("User-Agent", c.s.userAgent())
22212 if c.ifNoneMatch_ != "" {
22213 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
22214 }
22215 var body io.Reader = nil
22216 c.urlParams_.Set("alt", alt)
22217 c.urlParams_.Set("prettyPrint", "false")
22218 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/changeLogs")
22219 urls += "?" + c.urlParams_.Encode()
22220 req, err := http.NewRequest("GET", urls, body)
22221 if err != nil {
22222 return nil, err
22223 }
22224 req.Header = reqHeaders
22225 googleapi.Expand(req.URL, map[string]string{
22226 "profileId": strconv.FormatInt(c.profileId, 10),
22227 })
22228 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22229 }
22230
22231
22232
22233
22234
22235
22236
22237
22238 func (c *ChangeLogsListCall) Do(opts ...googleapi.CallOption) (*ChangeLogsListResponse, error) {
22239 gensupport.SetOptions(c.urlParams_, opts...)
22240 res, err := c.doRequest("json")
22241 if res != nil && res.StatusCode == http.StatusNotModified {
22242 if res.Body != nil {
22243 res.Body.Close()
22244 }
22245 return nil, &googleapi.Error{
22246 Code: res.StatusCode,
22247 Header: res.Header,
22248 }
22249 }
22250 if err != nil {
22251 return nil, err
22252 }
22253 defer googleapi.CloseBody(res)
22254 if err := googleapi.CheckResponse(res); err != nil {
22255 return nil, err
22256 }
22257 ret := &ChangeLogsListResponse{
22258 ServerResponse: googleapi.ServerResponse{
22259 Header: res.Header,
22260 HTTPStatusCode: res.StatusCode,
22261 },
22262 }
22263 target := &ret
22264 if err := gensupport.DecodeResponse(target, res); err != nil {
22265 return nil, err
22266 }
22267 return ret, nil
22268
22269
22270
22271
22272
22273
22274
22275
22276
22277
22278
22279
22280
22281
22282
22283
22284
22285
22286
22287
22288
22289
22290
22291
22292
22293
22294
22295
22296
22297
22298
22299
22300
22301
22302
22303
22304
22305
22306
22307
22308
22309
22310
22311
22312
22313
22314
22315
22316
22317
22318
22319
22320
22321
22322
22323
22324
22325
22326
22327
22328
22329
22330
22331
22332
22333
22334
22335
22336
22337
22338
22339
22340
22341
22342
22343
22344
22345
22346
22347
22348
22349
22350
22351
22352
22353
22354
22355
22356
22357
22358
22359
22360
22361
22362
22363
22364
22365
22366
22367
22368
22369
22370
22371
22372
22373
22374
22375
22376
22377
22378
22379
22380
22381
22382
22383
22384
22385
22386
22387
22388
22389
22390
22391
22392
22393
22394
22395
22396
22397
22398
22399
22400
22401
22402
22403
22404
22405
22406
22407
22408
22409
22410
22411
22412
22413
22414
22415
22416
22417
22418
22419
22420
22421
22422
22423
22424
22425
22426
22427
22428
22429
22430
22431
22432
22433
22434
22435
22436
22437
22438
22439
22440
22441
22442
22443
22444
22445
22446
22447
22448
22449
22450
22451
22452
22453
22454
22455
22456
22457
22458
22459
22460
22461
22462
22463
22464
22465
22466
22467
22468
22469
22470
22471
22472
22473
22474
22475 }
22476
22477
22478
22479
22480 func (c *ChangeLogsListCall) Pages(ctx context.Context, f func(*ChangeLogsListResponse) error) error {
22481 c.ctx_ = ctx
22482 defer c.PageToken(c.urlParams_.Get("pageToken"))
22483 for {
22484 x, err := c.Do()
22485 if err != nil {
22486 return err
22487 }
22488 if err := f(x); err != nil {
22489 return err
22490 }
22491 if x.NextPageToken == "" {
22492 return nil
22493 }
22494 c.PageToken(x.NextPageToken)
22495 }
22496 }
22497
22498
22499
22500 type CitiesListCall struct {
22501 s *Service
22502 profileId int64
22503 urlParams_ gensupport.URLParams
22504 ifNoneMatch_ string
22505 ctx_ context.Context
22506 header_ http.Header
22507 }
22508
22509
22510 func (r *CitiesService) List(profileId int64) *CitiesListCall {
22511 c := &CitiesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22512 c.profileId = profileId
22513 return c
22514 }
22515
22516
22517
22518 func (c *CitiesListCall) CountryDartIds(countryDartIds ...int64) *CitiesListCall {
22519 var countryDartIds_ []string
22520 for _, v := range countryDartIds {
22521 countryDartIds_ = append(countryDartIds_, fmt.Sprint(v))
22522 }
22523 c.urlParams_.SetMulti("countryDartIds", countryDartIds_)
22524 return c
22525 }
22526
22527
22528
22529 func (c *CitiesListCall) DartIds(dartIds ...int64) *CitiesListCall {
22530 var dartIds_ []string
22531 for _, v := range dartIds {
22532 dartIds_ = append(dartIds_, fmt.Sprint(v))
22533 }
22534 c.urlParams_.SetMulti("dartIds", dartIds_)
22535 return c
22536 }
22537
22538
22539
22540 func (c *CitiesListCall) NamePrefix(namePrefix string) *CitiesListCall {
22541 c.urlParams_.Set("namePrefix", namePrefix)
22542 return c
22543 }
22544
22545
22546
22547 func (c *CitiesListCall) RegionDartIds(regionDartIds ...int64) *CitiesListCall {
22548 var regionDartIds_ []string
22549 for _, v := range regionDartIds {
22550 regionDartIds_ = append(regionDartIds_, fmt.Sprint(v))
22551 }
22552 c.urlParams_.SetMulti("regionDartIds", regionDartIds_)
22553 return c
22554 }
22555
22556
22557
22558
22559 func (c *CitiesListCall) Fields(s ...googleapi.Field) *CitiesListCall {
22560 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22561 return c
22562 }
22563
22564
22565
22566
22567
22568
22569 func (c *CitiesListCall) IfNoneMatch(entityTag string) *CitiesListCall {
22570 c.ifNoneMatch_ = entityTag
22571 return c
22572 }
22573
22574
22575
22576
22577 func (c *CitiesListCall) Context(ctx context.Context) *CitiesListCall {
22578 c.ctx_ = ctx
22579 return c
22580 }
22581
22582
22583
22584 func (c *CitiesListCall) Header() http.Header {
22585 if c.header_ == nil {
22586 c.header_ = make(http.Header)
22587 }
22588 return c.header_
22589 }
22590
22591 func (c *CitiesListCall) doRequest(alt string) (*http.Response, error) {
22592 reqHeaders := make(http.Header)
22593 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
22594 for k, v := range c.header_ {
22595 reqHeaders[k] = v
22596 }
22597 reqHeaders.Set("User-Agent", c.s.userAgent())
22598 if c.ifNoneMatch_ != "" {
22599 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
22600 }
22601 var body io.Reader = nil
22602 c.urlParams_.Set("alt", alt)
22603 c.urlParams_.Set("prettyPrint", "false")
22604 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/cities")
22605 urls += "?" + c.urlParams_.Encode()
22606 req, err := http.NewRequest("GET", urls, body)
22607 if err != nil {
22608 return nil, err
22609 }
22610 req.Header = reqHeaders
22611 googleapi.Expand(req.URL, map[string]string{
22612 "profileId": strconv.FormatInt(c.profileId, 10),
22613 })
22614 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22615 }
22616
22617
22618
22619
22620
22621
22622
22623
22624 func (c *CitiesListCall) Do(opts ...googleapi.CallOption) (*CitiesListResponse, error) {
22625 gensupport.SetOptions(c.urlParams_, opts...)
22626 res, err := c.doRequest("json")
22627 if res != nil && res.StatusCode == http.StatusNotModified {
22628 if res.Body != nil {
22629 res.Body.Close()
22630 }
22631 return nil, &googleapi.Error{
22632 Code: res.StatusCode,
22633 Header: res.Header,
22634 }
22635 }
22636 if err != nil {
22637 return nil, err
22638 }
22639 defer googleapi.CloseBody(res)
22640 if err := googleapi.CheckResponse(res); err != nil {
22641 return nil, err
22642 }
22643 ret := &CitiesListResponse{
22644 ServerResponse: googleapi.ServerResponse{
22645 Header: res.Header,
22646 HTTPStatusCode: res.StatusCode,
22647 },
22648 }
22649 target := &ret
22650 if err := gensupport.DecodeResponse(target, res); err != nil {
22651 return nil, err
22652 }
22653 return ret, nil
22654
22655
22656
22657
22658
22659
22660
22661
22662
22663
22664
22665
22666
22667
22668
22669
22670
22671
22672
22673
22674
22675
22676
22677
22678
22679
22680
22681
22682
22683
22684
22685
22686
22687
22688
22689
22690
22691
22692
22693
22694
22695
22696
22697
22698
22699
22700
22701
22702
22703
22704
22705 }
22706
22707
22708
22709 type ConnectionTypesGetCall struct {
22710 s *Service
22711 profileId int64
22712 id int64
22713 urlParams_ gensupport.URLParams
22714 ifNoneMatch_ string
22715 ctx_ context.Context
22716 header_ http.Header
22717 }
22718
22719
22720 func (r *ConnectionTypesService) Get(profileId int64, id int64) *ConnectionTypesGetCall {
22721 c := &ConnectionTypesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22722 c.profileId = profileId
22723 c.id = id
22724 return c
22725 }
22726
22727
22728
22729
22730 func (c *ConnectionTypesGetCall) Fields(s ...googleapi.Field) *ConnectionTypesGetCall {
22731 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22732 return c
22733 }
22734
22735
22736
22737
22738
22739
22740 func (c *ConnectionTypesGetCall) IfNoneMatch(entityTag string) *ConnectionTypesGetCall {
22741 c.ifNoneMatch_ = entityTag
22742 return c
22743 }
22744
22745
22746
22747
22748 func (c *ConnectionTypesGetCall) Context(ctx context.Context) *ConnectionTypesGetCall {
22749 c.ctx_ = ctx
22750 return c
22751 }
22752
22753
22754
22755 func (c *ConnectionTypesGetCall) Header() http.Header {
22756 if c.header_ == nil {
22757 c.header_ = make(http.Header)
22758 }
22759 return c.header_
22760 }
22761
22762 func (c *ConnectionTypesGetCall) doRequest(alt string) (*http.Response, error) {
22763 reqHeaders := make(http.Header)
22764 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
22765 for k, v := range c.header_ {
22766 reqHeaders[k] = v
22767 }
22768 reqHeaders.Set("User-Agent", c.s.userAgent())
22769 if c.ifNoneMatch_ != "" {
22770 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
22771 }
22772 var body io.Reader = nil
22773 c.urlParams_.Set("alt", alt)
22774 c.urlParams_.Set("prettyPrint", "false")
22775 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/connectionTypes/{id}")
22776 urls += "?" + c.urlParams_.Encode()
22777 req, err := http.NewRequest("GET", urls, body)
22778 if err != nil {
22779 return nil, err
22780 }
22781 req.Header = reqHeaders
22782 googleapi.Expand(req.URL, map[string]string{
22783 "profileId": strconv.FormatInt(c.profileId, 10),
22784 "id": strconv.FormatInt(c.id, 10),
22785 })
22786 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22787 }
22788
22789
22790
22791
22792
22793
22794
22795
22796 func (c *ConnectionTypesGetCall) Do(opts ...googleapi.CallOption) (*ConnectionType, error) {
22797 gensupport.SetOptions(c.urlParams_, opts...)
22798 res, err := c.doRequest("json")
22799 if res != nil && res.StatusCode == http.StatusNotModified {
22800 if res.Body != nil {
22801 res.Body.Close()
22802 }
22803 return nil, &googleapi.Error{
22804 Code: res.StatusCode,
22805 Header: res.Header,
22806 }
22807 }
22808 if err != nil {
22809 return nil, err
22810 }
22811 defer googleapi.CloseBody(res)
22812 if err := googleapi.CheckResponse(res); err != nil {
22813 return nil, err
22814 }
22815 ret := &ConnectionType{
22816 ServerResponse: googleapi.ServerResponse{
22817 Header: res.Header,
22818 HTTPStatusCode: res.StatusCode,
22819 },
22820 }
22821 target := &ret
22822 if err := gensupport.DecodeResponse(target, res); err != nil {
22823 return nil, err
22824 }
22825 return ret, nil
22826
22827
22828
22829
22830
22831
22832
22833
22834
22835
22836
22837
22838
22839
22840
22841
22842
22843
22844
22845
22846
22847
22848
22849
22850
22851
22852
22853
22854
22855
22856
22857
22858
22859 }
22860
22861
22862
22863 type ConnectionTypesListCall struct {
22864 s *Service
22865 profileId int64
22866 urlParams_ gensupport.URLParams
22867 ifNoneMatch_ string
22868 ctx_ context.Context
22869 header_ http.Header
22870 }
22871
22872
22873 func (r *ConnectionTypesService) List(profileId int64) *ConnectionTypesListCall {
22874 c := &ConnectionTypesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22875 c.profileId = profileId
22876 return c
22877 }
22878
22879
22880
22881
22882 func (c *ConnectionTypesListCall) Fields(s ...googleapi.Field) *ConnectionTypesListCall {
22883 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22884 return c
22885 }
22886
22887
22888
22889
22890
22891
22892 func (c *ConnectionTypesListCall) IfNoneMatch(entityTag string) *ConnectionTypesListCall {
22893 c.ifNoneMatch_ = entityTag
22894 return c
22895 }
22896
22897
22898
22899
22900 func (c *ConnectionTypesListCall) Context(ctx context.Context) *ConnectionTypesListCall {
22901 c.ctx_ = ctx
22902 return c
22903 }
22904
22905
22906
22907 func (c *ConnectionTypesListCall) Header() http.Header {
22908 if c.header_ == nil {
22909 c.header_ = make(http.Header)
22910 }
22911 return c.header_
22912 }
22913
22914 func (c *ConnectionTypesListCall) doRequest(alt string) (*http.Response, error) {
22915 reqHeaders := make(http.Header)
22916 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
22917 for k, v := range c.header_ {
22918 reqHeaders[k] = v
22919 }
22920 reqHeaders.Set("User-Agent", c.s.userAgent())
22921 if c.ifNoneMatch_ != "" {
22922 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
22923 }
22924 var body io.Reader = nil
22925 c.urlParams_.Set("alt", alt)
22926 c.urlParams_.Set("prettyPrint", "false")
22927 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/connectionTypes")
22928 urls += "?" + c.urlParams_.Encode()
22929 req, err := http.NewRequest("GET", urls, body)
22930 if err != nil {
22931 return nil, err
22932 }
22933 req.Header = reqHeaders
22934 googleapi.Expand(req.URL, map[string]string{
22935 "profileId": strconv.FormatInt(c.profileId, 10),
22936 })
22937 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22938 }
22939
22940
22941
22942
22943
22944
22945
22946
22947 func (c *ConnectionTypesListCall) Do(opts ...googleapi.CallOption) (*ConnectionTypesListResponse, error) {
22948 gensupport.SetOptions(c.urlParams_, opts...)
22949 res, err := c.doRequest("json")
22950 if res != nil && res.StatusCode == http.StatusNotModified {
22951 if res.Body != nil {
22952 res.Body.Close()
22953 }
22954 return nil, &googleapi.Error{
22955 Code: res.StatusCode,
22956 Header: res.Header,
22957 }
22958 }
22959 if err != nil {
22960 return nil, err
22961 }
22962 defer googleapi.CloseBody(res)
22963 if err := googleapi.CheckResponse(res); err != nil {
22964 return nil, err
22965 }
22966 ret := &ConnectionTypesListResponse{
22967 ServerResponse: googleapi.ServerResponse{
22968 Header: res.Header,
22969 HTTPStatusCode: res.StatusCode,
22970 },
22971 }
22972 target := &ret
22973 if err := gensupport.DecodeResponse(target, res); err != nil {
22974 return nil, err
22975 }
22976 return ret, nil
22977
22978
22979
22980
22981
22982
22983
22984
22985
22986
22987
22988
22989
22990
22991
22992
22993
22994
22995
22996
22997
22998
22999
23000
23001
23002 }
23003
23004
23005
23006 type ContentCategoriesDeleteCall struct {
23007 s *Service
23008 profileId int64
23009 id int64
23010 urlParams_ gensupport.URLParams
23011 ctx_ context.Context
23012 header_ http.Header
23013 }
23014
23015
23016 func (r *ContentCategoriesService) Delete(profileId int64, id int64) *ContentCategoriesDeleteCall {
23017 c := &ContentCategoriesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23018 c.profileId = profileId
23019 c.id = id
23020 return c
23021 }
23022
23023
23024
23025
23026 func (c *ContentCategoriesDeleteCall) Fields(s ...googleapi.Field) *ContentCategoriesDeleteCall {
23027 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23028 return c
23029 }
23030
23031
23032
23033
23034 func (c *ContentCategoriesDeleteCall) Context(ctx context.Context) *ContentCategoriesDeleteCall {
23035 c.ctx_ = ctx
23036 return c
23037 }
23038
23039
23040
23041 func (c *ContentCategoriesDeleteCall) Header() http.Header {
23042 if c.header_ == nil {
23043 c.header_ = make(http.Header)
23044 }
23045 return c.header_
23046 }
23047
23048 func (c *ContentCategoriesDeleteCall) doRequest(alt string) (*http.Response, error) {
23049 reqHeaders := make(http.Header)
23050 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
23051 for k, v := range c.header_ {
23052 reqHeaders[k] = v
23053 }
23054 reqHeaders.Set("User-Agent", c.s.userAgent())
23055 var body io.Reader = nil
23056 c.urlParams_.Set("alt", alt)
23057 c.urlParams_.Set("prettyPrint", "false")
23058 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/contentCategories/{id}")
23059 urls += "?" + c.urlParams_.Encode()
23060 req, err := http.NewRequest("DELETE", urls, body)
23061 if err != nil {
23062 return nil, err
23063 }
23064 req.Header = reqHeaders
23065 googleapi.Expand(req.URL, map[string]string{
23066 "profileId": strconv.FormatInt(c.profileId, 10),
23067 "id": strconv.FormatInt(c.id, 10),
23068 })
23069 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23070 }
23071
23072
23073 func (c *ContentCategoriesDeleteCall) Do(opts ...googleapi.CallOption) error {
23074 gensupport.SetOptions(c.urlParams_, opts...)
23075 res, err := c.doRequest("json")
23076 if err != nil {
23077 return err
23078 }
23079 defer googleapi.CloseBody(res)
23080 if err := googleapi.CheckResponse(res); err != nil {
23081 return err
23082 }
23083 return nil
23084
23085
23086
23087
23088
23089
23090
23091
23092
23093
23094
23095
23096
23097
23098
23099
23100
23101
23102
23103
23104
23105
23106
23107
23108
23109
23110
23111
23112
23113
23114 }
23115
23116
23117
23118 type ContentCategoriesGetCall struct {
23119 s *Service
23120 profileId int64
23121 id int64
23122 urlParams_ gensupport.URLParams
23123 ifNoneMatch_ string
23124 ctx_ context.Context
23125 header_ http.Header
23126 }
23127
23128
23129 func (r *ContentCategoriesService) Get(profileId int64, id int64) *ContentCategoriesGetCall {
23130 c := &ContentCategoriesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23131 c.profileId = profileId
23132 c.id = id
23133 return c
23134 }
23135
23136
23137
23138
23139 func (c *ContentCategoriesGetCall) Fields(s ...googleapi.Field) *ContentCategoriesGetCall {
23140 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23141 return c
23142 }
23143
23144
23145
23146
23147
23148
23149 func (c *ContentCategoriesGetCall) IfNoneMatch(entityTag string) *ContentCategoriesGetCall {
23150 c.ifNoneMatch_ = entityTag
23151 return c
23152 }
23153
23154
23155
23156
23157 func (c *ContentCategoriesGetCall) Context(ctx context.Context) *ContentCategoriesGetCall {
23158 c.ctx_ = ctx
23159 return c
23160 }
23161
23162
23163
23164 func (c *ContentCategoriesGetCall) Header() http.Header {
23165 if c.header_ == nil {
23166 c.header_ = make(http.Header)
23167 }
23168 return c.header_
23169 }
23170
23171 func (c *ContentCategoriesGetCall) doRequest(alt string) (*http.Response, error) {
23172 reqHeaders := make(http.Header)
23173 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
23174 for k, v := range c.header_ {
23175 reqHeaders[k] = v
23176 }
23177 reqHeaders.Set("User-Agent", c.s.userAgent())
23178 if c.ifNoneMatch_ != "" {
23179 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
23180 }
23181 var body io.Reader = nil
23182 c.urlParams_.Set("alt", alt)
23183 c.urlParams_.Set("prettyPrint", "false")
23184 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/contentCategories/{id}")
23185 urls += "?" + c.urlParams_.Encode()
23186 req, err := http.NewRequest("GET", urls, body)
23187 if err != nil {
23188 return nil, err
23189 }
23190 req.Header = reqHeaders
23191 googleapi.Expand(req.URL, map[string]string{
23192 "profileId": strconv.FormatInt(c.profileId, 10),
23193 "id": strconv.FormatInt(c.id, 10),
23194 })
23195 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23196 }
23197
23198
23199
23200
23201
23202
23203
23204
23205 func (c *ContentCategoriesGetCall) Do(opts ...googleapi.CallOption) (*ContentCategory, error) {
23206 gensupport.SetOptions(c.urlParams_, opts...)
23207 res, err := c.doRequest("json")
23208 if res != nil && res.StatusCode == http.StatusNotModified {
23209 if res.Body != nil {
23210 res.Body.Close()
23211 }
23212 return nil, &googleapi.Error{
23213 Code: res.StatusCode,
23214 Header: res.Header,
23215 }
23216 }
23217 if err != nil {
23218 return nil, err
23219 }
23220 defer googleapi.CloseBody(res)
23221 if err := googleapi.CheckResponse(res); err != nil {
23222 return nil, err
23223 }
23224 ret := &ContentCategory{
23225 ServerResponse: googleapi.ServerResponse{
23226 Header: res.Header,
23227 HTTPStatusCode: res.StatusCode,
23228 },
23229 }
23230 target := &ret
23231 if err := gensupport.DecodeResponse(target, res); err != nil {
23232 return nil, err
23233 }
23234 return ret, nil
23235
23236
23237
23238
23239
23240
23241
23242
23243
23244
23245
23246
23247
23248
23249
23250
23251
23252
23253
23254
23255
23256
23257
23258
23259
23260
23261
23262
23263
23264
23265
23266
23267
23268 }
23269
23270
23271
23272 type ContentCategoriesInsertCall struct {
23273 s *Service
23274 profileId int64
23275 contentcategory *ContentCategory
23276 urlParams_ gensupport.URLParams
23277 ctx_ context.Context
23278 header_ http.Header
23279 }
23280
23281
23282 func (r *ContentCategoriesService) Insert(profileId int64, contentcategory *ContentCategory) *ContentCategoriesInsertCall {
23283 c := &ContentCategoriesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23284 c.profileId = profileId
23285 c.contentcategory = contentcategory
23286 return c
23287 }
23288
23289
23290
23291
23292 func (c *ContentCategoriesInsertCall) Fields(s ...googleapi.Field) *ContentCategoriesInsertCall {
23293 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23294 return c
23295 }
23296
23297
23298
23299
23300 func (c *ContentCategoriesInsertCall) Context(ctx context.Context) *ContentCategoriesInsertCall {
23301 c.ctx_ = ctx
23302 return c
23303 }
23304
23305
23306
23307 func (c *ContentCategoriesInsertCall) Header() http.Header {
23308 if c.header_ == nil {
23309 c.header_ = make(http.Header)
23310 }
23311 return c.header_
23312 }
23313
23314 func (c *ContentCategoriesInsertCall) doRequest(alt string) (*http.Response, error) {
23315 reqHeaders := make(http.Header)
23316 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
23317 for k, v := range c.header_ {
23318 reqHeaders[k] = v
23319 }
23320 reqHeaders.Set("User-Agent", c.s.userAgent())
23321 var body io.Reader = nil
23322 body, err := googleapi.WithoutDataWrapper.JSONReader(c.contentcategory)
23323 if err != nil {
23324 return nil, err
23325 }
23326 reqHeaders.Set("Content-Type", "application/json")
23327 c.urlParams_.Set("alt", alt)
23328 c.urlParams_.Set("prettyPrint", "false")
23329 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/contentCategories")
23330 urls += "?" + c.urlParams_.Encode()
23331 req, err := http.NewRequest("POST", urls, body)
23332 if err != nil {
23333 return nil, err
23334 }
23335 req.Header = reqHeaders
23336 googleapi.Expand(req.URL, map[string]string{
23337 "profileId": strconv.FormatInt(c.profileId, 10),
23338 })
23339 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23340 }
23341
23342
23343
23344
23345
23346
23347
23348
23349 func (c *ContentCategoriesInsertCall) Do(opts ...googleapi.CallOption) (*ContentCategory, error) {
23350 gensupport.SetOptions(c.urlParams_, opts...)
23351 res, err := c.doRequest("json")
23352 if res != nil && res.StatusCode == http.StatusNotModified {
23353 if res.Body != nil {
23354 res.Body.Close()
23355 }
23356 return nil, &googleapi.Error{
23357 Code: res.StatusCode,
23358 Header: res.Header,
23359 }
23360 }
23361 if err != nil {
23362 return nil, err
23363 }
23364 defer googleapi.CloseBody(res)
23365 if err := googleapi.CheckResponse(res); err != nil {
23366 return nil, err
23367 }
23368 ret := &ContentCategory{
23369 ServerResponse: googleapi.ServerResponse{
23370 Header: res.Header,
23371 HTTPStatusCode: res.StatusCode,
23372 },
23373 }
23374 target := &ret
23375 if err := gensupport.DecodeResponse(target, res); err != nil {
23376 return nil, err
23377 }
23378 return ret, nil
23379
23380
23381
23382
23383
23384
23385
23386
23387
23388
23389
23390
23391
23392
23393
23394
23395
23396
23397
23398
23399
23400
23401
23402
23403
23404
23405
23406
23407 }
23408
23409
23410
23411 type ContentCategoriesListCall struct {
23412 s *Service
23413 profileId int64
23414 urlParams_ gensupport.URLParams
23415 ifNoneMatch_ string
23416 ctx_ context.Context
23417 header_ http.Header
23418 }
23419
23420
23421
23422 func (r *ContentCategoriesService) List(profileId int64) *ContentCategoriesListCall {
23423 c := &ContentCategoriesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23424 c.profileId = profileId
23425 return c
23426 }
23427
23428
23429
23430 func (c *ContentCategoriesListCall) Ids(ids ...int64) *ContentCategoriesListCall {
23431 var ids_ []string
23432 for _, v := range ids {
23433 ids_ = append(ids_, fmt.Sprint(v))
23434 }
23435 c.urlParams_.SetMulti("ids", ids_)
23436 return c
23437 }
23438
23439
23440
23441 func (c *ContentCategoriesListCall) MaxResults(maxResults int64) *ContentCategoriesListCall {
23442 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
23443 return c
23444 }
23445
23446
23447
23448 func (c *ContentCategoriesListCall) PageToken(pageToken string) *ContentCategoriesListCall {
23449 c.urlParams_.Set("pageToken", pageToken)
23450 return c
23451 }
23452
23453
23454
23455
23456
23457
23458
23459
23460
23461
23462 func (c *ContentCategoriesListCall) SearchString(searchString string) *ContentCategoriesListCall {
23463 c.urlParams_.Set("searchString", searchString)
23464 return c
23465 }
23466
23467
23468
23469
23470
23471
23472
23473
23474 func (c *ContentCategoriesListCall) SortField(sortField string) *ContentCategoriesListCall {
23475 c.urlParams_.Set("sortField", sortField)
23476 return c
23477 }
23478
23479
23480
23481
23482
23483
23484
23485
23486 func (c *ContentCategoriesListCall) SortOrder(sortOrder string) *ContentCategoriesListCall {
23487 c.urlParams_.Set("sortOrder", sortOrder)
23488 return c
23489 }
23490
23491
23492
23493
23494 func (c *ContentCategoriesListCall) Fields(s ...googleapi.Field) *ContentCategoriesListCall {
23495 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23496 return c
23497 }
23498
23499
23500
23501
23502
23503
23504 func (c *ContentCategoriesListCall) IfNoneMatch(entityTag string) *ContentCategoriesListCall {
23505 c.ifNoneMatch_ = entityTag
23506 return c
23507 }
23508
23509
23510
23511
23512 func (c *ContentCategoriesListCall) Context(ctx context.Context) *ContentCategoriesListCall {
23513 c.ctx_ = ctx
23514 return c
23515 }
23516
23517
23518
23519 func (c *ContentCategoriesListCall) Header() http.Header {
23520 if c.header_ == nil {
23521 c.header_ = make(http.Header)
23522 }
23523 return c.header_
23524 }
23525
23526 func (c *ContentCategoriesListCall) doRequest(alt string) (*http.Response, error) {
23527 reqHeaders := make(http.Header)
23528 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
23529 for k, v := range c.header_ {
23530 reqHeaders[k] = v
23531 }
23532 reqHeaders.Set("User-Agent", c.s.userAgent())
23533 if c.ifNoneMatch_ != "" {
23534 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
23535 }
23536 var body io.Reader = nil
23537 c.urlParams_.Set("alt", alt)
23538 c.urlParams_.Set("prettyPrint", "false")
23539 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/contentCategories")
23540 urls += "?" + c.urlParams_.Encode()
23541 req, err := http.NewRequest("GET", urls, body)
23542 if err != nil {
23543 return nil, err
23544 }
23545 req.Header = reqHeaders
23546 googleapi.Expand(req.URL, map[string]string{
23547 "profileId": strconv.FormatInt(c.profileId, 10),
23548 })
23549 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23550 }
23551
23552
23553
23554
23555
23556
23557
23558
23559 func (c *ContentCategoriesListCall) Do(opts ...googleapi.CallOption) (*ContentCategoriesListResponse, error) {
23560 gensupport.SetOptions(c.urlParams_, opts...)
23561 res, err := c.doRequest("json")
23562 if res != nil && res.StatusCode == http.StatusNotModified {
23563 if res.Body != nil {
23564 res.Body.Close()
23565 }
23566 return nil, &googleapi.Error{
23567 Code: res.StatusCode,
23568 Header: res.Header,
23569 }
23570 }
23571 if err != nil {
23572 return nil, err
23573 }
23574 defer googleapi.CloseBody(res)
23575 if err := googleapi.CheckResponse(res); err != nil {
23576 return nil, err
23577 }
23578 ret := &ContentCategoriesListResponse{
23579 ServerResponse: googleapi.ServerResponse{
23580 Header: res.Header,
23581 HTTPStatusCode: res.StatusCode,
23582 },
23583 }
23584 target := &ret
23585 if err := gensupport.DecodeResponse(target, res); err != nil {
23586 return nil, err
23587 }
23588 return ret, nil
23589
23590
23591
23592
23593
23594
23595
23596
23597
23598
23599
23600
23601
23602
23603
23604
23605
23606
23607
23608
23609
23610
23611
23612
23613
23614
23615
23616
23617
23618
23619
23620
23621
23622
23623
23624
23625
23626
23627
23628
23629
23630
23631
23632
23633
23634
23635
23636
23637
23638
23639
23640
23641
23642
23643
23644
23645
23646
23647
23648
23649
23650
23651
23652
23653
23654
23655
23656
23657
23658
23659
23660
23661
23662
23663
23664
23665
23666
23667
23668 }
23669
23670
23671
23672
23673 func (c *ContentCategoriesListCall) Pages(ctx context.Context, f func(*ContentCategoriesListResponse) error) error {
23674 c.ctx_ = ctx
23675 defer c.PageToken(c.urlParams_.Get("pageToken"))
23676 for {
23677 x, err := c.Do()
23678 if err != nil {
23679 return err
23680 }
23681 if err := f(x); err != nil {
23682 return err
23683 }
23684 if x.NextPageToken == "" {
23685 return nil
23686 }
23687 c.PageToken(x.NextPageToken)
23688 }
23689 }
23690
23691
23692
23693 type ContentCategoriesPatchCall struct {
23694 s *Service
23695 profileId int64
23696 contentcategory *ContentCategory
23697 urlParams_ gensupport.URLParams
23698 ctx_ context.Context
23699 header_ http.Header
23700 }
23701
23702
23703
23704 func (r *ContentCategoriesService) Patch(profileId int64, id int64, contentcategory *ContentCategory) *ContentCategoriesPatchCall {
23705 c := &ContentCategoriesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23706 c.profileId = profileId
23707 c.urlParams_.Set("id", fmt.Sprint(id))
23708 c.contentcategory = contentcategory
23709 return c
23710 }
23711
23712
23713
23714
23715 func (c *ContentCategoriesPatchCall) Fields(s ...googleapi.Field) *ContentCategoriesPatchCall {
23716 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23717 return c
23718 }
23719
23720
23721
23722
23723 func (c *ContentCategoriesPatchCall) Context(ctx context.Context) *ContentCategoriesPatchCall {
23724 c.ctx_ = ctx
23725 return c
23726 }
23727
23728
23729
23730 func (c *ContentCategoriesPatchCall) Header() http.Header {
23731 if c.header_ == nil {
23732 c.header_ = make(http.Header)
23733 }
23734 return c.header_
23735 }
23736
23737 func (c *ContentCategoriesPatchCall) doRequest(alt string) (*http.Response, error) {
23738 reqHeaders := make(http.Header)
23739 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
23740 for k, v := range c.header_ {
23741 reqHeaders[k] = v
23742 }
23743 reqHeaders.Set("User-Agent", c.s.userAgent())
23744 var body io.Reader = nil
23745 body, err := googleapi.WithoutDataWrapper.JSONReader(c.contentcategory)
23746 if err != nil {
23747 return nil, err
23748 }
23749 reqHeaders.Set("Content-Type", "application/json")
23750 c.urlParams_.Set("alt", alt)
23751 c.urlParams_.Set("prettyPrint", "false")
23752 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/contentCategories")
23753 urls += "?" + c.urlParams_.Encode()
23754 req, err := http.NewRequest("PATCH", urls, body)
23755 if err != nil {
23756 return nil, err
23757 }
23758 req.Header = reqHeaders
23759 googleapi.Expand(req.URL, map[string]string{
23760 "profileId": strconv.FormatInt(c.profileId, 10),
23761 })
23762 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23763 }
23764
23765
23766
23767
23768
23769
23770
23771
23772 func (c *ContentCategoriesPatchCall) Do(opts ...googleapi.CallOption) (*ContentCategory, error) {
23773 gensupport.SetOptions(c.urlParams_, opts...)
23774 res, err := c.doRequest("json")
23775 if res != nil && res.StatusCode == http.StatusNotModified {
23776 if res.Body != nil {
23777 res.Body.Close()
23778 }
23779 return nil, &googleapi.Error{
23780 Code: res.StatusCode,
23781 Header: res.Header,
23782 }
23783 }
23784 if err != nil {
23785 return nil, err
23786 }
23787 defer googleapi.CloseBody(res)
23788 if err := googleapi.CheckResponse(res); err != nil {
23789 return nil, err
23790 }
23791 ret := &ContentCategory{
23792 ServerResponse: googleapi.ServerResponse{
23793 Header: res.Header,
23794 HTTPStatusCode: res.StatusCode,
23795 },
23796 }
23797 target := &ret
23798 if err := gensupport.DecodeResponse(target, res); err != nil {
23799 return nil, err
23800 }
23801 return ret, nil
23802
23803
23804
23805
23806
23807
23808
23809
23810
23811
23812
23813
23814
23815
23816
23817
23818
23819
23820
23821
23822
23823
23824
23825
23826
23827
23828
23829
23830
23831
23832
23833
23834
23835
23836
23837
23838 }
23839
23840
23841
23842 type ContentCategoriesUpdateCall struct {
23843 s *Service
23844 profileId int64
23845 contentcategory *ContentCategory
23846 urlParams_ gensupport.URLParams
23847 ctx_ context.Context
23848 header_ http.Header
23849 }
23850
23851
23852 func (r *ContentCategoriesService) Update(profileId int64, contentcategory *ContentCategory) *ContentCategoriesUpdateCall {
23853 c := &ContentCategoriesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23854 c.profileId = profileId
23855 c.contentcategory = contentcategory
23856 return c
23857 }
23858
23859
23860
23861
23862 func (c *ContentCategoriesUpdateCall) Fields(s ...googleapi.Field) *ContentCategoriesUpdateCall {
23863 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23864 return c
23865 }
23866
23867
23868
23869
23870 func (c *ContentCategoriesUpdateCall) Context(ctx context.Context) *ContentCategoriesUpdateCall {
23871 c.ctx_ = ctx
23872 return c
23873 }
23874
23875
23876
23877 func (c *ContentCategoriesUpdateCall) Header() http.Header {
23878 if c.header_ == nil {
23879 c.header_ = make(http.Header)
23880 }
23881 return c.header_
23882 }
23883
23884 func (c *ContentCategoriesUpdateCall) doRequest(alt string) (*http.Response, error) {
23885 reqHeaders := make(http.Header)
23886 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
23887 for k, v := range c.header_ {
23888 reqHeaders[k] = v
23889 }
23890 reqHeaders.Set("User-Agent", c.s.userAgent())
23891 var body io.Reader = nil
23892 body, err := googleapi.WithoutDataWrapper.JSONReader(c.contentcategory)
23893 if err != nil {
23894 return nil, err
23895 }
23896 reqHeaders.Set("Content-Type", "application/json")
23897 c.urlParams_.Set("alt", alt)
23898 c.urlParams_.Set("prettyPrint", "false")
23899 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/contentCategories")
23900 urls += "?" + c.urlParams_.Encode()
23901 req, err := http.NewRequest("PUT", urls, body)
23902 if err != nil {
23903 return nil, err
23904 }
23905 req.Header = reqHeaders
23906 googleapi.Expand(req.URL, map[string]string{
23907 "profileId": strconv.FormatInt(c.profileId, 10),
23908 })
23909 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23910 }
23911
23912
23913
23914
23915
23916
23917
23918
23919 func (c *ContentCategoriesUpdateCall) Do(opts ...googleapi.CallOption) (*ContentCategory, error) {
23920 gensupport.SetOptions(c.urlParams_, opts...)
23921 res, err := c.doRequest("json")
23922 if res != nil && res.StatusCode == http.StatusNotModified {
23923 if res.Body != nil {
23924 res.Body.Close()
23925 }
23926 return nil, &googleapi.Error{
23927 Code: res.StatusCode,
23928 Header: res.Header,
23929 }
23930 }
23931 if err != nil {
23932 return nil, err
23933 }
23934 defer googleapi.CloseBody(res)
23935 if err := googleapi.CheckResponse(res); err != nil {
23936 return nil, err
23937 }
23938 ret := &ContentCategory{
23939 ServerResponse: googleapi.ServerResponse{
23940 Header: res.Header,
23941 HTTPStatusCode: res.StatusCode,
23942 },
23943 }
23944 target := &ret
23945 if err := gensupport.DecodeResponse(target, res); err != nil {
23946 return nil, err
23947 }
23948 return ret, nil
23949
23950
23951
23952
23953
23954
23955
23956
23957
23958
23959
23960
23961
23962
23963
23964
23965
23966
23967
23968
23969
23970
23971
23972
23973
23974
23975
23976
23977 }
23978
23979
23980
23981 type ConversionsBatchinsertCall struct {
23982 s *Service
23983 profileId int64
23984 conversionsbatchinsertrequest *ConversionsBatchInsertRequest
23985 urlParams_ gensupport.URLParams
23986 ctx_ context.Context
23987 header_ http.Header
23988 }
23989
23990
23991 func (r *ConversionsService) Batchinsert(profileId int64, conversionsbatchinsertrequest *ConversionsBatchInsertRequest) *ConversionsBatchinsertCall {
23992 c := &ConversionsBatchinsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23993 c.profileId = profileId
23994 c.conversionsbatchinsertrequest = conversionsbatchinsertrequest
23995 return c
23996 }
23997
23998
23999
24000
24001 func (c *ConversionsBatchinsertCall) Fields(s ...googleapi.Field) *ConversionsBatchinsertCall {
24002 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24003 return c
24004 }
24005
24006
24007
24008
24009 func (c *ConversionsBatchinsertCall) Context(ctx context.Context) *ConversionsBatchinsertCall {
24010 c.ctx_ = ctx
24011 return c
24012 }
24013
24014
24015
24016 func (c *ConversionsBatchinsertCall) Header() http.Header {
24017 if c.header_ == nil {
24018 c.header_ = make(http.Header)
24019 }
24020 return c.header_
24021 }
24022
24023 func (c *ConversionsBatchinsertCall) doRequest(alt string) (*http.Response, error) {
24024 reqHeaders := make(http.Header)
24025 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
24026 for k, v := range c.header_ {
24027 reqHeaders[k] = v
24028 }
24029 reqHeaders.Set("User-Agent", c.s.userAgent())
24030 var body io.Reader = nil
24031 body, err := googleapi.WithoutDataWrapper.JSONReader(c.conversionsbatchinsertrequest)
24032 if err != nil {
24033 return nil, err
24034 }
24035 reqHeaders.Set("Content-Type", "application/json")
24036 c.urlParams_.Set("alt", alt)
24037 c.urlParams_.Set("prettyPrint", "false")
24038 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/conversions/batchinsert")
24039 urls += "?" + c.urlParams_.Encode()
24040 req, err := http.NewRequest("POST", urls, body)
24041 if err != nil {
24042 return nil, err
24043 }
24044 req.Header = reqHeaders
24045 googleapi.Expand(req.URL, map[string]string{
24046 "profileId": strconv.FormatInt(c.profileId, 10),
24047 })
24048 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24049 }
24050
24051
24052
24053
24054
24055
24056
24057
24058 func (c *ConversionsBatchinsertCall) Do(opts ...googleapi.CallOption) (*ConversionsBatchInsertResponse, error) {
24059 gensupport.SetOptions(c.urlParams_, opts...)
24060 res, err := c.doRequest("json")
24061 if res != nil && res.StatusCode == http.StatusNotModified {
24062 if res.Body != nil {
24063 res.Body.Close()
24064 }
24065 return nil, &googleapi.Error{
24066 Code: res.StatusCode,
24067 Header: res.Header,
24068 }
24069 }
24070 if err != nil {
24071 return nil, err
24072 }
24073 defer googleapi.CloseBody(res)
24074 if err := googleapi.CheckResponse(res); err != nil {
24075 return nil, err
24076 }
24077 ret := &ConversionsBatchInsertResponse{
24078 ServerResponse: googleapi.ServerResponse{
24079 Header: res.Header,
24080 HTTPStatusCode: res.StatusCode,
24081 },
24082 }
24083 target := &ret
24084 if err := gensupport.DecodeResponse(target, res); err != nil {
24085 return nil, err
24086 }
24087 return ret, nil
24088
24089
24090
24091
24092
24093
24094
24095
24096
24097
24098
24099
24100
24101
24102
24103
24104
24105
24106
24107
24108
24109
24110
24111
24112
24113
24114
24115
24116 }
24117
24118
24119
24120 type ConversionsBatchupdateCall struct {
24121 s *Service
24122 profileId int64
24123 conversionsbatchupdaterequest *ConversionsBatchUpdateRequest
24124 urlParams_ gensupport.URLParams
24125 ctx_ context.Context
24126 header_ http.Header
24127 }
24128
24129
24130 func (r *ConversionsService) Batchupdate(profileId int64, conversionsbatchupdaterequest *ConversionsBatchUpdateRequest) *ConversionsBatchupdateCall {
24131 c := &ConversionsBatchupdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24132 c.profileId = profileId
24133 c.conversionsbatchupdaterequest = conversionsbatchupdaterequest
24134 return c
24135 }
24136
24137
24138
24139
24140 func (c *ConversionsBatchupdateCall) Fields(s ...googleapi.Field) *ConversionsBatchupdateCall {
24141 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24142 return c
24143 }
24144
24145
24146
24147
24148 func (c *ConversionsBatchupdateCall) Context(ctx context.Context) *ConversionsBatchupdateCall {
24149 c.ctx_ = ctx
24150 return c
24151 }
24152
24153
24154
24155 func (c *ConversionsBatchupdateCall) Header() http.Header {
24156 if c.header_ == nil {
24157 c.header_ = make(http.Header)
24158 }
24159 return c.header_
24160 }
24161
24162 func (c *ConversionsBatchupdateCall) doRequest(alt string) (*http.Response, error) {
24163 reqHeaders := make(http.Header)
24164 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
24165 for k, v := range c.header_ {
24166 reqHeaders[k] = v
24167 }
24168 reqHeaders.Set("User-Agent", c.s.userAgent())
24169 var body io.Reader = nil
24170 body, err := googleapi.WithoutDataWrapper.JSONReader(c.conversionsbatchupdaterequest)
24171 if err != nil {
24172 return nil, err
24173 }
24174 reqHeaders.Set("Content-Type", "application/json")
24175 c.urlParams_.Set("alt", alt)
24176 c.urlParams_.Set("prettyPrint", "false")
24177 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/conversions/batchupdate")
24178 urls += "?" + c.urlParams_.Encode()
24179 req, err := http.NewRequest("POST", urls, body)
24180 if err != nil {
24181 return nil, err
24182 }
24183 req.Header = reqHeaders
24184 googleapi.Expand(req.URL, map[string]string{
24185 "profileId": strconv.FormatInt(c.profileId, 10),
24186 })
24187 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24188 }
24189
24190
24191
24192
24193
24194
24195
24196
24197 func (c *ConversionsBatchupdateCall) Do(opts ...googleapi.CallOption) (*ConversionsBatchUpdateResponse, error) {
24198 gensupport.SetOptions(c.urlParams_, opts...)
24199 res, err := c.doRequest("json")
24200 if res != nil && res.StatusCode == http.StatusNotModified {
24201 if res.Body != nil {
24202 res.Body.Close()
24203 }
24204 return nil, &googleapi.Error{
24205 Code: res.StatusCode,
24206 Header: res.Header,
24207 }
24208 }
24209 if err != nil {
24210 return nil, err
24211 }
24212 defer googleapi.CloseBody(res)
24213 if err := googleapi.CheckResponse(res); err != nil {
24214 return nil, err
24215 }
24216 ret := &ConversionsBatchUpdateResponse{
24217 ServerResponse: googleapi.ServerResponse{
24218 Header: res.Header,
24219 HTTPStatusCode: res.StatusCode,
24220 },
24221 }
24222 target := &ret
24223 if err := gensupport.DecodeResponse(target, res); err != nil {
24224 return nil, err
24225 }
24226 return ret, nil
24227
24228
24229
24230
24231
24232
24233
24234
24235
24236
24237
24238
24239
24240
24241
24242
24243
24244
24245
24246
24247
24248
24249
24250
24251
24252
24253
24254
24255 }
24256
24257
24258
24259 type CountriesGetCall struct {
24260 s *Service
24261 profileId int64
24262 dartId int64
24263 urlParams_ gensupport.URLParams
24264 ifNoneMatch_ string
24265 ctx_ context.Context
24266 header_ http.Header
24267 }
24268
24269
24270 func (r *CountriesService) Get(profileId int64, dartId int64) *CountriesGetCall {
24271 c := &CountriesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24272 c.profileId = profileId
24273 c.dartId = dartId
24274 return c
24275 }
24276
24277
24278
24279
24280 func (c *CountriesGetCall) Fields(s ...googleapi.Field) *CountriesGetCall {
24281 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24282 return c
24283 }
24284
24285
24286
24287
24288
24289
24290 func (c *CountriesGetCall) IfNoneMatch(entityTag string) *CountriesGetCall {
24291 c.ifNoneMatch_ = entityTag
24292 return c
24293 }
24294
24295
24296
24297
24298 func (c *CountriesGetCall) Context(ctx context.Context) *CountriesGetCall {
24299 c.ctx_ = ctx
24300 return c
24301 }
24302
24303
24304
24305 func (c *CountriesGetCall) Header() http.Header {
24306 if c.header_ == nil {
24307 c.header_ = make(http.Header)
24308 }
24309 return c.header_
24310 }
24311
24312 func (c *CountriesGetCall) doRequest(alt string) (*http.Response, error) {
24313 reqHeaders := make(http.Header)
24314 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
24315 for k, v := range c.header_ {
24316 reqHeaders[k] = v
24317 }
24318 reqHeaders.Set("User-Agent", c.s.userAgent())
24319 if c.ifNoneMatch_ != "" {
24320 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
24321 }
24322 var body io.Reader = nil
24323 c.urlParams_.Set("alt", alt)
24324 c.urlParams_.Set("prettyPrint", "false")
24325 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/countries/{dartId}")
24326 urls += "?" + c.urlParams_.Encode()
24327 req, err := http.NewRequest("GET", urls, body)
24328 if err != nil {
24329 return nil, err
24330 }
24331 req.Header = reqHeaders
24332 googleapi.Expand(req.URL, map[string]string{
24333 "profileId": strconv.FormatInt(c.profileId, 10),
24334 "dartId": strconv.FormatInt(c.dartId, 10),
24335 })
24336 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24337 }
24338
24339
24340
24341
24342
24343
24344
24345
24346 func (c *CountriesGetCall) Do(opts ...googleapi.CallOption) (*Country, error) {
24347 gensupport.SetOptions(c.urlParams_, opts...)
24348 res, err := c.doRequest("json")
24349 if res != nil && res.StatusCode == http.StatusNotModified {
24350 if res.Body != nil {
24351 res.Body.Close()
24352 }
24353 return nil, &googleapi.Error{
24354 Code: res.StatusCode,
24355 Header: res.Header,
24356 }
24357 }
24358 if err != nil {
24359 return nil, err
24360 }
24361 defer googleapi.CloseBody(res)
24362 if err := googleapi.CheckResponse(res); err != nil {
24363 return nil, err
24364 }
24365 ret := &Country{
24366 ServerResponse: googleapi.ServerResponse{
24367 Header: res.Header,
24368 HTTPStatusCode: res.StatusCode,
24369 },
24370 }
24371 target := &ret
24372 if err := gensupport.DecodeResponse(target, res); err != nil {
24373 return nil, err
24374 }
24375 return ret, nil
24376
24377
24378
24379
24380
24381
24382
24383
24384
24385
24386
24387
24388
24389
24390
24391
24392
24393
24394
24395
24396
24397
24398
24399
24400
24401
24402
24403
24404
24405
24406
24407
24408
24409 }
24410
24411
24412
24413 type CountriesListCall struct {
24414 s *Service
24415 profileId int64
24416 urlParams_ gensupport.URLParams
24417 ifNoneMatch_ string
24418 ctx_ context.Context
24419 header_ http.Header
24420 }
24421
24422
24423 func (r *CountriesService) List(profileId int64) *CountriesListCall {
24424 c := &CountriesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24425 c.profileId = profileId
24426 return c
24427 }
24428
24429
24430
24431
24432 func (c *CountriesListCall) Fields(s ...googleapi.Field) *CountriesListCall {
24433 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24434 return c
24435 }
24436
24437
24438
24439
24440
24441
24442 func (c *CountriesListCall) IfNoneMatch(entityTag string) *CountriesListCall {
24443 c.ifNoneMatch_ = entityTag
24444 return c
24445 }
24446
24447
24448
24449
24450 func (c *CountriesListCall) Context(ctx context.Context) *CountriesListCall {
24451 c.ctx_ = ctx
24452 return c
24453 }
24454
24455
24456
24457 func (c *CountriesListCall) Header() http.Header {
24458 if c.header_ == nil {
24459 c.header_ = make(http.Header)
24460 }
24461 return c.header_
24462 }
24463
24464 func (c *CountriesListCall) doRequest(alt string) (*http.Response, error) {
24465 reqHeaders := make(http.Header)
24466 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
24467 for k, v := range c.header_ {
24468 reqHeaders[k] = v
24469 }
24470 reqHeaders.Set("User-Agent", c.s.userAgent())
24471 if c.ifNoneMatch_ != "" {
24472 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
24473 }
24474 var body io.Reader = nil
24475 c.urlParams_.Set("alt", alt)
24476 c.urlParams_.Set("prettyPrint", "false")
24477 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/countries")
24478 urls += "?" + c.urlParams_.Encode()
24479 req, err := http.NewRequest("GET", urls, body)
24480 if err != nil {
24481 return nil, err
24482 }
24483 req.Header = reqHeaders
24484 googleapi.Expand(req.URL, map[string]string{
24485 "profileId": strconv.FormatInt(c.profileId, 10),
24486 })
24487 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24488 }
24489
24490
24491
24492
24493
24494
24495
24496
24497 func (c *CountriesListCall) Do(opts ...googleapi.CallOption) (*CountriesListResponse, error) {
24498 gensupport.SetOptions(c.urlParams_, opts...)
24499 res, err := c.doRequest("json")
24500 if res != nil && res.StatusCode == http.StatusNotModified {
24501 if res.Body != nil {
24502 res.Body.Close()
24503 }
24504 return nil, &googleapi.Error{
24505 Code: res.StatusCode,
24506 Header: res.Header,
24507 }
24508 }
24509 if err != nil {
24510 return nil, err
24511 }
24512 defer googleapi.CloseBody(res)
24513 if err := googleapi.CheckResponse(res); err != nil {
24514 return nil, err
24515 }
24516 ret := &CountriesListResponse{
24517 ServerResponse: googleapi.ServerResponse{
24518 Header: res.Header,
24519 HTTPStatusCode: res.StatusCode,
24520 },
24521 }
24522 target := &ret
24523 if err := gensupport.DecodeResponse(target, res); err != nil {
24524 return nil, err
24525 }
24526 return ret, nil
24527
24528
24529
24530
24531
24532
24533
24534
24535
24536
24537
24538
24539
24540
24541
24542
24543
24544
24545
24546
24547
24548
24549
24550
24551
24552 }
24553
24554
24555
24556 type CreativeAssetsInsertCall struct {
24557 s *Service
24558 profileId int64
24559 advertiserId int64
24560 creativeassetmetadata *CreativeAssetMetadata
24561 urlParams_ gensupport.URLParams
24562 mediaInfo_ *gensupport.MediaInfo
24563 ctx_ context.Context
24564 header_ http.Header
24565 }
24566
24567
24568 func (r *CreativeAssetsService) Insert(profileId int64, advertiserId int64, creativeassetmetadata *CreativeAssetMetadata) *CreativeAssetsInsertCall {
24569 c := &CreativeAssetsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24570 c.profileId = profileId
24571 c.advertiserId = advertiserId
24572 c.creativeassetmetadata = creativeassetmetadata
24573 return c
24574 }
24575
24576
24577
24578
24579
24580
24581
24582
24583
24584 func (c *CreativeAssetsInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *CreativeAssetsInsertCall {
24585 c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
24586 return c
24587 }
24588
24589
24590
24591
24592
24593
24594
24595
24596
24597
24598 func (c *CreativeAssetsInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *CreativeAssetsInsertCall {
24599 c.ctx_ = ctx
24600 c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
24601 return c
24602 }
24603
24604
24605
24606
24607
24608 func (c *CreativeAssetsInsertCall) ProgressUpdater(pu googleapi.ProgressUpdater) *CreativeAssetsInsertCall {
24609 c.mediaInfo_.SetProgressUpdater(pu)
24610 return c
24611 }
24612
24613
24614
24615
24616 func (c *CreativeAssetsInsertCall) Fields(s ...googleapi.Field) *CreativeAssetsInsertCall {
24617 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24618 return c
24619 }
24620
24621
24622
24623
24624
24625
24626 func (c *CreativeAssetsInsertCall) Context(ctx context.Context) *CreativeAssetsInsertCall {
24627 c.ctx_ = ctx
24628 return c
24629 }
24630
24631
24632
24633 func (c *CreativeAssetsInsertCall) Header() http.Header {
24634 if c.header_ == nil {
24635 c.header_ = make(http.Header)
24636 }
24637 return c.header_
24638 }
24639
24640 func (c *CreativeAssetsInsertCall) doRequest(alt string) (*http.Response, error) {
24641 reqHeaders := make(http.Header)
24642 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
24643 for k, v := range c.header_ {
24644 reqHeaders[k] = v
24645 }
24646 reqHeaders.Set("User-Agent", c.s.userAgent())
24647 var body io.Reader = nil
24648 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativeassetmetadata)
24649 if err != nil {
24650 return nil, err
24651 }
24652 reqHeaders.Set("Content-Type", "application/json")
24653 c.urlParams_.Set("alt", alt)
24654 c.urlParams_.Set("prettyPrint", "false")
24655 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeAssets/{advertiserId}/creativeAssets")
24656 if c.mediaInfo_ != nil {
24657 urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/dfareporting/v3.1/userprofiles/{profileId}/creativeAssets/{advertiserId}/creativeAssets")
24658 c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
24659 }
24660 if body == nil {
24661 body = new(bytes.Buffer)
24662 reqHeaders.Set("Content-Type", "application/json")
24663 }
24664 body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
24665 defer cleanup()
24666 urls += "?" + c.urlParams_.Encode()
24667 req, err := http.NewRequest("POST", urls, body)
24668 if err != nil {
24669 return nil, err
24670 }
24671 req.Header = reqHeaders
24672 req.GetBody = getBody
24673 googleapi.Expand(req.URL, map[string]string{
24674 "profileId": strconv.FormatInt(c.profileId, 10),
24675 "advertiserId": strconv.FormatInt(c.advertiserId, 10),
24676 })
24677 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24678 }
24679
24680
24681
24682
24683
24684
24685
24686
24687 func (c *CreativeAssetsInsertCall) Do(opts ...googleapi.CallOption) (*CreativeAssetMetadata, error) {
24688 gensupport.SetOptions(c.urlParams_, opts...)
24689 res, err := c.doRequest("json")
24690 if res != nil && res.StatusCode == http.StatusNotModified {
24691 if res.Body != nil {
24692 res.Body.Close()
24693 }
24694 return nil, &googleapi.Error{
24695 Code: res.StatusCode,
24696 Header: res.Header,
24697 }
24698 }
24699 if err != nil {
24700 return nil, err
24701 }
24702 defer googleapi.CloseBody(res)
24703 if err := googleapi.CheckResponse(res); err != nil {
24704 return nil, err
24705 }
24706 rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
24707 if rx != nil {
24708 rx.Client = c.s.client
24709 rx.UserAgent = c.s.userAgent()
24710 ctx := c.ctx_
24711 if ctx == nil {
24712 ctx = context.TODO()
24713 }
24714 res, err = rx.Upload(ctx)
24715 if err != nil {
24716 return nil, err
24717 }
24718 defer res.Body.Close()
24719 if err := googleapi.CheckResponse(res); err != nil {
24720 return nil, err
24721 }
24722 }
24723 ret := &CreativeAssetMetadata{
24724 ServerResponse: googleapi.ServerResponse{
24725 Header: res.Header,
24726 HTTPStatusCode: res.StatusCode,
24727 },
24728 }
24729 target := &ret
24730 if err := gensupport.DecodeResponse(target, res); err != nil {
24731 return nil, err
24732 }
24733 return ret, nil
24734
24735
24736
24737
24738
24739
24740
24741
24742
24743
24744
24745
24746
24747
24748
24749
24750
24751
24752
24753
24754
24755
24756
24757
24758
24759
24760
24761
24762
24763
24764
24765
24766
24767
24768
24769
24770
24771
24772
24773
24774
24775
24776
24777
24778
24779
24780
24781
24782
24783
24784
24785
24786
24787 }
24788
24789
24790
24791 type CreativeFieldValuesDeleteCall struct {
24792 s *Service
24793 profileId int64
24794 creativeFieldId int64
24795 id int64
24796 urlParams_ gensupport.URLParams
24797 ctx_ context.Context
24798 header_ http.Header
24799 }
24800
24801
24802 func (r *CreativeFieldValuesService) Delete(profileId int64, creativeFieldId int64, id int64) *CreativeFieldValuesDeleteCall {
24803 c := &CreativeFieldValuesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24804 c.profileId = profileId
24805 c.creativeFieldId = creativeFieldId
24806 c.id = id
24807 return c
24808 }
24809
24810
24811
24812
24813 func (c *CreativeFieldValuesDeleteCall) Fields(s ...googleapi.Field) *CreativeFieldValuesDeleteCall {
24814 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24815 return c
24816 }
24817
24818
24819
24820
24821 func (c *CreativeFieldValuesDeleteCall) Context(ctx context.Context) *CreativeFieldValuesDeleteCall {
24822 c.ctx_ = ctx
24823 return c
24824 }
24825
24826
24827
24828 func (c *CreativeFieldValuesDeleteCall) Header() http.Header {
24829 if c.header_ == nil {
24830 c.header_ = make(http.Header)
24831 }
24832 return c.header_
24833 }
24834
24835 func (c *CreativeFieldValuesDeleteCall) doRequest(alt string) (*http.Response, error) {
24836 reqHeaders := make(http.Header)
24837 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
24838 for k, v := range c.header_ {
24839 reqHeaders[k] = v
24840 }
24841 reqHeaders.Set("User-Agent", c.s.userAgent())
24842 var body io.Reader = nil
24843 c.urlParams_.Set("alt", alt)
24844 c.urlParams_.Set("prettyPrint", "false")
24845 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields/{creativeFieldId}/creativeFieldValues/{id}")
24846 urls += "?" + c.urlParams_.Encode()
24847 req, err := http.NewRequest("DELETE", urls, body)
24848 if err != nil {
24849 return nil, err
24850 }
24851 req.Header = reqHeaders
24852 googleapi.Expand(req.URL, map[string]string{
24853 "profileId": strconv.FormatInt(c.profileId, 10),
24854 "creativeFieldId": strconv.FormatInt(c.creativeFieldId, 10),
24855 "id": strconv.FormatInt(c.id, 10),
24856 })
24857 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24858 }
24859
24860
24861 func (c *CreativeFieldValuesDeleteCall) Do(opts ...googleapi.CallOption) error {
24862 gensupport.SetOptions(c.urlParams_, opts...)
24863 res, err := c.doRequest("json")
24864 if err != nil {
24865 return err
24866 }
24867 defer googleapi.CloseBody(res)
24868 if err := googleapi.CheckResponse(res); err != nil {
24869 return err
24870 }
24871 return nil
24872
24873
24874
24875
24876
24877
24878
24879
24880
24881
24882
24883
24884
24885
24886
24887
24888
24889
24890
24891
24892
24893
24894
24895
24896
24897
24898
24899
24900
24901
24902
24903
24904
24905
24906
24907
24908
24909
24910 }
24911
24912
24913
24914 type CreativeFieldValuesGetCall struct {
24915 s *Service
24916 profileId int64
24917 creativeFieldId int64
24918 id int64
24919 urlParams_ gensupport.URLParams
24920 ifNoneMatch_ string
24921 ctx_ context.Context
24922 header_ http.Header
24923 }
24924
24925
24926 func (r *CreativeFieldValuesService) Get(profileId int64, creativeFieldId int64, id int64) *CreativeFieldValuesGetCall {
24927 c := &CreativeFieldValuesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24928 c.profileId = profileId
24929 c.creativeFieldId = creativeFieldId
24930 c.id = id
24931 return c
24932 }
24933
24934
24935
24936
24937 func (c *CreativeFieldValuesGetCall) Fields(s ...googleapi.Field) *CreativeFieldValuesGetCall {
24938 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24939 return c
24940 }
24941
24942
24943
24944
24945
24946
24947 func (c *CreativeFieldValuesGetCall) IfNoneMatch(entityTag string) *CreativeFieldValuesGetCall {
24948 c.ifNoneMatch_ = entityTag
24949 return c
24950 }
24951
24952
24953
24954
24955 func (c *CreativeFieldValuesGetCall) Context(ctx context.Context) *CreativeFieldValuesGetCall {
24956 c.ctx_ = ctx
24957 return c
24958 }
24959
24960
24961
24962 func (c *CreativeFieldValuesGetCall) Header() http.Header {
24963 if c.header_ == nil {
24964 c.header_ = make(http.Header)
24965 }
24966 return c.header_
24967 }
24968
24969 func (c *CreativeFieldValuesGetCall) doRequest(alt string) (*http.Response, error) {
24970 reqHeaders := make(http.Header)
24971 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
24972 for k, v := range c.header_ {
24973 reqHeaders[k] = v
24974 }
24975 reqHeaders.Set("User-Agent", c.s.userAgent())
24976 if c.ifNoneMatch_ != "" {
24977 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
24978 }
24979 var body io.Reader = nil
24980 c.urlParams_.Set("alt", alt)
24981 c.urlParams_.Set("prettyPrint", "false")
24982 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields/{creativeFieldId}/creativeFieldValues/{id}")
24983 urls += "?" + c.urlParams_.Encode()
24984 req, err := http.NewRequest("GET", urls, body)
24985 if err != nil {
24986 return nil, err
24987 }
24988 req.Header = reqHeaders
24989 googleapi.Expand(req.URL, map[string]string{
24990 "profileId": strconv.FormatInt(c.profileId, 10),
24991 "creativeFieldId": strconv.FormatInt(c.creativeFieldId, 10),
24992 "id": strconv.FormatInt(c.id, 10),
24993 })
24994 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24995 }
24996
24997
24998
24999
25000
25001
25002
25003
25004 func (c *CreativeFieldValuesGetCall) Do(opts ...googleapi.CallOption) (*CreativeFieldValue, error) {
25005 gensupport.SetOptions(c.urlParams_, opts...)
25006 res, err := c.doRequest("json")
25007 if res != nil && res.StatusCode == http.StatusNotModified {
25008 if res.Body != nil {
25009 res.Body.Close()
25010 }
25011 return nil, &googleapi.Error{
25012 Code: res.StatusCode,
25013 Header: res.Header,
25014 }
25015 }
25016 if err != nil {
25017 return nil, err
25018 }
25019 defer googleapi.CloseBody(res)
25020 if err := googleapi.CheckResponse(res); err != nil {
25021 return nil, err
25022 }
25023 ret := &CreativeFieldValue{
25024 ServerResponse: googleapi.ServerResponse{
25025 Header: res.Header,
25026 HTTPStatusCode: res.StatusCode,
25027 },
25028 }
25029 target := &ret
25030 if err := gensupport.DecodeResponse(target, res); err != nil {
25031 return nil, err
25032 }
25033 return ret, nil
25034
25035
25036
25037
25038
25039
25040
25041
25042
25043
25044
25045
25046
25047
25048
25049
25050
25051
25052
25053
25054
25055
25056
25057
25058
25059
25060
25061
25062
25063
25064
25065
25066
25067
25068
25069
25070
25071
25072
25073
25074
25075 }
25076
25077
25078
25079 type CreativeFieldValuesInsertCall struct {
25080 s *Service
25081 profileId int64
25082 creativeFieldId int64
25083 creativefieldvalue *CreativeFieldValue
25084 urlParams_ gensupport.URLParams
25085 ctx_ context.Context
25086 header_ http.Header
25087 }
25088
25089
25090 func (r *CreativeFieldValuesService) Insert(profileId int64, creativeFieldId int64, creativefieldvalue *CreativeFieldValue) *CreativeFieldValuesInsertCall {
25091 c := &CreativeFieldValuesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25092 c.profileId = profileId
25093 c.creativeFieldId = creativeFieldId
25094 c.creativefieldvalue = creativefieldvalue
25095 return c
25096 }
25097
25098
25099
25100
25101 func (c *CreativeFieldValuesInsertCall) Fields(s ...googleapi.Field) *CreativeFieldValuesInsertCall {
25102 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25103 return c
25104 }
25105
25106
25107
25108
25109 func (c *CreativeFieldValuesInsertCall) Context(ctx context.Context) *CreativeFieldValuesInsertCall {
25110 c.ctx_ = ctx
25111 return c
25112 }
25113
25114
25115
25116 func (c *CreativeFieldValuesInsertCall) Header() http.Header {
25117 if c.header_ == nil {
25118 c.header_ = make(http.Header)
25119 }
25120 return c.header_
25121 }
25122
25123 func (c *CreativeFieldValuesInsertCall) doRequest(alt string) (*http.Response, error) {
25124 reqHeaders := make(http.Header)
25125 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
25126 for k, v := range c.header_ {
25127 reqHeaders[k] = v
25128 }
25129 reqHeaders.Set("User-Agent", c.s.userAgent())
25130 var body io.Reader = nil
25131 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativefieldvalue)
25132 if err != nil {
25133 return nil, err
25134 }
25135 reqHeaders.Set("Content-Type", "application/json")
25136 c.urlParams_.Set("alt", alt)
25137 c.urlParams_.Set("prettyPrint", "false")
25138 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields/{creativeFieldId}/creativeFieldValues")
25139 urls += "?" + c.urlParams_.Encode()
25140 req, err := http.NewRequest("POST", urls, body)
25141 if err != nil {
25142 return nil, err
25143 }
25144 req.Header = reqHeaders
25145 googleapi.Expand(req.URL, map[string]string{
25146 "profileId": strconv.FormatInt(c.profileId, 10),
25147 "creativeFieldId": strconv.FormatInt(c.creativeFieldId, 10),
25148 })
25149 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25150 }
25151
25152
25153
25154
25155
25156
25157
25158
25159 func (c *CreativeFieldValuesInsertCall) Do(opts ...googleapi.CallOption) (*CreativeFieldValue, error) {
25160 gensupport.SetOptions(c.urlParams_, opts...)
25161 res, err := c.doRequest("json")
25162 if res != nil && res.StatusCode == http.StatusNotModified {
25163 if res.Body != nil {
25164 res.Body.Close()
25165 }
25166 return nil, &googleapi.Error{
25167 Code: res.StatusCode,
25168 Header: res.Header,
25169 }
25170 }
25171 if err != nil {
25172 return nil, err
25173 }
25174 defer googleapi.CloseBody(res)
25175 if err := googleapi.CheckResponse(res); err != nil {
25176 return nil, err
25177 }
25178 ret := &CreativeFieldValue{
25179 ServerResponse: googleapi.ServerResponse{
25180 Header: res.Header,
25181 HTTPStatusCode: res.StatusCode,
25182 },
25183 }
25184 target := &ret
25185 if err := gensupport.DecodeResponse(target, res); err != nil {
25186 return nil, err
25187 }
25188 return ret, nil
25189
25190
25191
25192
25193
25194
25195
25196
25197
25198
25199
25200
25201
25202
25203
25204
25205
25206
25207
25208
25209
25210
25211
25212
25213
25214
25215
25216
25217
25218
25219
25220
25221
25222
25223
25224
25225 }
25226
25227
25228
25229 type CreativeFieldValuesListCall struct {
25230 s *Service
25231 profileId int64
25232 creativeFieldId int64
25233 urlParams_ gensupport.URLParams
25234 ifNoneMatch_ string
25235 ctx_ context.Context
25236 header_ http.Header
25237 }
25238
25239
25240
25241 func (r *CreativeFieldValuesService) List(profileId int64, creativeFieldId int64) *CreativeFieldValuesListCall {
25242 c := &CreativeFieldValuesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25243 c.profileId = profileId
25244 c.creativeFieldId = creativeFieldId
25245 return c
25246 }
25247
25248
25249
25250 func (c *CreativeFieldValuesListCall) Ids(ids ...int64) *CreativeFieldValuesListCall {
25251 var ids_ []string
25252 for _, v := range ids {
25253 ids_ = append(ids_, fmt.Sprint(v))
25254 }
25255 c.urlParams_.SetMulti("ids", ids_)
25256 return c
25257 }
25258
25259
25260
25261 func (c *CreativeFieldValuesListCall) MaxResults(maxResults int64) *CreativeFieldValuesListCall {
25262 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
25263 return c
25264 }
25265
25266
25267
25268 func (c *CreativeFieldValuesListCall) PageToken(pageToken string) *CreativeFieldValuesListCall {
25269 c.urlParams_.Set("pageToken", pageToken)
25270 return c
25271 }
25272
25273
25274
25275
25276 func (c *CreativeFieldValuesListCall) SearchString(searchString string) *CreativeFieldValuesListCall {
25277 c.urlParams_.Set("searchString", searchString)
25278 return c
25279 }
25280
25281
25282
25283
25284
25285
25286
25287
25288 func (c *CreativeFieldValuesListCall) SortField(sortField string) *CreativeFieldValuesListCall {
25289 c.urlParams_.Set("sortField", sortField)
25290 return c
25291 }
25292
25293
25294
25295
25296
25297
25298
25299
25300 func (c *CreativeFieldValuesListCall) SortOrder(sortOrder string) *CreativeFieldValuesListCall {
25301 c.urlParams_.Set("sortOrder", sortOrder)
25302 return c
25303 }
25304
25305
25306
25307
25308 func (c *CreativeFieldValuesListCall) Fields(s ...googleapi.Field) *CreativeFieldValuesListCall {
25309 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25310 return c
25311 }
25312
25313
25314
25315
25316
25317
25318 func (c *CreativeFieldValuesListCall) IfNoneMatch(entityTag string) *CreativeFieldValuesListCall {
25319 c.ifNoneMatch_ = entityTag
25320 return c
25321 }
25322
25323
25324
25325
25326 func (c *CreativeFieldValuesListCall) Context(ctx context.Context) *CreativeFieldValuesListCall {
25327 c.ctx_ = ctx
25328 return c
25329 }
25330
25331
25332
25333 func (c *CreativeFieldValuesListCall) Header() http.Header {
25334 if c.header_ == nil {
25335 c.header_ = make(http.Header)
25336 }
25337 return c.header_
25338 }
25339
25340 func (c *CreativeFieldValuesListCall) doRequest(alt string) (*http.Response, error) {
25341 reqHeaders := make(http.Header)
25342 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
25343 for k, v := range c.header_ {
25344 reqHeaders[k] = v
25345 }
25346 reqHeaders.Set("User-Agent", c.s.userAgent())
25347 if c.ifNoneMatch_ != "" {
25348 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
25349 }
25350 var body io.Reader = nil
25351 c.urlParams_.Set("alt", alt)
25352 c.urlParams_.Set("prettyPrint", "false")
25353 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields/{creativeFieldId}/creativeFieldValues")
25354 urls += "?" + c.urlParams_.Encode()
25355 req, err := http.NewRequest("GET", urls, body)
25356 if err != nil {
25357 return nil, err
25358 }
25359 req.Header = reqHeaders
25360 googleapi.Expand(req.URL, map[string]string{
25361 "profileId": strconv.FormatInt(c.profileId, 10),
25362 "creativeFieldId": strconv.FormatInt(c.creativeFieldId, 10),
25363 })
25364 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25365 }
25366
25367
25368
25369
25370
25371
25372
25373
25374 func (c *CreativeFieldValuesListCall) Do(opts ...googleapi.CallOption) (*CreativeFieldValuesListResponse, error) {
25375 gensupport.SetOptions(c.urlParams_, opts...)
25376 res, err := c.doRequest("json")
25377 if res != nil && res.StatusCode == http.StatusNotModified {
25378 if res.Body != nil {
25379 res.Body.Close()
25380 }
25381 return nil, &googleapi.Error{
25382 Code: res.StatusCode,
25383 Header: res.Header,
25384 }
25385 }
25386 if err != nil {
25387 return nil, err
25388 }
25389 defer googleapi.CloseBody(res)
25390 if err := googleapi.CheckResponse(res); err != nil {
25391 return nil, err
25392 }
25393 ret := &CreativeFieldValuesListResponse{
25394 ServerResponse: googleapi.ServerResponse{
25395 Header: res.Header,
25396 HTTPStatusCode: res.StatusCode,
25397 },
25398 }
25399 target := &ret
25400 if err := gensupport.DecodeResponse(target, res); err != nil {
25401 return nil, err
25402 }
25403 return ret, nil
25404
25405
25406
25407
25408
25409
25410
25411
25412
25413
25414
25415
25416
25417
25418
25419
25420
25421
25422
25423
25424
25425
25426
25427
25428
25429
25430
25431
25432
25433
25434
25435
25436
25437
25438
25439
25440
25441
25442
25443
25444
25445
25446
25447
25448
25449
25450
25451
25452
25453
25454
25455
25456
25457
25458
25459
25460
25461
25462
25463
25464
25465
25466
25467
25468
25469
25470
25471
25472
25473
25474
25475
25476
25477
25478
25479
25480
25481
25482
25483
25484
25485
25486
25487
25488
25489
25490
25491 }
25492
25493
25494
25495
25496 func (c *CreativeFieldValuesListCall) Pages(ctx context.Context, f func(*CreativeFieldValuesListResponse) error) error {
25497 c.ctx_ = ctx
25498 defer c.PageToken(c.urlParams_.Get("pageToken"))
25499 for {
25500 x, err := c.Do()
25501 if err != nil {
25502 return err
25503 }
25504 if err := f(x); err != nil {
25505 return err
25506 }
25507 if x.NextPageToken == "" {
25508 return nil
25509 }
25510 c.PageToken(x.NextPageToken)
25511 }
25512 }
25513
25514
25515
25516 type CreativeFieldValuesPatchCall struct {
25517 s *Service
25518 profileId int64
25519 creativeFieldId int64
25520 creativefieldvalue *CreativeFieldValue
25521 urlParams_ gensupport.URLParams
25522 ctx_ context.Context
25523 header_ http.Header
25524 }
25525
25526
25527
25528 func (r *CreativeFieldValuesService) Patch(profileId int64, creativeFieldId int64, id int64, creativefieldvalue *CreativeFieldValue) *CreativeFieldValuesPatchCall {
25529 c := &CreativeFieldValuesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25530 c.profileId = profileId
25531 c.creativeFieldId = creativeFieldId
25532 c.urlParams_.Set("id", fmt.Sprint(id))
25533 c.creativefieldvalue = creativefieldvalue
25534 return c
25535 }
25536
25537
25538
25539
25540 func (c *CreativeFieldValuesPatchCall) Fields(s ...googleapi.Field) *CreativeFieldValuesPatchCall {
25541 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25542 return c
25543 }
25544
25545
25546
25547
25548 func (c *CreativeFieldValuesPatchCall) Context(ctx context.Context) *CreativeFieldValuesPatchCall {
25549 c.ctx_ = ctx
25550 return c
25551 }
25552
25553
25554
25555 func (c *CreativeFieldValuesPatchCall) Header() http.Header {
25556 if c.header_ == nil {
25557 c.header_ = make(http.Header)
25558 }
25559 return c.header_
25560 }
25561
25562 func (c *CreativeFieldValuesPatchCall) doRequest(alt string) (*http.Response, error) {
25563 reqHeaders := make(http.Header)
25564 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
25565 for k, v := range c.header_ {
25566 reqHeaders[k] = v
25567 }
25568 reqHeaders.Set("User-Agent", c.s.userAgent())
25569 var body io.Reader = nil
25570 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativefieldvalue)
25571 if err != nil {
25572 return nil, err
25573 }
25574 reqHeaders.Set("Content-Type", "application/json")
25575 c.urlParams_.Set("alt", alt)
25576 c.urlParams_.Set("prettyPrint", "false")
25577 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields/{creativeFieldId}/creativeFieldValues")
25578 urls += "?" + c.urlParams_.Encode()
25579 req, err := http.NewRequest("PATCH", urls, body)
25580 if err != nil {
25581 return nil, err
25582 }
25583 req.Header = reqHeaders
25584 googleapi.Expand(req.URL, map[string]string{
25585 "profileId": strconv.FormatInt(c.profileId, 10),
25586 "creativeFieldId": strconv.FormatInt(c.creativeFieldId, 10),
25587 })
25588 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25589 }
25590
25591
25592
25593
25594
25595
25596
25597
25598 func (c *CreativeFieldValuesPatchCall) Do(opts ...googleapi.CallOption) (*CreativeFieldValue, error) {
25599 gensupport.SetOptions(c.urlParams_, opts...)
25600 res, err := c.doRequest("json")
25601 if res != nil && res.StatusCode == http.StatusNotModified {
25602 if res.Body != nil {
25603 res.Body.Close()
25604 }
25605 return nil, &googleapi.Error{
25606 Code: res.StatusCode,
25607 Header: res.Header,
25608 }
25609 }
25610 if err != nil {
25611 return nil, err
25612 }
25613 defer googleapi.CloseBody(res)
25614 if err := googleapi.CheckResponse(res); err != nil {
25615 return nil, err
25616 }
25617 ret := &CreativeFieldValue{
25618 ServerResponse: googleapi.ServerResponse{
25619 Header: res.Header,
25620 HTTPStatusCode: res.StatusCode,
25621 },
25622 }
25623 target := &ret
25624 if err := gensupport.DecodeResponse(target, res); err != nil {
25625 return nil, err
25626 }
25627 return ret, nil
25628
25629
25630
25631
25632
25633
25634
25635
25636
25637
25638
25639
25640
25641
25642
25643
25644
25645
25646
25647
25648
25649
25650
25651
25652
25653
25654
25655
25656
25657
25658
25659
25660
25661
25662
25663
25664
25665
25666
25667
25668
25669
25670
25671
25672 }
25673
25674
25675
25676 type CreativeFieldValuesUpdateCall struct {
25677 s *Service
25678 profileId int64
25679 creativeFieldId int64
25680 creativefieldvalue *CreativeFieldValue
25681 urlParams_ gensupport.URLParams
25682 ctx_ context.Context
25683 header_ http.Header
25684 }
25685
25686
25687 func (r *CreativeFieldValuesService) Update(profileId int64, creativeFieldId int64, creativefieldvalue *CreativeFieldValue) *CreativeFieldValuesUpdateCall {
25688 c := &CreativeFieldValuesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25689 c.profileId = profileId
25690 c.creativeFieldId = creativeFieldId
25691 c.creativefieldvalue = creativefieldvalue
25692 return c
25693 }
25694
25695
25696
25697
25698 func (c *CreativeFieldValuesUpdateCall) Fields(s ...googleapi.Field) *CreativeFieldValuesUpdateCall {
25699 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25700 return c
25701 }
25702
25703
25704
25705
25706 func (c *CreativeFieldValuesUpdateCall) Context(ctx context.Context) *CreativeFieldValuesUpdateCall {
25707 c.ctx_ = ctx
25708 return c
25709 }
25710
25711
25712
25713 func (c *CreativeFieldValuesUpdateCall) Header() http.Header {
25714 if c.header_ == nil {
25715 c.header_ = make(http.Header)
25716 }
25717 return c.header_
25718 }
25719
25720 func (c *CreativeFieldValuesUpdateCall) doRequest(alt string) (*http.Response, error) {
25721 reqHeaders := make(http.Header)
25722 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
25723 for k, v := range c.header_ {
25724 reqHeaders[k] = v
25725 }
25726 reqHeaders.Set("User-Agent", c.s.userAgent())
25727 var body io.Reader = nil
25728 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativefieldvalue)
25729 if err != nil {
25730 return nil, err
25731 }
25732 reqHeaders.Set("Content-Type", "application/json")
25733 c.urlParams_.Set("alt", alt)
25734 c.urlParams_.Set("prettyPrint", "false")
25735 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields/{creativeFieldId}/creativeFieldValues")
25736 urls += "?" + c.urlParams_.Encode()
25737 req, err := http.NewRequest("PUT", urls, body)
25738 if err != nil {
25739 return nil, err
25740 }
25741 req.Header = reqHeaders
25742 googleapi.Expand(req.URL, map[string]string{
25743 "profileId": strconv.FormatInt(c.profileId, 10),
25744 "creativeFieldId": strconv.FormatInt(c.creativeFieldId, 10),
25745 })
25746 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25747 }
25748
25749
25750
25751
25752
25753
25754
25755
25756 func (c *CreativeFieldValuesUpdateCall) Do(opts ...googleapi.CallOption) (*CreativeFieldValue, error) {
25757 gensupport.SetOptions(c.urlParams_, opts...)
25758 res, err := c.doRequest("json")
25759 if res != nil && res.StatusCode == http.StatusNotModified {
25760 if res.Body != nil {
25761 res.Body.Close()
25762 }
25763 return nil, &googleapi.Error{
25764 Code: res.StatusCode,
25765 Header: res.Header,
25766 }
25767 }
25768 if err != nil {
25769 return nil, err
25770 }
25771 defer googleapi.CloseBody(res)
25772 if err := googleapi.CheckResponse(res); err != nil {
25773 return nil, err
25774 }
25775 ret := &CreativeFieldValue{
25776 ServerResponse: googleapi.ServerResponse{
25777 Header: res.Header,
25778 HTTPStatusCode: res.StatusCode,
25779 },
25780 }
25781 target := &ret
25782 if err := gensupport.DecodeResponse(target, res); err != nil {
25783 return nil, err
25784 }
25785 return ret, nil
25786
25787
25788
25789
25790
25791
25792
25793
25794
25795
25796
25797
25798
25799
25800
25801
25802
25803
25804
25805
25806
25807
25808
25809
25810
25811
25812
25813
25814
25815
25816
25817
25818
25819
25820
25821
25822 }
25823
25824
25825
25826 type CreativeFieldsDeleteCall struct {
25827 s *Service
25828 profileId int64
25829 id int64
25830 urlParams_ gensupport.URLParams
25831 ctx_ context.Context
25832 header_ http.Header
25833 }
25834
25835
25836 func (r *CreativeFieldsService) Delete(profileId int64, id int64) *CreativeFieldsDeleteCall {
25837 c := &CreativeFieldsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25838 c.profileId = profileId
25839 c.id = id
25840 return c
25841 }
25842
25843
25844
25845
25846 func (c *CreativeFieldsDeleteCall) Fields(s ...googleapi.Field) *CreativeFieldsDeleteCall {
25847 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25848 return c
25849 }
25850
25851
25852
25853
25854 func (c *CreativeFieldsDeleteCall) Context(ctx context.Context) *CreativeFieldsDeleteCall {
25855 c.ctx_ = ctx
25856 return c
25857 }
25858
25859
25860
25861 func (c *CreativeFieldsDeleteCall) Header() http.Header {
25862 if c.header_ == nil {
25863 c.header_ = make(http.Header)
25864 }
25865 return c.header_
25866 }
25867
25868 func (c *CreativeFieldsDeleteCall) doRequest(alt string) (*http.Response, error) {
25869 reqHeaders := make(http.Header)
25870 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
25871 for k, v := range c.header_ {
25872 reqHeaders[k] = v
25873 }
25874 reqHeaders.Set("User-Agent", c.s.userAgent())
25875 var body io.Reader = nil
25876 c.urlParams_.Set("alt", alt)
25877 c.urlParams_.Set("prettyPrint", "false")
25878 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields/{id}")
25879 urls += "?" + c.urlParams_.Encode()
25880 req, err := http.NewRequest("DELETE", urls, body)
25881 if err != nil {
25882 return nil, err
25883 }
25884 req.Header = reqHeaders
25885 googleapi.Expand(req.URL, map[string]string{
25886 "profileId": strconv.FormatInt(c.profileId, 10),
25887 "id": strconv.FormatInt(c.id, 10),
25888 })
25889 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25890 }
25891
25892
25893 func (c *CreativeFieldsDeleteCall) Do(opts ...googleapi.CallOption) error {
25894 gensupport.SetOptions(c.urlParams_, opts...)
25895 res, err := c.doRequest("json")
25896 if err != nil {
25897 return err
25898 }
25899 defer googleapi.CloseBody(res)
25900 if err := googleapi.CheckResponse(res); err != nil {
25901 return err
25902 }
25903 return nil
25904
25905
25906
25907
25908
25909
25910
25911
25912
25913
25914
25915
25916
25917
25918
25919
25920
25921
25922
25923
25924
25925
25926
25927
25928
25929
25930
25931
25932
25933
25934 }
25935
25936
25937
25938 type CreativeFieldsGetCall struct {
25939 s *Service
25940 profileId int64
25941 id int64
25942 urlParams_ gensupport.URLParams
25943 ifNoneMatch_ string
25944 ctx_ context.Context
25945 header_ http.Header
25946 }
25947
25948
25949 func (r *CreativeFieldsService) Get(profileId int64, id int64) *CreativeFieldsGetCall {
25950 c := &CreativeFieldsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25951 c.profileId = profileId
25952 c.id = id
25953 return c
25954 }
25955
25956
25957
25958
25959 func (c *CreativeFieldsGetCall) Fields(s ...googleapi.Field) *CreativeFieldsGetCall {
25960 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25961 return c
25962 }
25963
25964
25965
25966
25967
25968
25969 func (c *CreativeFieldsGetCall) IfNoneMatch(entityTag string) *CreativeFieldsGetCall {
25970 c.ifNoneMatch_ = entityTag
25971 return c
25972 }
25973
25974
25975
25976
25977 func (c *CreativeFieldsGetCall) Context(ctx context.Context) *CreativeFieldsGetCall {
25978 c.ctx_ = ctx
25979 return c
25980 }
25981
25982
25983
25984 func (c *CreativeFieldsGetCall) Header() http.Header {
25985 if c.header_ == nil {
25986 c.header_ = make(http.Header)
25987 }
25988 return c.header_
25989 }
25990
25991 func (c *CreativeFieldsGetCall) doRequest(alt string) (*http.Response, error) {
25992 reqHeaders := make(http.Header)
25993 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
25994 for k, v := range c.header_ {
25995 reqHeaders[k] = v
25996 }
25997 reqHeaders.Set("User-Agent", c.s.userAgent())
25998 if c.ifNoneMatch_ != "" {
25999 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
26000 }
26001 var body io.Reader = nil
26002 c.urlParams_.Set("alt", alt)
26003 c.urlParams_.Set("prettyPrint", "false")
26004 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields/{id}")
26005 urls += "?" + c.urlParams_.Encode()
26006 req, err := http.NewRequest("GET", urls, body)
26007 if err != nil {
26008 return nil, err
26009 }
26010 req.Header = reqHeaders
26011 googleapi.Expand(req.URL, map[string]string{
26012 "profileId": strconv.FormatInt(c.profileId, 10),
26013 "id": strconv.FormatInt(c.id, 10),
26014 })
26015 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26016 }
26017
26018
26019
26020
26021
26022
26023
26024
26025 func (c *CreativeFieldsGetCall) Do(opts ...googleapi.CallOption) (*CreativeField, error) {
26026 gensupport.SetOptions(c.urlParams_, opts...)
26027 res, err := c.doRequest("json")
26028 if res != nil && res.StatusCode == http.StatusNotModified {
26029 if res.Body != nil {
26030 res.Body.Close()
26031 }
26032 return nil, &googleapi.Error{
26033 Code: res.StatusCode,
26034 Header: res.Header,
26035 }
26036 }
26037 if err != nil {
26038 return nil, err
26039 }
26040 defer googleapi.CloseBody(res)
26041 if err := googleapi.CheckResponse(res); err != nil {
26042 return nil, err
26043 }
26044 ret := &CreativeField{
26045 ServerResponse: googleapi.ServerResponse{
26046 Header: res.Header,
26047 HTTPStatusCode: res.StatusCode,
26048 },
26049 }
26050 target := &ret
26051 if err := gensupport.DecodeResponse(target, res); err != nil {
26052 return nil, err
26053 }
26054 return ret, nil
26055
26056
26057
26058
26059
26060
26061
26062
26063
26064
26065
26066
26067
26068
26069
26070
26071
26072
26073
26074
26075
26076
26077
26078
26079
26080
26081
26082
26083
26084
26085
26086
26087
26088 }
26089
26090
26091
26092 type CreativeFieldsInsertCall struct {
26093 s *Service
26094 profileId int64
26095 creativefield *CreativeField
26096 urlParams_ gensupport.URLParams
26097 ctx_ context.Context
26098 header_ http.Header
26099 }
26100
26101
26102 func (r *CreativeFieldsService) Insert(profileId int64, creativefield *CreativeField) *CreativeFieldsInsertCall {
26103 c := &CreativeFieldsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26104 c.profileId = profileId
26105 c.creativefield = creativefield
26106 return c
26107 }
26108
26109
26110
26111
26112 func (c *CreativeFieldsInsertCall) Fields(s ...googleapi.Field) *CreativeFieldsInsertCall {
26113 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26114 return c
26115 }
26116
26117
26118
26119
26120 func (c *CreativeFieldsInsertCall) Context(ctx context.Context) *CreativeFieldsInsertCall {
26121 c.ctx_ = ctx
26122 return c
26123 }
26124
26125
26126
26127 func (c *CreativeFieldsInsertCall) Header() http.Header {
26128 if c.header_ == nil {
26129 c.header_ = make(http.Header)
26130 }
26131 return c.header_
26132 }
26133
26134 func (c *CreativeFieldsInsertCall) doRequest(alt string) (*http.Response, error) {
26135 reqHeaders := make(http.Header)
26136 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
26137 for k, v := range c.header_ {
26138 reqHeaders[k] = v
26139 }
26140 reqHeaders.Set("User-Agent", c.s.userAgent())
26141 var body io.Reader = nil
26142 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativefield)
26143 if err != nil {
26144 return nil, err
26145 }
26146 reqHeaders.Set("Content-Type", "application/json")
26147 c.urlParams_.Set("alt", alt)
26148 c.urlParams_.Set("prettyPrint", "false")
26149 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields")
26150 urls += "?" + c.urlParams_.Encode()
26151 req, err := http.NewRequest("POST", urls, body)
26152 if err != nil {
26153 return nil, err
26154 }
26155 req.Header = reqHeaders
26156 googleapi.Expand(req.URL, map[string]string{
26157 "profileId": strconv.FormatInt(c.profileId, 10),
26158 })
26159 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26160 }
26161
26162
26163
26164
26165
26166
26167
26168
26169 func (c *CreativeFieldsInsertCall) Do(opts ...googleapi.CallOption) (*CreativeField, error) {
26170 gensupport.SetOptions(c.urlParams_, opts...)
26171 res, err := c.doRequest("json")
26172 if res != nil && res.StatusCode == http.StatusNotModified {
26173 if res.Body != nil {
26174 res.Body.Close()
26175 }
26176 return nil, &googleapi.Error{
26177 Code: res.StatusCode,
26178 Header: res.Header,
26179 }
26180 }
26181 if err != nil {
26182 return nil, err
26183 }
26184 defer googleapi.CloseBody(res)
26185 if err := googleapi.CheckResponse(res); err != nil {
26186 return nil, err
26187 }
26188 ret := &CreativeField{
26189 ServerResponse: googleapi.ServerResponse{
26190 Header: res.Header,
26191 HTTPStatusCode: res.StatusCode,
26192 },
26193 }
26194 target := &ret
26195 if err := gensupport.DecodeResponse(target, res); err != nil {
26196 return nil, err
26197 }
26198 return ret, nil
26199
26200
26201
26202
26203
26204
26205
26206
26207
26208
26209
26210
26211
26212
26213
26214
26215
26216
26217
26218
26219
26220
26221
26222
26223
26224
26225
26226
26227 }
26228
26229
26230
26231 type CreativeFieldsListCall struct {
26232 s *Service
26233 profileId int64
26234 urlParams_ gensupport.URLParams
26235 ifNoneMatch_ string
26236 ctx_ context.Context
26237 header_ http.Header
26238 }
26239
26240
26241
26242 func (r *CreativeFieldsService) List(profileId int64) *CreativeFieldsListCall {
26243 c := &CreativeFieldsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26244 c.profileId = profileId
26245 return c
26246 }
26247
26248
26249
26250 func (c *CreativeFieldsListCall) AdvertiserIds(advertiserIds ...int64) *CreativeFieldsListCall {
26251 var advertiserIds_ []string
26252 for _, v := range advertiserIds {
26253 advertiserIds_ = append(advertiserIds_, fmt.Sprint(v))
26254 }
26255 c.urlParams_.SetMulti("advertiserIds", advertiserIds_)
26256 return c
26257 }
26258
26259
26260
26261 func (c *CreativeFieldsListCall) Ids(ids ...int64) *CreativeFieldsListCall {
26262 var ids_ []string
26263 for _, v := range ids {
26264 ids_ = append(ids_, fmt.Sprint(v))
26265 }
26266 c.urlParams_.SetMulti("ids", ids_)
26267 return c
26268 }
26269
26270
26271
26272 func (c *CreativeFieldsListCall) MaxResults(maxResults int64) *CreativeFieldsListCall {
26273 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
26274 return c
26275 }
26276
26277
26278
26279 func (c *CreativeFieldsListCall) PageToken(pageToken string) *CreativeFieldsListCall {
26280 c.urlParams_.Set("pageToken", pageToken)
26281 return c
26282 }
26283
26284
26285
26286
26287
26288
26289
26290
26291
26292
26293 func (c *CreativeFieldsListCall) SearchString(searchString string) *CreativeFieldsListCall {
26294 c.urlParams_.Set("searchString", searchString)
26295 return c
26296 }
26297
26298
26299
26300
26301
26302
26303
26304
26305 func (c *CreativeFieldsListCall) SortField(sortField string) *CreativeFieldsListCall {
26306 c.urlParams_.Set("sortField", sortField)
26307 return c
26308 }
26309
26310
26311
26312
26313
26314
26315
26316
26317 func (c *CreativeFieldsListCall) SortOrder(sortOrder string) *CreativeFieldsListCall {
26318 c.urlParams_.Set("sortOrder", sortOrder)
26319 return c
26320 }
26321
26322
26323
26324
26325 func (c *CreativeFieldsListCall) Fields(s ...googleapi.Field) *CreativeFieldsListCall {
26326 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26327 return c
26328 }
26329
26330
26331
26332
26333
26334
26335 func (c *CreativeFieldsListCall) IfNoneMatch(entityTag string) *CreativeFieldsListCall {
26336 c.ifNoneMatch_ = entityTag
26337 return c
26338 }
26339
26340
26341
26342
26343 func (c *CreativeFieldsListCall) Context(ctx context.Context) *CreativeFieldsListCall {
26344 c.ctx_ = ctx
26345 return c
26346 }
26347
26348
26349
26350 func (c *CreativeFieldsListCall) Header() http.Header {
26351 if c.header_ == nil {
26352 c.header_ = make(http.Header)
26353 }
26354 return c.header_
26355 }
26356
26357 func (c *CreativeFieldsListCall) doRequest(alt string) (*http.Response, error) {
26358 reqHeaders := make(http.Header)
26359 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
26360 for k, v := range c.header_ {
26361 reqHeaders[k] = v
26362 }
26363 reqHeaders.Set("User-Agent", c.s.userAgent())
26364 if c.ifNoneMatch_ != "" {
26365 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
26366 }
26367 var body io.Reader = nil
26368 c.urlParams_.Set("alt", alt)
26369 c.urlParams_.Set("prettyPrint", "false")
26370 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields")
26371 urls += "?" + c.urlParams_.Encode()
26372 req, err := http.NewRequest("GET", urls, body)
26373 if err != nil {
26374 return nil, err
26375 }
26376 req.Header = reqHeaders
26377 googleapi.Expand(req.URL, map[string]string{
26378 "profileId": strconv.FormatInt(c.profileId, 10),
26379 })
26380 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26381 }
26382
26383
26384
26385
26386
26387
26388
26389
26390 func (c *CreativeFieldsListCall) Do(opts ...googleapi.CallOption) (*CreativeFieldsListResponse, error) {
26391 gensupport.SetOptions(c.urlParams_, opts...)
26392 res, err := c.doRequest("json")
26393 if res != nil && res.StatusCode == http.StatusNotModified {
26394 if res.Body != nil {
26395 res.Body.Close()
26396 }
26397 return nil, &googleapi.Error{
26398 Code: res.StatusCode,
26399 Header: res.Header,
26400 }
26401 }
26402 if err != nil {
26403 return nil, err
26404 }
26405 defer googleapi.CloseBody(res)
26406 if err := googleapi.CheckResponse(res); err != nil {
26407 return nil, err
26408 }
26409 ret := &CreativeFieldsListResponse{
26410 ServerResponse: googleapi.ServerResponse{
26411 Header: res.Header,
26412 HTTPStatusCode: res.StatusCode,
26413 },
26414 }
26415 target := &ret
26416 if err := gensupport.DecodeResponse(target, res); err != nil {
26417 return nil, err
26418 }
26419 return ret, nil
26420
26421
26422
26423
26424
26425
26426
26427
26428
26429
26430
26431
26432
26433
26434
26435
26436
26437
26438
26439
26440
26441
26442
26443
26444
26445
26446
26447
26448
26449
26450
26451
26452
26453
26454
26455
26456
26457
26458
26459
26460
26461
26462
26463
26464
26465
26466
26467
26468
26469
26470
26471
26472
26473
26474
26475
26476
26477
26478
26479
26480
26481
26482
26483
26484
26485
26486
26487
26488
26489
26490
26491
26492
26493
26494
26495
26496
26497
26498
26499
26500
26501
26502
26503
26504
26505
26506 }
26507
26508
26509
26510
26511 func (c *CreativeFieldsListCall) Pages(ctx context.Context, f func(*CreativeFieldsListResponse) error) error {
26512 c.ctx_ = ctx
26513 defer c.PageToken(c.urlParams_.Get("pageToken"))
26514 for {
26515 x, err := c.Do()
26516 if err != nil {
26517 return err
26518 }
26519 if err := f(x); err != nil {
26520 return err
26521 }
26522 if x.NextPageToken == "" {
26523 return nil
26524 }
26525 c.PageToken(x.NextPageToken)
26526 }
26527 }
26528
26529
26530
26531 type CreativeFieldsPatchCall struct {
26532 s *Service
26533 profileId int64
26534 creativefield *CreativeField
26535 urlParams_ gensupport.URLParams
26536 ctx_ context.Context
26537 header_ http.Header
26538 }
26539
26540
26541
26542 func (r *CreativeFieldsService) Patch(profileId int64, id int64, creativefield *CreativeField) *CreativeFieldsPatchCall {
26543 c := &CreativeFieldsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26544 c.profileId = profileId
26545 c.urlParams_.Set("id", fmt.Sprint(id))
26546 c.creativefield = creativefield
26547 return c
26548 }
26549
26550
26551
26552
26553 func (c *CreativeFieldsPatchCall) Fields(s ...googleapi.Field) *CreativeFieldsPatchCall {
26554 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26555 return c
26556 }
26557
26558
26559
26560
26561 func (c *CreativeFieldsPatchCall) Context(ctx context.Context) *CreativeFieldsPatchCall {
26562 c.ctx_ = ctx
26563 return c
26564 }
26565
26566
26567
26568 func (c *CreativeFieldsPatchCall) Header() http.Header {
26569 if c.header_ == nil {
26570 c.header_ = make(http.Header)
26571 }
26572 return c.header_
26573 }
26574
26575 func (c *CreativeFieldsPatchCall) doRequest(alt string) (*http.Response, error) {
26576 reqHeaders := make(http.Header)
26577 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
26578 for k, v := range c.header_ {
26579 reqHeaders[k] = v
26580 }
26581 reqHeaders.Set("User-Agent", c.s.userAgent())
26582 var body io.Reader = nil
26583 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativefield)
26584 if err != nil {
26585 return nil, err
26586 }
26587 reqHeaders.Set("Content-Type", "application/json")
26588 c.urlParams_.Set("alt", alt)
26589 c.urlParams_.Set("prettyPrint", "false")
26590 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields")
26591 urls += "?" + c.urlParams_.Encode()
26592 req, err := http.NewRequest("PATCH", urls, body)
26593 if err != nil {
26594 return nil, err
26595 }
26596 req.Header = reqHeaders
26597 googleapi.Expand(req.URL, map[string]string{
26598 "profileId": strconv.FormatInt(c.profileId, 10),
26599 })
26600 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26601 }
26602
26603
26604
26605
26606
26607
26608
26609
26610 func (c *CreativeFieldsPatchCall) Do(opts ...googleapi.CallOption) (*CreativeField, error) {
26611 gensupport.SetOptions(c.urlParams_, opts...)
26612 res, err := c.doRequest("json")
26613 if res != nil && res.StatusCode == http.StatusNotModified {
26614 if res.Body != nil {
26615 res.Body.Close()
26616 }
26617 return nil, &googleapi.Error{
26618 Code: res.StatusCode,
26619 Header: res.Header,
26620 }
26621 }
26622 if err != nil {
26623 return nil, err
26624 }
26625 defer googleapi.CloseBody(res)
26626 if err := googleapi.CheckResponse(res); err != nil {
26627 return nil, err
26628 }
26629 ret := &CreativeField{
26630 ServerResponse: googleapi.ServerResponse{
26631 Header: res.Header,
26632 HTTPStatusCode: res.StatusCode,
26633 },
26634 }
26635 target := &ret
26636 if err := gensupport.DecodeResponse(target, res); err != nil {
26637 return nil, err
26638 }
26639 return ret, nil
26640
26641
26642
26643
26644
26645
26646
26647
26648
26649
26650
26651
26652
26653
26654
26655
26656
26657
26658
26659
26660
26661
26662
26663
26664
26665
26666
26667
26668
26669
26670
26671
26672
26673
26674
26675
26676 }
26677
26678
26679
26680 type CreativeFieldsUpdateCall struct {
26681 s *Service
26682 profileId int64
26683 creativefield *CreativeField
26684 urlParams_ gensupport.URLParams
26685 ctx_ context.Context
26686 header_ http.Header
26687 }
26688
26689
26690 func (r *CreativeFieldsService) Update(profileId int64, creativefield *CreativeField) *CreativeFieldsUpdateCall {
26691 c := &CreativeFieldsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26692 c.profileId = profileId
26693 c.creativefield = creativefield
26694 return c
26695 }
26696
26697
26698
26699
26700 func (c *CreativeFieldsUpdateCall) Fields(s ...googleapi.Field) *CreativeFieldsUpdateCall {
26701 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26702 return c
26703 }
26704
26705
26706
26707
26708 func (c *CreativeFieldsUpdateCall) Context(ctx context.Context) *CreativeFieldsUpdateCall {
26709 c.ctx_ = ctx
26710 return c
26711 }
26712
26713
26714
26715 func (c *CreativeFieldsUpdateCall) Header() http.Header {
26716 if c.header_ == nil {
26717 c.header_ = make(http.Header)
26718 }
26719 return c.header_
26720 }
26721
26722 func (c *CreativeFieldsUpdateCall) doRequest(alt string) (*http.Response, error) {
26723 reqHeaders := make(http.Header)
26724 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
26725 for k, v := range c.header_ {
26726 reqHeaders[k] = v
26727 }
26728 reqHeaders.Set("User-Agent", c.s.userAgent())
26729 var body io.Reader = nil
26730 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativefield)
26731 if err != nil {
26732 return nil, err
26733 }
26734 reqHeaders.Set("Content-Type", "application/json")
26735 c.urlParams_.Set("alt", alt)
26736 c.urlParams_.Set("prettyPrint", "false")
26737 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeFields")
26738 urls += "?" + c.urlParams_.Encode()
26739 req, err := http.NewRequest("PUT", urls, body)
26740 if err != nil {
26741 return nil, err
26742 }
26743 req.Header = reqHeaders
26744 googleapi.Expand(req.URL, map[string]string{
26745 "profileId": strconv.FormatInt(c.profileId, 10),
26746 })
26747 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26748 }
26749
26750
26751
26752
26753
26754
26755
26756
26757 func (c *CreativeFieldsUpdateCall) Do(opts ...googleapi.CallOption) (*CreativeField, error) {
26758 gensupport.SetOptions(c.urlParams_, opts...)
26759 res, err := c.doRequest("json")
26760 if res != nil && res.StatusCode == http.StatusNotModified {
26761 if res.Body != nil {
26762 res.Body.Close()
26763 }
26764 return nil, &googleapi.Error{
26765 Code: res.StatusCode,
26766 Header: res.Header,
26767 }
26768 }
26769 if err != nil {
26770 return nil, err
26771 }
26772 defer googleapi.CloseBody(res)
26773 if err := googleapi.CheckResponse(res); err != nil {
26774 return nil, err
26775 }
26776 ret := &CreativeField{
26777 ServerResponse: googleapi.ServerResponse{
26778 Header: res.Header,
26779 HTTPStatusCode: res.StatusCode,
26780 },
26781 }
26782 target := &ret
26783 if err := gensupport.DecodeResponse(target, res); err != nil {
26784 return nil, err
26785 }
26786 return ret, nil
26787
26788
26789
26790
26791
26792
26793
26794
26795
26796
26797
26798
26799
26800
26801
26802
26803
26804
26805
26806
26807
26808
26809
26810
26811
26812
26813
26814
26815 }
26816
26817
26818
26819 type CreativeGroupsGetCall struct {
26820 s *Service
26821 profileId int64
26822 id int64
26823 urlParams_ gensupport.URLParams
26824 ifNoneMatch_ string
26825 ctx_ context.Context
26826 header_ http.Header
26827 }
26828
26829
26830 func (r *CreativeGroupsService) Get(profileId int64, id int64) *CreativeGroupsGetCall {
26831 c := &CreativeGroupsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26832 c.profileId = profileId
26833 c.id = id
26834 return c
26835 }
26836
26837
26838
26839
26840 func (c *CreativeGroupsGetCall) Fields(s ...googleapi.Field) *CreativeGroupsGetCall {
26841 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26842 return c
26843 }
26844
26845
26846
26847
26848
26849
26850 func (c *CreativeGroupsGetCall) IfNoneMatch(entityTag string) *CreativeGroupsGetCall {
26851 c.ifNoneMatch_ = entityTag
26852 return c
26853 }
26854
26855
26856
26857
26858 func (c *CreativeGroupsGetCall) Context(ctx context.Context) *CreativeGroupsGetCall {
26859 c.ctx_ = ctx
26860 return c
26861 }
26862
26863
26864
26865 func (c *CreativeGroupsGetCall) Header() http.Header {
26866 if c.header_ == nil {
26867 c.header_ = make(http.Header)
26868 }
26869 return c.header_
26870 }
26871
26872 func (c *CreativeGroupsGetCall) doRequest(alt string) (*http.Response, error) {
26873 reqHeaders := make(http.Header)
26874 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
26875 for k, v := range c.header_ {
26876 reqHeaders[k] = v
26877 }
26878 reqHeaders.Set("User-Agent", c.s.userAgent())
26879 if c.ifNoneMatch_ != "" {
26880 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
26881 }
26882 var body io.Reader = nil
26883 c.urlParams_.Set("alt", alt)
26884 c.urlParams_.Set("prettyPrint", "false")
26885 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeGroups/{id}")
26886 urls += "?" + c.urlParams_.Encode()
26887 req, err := http.NewRequest("GET", urls, body)
26888 if err != nil {
26889 return nil, err
26890 }
26891 req.Header = reqHeaders
26892 googleapi.Expand(req.URL, map[string]string{
26893 "profileId": strconv.FormatInt(c.profileId, 10),
26894 "id": strconv.FormatInt(c.id, 10),
26895 })
26896 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26897 }
26898
26899
26900
26901
26902
26903
26904
26905
26906 func (c *CreativeGroupsGetCall) Do(opts ...googleapi.CallOption) (*CreativeGroup, error) {
26907 gensupport.SetOptions(c.urlParams_, opts...)
26908 res, err := c.doRequest("json")
26909 if res != nil && res.StatusCode == http.StatusNotModified {
26910 if res.Body != nil {
26911 res.Body.Close()
26912 }
26913 return nil, &googleapi.Error{
26914 Code: res.StatusCode,
26915 Header: res.Header,
26916 }
26917 }
26918 if err != nil {
26919 return nil, err
26920 }
26921 defer googleapi.CloseBody(res)
26922 if err := googleapi.CheckResponse(res); err != nil {
26923 return nil, err
26924 }
26925 ret := &CreativeGroup{
26926 ServerResponse: googleapi.ServerResponse{
26927 Header: res.Header,
26928 HTTPStatusCode: res.StatusCode,
26929 },
26930 }
26931 target := &ret
26932 if err := gensupport.DecodeResponse(target, res); err != nil {
26933 return nil, err
26934 }
26935 return ret, nil
26936
26937
26938
26939
26940
26941
26942
26943
26944
26945
26946
26947
26948
26949
26950
26951
26952
26953
26954
26955
26956
26957
26958
26959
26960
26961
26962
26963
26964
26965
26966
26967
26968
26969 }
26970
26971
26972
26973 type CreativeGroupsInsertCall struct {
26974 s *Service
26975 profileId int64
26976 creativegroup *CreativeGroup
26977 urlParams_ gensupport.URLParams
26978 ctx_ context.Context
26979 header_ http.Header
26980 }
26981
26982
26983 func (r *CreativeGroupsService) Insert(profileId int64, creativegroup *CreativeGroup) *CreativeGroupsInsertCall {
26984 c := &CreativeGroupsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26985 c.profileId = profileId
26986 c.creativegroup = creativegroup
26987 return c
26988 }
26989
26990
26991
26992
26993 func (c *CreativeGroupsInsertCall) Fields(s ...googleapi.Field) *CreativeGroupsInsertCall {
26994 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26995 return c
26996 }
26997
26998
26999
27000
27001 func (c *CreativeGroupsInsertCall) Context(ctx context.Context) *CreativeGroupsInsertCall {
27002 c.ctx_ = ctx
27003 return c
27004 }
27005
27006
27007
27008 func (c *CreativeGroupsInsertCall) Header() http.Header {
27009 if c.header_ == nil {
27010 c.header_ = make(http.Header)
27011 }
27012 return c.header_
27013 }
27014
27015 func (c *CreativeGroupsInsertCall) doRequest(alt string) (*http.Response, error) {
27016 reqHeaders := make(http.Header)
27017 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
27018 for k, v := range c.header_ {
27019 reqHeaders[k] = v
27020 }
27021 reqHeaders.Set("User-Agent", c.s.userAgent())
27022 var body io.Reader = nil
27023 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativegroup)
27024 if err != nil {
27025 return nil, err
27026 }
27027 reqHeaders.Set("Content-Type", "application/json")
27028 c.urlParams_.Set("alt", alt)
27029 c.urlParams_.Set("prettyPrint", "false")
27030 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeGroups")
27031 urls += "?" + c.urlParams_.Encode()
27032 req, err := http.NewRequest("POST", urls, body)
27033 if err != nil {
27034 return nil, err
27035 }
27036 req.Header = reqHeaders
27037 googleapi.Expand(req.URL, map[string]string{
27038 "profileId": strconv.FormatInt(c.profileId, 10),
27039 })
27040 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27041 }
27042
27043
27044
27045
27046
27047
27048
27049
27050 func (c *CreativeGroupsInsertCall) Do(opts ...googleapi.CallOption) (*CreativeGroup, error) {
27051 gensupport.SetOptions(c.urlParams_, opts...)
27052 res, err := c.doRequest("json")
27053 if res != nil && res.StatusCode == http.StatusNotModified {
27054 if res.Body != nil {
27055 res.Body.Close()
27056 }
27057 return nil, &googleapi.Error{
27058 Code: res.StatusCode,
27059 Header: res.Header,
27060 }
27061 }
27062 if err != nil {
27063 return nil, err
27064 }
27065 defer googleapi.CloseBody(res)
27066 if err := googleapi.CheckResponse(res); err != nil {
27067 return nil, err
27068 }
27069 ret := &CreativeGroup{
27070 ServerResponse: googleapi.ServerResponse{
27071 Header: res.Header,
27072 HTTPStatusCode: res.StatusCode,
27073 },
27074 }
27075 target := &ret
27076 if err := gensupport.DecodeResponse(target, res); err != nil {
27077 return nil, err
27078 }
27079 return ret, nil
27080
27081
27082
27083
27084
27085
27086
27087
27088
27089
27090
27091
27092
27093
27094
27095
27096
27097
27098
27099
27100
27101
27102
27103
27104
27105
27106
27107
27108 }
27109
27110
27111
27112 type CreativeGroupsListCall struct {
27113 s *Service
27114 profileId int64
27115 urlParams_ gensupport.URLParams
27116 ifNoneMatch_ string
27117 ctx_ context.Context
27118 header_ http.Header
27119 }
27120
27121
27122
27123 func (r *CreativeGroupsService) List(profileId int64) *CreativeGroupsListCall {
27124 c := &CreativeGroupsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27125 c.profileId = profileId
27126 return c
27127 }
27128
27129
27130
27131 func (c *CreativeGroupsListCall) AdvertiserIds(advertiserIds ...int64) *CreativeGroupsListCall {
27132 var advertiserIds_ []string
27133 for _, v := range advertiserIds {
27134 advertiserIds_ = append(advertiserIds_, fmt.Sprint(v))
27135 }
27136 c.urlParams_.SetMulti("advertiserIds", advertiserIds_)
27137 return c
27138 }
27139
27140
27141
27142 func (c *CreativeGroupsListCall) GroupNumber(groupNumber int64) *CreativeGroupsListCall {
27143 c.urlParams_.Set("groupNumber", fmt.Sprint(groupNumber))
27144 return c
27145 }
27146
27147
27148
27149 func (c *CreativeGroupsListCall) Ids(ids ...int64) *CreativeGroupsListCall {
27150 var ids_ []string
27151 for _, v := range ids {
27152 ids_ = append(ids_, fmt.Sprint(v))
27153 }
27154 c.urlParams_.SetMulti("ids", ids_)
27155 return c
27156 }
27157
27158
27159
27160 func (c *CreativeGroupsListCall) MaxResults(maxResults int64) *CreativeGroupsListCall {
27161 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
27162 return c
27163 }
27164
27165
27166
27167 func (c *CreativeGroupsListCall) PageToken(pageToken string) *CreativeGroupsListCall {
27168 c.urlParams_.Set("pageToken", pageToken)
27169 return c
27170 }
27171
27172
27173
27174
27175
27176
27177
27178
27179
27180
27181 func (c *CreativeGroupsListCall) SearchString(searchString string) *CreativeGroupsListCall {
27182 c.urlParams_.Set("searchString", searchString)
27183 return c
27184 }
27185
27186
27187
27188
27189
27190
27191
27192
27193 func (c *CreativeGroupsListCall) SortField(sortField string) *CreativeGroupsListCall {
27194 c.urlParams_.Set("sortField", sortField)
27195 return c
27196 }
27197
27198
27199
27200
27201
27202
27203
27204
27205 func (c *CreativeGroupsListCall) SortOrder(sortOrder string) *CreativeGroupsListCall {
27206 c.urlParams_.Set("sortOrder", sortOrder)
27207 return c
27208 }
27209
27210
27211
27212
27213 func (c *CreativeGroupsListCall) Fields(s ...googleapi.Field) *CreativeGroupsListCall {
27214 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27215 return c
27216 }
27217
27218
27219
27220
27221
27222
27223 func (c *CreativeGroupsListCall) IfNoneMatch(entityTag string) *CreativeGroupsListCall {
27224 c.ifNoneMatch_ = entityTag
27225 return c
27226 }
27227
27228
27229
27230
27231 func (c *CreativeGroupsListCall) Context(ctx context.Context) *CreativeGroupsListCall {
27232 c.ctx_ = ctx
27233 return c
27234 }
27235
27236
27237
27238 func (c *CreativeGroupsListCall) Header() http.Header {
27239 if c.header_ == nil {
27240 c.header_ = make(http.Header)
27241 }
27242 return c.header_
27243 }
27244
27245 func (c *CreativeGroupsListCall) doRequest(alt string) (*http.Response, error) {
27246 reqHeaders := make(http.Header)
27247 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
27248 for k, v := range c.header_ {
27249 reqHeaders[k] = v
27250 }
27251 reqHeaders.Set("User-Agent", c.s.userAgent())
27252 if c.ifNoneMatch_ != "" {
27253 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
27254 }
27255 var body io.Reader = nil
27256 c.urlParams_.Set("alt", alt)
27257 c.urlParams_.Set("prettyPrint", "false")
27258 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeGroups")
27259 urls += "?" + c.urlParams_.Encode()
27260 req, err := http.NewRequest("GET", urls, body)
27261 if err != nil {
27262 return nil, err
27263 }
27264 req.Header = reqHeaders
27265 googleapi.Expand(req.URL, map[string]string{
27266 "profileId": strconv.FormatInt(c.profileId, 10),
27267 })
27268 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27269 }
27270
27271
27272
27273
27274
27275
27276
27277
27278 func (c *CreativeGroupsListCall) Do(opts ...googleapi.CallOption) (*CreativeGroupsListResponse, error) {
27279 gensupport.SetOptions(c.urlParams_, opts...)
27280 res, err := c.doRequest("json")
27281 if res != nil && res.StatusCode == http.StatusNotModified {
27282 if res.Body != nil {
27283 res.Body.Close()
27284 }
27285 return nil, &googleapi.Error{
27286 Code: res.StatusCode,
27287 Header: res.Header,
27288 }
27289 }
27290 if err != nil {
27291 return nil, err
27292 }
27293 defer googleapi.CloseBody(res)
27294 if err := googleapi.CheckResponse(res); err != nil {
27295 return nil, err
27296 }
27297 ret := &CreativeGroupsListResponse{
27298 ServerResponse: googleapi.ServerResponse{
27299 Header: res.Header,
27300 HTTPStatusCode: res.StatusCode,
27301 },
27302 }
27303 target := &ret
27304 if err := gensupport.DecodeResponse(target, res); err != nil {
27305 return nil, err
27306 }
27307 return ret, nil
27308
27309
27310
27311
27312
27313
27314
27315
27316
27317
27318
27319
27320
27321
27322
27323
27324
27325
27326
27327
27328
27329
27330
27331
27332
27333
27334
27335
27336
27337
27338
27339
27340
27341
27342
27343
27344
27345
27346
27347
27348
27349
27350
27351
27352
27353
27354
27355
27356
27357
27358
27359
27360
27361
27362
27363
27364
27365
27366
27367
27368
27369
27370
27371
27372
27373
27374
27375
27376
27377
27378
27379
27380
27381
27382
27383
27384
27385
27386
27387
27388
27389
27390
27391
27392
27393
27394
27395
27396
27397
27398
27399
27400
27401
27402 }
27403
27404
27405
27406
27407 func (c *CreativeGroupsListCall) Pages(ctx context.Context, f func(*CreativeGroupsListResponse) error) error {
27408 c.ctx_ = ctx
27409 defer c.PageToken(c.urlParams_.Get("pageToken"))
27410 for {
27411 x, err := c.Do()
27412 if err != nil {
27413 return err
27414 }
27415 if err := f(x); err != nil {
27416 return err
27417 }
27418 if x.NextPageToken == "" {
27419 return nil
27420 }
27421 c.PageToken(x.NextPageToken)
27422 }
27423 }
27424
27425
27426
27427 type CreativeGroupsPatchCall struct {
27428 s *Service
27429 profileId int64
27430 creativegroup *CreativeGroup
27431 urlParams_ gensupport.URLParams
27432 ctx_ context.Context
27433 header_ http.Header
27434 }
27435
27436
27437
27438 func (r *CreativeGroupsService) Patch(profileId int64, id int64, creativegroup *CreativeGroup) *CreativeGroupsPatchCall {
27439 c := &CreativeGroupsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27440 c.profileId = profileId
27441 c.urlParams_.Set("id", fmt.Sprint(id))
27442 c.creativegroup = creativegroup
27443 return c
27444 }
27445
27446
27447
27448
27449 func (c *CreativeGroupsPatchCall) Fields(s ...googleapi.Field) *CreativeGroupsPatchCall {
27450 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27451 return c
27452 }
27453
27454
27455
27456
27457 func (c *CreativeGroupsPatchCall) Context(ctx context.Context) *CreativeGroupsPatchCall {
27458 c.ctx_ = ctx
27459 return c
27460 }
27461
27462
27463
27464 func (c *CreativeGroupsPatchCall) Header() http.Header {
27465 if c.header_ == nil {
27466 c.header_ = make(http.Header)
27467 }
27468 return c.header_
27469 }
27470
27471 func (c *CreativeGroupsPatchCall) doRequest(alt string) (*http.Response, error) {
27472 reqHeaders := make(http.Header)
27473 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
27474 for k, v := range c.header_ {
27475 reqHeaders[k] = v
27476 }
27477 reqHeaders.Set("User-Agent", c.s.userAgent())
27478 var body io.Reader = nil
27479 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativegroup)
27480 if err != nil {
27481 return nil, err
27482 }
27483 reqHeaders.Set("Content-Type", "application/json")
27484 c.urlParams_.Set("alt", alt)
27485 c.urlParams_.Set("prettyPrint", "false")
27486 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeGroups")
27487 urls += "?" + c.urlParams_.Encode()
27488 req, err := http.NewRequest("PATCH", urls, body)
27489 if err != nil {
27490 return nil, err
27491 }
27492 req.Header = reqHeaders
27493 googleapi.Expand(req.URL, map[string]string{
27494 "profileId": strconv.FormatInt(c.profileId, 10),
27495 })
27496 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27497 }
27498
27499
27500
27501
27502
27503
27504
27505
27506 func (c *CreativeGroupsPatchCall) Do(opts ...googleapi.CallOption) (*CreativeGroup, error) {
27507 gensupport.SetOptions(c.urlParams_, opts...)
27508 res, err := c.doRequest("json")
27509 if res != nil && res.StatusCode == http.StatusNotModified {
27510 if res.Body != nil {
27511 res.Body.Close()
27512 }
27513 return nil, &googleapi.Error{
27514 Code: res.StatusCode,
27515 Header: res.Header,
27516 }
27517 }
27518 if err != nil {
27519 return nil, err
27520 }
27521 defer googleapi.CloseBody(res)
27522 if err := googleapi.CheckResponse(res); err != nil {
27523 return nil, err
27524 }
27525 ret := &CreativeGroup{
27526 ServerResponse: googleapi.ServerResponse{
27527 Header: res.Header,
27528 HTTPStatusCode: res.StatusCode,
27529 },
27530 }
27531 target := &ret
27532 if err := gensupport.DecodeResponse(target, res); err != nil {
27533 return nil, err
27534 }
27535 return ret, nil
27536
27537
27538
27539
27540
27541
27542
27543
27544
27545
27546
27547
27548
27549
27550
27551
27552
27553
27554
27555
27556
27557
27558
27559
27560
27561
27562
27563
27564
27565
27566
27567
27568
27569
27570
27571
27572 }
27573
27574
27575
27576 type CreativeGroupsUpdateCall struct {
27577 s *Service
27578 profileId int64
27579 creativegroup *CreativeGroup
27580 urlParams_ gensupport.URLParams
27581 ctx_ context.Context
27582 header_ http.Header
27583 }
27584
27585
27586 func (r *CreativeGroupsService) Update(profileId int64, creativegroup *CreativeGroup) *CreativeGroupsUpdateCall {
27587 c := &CreativeGroupsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27588 c.profileId = profileId
27589 c.creativegroup = creativegroup
27590 return c
27591 }
27592
27593
27594
27595
27596 func (c *CreativeGroupsUpdateCall) Fields(s ...googleapi.Field) *CreativeGroupsUpdateCall {
27597 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27598 return c
27599 }
27600
27601
27602
27603
27604 func (c *CreativeGroupsUpdateCall) Context(ctx context.Context) *CreativeGroupsUpdateCall {
27605 c.ctx_ = ctx
27606 return c
27607 }
27608
27609
27610
27611 func (c *CreativeGroupsUpdateCall) Header() http.Header {
27612 if c.header_ == nil {
27613 c.header_ = make(http.Header)
27614 }
27615 return c.header_
27616 }
27617
27618 func (c *CreativeGroupsUpdateCall) doRequest(alt string) (*http.Response, error) {
27619 reqHeaders := make(http.Header)
27620 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
27621 for k, v := range c.header_ {
27622 reqHeaders[k] = v
27623 }
27624 reqHeaders.Set("User-Agent", c.s.userAgent())
27625 var body io.Reader = nil
27626 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creativegroup)
27627 if err != nil {
27628 return nil, err
27629 }
27630 reqHeaders.Set("Content-Type", "application/json")
27631 c.urlParams_.Set("alt", alt)
27632 c.urlParams_.Set("prettyPrint", "false")
27633 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creativeGroups")
27634 urls += "?" + c.urlParams_.Encode()
27635 req, err := http.NewRequest("PUT", urls, body)
27636 if err != nil {
27637 return nil, err
27638 }
27639 req.Header = reqHeaders
27640 googleapi.Expand(req.URL, map[string]string{
27641 "profileId": strconv.FormatInt(c.profileId, 10),
27642 })
27643 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27644 }
27645
27646
27647
27648
27649
27650
27651
27652
27653 func (c *CreativeGroupsUpdateCall) Do(opts ...googleapi.CallOption) (*CreativeGroup, error) {
27654 gensupport.SetOptions(c.urlParams_, opts...)
27655 res, err := c.doRequest("json")
27656 if res != nil && res.StatusCode == http.StatusNotModified {
27657 if res.Body != nil {
27658 res.Body.Close()
27659 }
27660 return nil, &googleapi.Error{
27661 Code: res.StatusCode,
27662 Header: res.Header,
27663 }
27664 }
27665 if err != nil {
27666 return nil, err
27667 }
27668 defer googleapi.CloseBody(res)
27669 if err := googleapi.CheckResponse(res); err != nil {
27670 return nil, err
27671 }
27672 ret := &CreativeGroup{
27673 ServerResponse: googleapi.ServerResponse{
27674 Header: res.Header,
27675 HTTPStatusCode: res.StatusCode,
27676 },
27677 }
27678 target := &ret
27679 if err := gensupport.DecodeResponse(target, res); err != nil {
27680 return nil, err
27681 }
27682 return ret, nil
27683
27684
27685
27686
27687
27688
27689
27690
27691
27692
27693
27694
27695
27696
27697
27698
27699
27700
27701
27702
27703
27704
27705
27706
27707
27708
27709
27710
27711 }
27712
27713
27714
27715 type CreativesGetCall struct {
27716 s *Service
27717 profileId int64
27718 id int64
27719 urlParams_ gensupport.URLParams
27720 ifNoneMatch_ string
27721 ctx_ context.Context
27722 header_ http.Header
27723 }
27724
27725
27726 func (r *CreativesService) Get(profileId int64, id int64) *CreativesGetCall {
27727 c := &CreativesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27728 c.profileId = profileId
27729 c.id = id
27730 return c
27731 }
27732
27733
27734
27735
27736 func (c *CreativesGetCall) Fields(s ...googleapi.Field) *CreativesGetCall {
27737 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27738 return c
27739 }
27740
27741
27742
27743
27744
27745
27746 func (c *CreativesGetCall) IfNoneMatch(entityTag string) *CreativesGetCall {
27747 c.ifNoneMatch_ = entityTag
27748 return c
27749 }
27750
27751
27752
27753
27754 func (c *CreativesGetCall) Context(ctx context.Context) *CreativesGetCall {
27755 c.ctx_ = ctx
27756 return c
27757 }
27758
27759
27760
27761 func (c *CreativesGetCall) Header() http.Header {
27762 if c.header_ == nil {
27763 c.header_ = make(http.Header)
27764 }
27765 return c.header_
27766 }
27767
27768 func (c *CreativesGetCall) doRequest(alt string) (*http.Response, error) {
27769 reqHeaders := make(http.Header)
27770 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
27771 for k, v := range c.header_ {
27772 reqHeaders[k] = v
27773 }
27774 reqHeaders.Set("User-Agent", c.s.userAgent())
27775 if c.ifNoneMatch_ != "" {
27776 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
27777 }
27778 var body io.Reader = nil
27779 c.urlParams_.Set("alt", alt)
27780 c.urlParams_.Set("prettyPrint", "false")
27781 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creatives/{id}")
27782 urls += "?" + c.urlParams_.Encode()
27783 req, err := http.NewRequest("GET", urls, body)
27784 if err != nil {
27785 return nil, err
27786 }
27787 req.Header = reqHeaders
27788 googleapi.Expand(req.URL, map[string]string{
27789 "profileId": strconv.FormatInt(c.profileId, 10),
27790 "id": strconv.FormatInt(c.id, 10),
27791 })
27792 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27793 }
27794
27795
27796
27797
27798
27799
27800
27801
27802 func (c *CreativesGetCall) Do(opts ...googleapi.CallOption) (*Creative, error) {
27803 gensupport.SetOptions(c.urlParams_, opts...)
27804 res, err := c.doRequest("json")
27805 if res != nil && res.StatusCode == http.StatusNotModified {
27806 if res.Body != nil {
27807 res.Body.Close()
27808 }
27809 return nil, &googleapi.Error{
27810 Code: res.StatusCode,
27811 Header: res.Header,
27812 }
27813 }
27814 if err != nil {
27815 return nil, err
27816 }
27817 defer googleapi.CloseBody(res)
27818 if err := googleapi.CheckResponse(res); err != nil {
27819 return nil, err
27820 }
27821 ret := &Creative{
27822 ServerResponse: googleapi.ServerResponse{
27823 Header: res.Header,
27824 HTTPStatusCode: res.StatusCode,
27825 },
27826 }
27827 target := &ret
27828 if err := gensupport.DecodeResponse(target, res); err != nil {
27829 return nil, err
27830 }
27831 return ret, nil
27832
27833
27834
27835
27836
27837
27838
27839
27840
27841
27842
27843
27844
27845
27846
27847
27848
27849
27850
27851
27852
27853
27854
27855
27856
27857
27858
27859
27860
27861
27862
27863
27864
27865 }
27866
27867
27868
27869 type CreativesInsertCall struct {
27870 s *Service
27871 profileId int64
27872 creative *Creative
27873 urlParams_ gensupport.URLParams
27874 ctx_ context.Context
27875 header_ http.Header
27876 }
27877
27878
27879 func (r *CreativesService) Insert(profileId int64, creative *Creative) *CreativesInsertCall {
27880 c := &CreativesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27881 c.profileId = profileId
27882 c.creative = creative
27883 return c
27884 }
27885
27886
27887
27888
27889 func (c *CreativesInsertCall) Fields(s ...googleapi.Field) *CreativesInsertCall {
27890 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27891 return c
27892 }
27893
27894
27895
27896
27897 func (c *CreativesInsertCall) Context(ctx context.Context) *CreativesInsertCall {
27898 c.ctx_ = ctx
27899 return c
27900 }
27901
27902
27903
27904 func (c *CreativesInsertCall) Header() http.Header {
27905 if c.header_ == nil {
27906 c.header_ = make(http.Header)
27907 }
27908 return c.header_
27909 }
27910
27911 func (c *CreativesInsertCall) doRequest(alt string) (*http.Response, error) {
27912 reqHeaders := make(http.Header)
27913 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
27914 for k, v := range c.header_ {
27915 reqHeaders[k] = v
27916 }
27917 reqHeaders.Set("User-Agent", c.s.userAgent())
27918 var body io.Reader = nil
27919 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creative)
27920 if err != nil {
27921 return nil, err
27922 }
27923 reqHeaders.Set("Content-Type", "application/json")
27924 c.urlParams_.Set("alt", alt)
27925 c.urlParams_.Set("prettyPrint", "false")
27926 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creatives")
27927 urls += "?" + c.urlParams_.Encode()
27928 req, err := http.NewRequest("POST", urls, body)
27929 if err != nil {
27930 return nil, err
27931 }
27932 req.Header = reqHeaders
27933 googleapi.Expand(req.URL, map[string]string{
27934 "profileId": strconv.FormatInt(c.profileId, 10),
27935 })
27936 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27937 }
27938
27939
27940
27941
27942
27943
27944
27945
27946 func (c *CreativesInsertCall) Do(opts ...googleapi.CallOption) (*Creative, error) {
27947 gensupport.SetOptions(c.urlParams_, opts...)
27948 res, err := c.doRequest("json")
27949 if res != nil && res.StatusCode == http.StatusNotModified {
27950 if res.Body != nil {
27951 res.Body.Close()
27952 }
27953 return nil, &googleapi.Error{
27954 Code: res.StatusCode,
27955 Header: res.Header,
27956 }
27957 }
27958 if err != nil {
27959 return nil, err
27960 }
27961 defer googleapi.CloseBody(res)
27962 if err := googleapi.CheckResponse(res); err != nil {
27963 return nil, err
27964 }
27965 ret := &Creative{
27966 ServerResponse: googleapi.ServerResponse{
27967 Header: res.Header,
27968 HTTPStatusCode: res.StatusCode,
27969 },
27970 }
27971 target := &ret
27972 if err := gensupport.DecodeResponse(target, res); err != nil {
27973 return nil, err
27974 }
27975 return ret, nil
27976
27977
27978
27979
27980
27981
27982
27983
27984
27985
27986
27987
27988
27989
27990
27991
27992
27993
27994
27995
27996
27997
27998
27999
28000
28001
28002
28003
28004 }
28005
28006
28007
28008 type CreativesListCall struct {
28009 s *Service
28010 profileId int64
28011 urlParams_ gensupport.URLParams
28012 ifNoneMatch_ string
28013 ctx_ context.Context
28014 header_ http.Header
28015 }
28016
28017
28018
28019 func (r *CreativesService) List(profileId int64) *CreativesListCall {
28020 c := &CreativesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28021 c.profileId = profileId
28022 return c
28023 }
28024
28025
28026
28027 func (c *CreativesListCall) Active(active bool) *CreativesListCall {
28028 c.urlParams_.Set("active", fmt.Sprint(active))
28029 return c
28030 }
28031
28032
28033
28034 func (c *CreativesListCall) AdvertiserId(advertiserId int64) *CreativesListCall {
28035 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
28036 return c
28037 }
28038
28039
28040
28041 func (c *CreativesListCall) Archived(archived bool) *CreativesListCall {
28042 c.urlParams_.Set("archived", fmt.Sprint(archived))
28043 return c
28044 }
28045
28046
28047
28048 func (c *CreativesListCall) CampaignId(campaignId int64) *CreativesListCall {
28049 c.urlParams_.Set("campaignId", fmt.Sprint(campaignId))
28050 return c
28051 }
28052
28053
28054
28055
28056 func (c *CreativesListCall) CompanionCreativeIds(companionCreativeIds ...int64) *CreativesListCall {
28057 var companionCreativeIds_ []string
28058 for _, v := range companionCreativeIds {
28059 companionCreativeIds_ = append(companionCreativeIds_, fmt.Sprint(v))
28060 }
28061 c.urlParams_.SetMulti("companionCreativeIds", companionCreativeIds_)
28062 return c
28063 }
28064
28065
28066
28067 func (c *CreativesListCall) CreativeFieldIds(creativeFieldIds ...int64) *CreativesListCall {
28068 var creativeFieldIds_ []string
28069 for _, v := range creativeFieldIds {
28070 creativeFieldIds_ = append(creativeFieldIds_, fmt.Sprint(v))
28071 }
28072 c.urlParams_.SetMulti("creativeFieldIds", creativeFieldIds_)
28073 return c
28074 }
28075
28076
28077
28078 func (c *CreativesListCall) Ids(ids ...int64) *CreativesListCall {
28079 var ids_ []string
28080 for _, v := range ids {
28081 ids_ = append(ids_, fmt.Sprint(v))
28082 }
28083 c.urlParams_.SetMulti("ids", ids_)
28084 return c
28085 }
28086
28087
28088
28089 func (c *CreativesListCall) MaxResults(maxResults int64) *CreativesListCall {
28090 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
28091 return c
28092 }
28093
28094
28095
28096 func (c *CreativesListCall) PageToken(pageToken string) *CreativesListCall {
28097 c.urlParams_.Set("pageToken", pageToken)
28098 return c
28099 }
28100
28101
28102
28103 func (c *CreativesListCall) RenderingIds(renderingIds ...int64) *CreativesListCall {
28104 var renderingIds_ []string
28105 for _, v := range renderingIds {
28106 renderingIds_ = append(renderingIds_, fmt.Sprint(v))
28107 }
28108 c.urlParams_.SetMulti("renderingIds", renderingIds_)
28109 return c
28110 }
28111
28112
28113
28114
28115
28116
28117
28118
28119
28120 func (c *CreativesListCall) SearchString(searchString string) *CreativesListCall {
28121 c.urlParams_.Set("searchString", searchString)
28122 return c
28123 }
28124
28125
28126
28127 func (c *CreativesListCall) SizeIds(sizeIds ...int64) *CreativesListCall {
28128 var sizeIds_ []string
28129 for _, v := range sizeIds {
28130 sizeIds_ = append(sizeIds_, fmt.Sprint(v))
28131 }
28132 c.urlParams_.SetMulti("sizeIds", sizeIds_)
28133 return c
28134 }
28135
28136
28137
28138
28139
28140
28141
28142
28143 func (c *CreativesListCall) SortField(sortField string) *CreativesListCall {
28144 c.urlParams_.Set("sortField", sortField)
28145 return c
28146 }
28147
28148
28149
28150
28151
28152
28153
28154
28155 func (c *CreativesListCall) SortOrder(sortOrder string) *CreativesListCall {
28156 c.urlParams_.Set("sortOrder", sortOrder)
28157 return c
28158 }
28159
28160
28161
28162 func (c *CreativesListCall) StudioCreativeId(studioCreativeId int64) *CreativesListCall {
28163 c.urlParams_.Set("studioCreativeId", fmt.Sprint(studioCreativeId))
28164 return c
28165 }
28166
28167
28168
28169
28170
28171
28172
28173
28174
28175
28176
28177
28178
28179
28180
28181
28182
28183
28184
28185
28186
28187
28188
28189
28190
28191
28192
28193
28194
28195
28196
28197 func (c *CreativesListCall) Types(types ...string) *CreativesListCall {
28198 c.urlParams_.SetMulti("types", append([]string{}, types...))
28199 return c
28200 }
28201
28202
28203
28204
28205 func (c *CreativesListCall) Fields(s ...googleapi.Field) *CreativesListCall {
28206 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28207 return c
28208 }
28209
28210
28211
28212
28213
28214
28215 func (c *CreativesListCall) IfNoneMatch(entityTag string) *CreativesListCall {
28216 c.ifNoneMatch_ = entityTag
28217 return c
28218 }
28219
28220
28221
28222
28223 func (c *CreativesListCall) Context(ctx context.Context) *CreativesListCall {
28224 c.ctx_ = ctx
28225 return c
28226 }
28227
28228
28229
28230 func (c *CreativesListCall) Header() http.Header {
28231 if c.header_ == nil {
28232 c.header_ = make(http.Header)
28233 }
28234 return c.header_
28235 }
28236
28237 func (c *CreativesListCall) doRequest(alt string) (*http.Response, error) {
28238 reqHeaders := make(http.Header)
28239 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
28240 for k, v := range c.header_ {
28241 reqHeaders[k] = v
28242 }
28243 reqHeaders.Set("User-Agent", c.s.userAgent())
28244 if c.ifNoneMatch_ != "" {
28245 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
28246 }
28247 var body io.Reader = nil
28248 c.urlParams_.Set("alt", alt)
28249 c.urlParams_.Set("prettyPrint", "false")
28250 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creatives")
28251 urls += "?" + c.urlParams_.Encode()
28252 req, err := http.NewRequest("GET", urls, body)
28253 if err != nil {
28254 return nil, err
28255 }
28256 req.Header = reqHeaders
28257 googleapi.Expand(req.URL, map[string]string{
28258 "profileId": strconv.FormatInt(c.profileId, 10),
28259 })
28260 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28261 }
28262
28263
28264
28265
28266
28267
28268
28269
28270 func (c *CreativesListCall) Do(opts ...googleapi.CallOption) (*CreativesListResponse, error) {
28271 gensupport.SetOptions(c.urlParams_, opts...)
28272 res, err := c.doRequest("json")
28273 if res != nil && res.StatusCode == http.StatusNotModified {
28274 if res.Body != nil {
28275 res.Body.Close()
28276 }
28277 return nil, &googleapi.Error{
28278 Code: res.StatusCode,
28279 Header: res.Header,
28280 }
28281 }
28282 if err != nil {
28283 return nil, err
28284 }
28285 defer googleapi.CloseBody(res)
28286 if err := googleapi.CheckResponse(res); err != nil {
28287 return nil, err
28288 }
28289 ret := &CreativesListResponse{
28290 ServerResponse: googleapi.ServerResponse{
28291 Header: res.Header,
28292 HTTPStatusCode: res.StatusCode,
28293 },
28294 }
28295 target := &ret
28296 if err := gensupport.DecodeResponse(target, res); err != nil {
28297 return nil, err
28298 }
28299 return ret, nil
28300
28301
28302
28303
28304
28305
28306
28307
28308
28309
28310
28311
28312
28313
28314
28315
28316
28317
28318
28319
28320
28321
28322
28323
28324
28325
28326
28327
28328
28329
28330
28331
28332
28333
28334
28335
28336
28337
28338
28339
28340
28341
28342
28343
28344
28345
28346
28347
28348
28349
28350
28351
28352
28353
28354
28355
28356
28357
28358
28359
28360
28361
28362
28363
28364
28365
28366
28367
28368
28369
28370
28371
28372
28373
28374
28375
28376
28377
28378
28379
28380
28381
28382
28383
28384
28385
28386
28387
28388
28389
28390
28391
28392
28393
28394
28395
28396
28397
28398
28399
28400
28401
28402
28403
28404
28405
28406
28407
28408
28409
28410
28411
28412
28413
28414
28415
28416
28417
28418
28419
28420
28421
28422
28423
28424
28425
28426
28427
28428
28429
28430
28431
28432
28433
28434
28435
28436
28437
28438
28439
28440
28441
28442
28443
28444
28445
28446
28447
28448
28449
28450
28451
28452
28453
28454
28455
28456
28457
28458
28459
28460
28461
28462
28463
28464
28465
28466
28467
28468
28469
28470
28471
28472
28473
28474
28475
28476
28477
28478
28479
28480
28481
28482
28483
28484
28485
28486
28487
28488
28489
28490
28491
28492
28493
28494
28495 }
28496
28497
28498
28499
28500 func (c *CreativesListCall) Pages(ctx context.Context, f func(*CreativesListResponse) error) error {
28501 c.ctx_ = ctx
28502 defer c.PageToken(c.urlParams_.Get("pageToken"))
28503 for {
28504 x, err := c.Do()
28505 if err != nil {
28506 return err
28507 }
28508 if err := f(x); err != nil {
28509 return err
28510 }
28511 if x.NextPageToken == "" {
28512 return nil
28513 }
28514 c.PageToken(x.NextPageToken)
28515 }
28516 }
28517
28518
28519
28520 type CreativesPatchCall struct {
28521 s *Service
28522 profileId int64
28523 creative *Creative
28524 urlParams_ gensupport.URLParams
28525 ctx_ context.Context
28526 header_ http.Header
28527 }
28528
28529
28530
28531 func (r *CreativesService) Patch(profileId int64, id int64, creative *Creative) *CreativesPatchCall {
28532 c := &CreativesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28533 c.profileId = profileId
28534 c.urlParams_.Set("id", fmt.Sprint(id))
28535 c.creative = creative
28536 return c
28537 }
28538
28539
28540
28541
28542 func (c *CreativesPatchCall) Fields(s ...googleapi.Field) *CreativesPatchCall {
28543 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28544 return c
28545 }
28546
28547
28548
28549
28550 func (c *CreativesPatchCall) Context(ctx context.Context) *CreativesPatchCall {
28551 c.ctx_ = ctx
28552 return c
28553 }
28554
28555
28556
28557 func (c *CreativesPatchCall) Header() http.Header {
28558 if c.header_ == nil {
28559 c.header_ = make(http.Header)
28560 }
28561 return c.header_
28562 }
28563
28564 func (c *CreativesPatchCall) doRequest(alt string) (*http.Response, error) {
28565 reqHeaders := make(http.Header)
28566 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
28567 for k, v := range c.header_ {
28568 reqHeaders[k] = v
28569 }
28570 reqHeaders.Set("User-Agent", c.s.userAgent())
28571 var body io.Reader = nil
28572 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creative)
28573 if err != nil {
28574 return nil, err
28575 }
28576 reqHeaders.Set("Content-Type", "application/json")
28577 c.urlParams_.Set("alt", alt)
28578 c.urlParams_.Set("prettyPrint", "false")
28579 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creatives")
28580 urls += "?" + c.urlParams_.Encode()
28581 req, err := http.NewRequest("PATCH", urls, body)
28582 if err != nil {
28583 return nil, err
28584 }
28585 req.Header = reqHeaders
28586 googleapi.Expand(req.URL, map[string]string{
28587 "profileId": strconv.FormatInt(c.profileId, 10),
28588 })
28589 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28590 }
28591
28592
28593
28594
28595
28596
28597
28598
28599 func (c *CreativesPatchCall) Do(opts ...googleapi.CallOption) (*Creative, error) {
28600 gensupport.SetOptions(c.urlParams_, opts...)
28601 res, err := c.doRequest("json")
28602 if res != nil && res.StatusCode == http.StatusNotModified {
28603 if res.Body != nil {
28604 res.Body.Close()
28605 }
28606 return nil, &googleapi.Error{
28607 Code: res.StatusCode,
28608 Header: res.Header,
28609 }
28610 }
28611 if err != nil {
28612 return nil, err
28613 }
28614 defer googleapi.CloseBody(res)
28615 if err := googleapi.CheckResponse(res); err != nil {
28616 return nil, err
28617 }
28618 ret := &Creative{
28619 ServerResponse: googleapi.ServerResponse{
28620 Header: res.Header,
28621 HTTPStatusCode: res.StatusCode,
28622 },
28623 }
28624 target := &ret
28625 if err := gensupport.DecodeResponse(target, res); err != nil {
28626 return nil, err
28627 }
28628 return ret, nil
28629
28630
28631
28632
28633
28634
28635
28636
28637
28638
28639
28640
28641
28642
28643
28644
28645
28646
28647
28648
28649
28650
28651
28652
28653
28654
28655
28656
28657
28658
28659
28660
28661
28662
28663
28664
28665 }
28666
28667
28668
28669 type CreativesUpdateCall struct {
28670 s *Service
28671 profileId int64
28672 creative *Creative
28673 urlParams_ gensupport.URLParams
28674 ctx_ context.Context
28675 header_ http.Header
28676 }
28677
28678
28679 func (r *CreativesService) Update(profileId int64, creative *Creative) *CreativesUpdateCall {
28680 c := &CreativesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28681 c.profileId = profileId
28682 c.creative = creative
28683 return c
28684 }
28685
28686
28687
28688
28689 func (c *CreativesUpdateCall) Fields(s ...googleapi.Field) *CreativesUpdateCall {
28690 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28691 return c
28692 }
28693
28694
28695
28696
28697 func (c *CreativesUpdateCall) Context(ctx context.Context) *CreativesUpdateCall {
28698 c.ctx_ = ctx
28699 return c
28700 }
28701
28702
28703
28704 func (c *CreativesUpdateCall) Header() http.Header {
28705 if c.header_ == nil {
28706 c.header_ = make(http.Header)
28707 }
28708 return c.header_
28709 }
28710
28711 func (c *CreativesUpdateCall) doRequest(alt string) (*http.Response, error) {
28712 reqHeaders := make(http.Header)
28713 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
28714 for k, v := range c.header_ {
28715 reqHeaders[k] = v
28716 }
28717 reqHeaders.Set("User-Agent", c.s.userAgent())
28718 var body io.Reader = nil
28719 body, err := googleapi.WithoutDataWrapper.JSONReader(c.creative)
28720 if err != nil {
28721 return nil, err
28722 }
28723 reqHeaders.Set("Content-Type", "application/json")
28724 c.urlParams_.Set("alt", alt)
28725 c.urlParams_.Set("prettyPrint", "false")
28726 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/creatives")
28727 urls += "?" + c.urlParams_.Encode()
28728 req, err := http.NewRequest("PUT", urls, body)
28729 if err != nil {
28730 return nil, err
28731 }
28732 req.Header = reqHeaders
28733 googleapi.Expand(req.URL, map[string]string{
28734 "profileId": strconv.FormatInt(c.profileId, 10),
28735 })
28736 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28737 }
28738
28739
28740
28741
28742
28743
28744
28745
28746 func (c *CreativesUpdateCall) Do(opts ...googleapi.CallOption) (*Creative, error) {
28747 gensupport.SetOptions(c.urlParams_, opts...)
28748 res, err := c.doRequest("json")
28749 if res != nil && res.StatusCode == http.StatusNotModified {
28750 if res.Body != nil {
28751 res.Body.Close()
28752 }
28753 return nil, &googleapi.Error{
28754 Code: res.StatusCode,
28755 Header: res.Header,
28756 }
28757 }
28758 if err != nil {
28759 return nil, err
28760 }
28761 defer googleapi.CloseBody(res)
28762 if err := googleapi.CheckResponse(res); err != nil {
28763 return nil, err
28764 }
28765 ret := &Creative{
28766 ServerResponse: googleapi.ServerResponse{
28767 Header: res.Header,
28768 HTTPStatusCode: res.StatusCode,
28769 },
28770 }
28771 target := &ret
28772 if err := gensupport.DecodeResponse(target, res); err != nil {
28773 return nil, err
28774 }
28775 return ret, nil
28776
28777
28778
28779
28780
28781
28782
28783
28784
28785
28786
28787
28788
28789
28790
28791
28792
28793
28794
28795
28796
28797
28798
28799
28800
28801
28802
28803
28804 }
28805
28806
28807
28808 type DimensionValuesQueryCall struct {
28809 s *Service
28810 profileId int64
28811 dimensionvaluerequest *DimensionValueRequest
28812 urlParams_ gensupport.URLParams
28813 ctx_ context.Context
28814 header_ http.Header
28815 }
28816
28817
28818
28819 func (r *DimensionValuesService) Query(profileId int64, dimensionvaluerequest *DimensionValueRequest) *DimensionValuesQueryCall {
28820 c := &DimensionValuesQueryCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28821 c.profileId = profileId
28822 c.dimensionvaluerequest = dimensionvaluerequest
28823 return c
28824 }
28825
28826
28827
28828 func (c *DimensionValuesQueryCall) MaxResults(maxResults int64) *DimensionValuesQueryCall {
28829 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
28830 return c
28831 }
28832
28833
28834
28835 func (c *DimensionValuesQueryCall) PageToken(pageToken string) *DimensionValuesQueryCall {
28836 c.urlParams_.Set("pageToken", pageToken)
28837 return c
28838 }
28839
28840
28841
28842
28843 func (c *DimensionValuesQueryCall) Fields(s ...googleapi.Field) *DimensionValuesQueryCall {
28844 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28845 return c
28846 }
28847
28848
28849
28850
28851 func (c *DimensionValuesQueryCall) Context(ctx context.Context) *DimensionValuesQueryCall {
28852 c.ctx_ = ctx
28853 return c
28854 }
28855
28856
28857
28858 func (c *DimensionValuesQueryCall) Header() http.Header {
28859 if c.header_ == nil {
28860 c.header_ = make(http.Header)
28861 }
28862 return c.header_
28863 }
28864
28865 func (c *DimensionValuesQueryCall) doRequest(alt string) (*http.Response, error) {
28866 reqHeaders := make(http.Header)
28867 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
28868 for k, v := range c.header_ {
28869 reqHeaders[k] = v
28870 }
28871 reqHeaders.Set("User-Agent", c.s.userAgent())
28872 var body io.Reader = nil
28873 body, err := googleapi.WithoutDataWrapper.JSONReader(c.dimensionvaluerequest)
28874 if err != nil {
28875 return nil, err
28876 }
28877 reqHeaders.Set("Content-Type", "application/json")
28878 c.urlParams_.Set("alt", alt)
28879 c.urlParams_.Set("prettyPrint", "false")
28880 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/dimensionvalues/query")
28881 urls += "?" + c.urlParams_.Encode()
28882 req, err := http.NewRequest("POST", urls, body)
28883 if err != nil {
28884 return nil, err
28885 }
28886 req.Header = reqHeaders
28887 googleapi.Expand(req.URL, map[string]string{
28888 "profileId": strconv.FormatInt(c.profileId, 10),
28889 })
28890 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28891 }
28892
28893
28894
28895
28896
28897
28898
28899
28900 func (c *DimensionValuesQueryCall) Do(opts ...googleapi.CallOption) (*DimensionValueList, error) {
28901 gensupport.SetOptions(c.urlParams_, opts...)
28902 res, err := c.doRequest("json")
28903 if res != nil && res.StatusCode == http.StatusNotModified {
28904 if res.Body != nil {
28905 res.Body.Close()
28906 }
28907 return nil, &googleapi.Error{
28908 Code: res.StatusCode,
28909 Header: res.Header,
28910 }
28911 }
28912 if err != nil {
28913 return nil, err
28914 }
28915 defer googleapi.CloseBody(res)
28916 if err := googleapi.CheckResponse(res); err != nil {
28917 return nil, err
28918 }
28919 ret := &DimensionValueList{
28920 ServerResponse: googleapi.ServerResponse{
28921 Header: res.Header,
28922 HTTPStatusCode: res.StatusCode,
28923 },
28924 }
28925 target := &ret
28926 if err := gensupport.DecodeResponse(target, res); err != nil {
28927 return nil, err
28928 }
28929 return ret, nil
28930
28931
28932
28933
28934
28935
28936
28937
28938
28939
28940
28941
28942
28943
28944
28945
28946
28947
28948
28949
28950
28951
28952
28953
28954
28955
28956
28957
28958
28959
28960
28961
28962
28963
28964
28965
28966
28967
28968
28969
28970
28971
28972 }
28973
28974
28975
28976
28977 func (c *DimensionValuesQueryCall) Pages(ctx context.Context, f func(*DimensionValueList) error) error {
28978 c.ctx_ = ctx
28979 defer c.PageToken(c.urlParams_.Get("pageToken"))
28980 for {
28981 x, err := c.Do()
28982 if err != nil {
28983 return err
28984 }
28985 if err := f(x); err != nil {
28986 return err
28987 }
28988 if x.NextPageToken == "" {
28989 return nil
28990 }
28991 c.PageToken(x.NextPageToken)
28992 }
28993 }
28994
28995
28996
28997 type DirectorySitesGetCall struct {
28998 s *Service
28999 profileId int64
29000 id int64
29001 urlParams_ gensupport.URLParams
29002 ifNoneMatch_ string
29003 ctx_ context.Context
29004 header_ http.Header
29005 }
29006
29007
29008 func (r *DirectorySitesService) Get(profileId int64, id int64) *DirectorySitesGetCall {
29009 c := &DirectorySitesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29010 c.profileId = profileId
29011 c.id = id
29012 return c
29013 }
29014
29015
29016
29017
29018 func (c *DirectorySitesGetCall) Fields(s ...googleapi.Field) *DirectorySitesGetCall {
29019 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29020 return c
29021 }
29022
29023
29024
29025
29026
29027
29028 func (c *DirectorySitesGetCall) IfNoneMatch(entityTag string) *DirectorySitesGetCall {
29029 c.ifNoneMatch_ = entityTag
29030 return c
29031 }
29032
29033
29034
29035
29036 func (c *DirectorySitesGetCall) Context(ctx context.Context) *DirectorySitesGetCall {
29037 c.ctx_ = ctx
29038 return c
29039 }
29040
29041
29042
29043 func (c *DirectorySitesGetCall) Header() http.Header {
29044 if c.header_ == nil {
29045 c.header_ = make(http.Header)
29046 }
29047 return c.header_
29048 }
29049
29050 func (c *DirectorySitesGetCall) doRequest(alt string) (*http.Response, error) {
29051 reqHeaders := make(http.Header)
29052 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
29053 for k, v := range c.header_ {
29054 reqHeaders[k] = v
29055 }
29056 reqHeaders.Set("User-Agent", c.s.userAgent())
29057 if c.ifNoneMatch_ != "" {
29058 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
29059 }
29060 var body io.Reader = nil
29061 c.urlParams_.Set("alt", alt)
29062 c.urlParams_.Set("prettyPrint", "false")
29063 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/directorySites/{id}")
29064 urls += "?" + c.urlParams_.Encode()
29065 req, err := http.NewRequest("GET", urls, body)
29066 if err != nil {
29067 return nil, err
29068 }
29069 req.Header = reqHeaders
29070 googleapi.Expand(req.URL, map[string]string{
29071 "profileId": strconv.FormatInt(c.profileId, 10),
29072 "id": strconv.FormatInt(c.id, 10),
29073 })
29074 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29075 }
29076
29077
29078
29079
29080
29081
29082
29083
29084 func (c *DirectorySitesGetCall) Do(opts ...googleapi.CallOption) (*DirectorySite, error) {
29085 gensupport.SetOptions(c.urlParams_, opts...)
29086 res, err := c.doRequest("json")
29087 if res != nil && res.StatusCode == http.StatusNotModified {
29088 if res.Body != nil {
29089 res.Body.Close()
29090 }
29091 return nil, &googleapi.Error{
29092 Code: res.StatusCode,
29093 Header: res.Header,
29094 }
29095 }
29096 if err != nil {
29097 return nil, err
29098 }
29099 defer googleapi.CloseBody(res)
29100 if err := googleapi.CheckResponse(res); err != nil {
29101 return nil, err
29102 }
29103 ret := &DirectorySite{
29104 ServerResponse: googleapi.ServerResponse{
29105 Header: res.Header,
29106 HTTPStatusCode: res.StatusCode,
29107 },
29108 }
29109 target := &ret
29110 if err := gensupport.DecodeResponse(target, res); err != nil {
29111 return nil, err
29112 }
29113 return ret, nil
29114
29115
29116
29117
29118
29119
29120
29121
29122
29123
29124
29125
29126
29127
29128
29129
29130
29131
29132
29133
29134
29135
29136
29137
29138
29139
29140
29141
29142
29143
29144
29145
29146
29147 }
29148
29149
29150
29151 type DirectorySitesInsertCall struct {
29152 s *Service
29153 profileId int64
29154 directorysite *DirectorySite
29155 urlParams_ gensupport.URLParams
29156 ctx_ context.Context
29157 header_ http.Header
29158 }
29159
29160
29161 func (r *DirectorySitesService) Insert(profileId int64, directorysite *DirectorySite) *DirectorySitesInsertCall {
29162 c := &DirectorySitesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29163 c.profileId = profileId
29164 c.directorysite = directorysite
29165 return c
29166 }
29167
29168
29169
29170
29171 func (c *DirectorySitesInsertCall) Fields(s ...googleapi.Field) *DirectorySitesInsertCall {
29172 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29173 return c
29174 }
29175
29176
29177
29178
29179 func (c *DirectorySitesInsertCall) Context(ctx context.Context) *DirectorySitesInsertCall {
29180 c.ctx_ = ctx
29181 return c
29182 }
29183
29184
29185
29186 func (c *DirectorySitesInsertCall) Header() http.Header {
29187 if c.header_ == nil {
29188 c.header_ = make(http.Header)
29189 }
29190 return c.header_
29191 }
29192
29193 func (c *DirectorySitesInsertCall) doRequest(alt string) (*http.Response, error) {
29194 reqHeaders := make(http.Header)
29195 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
29196 for k, v := range c.header_ {
29197 reqHeaders[k] = v
29198 }
29199 reqHeaders.Set("User-Agent", c.s.userAgent())
29200 var body io.Reader = nil
29201 body, err := googleapi.WithoutDataWrapper.JSONReader(c.directorysite)
29202 if err != nil {
29203 return nil, err
29204 }
29205 reqHeaders.Set("Content-Type", "application/json")
29206 c.urlParams_.Set("alt", alt)
29207 c.urlParams_.Set("prettyPrint", "false")
29208 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/directorySites")
29209 urls += "?" + c.urlParams_.Encode()
29210 req, err := http.NewRequest("POST", urls, body)
29211 if err != nil {
29212 return nil, err
29213 }
29214 req.Header = reqHeaders
29215 googleapi.Expand(req.URL, map[string]string{
29216 "profileId": strconv.FormatInt(c.profileId, 10),
29217 })
29218 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29219 }
29220
29221
29222
29223
29224
29225
29226
29227
29228 func (c *DirectorySitesInsertCall) Do(opts ...googleapi.CallOption) (*DirectorySite, error) {
29229 gensupport.SetOptions(c.urlParams_, opts...)
29230 res, err := c.doRequest("json")
29231 if res != nil && res.StatusCode == http.StatusNotModified {
29232 if res.Body != nil {
29233 res.Body.Close()
29234 }
29235 return nil, &googleapi.Error{
29236 Code: res.StatusCode,
29237 Header: res.Header,
29238 }
29239 }
29240 if err != nil {
29241 return nil, err
29242 }
29243 defer googleapi.CloseBody(res)
29244 if err := googleapi.CheckResponse(res); err != nil {
29245 return nil, err
29246 }
29247 ret := &DirectorySite{
29248 ServerResponse: googleapi.ServerResponse{
29249 Header: res.Header,
29250 HTTPStatusCode: res.StatusCode,
29251 },
29252 }
29253 target := &ret
29254 if err := gensupport.DecodeResponse(target, res); err != nil {
29255 return nil, err
29256 }
29257 return ret, nil
29258
29259
29260
29261
29262
29263
29264
29265
29266
29267
29268
29269
29270
29271
29272
29273
29274
29275
29276
29277
29278
29279
29280
29281
29282
29283
29284
29285
29286 }
29287
29288
29289
29290 type DirectorySitesListCall struct {
29291 s *Service
29292 profileId int64
29293 urlParams_ gensupport.URLParams
29294 ifNoneMatch_ string
29295 ctx_ context.Context
29296 header_ http.Header
29297 }
29298
29299
29300
29301 func (r *DirectorySitesService) List(profileId int64) *DirectorySitesListCall {
29302 c := &DirectorySitesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29303 c.profileId = profileId
29304 return c
29305 }
29306
29307
29308
29309
29310 func (c *DirectorySitesListCall) AcceptsInStreamVideoPlacements(acceptsInStreamVideoPlacements bool) *DirectorySitesListCall {
29311 c.urlParams_.Set("acceptsInStreamVideoPlacements", fmt.Sprint(acceptsInStreamVideoPlacements))
29312 return c
29313 }
29314
29315
29316
29317
29318 func (c *DirectorySitesListCall) AcceptsInterstitialPlacements(acceptsInterstitialPlacements bool) *DirectorySitesListCall {
29319 c.urlParams_.Set("acceptsInterstitialPlacements", fmt.Sprint(acceptsInterstitialPlacements))
29320 return c
29321 }
29322
29323
29324
29325
29326 func (c *DirectorySitesListCall) AcceptsPublisherPaidPlacements(acceptsPublisherPaidPlacements bool) *DirectorySitesListCall {
29327 c.urlParams_.Set("acceptsPublisherPaidPlacements", fmt.Sprint(acceptsPublisherPaidPlacements))
29328 return c
29329 }
29330
29331
29332
29333
29334 func (c *DirectorySitesListCall) Active(active bool) *DirectorySitesListCall {
29335 c.urlParams_.Set("active", fmt.Sprint(active))
29336 return c
29337 }
29338
29339
29340
29341 func (c *DirectorySitesListCall) DfpNetworkCode(dfpNetworkCode string) *DirectorySitesListCall {
29342 c.urlParams_.Set("dfpNetworkCode", dfpNetworkCode)
29343 return c
29344 }
29345
29346
29347
29348 func (c *DirectorySitesListCall) Ids(ids ...int64) *DirectorySitesListCall {
29349 var ids_ []string
29350 for _, v := range ids {
29351 ids_ = append(ids_, fmt.Sprint(v))
29352 }
29353 c.urlParams_.SetMulti("ids", ids_)
29354 return c
29355 }
29356
29357
29358
29359 func (c *DirectorySitesListCall) MaxResults(maxResults int64) *DirectorySitesListCall {
29360 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
29361 return c
29362 }
29363
29364
29365
29366 func (c *DirectorySitesListCall) PageToken(pageToken string) *DirectorySitesListCall {
29367 c.urlParams_.Set("pageToken", pageToken)
29368 return c
29369 }
29370
29371
29372
29373
29374
29375
29376
29377
29378
29379
29380 func (c *DirectorySitesListCall) SearchString(searchString string) *DirectorySitesListCall {
29381 c.urlParams_.Set("searchString", searchString)
29382 return c
29383 }
29384
29385
29386
29387
29388
29389
29390
29391
29392 func (c *DirectorySitesListCall) SortField(sortField string) *DirectorySitesListCall {
29393 c.urlParams_.Set("sortField", sortField)
29394 return c
29395 }
29396
29397
29398
29399
29400
29401
29402
29403
29404 func (c *DirectorySitesListCall) SortOrder(sortOrder string) *DirectorySitesListCall {
29405 c.urlParams_.Set("sortOrder", sortOrder)
29406 return c
29407 }
29408
29409
29410
29411
29412 func (c *DirectorySitesListCall) Fields(s ...googleapi.Field) *DirectorySitesListCall {
29413 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29414 return c
29415 }
29416
29417
29418
29419
29420
29421
29422 func (c *DirectorySitesListCall) IfNoneMatch(entityTag string) *DirectorySitesListCall {
29423 c.ifNoneMatch_ = entityTag
29424 return c
29425 }
29426
29427
29428
29429
29430 func (c *DirectorySitesListCall) Context(ctx context.Context) *DirectorySitesListCall {
29431 c.ctx_ = ctx
29432 return c
29433 }
29434
29435
29436
29437 func (c *DirectorySitesListCall) Header() http.Header {
29438 if c.header_ == nil {
29439 c.header_ = make(http.Header)
29440 }
29441 return c.header_
29442 }
29443
29444 func (c *DirectorySitesListCall) doRequest(alt string) (*http.Response, error) {
29445 reqHeaders := make(http.Header)
29446 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
29447 for k, v := range c.header_ {
29448 reqHeaders[k] = v
29449 }
29450 reqHeaders.Set("User-Agent", c.s.userAgent())
29451 if c.ifNoneMatch_ != "" {
29452 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
29453 }
29454 var body io.Reader = nil
29455 c.urlParams_.Set("alt", alt)
29456 c.urlParams_.Set("prettyPrint", "false")
29457 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/directorySites")
29458 urls += "?" + c.urlParams_.Encode()
29459 req, err := http.NewRequest("GET", urls, body)
29460 if err != nil {
29461 return nil, err
29462 }
29463 req.Header = reqHeaders
29464 googleapi.Expand(req.URL, map[string]string{
29465 "profileId": strconv.FormatInt(c.profileId, 10),
29466 })
29467 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29468 }
29469
29470
29471
29472
29473
29474
29475
29476
29477 func (c *DirectorySitesListCall) Do(opts ...googleapi.CallOption) (*DirectorySitesListResponse, error) {
29478 gensupport.SetOptions(c.urlParams_, opts...)
29479 res, err := c.doRequest("json")
29480 if res != nil && res.StatusCode == http.StatusNotModified {
29481 if res.Body != nil {
29482 res.Body.Close()
29483 }
29484 return nil, &googleapi.Error{
29485 Code: res.StatusCode,
29486 Header: res.Header,
29487 }
29488 }
29489 if err != nil {
29490 return nil, err
29491 }
29492 defer googleapi.CloseBody(res)
29493 if err := googleapi.CheckResponse(res); err != nil {
29494 return nil, err
29495 }
29496 ret := &DirectorySitesListResponse{
29497 ServerResponse: googleapi.ServerResponse{
29498 Header: res.Header,
29499 HTTPStatusCode: res.StatusCode,
29500 },
29501 }
29502 target := &ret
29503 if err := gensupport.DecodeResponse(target, res); err != nil {
29504 return nil, err
29505 }
29506 return ret, nil
29507
29508
29509
29510
29511
29512
29513
29514
29515
29516
29517
29518
29519
29520
29521
29522
29523
29524
29525
29526
29527
29528
29529
29530
29531
29532
29533
29534
29535
29536
29537
29538
29539
29540
29541
29542
29543
29544
29545
29546
29547
29548
29549
29550
29551
29552
29553
29554
29555
29556
29557
29558
29559
29560
29561
29562
29563
29564
29565
29566
29567
29568
29569
29570
29571
29572
29573
29574
29575
29576
29577
29578
29579
29580
29581
29582
29583
29584
29585
29586
29587
29588
29589
29590
29591
29592
29593
29594
29595
29596
29597
29598
29599
29600
29601
29602
29603
29604
29605
29606
29607
29608
29609
29610
29611 }
29612
29613
29614
29615
29616 func (c *DirectorySitesListCall) Pages(ctx context.Context, f func(*DirectorySitesListResponse) error) error {
29617 c.ctx_ = ctx
29618 defer c.PageToken(c.urlParams_.Get("pageToken"))
29619 for {
29620 x, err := c.Do()
29621 if err != nil {
29622 return err
29623 }
29624 if err := f(x); err != nil {
29625 return err
29626 }
29627 if x.NextPageToken == "" {
29628 return nil
29629 }
29630 c.PageToken(x.NextPageToken)
29631 }
29632 }
29633
29634
29635
29636 type DynamicTargetingKeysDeleteCall struct {
29637 s *Service
29638 profileId int64
29639 objectId int64
29640 urlParams_ gensupport.URLParams
29641 ctx_ context.Context
29642 header_ http.Header
29643 }
29644
29645
29646 func (r *DynamicTargetingKeysService) Delete(profileId int64, objectId int64, name string, objectType string) *DynamicTargetingKeysDeleteCall {
29647 c := &DynamicTargetingKeysDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29648 c.profileId = profileId
29649 c.objectId = objectId
29650 c.urlParams_.Set("name", name)
29651 c.urlParams_.Set("objectType", objectType)
29652 return c
29653 }
29654
29655
29656
29657
29658 func (c *DynamicTargetingKeysDeleteCall) Fields(s ...googleapi.Field) *DynamicTargetingKeysDeleteCall {
29659 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29660 return c
29661 }
29662
29663
29664
29665
29666 func (c *DynamicTargetingKeysDeleteCall) Context(ctx context.Context) *DynamicTargetingKeysDeleteCall {
29667 c.ctx_ = ctx
29668 return c
29669 }
29670
29671
29672
29673 func (c *DynamicTargetingKeysDeleteCall) Header() http.Header {
29674 if c.header_ == nil {
29675 c.header_ = make(http.Header)
29676 }
29677 return c.header_
29678 }
29679
29680 func (c *DynamicTargetingKeysDeleteCall) doRequest(alt string) (*http.Response, error) {
29681 reqHeaders := make(http.Header)
29682 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
29683 for k, v := range c.header_ {
29684 reqHeaders[k] = v
29685 }
29686 reqHeaders.Set("User-Agent", c.s.userAgent())
29687 var body io.Reader = nil
29688 c.urlParams_.Set("alt", alt)
29689 c.urlParams_.Set("prettyPrint", "false")
29690 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/dynamicTargetingKeys/{objectId}")
29691 urls += "?" + c.urlParams_.Encode()
29692 req, err := http.NewRequest("DELETE", urls, body)
29693 if err != nil {
29694 return nil, err
29695 }
29696 req.Header = reqHeaders
29697 googleapi.Expand(req.URL, map[string]string{
29698 "profileId": strconv.FormatInt(c.profileId, 10),
29699 "objectId": strconv.FormatInt(c.objectId, 10),
29700 })
29701 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29702 }
29703
29704
29705 func (c *DynamicTargetingKeysDeleteCall) Do(opts ...googleapi.CallOption) error {
29706 gensupport.SetOptions(c.urlParams_, opts...)
29707 res, err := c.doRequest("json")
29708 if err != nil {
29709 return err
29710 }
29711 defer googleapi.CloseBody(res)
29712 if err := googleapi.CheckResponse(res); err != nil {
29713 return err
29714 }
29715 return nil
29716
29717
29718
29719
29720
29721
29722
29723
29724
29725
29726
29727
29728
29729
29730
29731
29732
29733
29734
29735
29736
29737
29738
29739
29740
29741
29742
29743
29744
29745
29746
29747
29748
29749
29750
29751
29752
29753
29754
29755
29756
29757
29758
29759
29760
29761
29762
29763
29764
29765
29766
29767
29768
29769
29770
29771
29772 }
29773
29774
29775
29776 type DynamicTargetingKeysInsertCall struct {
29777 s *Service
29778 profileId int64
29779 dynamictargetingkey *DynamicTargetingKey
29780 urlParams_ gensupport.URLParams
29781 ctx_ context.Context
29782 header_ http.Header
29783 }
29784
29785
29786
29787
29788
29789
29790 func (r *DynamicTargetingKeysService) Insert(profileId int64, dynamictargetingkey *DynamicTargetingKey) *DynamicTargetingKeysInsertCall {
29791 c := &DynamicTargetingKeysInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29792 c.profileId = profileId
29793 c.dynamictargetingkey = dynamictargetingkey
29794 return c
29795 }
29796
29797
29798
29799
29800 func (c *DynamicTargetingKeysInsertCall) Fields(s ...googleapi.Field) *DynamicTargetingKeysInsertCall {
29801 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29802 return c
29803 }
29804
29805
29806
29807
29808 func (c *DynamicTargetingKeysInsertCall) Context(ctx context.Context) *DynamicTargetingKeysInsertCall {
29809 c.ctx_ = ctx
29810 return c
29811 }
29812
29813
29814
29815 func (c *DynamicTargetingKeysInsertCall) Header() http.Header {
29816 if c.header_ == nil {
29817 c.header_ = make(http.Header)
29818 }
29819 return c.header_
29820 }
29821
29822 func (c *DynamicTargetingKeysInsertCall) doRequest(alt string) (*http.Response, error) {
29823 reqHeaders := make(http.Header)
29824 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
29825 for k, v := range c.header_ {
29826 reqHeaders[k] = v
29827 }
29828 reqHeaders.Set("User-Agent", c.s.userAgent())
29829 var body io.Reader = nil
29830 body, err := googleapi.WithoutDataWrapper.JSONReader(c.dynamictargetingkey)
29831 if err != nil {
29832 return nil, err
29833 }
29834 reqHeaders.Set("Content-Type", "application/json")
29835 c.urlParams_.Set("alt", alt)
29836 c.urlParams_.Set("prettyPrint", "false")
29837 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/dynamicTargetingKeys")
29838 urls += "?" + c.urlParams_.Encode()
29839 req, err := http.NewRequest("POST", urls, body)
29840 if err != nil {
29841 return nil, err
29842 }
29843 req.Header = reqHeaders
29844 googleapi.Expand(req.URL, map[string]string{
29845 "profileId": strconv.FormatInt(c.profileId, 10),
29846 })
29847 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29848 }
29849
29850
29851
29852
29853
29854
29855
29856
29857 func (c *DynamicTargetingKeysInsertCall) Do(opts ...googleapi.CallOption) (*DynamicTargetingKey, error) {
29858 gensupport.SetOptions(c.urlParams_, opts...)
29859 res, err := c.doRequest("json")
29860 if res != nil && res.StatusCode == http.StatusNotModified {
29861 if res.Body != nil {
29862 res.Body.Close()
29863 }
29864 return nil, &googleapi.Error{
29865 Code: res.StatusCode,
29866 Header: res.Header,
29867 }
29868 }
29869 if err != nil {
29870 return nil, err
29871 }
29872 defer googleapi.CloseBody(res)
29873 if err := googleapi.CheckResponse(res); err != nil {
29874 return nil, err
29875 }
29876 ret := &DynamicTargetingKey{
29877 ServerResponse: googleapi.ServerResponse{
29878 Header: res.Header,
29879 HTTPStatusCode: res.StatusCode,
29880 },
29881 }
29882 target := &ret
29883 if err := gensupport.DecodeResponse(target, res); err != nil {
29884 return nil, err
29885 }
29886 return ret, nil
29887
29888
29889
29890
29891
29892
29893
29894
29895
29896
29897
29898
29899
29900
29901
29902
29903
29904
29905
29906
29907
29908
29909
29910
29911
29912
29913
29914
29915 }
29916
29917
29918
29919 type DynamicTargetingKeysListCall struct {
29920 s *Service
29921 profileId int64
29922 urlParams_ gensupport.URLParams
29923 ifNoneMatch_ string
29924 ctx_ context.Context
29925 header_ http.Header
29926 }
29927
29928
29929 func (r *DynamicTargetingKeysService) List(profileId int64) *DynamicTargetingKeysListCall {
29930 c := &DynamicTargetingKeysListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29931 c.profileId = profileId
29932 return c
29933 }
29934
29935
29936
29937 func (c *DynamicTargetingKeysListCall) AdvertiserId(advertiserId int64) *DynamicTargetingKeysListCall {
29938 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
29939 return c
29940 }
29941
29942
29943
29944 func (c *DynamicTargetingKeysListCall) Names(names ...string) *DynamicTargetingKeysListCall {
29945 c.urlParams_.SetMulti("names", append([]string{}, names...))
29946 return c
29947 }
29948
29949
29950
29951 func (c *DynamicTargetingKeysListCall) ObjectId(objectId int64) *DynamicTargetingKeysListCall {
29952 c.urlParams_.Set("objectId", fmt.Sprint(objectId))
29953 return c
29954 }
29955
29956
29957
29958
29959
29960
29961
29962
29963
29964
29965 func (c *DynamicTargetingKeysListCall) ObjectType(objectType string) *DynamicTargetingKeysListCall {
29966 c.urlParams_.Set("objectType", objectType)
29967 return c
29968 }
29969
29970
29971
29972
29973 func (c *DynamicTargetingKeysListCall) Fields(s ...googleapi.Field) *DynamicTargetingKeysListCall {
29974 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29975 return c
29976 }
29977
29978
29979
29980
29981
29982
29983 func (c *DynamicTargetingKeysListCall) IfNoneMatch(entityTag string) *DynamicTargetingKeysListCall {
29984 c.ifNoneMatch_ = entityTag
29985 return c
29986 }
29987
29988
29989
29990
29991 func (c *DynamicTargetingKeysListCall) Context(ctx context.Context) *DynamicTargetingKeysListCall {
29992 c.ctx_ = ctx
29993 return c
29994 }
29995
29996
29997
29998 func (c *DynamicTargetingKeysListCall) Header() http.Header {
29999 if c.header_ == nil {
30000 c.header_ = make(http.Header)
30001 }
30002 return c.header_
30003 }
30004
30005 func (c *DynamicTargetingKeysListCall) doRequest(alt string) (*http.Response, error) {
30006 reqHeaders := make(http.Header)
30007 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
30008 for k, v := range c.header_ {
30009 reqHeaders[k] = v
30010 }
30011 reqHeaders.Set("User-Agent", c.s.userAgent())
30012 if c.ifNoneMatch_ != "" {
30013 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
30014 }
30015 var body io.Reader = nil
30016 c.urlParams_.Set("alt", alt)
30017 c.urlParams_.Set("prettyPrint", "false")
30018 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/dynamicTargetingKeys")
30019 urls += "?" + c.urlParams_.Encode()
30020 req, err := http.NewRequest("GET", urls, body)
30021 if err != nil {
30022 return nil, err
30023 }
30024 req.Header = reqHeaders
30025 googleapi.Expand(req.URL, map[string]string{
30026 "profileId": strconv.FormatInt(c.profileId, 10),
30027 })
30028 return gensupport.SendRequest(c.ctx_, c.s.client, req)
30029 }
30030
30031
30032
30033
30034
30035
30036
30037
30038 func (c *DynamicTargetingKeysListCall) Do(opts ...googleapi.CallOption) (*DynamicTargetingKeysListResponse, error) {
30039 gensupport.SetOptions(c.urlParams_, opts...)
30040 res, err := c.doRequest("json")
30041 if res != nil && res.StatusCode == http.StatusNotModified {
30042 if res.Body != nil {
30043 res.Body.Close()
30044 }
30045 return nil, &googleapi.Error{
30046 Code: res.StatusCode,
30047 Header: res.Header,
30048 }
30049 }
30050 if err != nil {
30051 return nil, err
30052 }
30053 defer googleapi.CloseBody(res)
30054 if err := googleapi.CheckResponse(res); err != nil {
30055 return nil, err
30056 }
30057 ret := &DynamicTargetingKeysListResponse{
30058 ServerResponse: googleapi.ServerResponse{
30059 Header: res.Header,
30060 HTTPStatusCode: res.StatusCode,
30061 },
30062 }
30063 target := &ret
30064 if err := gensupport.DecodeResponse(target, res); err != nil {
30065 return nil, err
30066 }
30067 return ret, nil
30068
30069
30070
30071
30072
30073
30074
30075
30076
30077
30078
30079
30080
30081
30082
30083
30084
30085
30086
30087
30088
30089
30090
30091
30092
30093
30094
30095
30096
30097
30098
30099
30100
30101
30102
30103
30104
30105
30106
30107
30108
30109
30110
30111
30112
30113
30114
30115
30116
30117
30118
30119
30120
30121
30122
30123
30124
30125
30126
30127
30128 }
30129
30130
30131
30132 type EventTagsDeleteCall struct {
30133 s *Service
30134 profileId int64
30135 id int64
30136 urlParams_ gensupport.URLParams
30137 ctx_ context.Context
30138 header_ http.Header
30139 }
30140
30141
30142 func (r *EventTagsService) Delete(profileId int64, id int64) *EventTagsDeleteCall {
30143 c := &EventTagsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
30144 c.profileId = profileId
30145 c.id = id
30146 return c
30147 }
30148
30149
30150
30151
30152 func (c *EventTagsDeleteCall) Fields(s ...googleapi.Field) *EventTagsDeleteCall {
30153 c.urlParams_.Set("fields", googleapi.CombineFields(s))
30154 return c
30155 }
30156
30157
30158
30159
30160 func (c *EventTagsDeleteCall) Context(ctx context.Context) *EventTagsDeleteCall {
30161 c.ctx_ = ctx
30162 return c
30163 }
30164
30165
30166
30167 func (c *EventTagsDeleteCall) Header() http.Header {
30168 if c.header_ == nil {
30169 c.header_ = make(http.Header)
30170 }
30171 return c.header_
30172 }
30173
30174 func (c *EventTagsDeleteCall) doRequest(alt string) (*http.Response, error) {
30175 reqHeaders := make(http.Header)
30176 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
30177 for k, v := range c.header_ {
30178 reqHeaders[k] = v
30179 }
30180 reqHeaders.Set("User-Agent", c.s.userAgent())
30181 var body io.Reader = nil
30182 c.urlParams_.Set("alt", alt)
30183 c.urlParams_.Set("prettyPrint", "false")
30184 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/eventTags/{id}")
30185 urls += "?" + c.urlParams_.Encode()
30186 req, err := http.NewRequest("DELETE", urls, body)
30187 if err != nil {
30188 return nil, err
30189 }
30190 req.Header = reqHeaders
30191 googleapi.Expand(req.URL, map[string]string{
30192 "profileId": strconv.FormatInt(c.profileId, 10),
30193 "id": strconv.FormatInt(c.id, 10),
30194 })
30195 return gensupport.SendRequest(c.ctx_, c.s.client, req)
30196 }
30197
30198
30199 func (c *EventTagsDeleteCall) Do(opts ...googleapi.CallOption) error {
30200 gensupport.SetOptions(c.urlParams_, opts...)
30201 res, err := c.doRequest("json")
30202 if err != nil {
30203 return err
30204 }
30205 defer googleapi.CloseBody(res)
30206 if err := googleapi.CheckResponse(res); err != nil {
30207 return err
30208 }
30209 return nil
30210
30211
30212
30213
30214
30215
30216
30217
30218
30219
30220
30221
30222
30223
30224
30225
30226
30227
30228
30229
30230
30231
30232
30233
30234
30235
30236
30237
30238
30239
30240 }
30241
30242
30243
30244 type EventTagsGetCall struct {
30245 s *Service
30246 profileId int64
30247 id int64
30248 urlParams_ gensupport.URLParams
30249 ifNoneMatch_ string
30250 ctx_ context.Context
30251 header_ http.Header
30252 }
30253
30254
30255 func (r *EventTagsService) Get(profileId int64, id int64) *EventTagsGetCall {
30256 c := &EventTagsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
30257 c.profileId = profileId
30258 c.id = id
30259 return c
30260 }
30261
30262
30263
30264
30265 func (c *EventTagsGetCall) Fields(s ...googleapi.Field) *EventTagsGetCall {
30266 c.urlParams_.Set("fields", googleapi.CombineFields(s))
30267 return c
30268 }
30269
30270
30271
30272
30273
30274
30275 func (c *EventTagsGetCall) IfNoneMatch(entityTag string) *EventTagsGetCall {
30276 c.ifNoneMatch_ = entityTag
30277 return c
30278 }
30279
30280
30281
30282
30283 func (c *EventTagsGetCall) Context(ctx context.Context) *EventTagsGetCall {
30284 c.ctx_ = ctx
30285 return c
30286 }
30287
30288
30289
30290 func (c *EventTagsGetCall) Header() http.Header {
30291 if c.header_ == nil {
30292 c.header_ = make(http.Header)
30293 }
30294 return c.header_
30295 }
30296
30297 func (c *EventTagsGetCall) doRequest(alt string) (*http.Response, error) {
30298 reqHeaders := make(http.Header)
30299 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
30300 for k, v := range c.header_ {
30301 reqHeaders[k] = v
30302 }
30303 reqHeaders.Set("User-Agent", c.s.userAgent())
30304 if c.ifNoneMatch_ != "" {
30305 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
30306 }
30307 var body io.Reader = nil
30308 c.urlParams_.Set("alt", alt)
30309 c.urlParams_.Set("prettyPrint", "false")
30310 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/eventTags/{id}")
30311 urls += "?" + c.urlParams_.Encode()
30312 req, err := http.NewRequest("GET", urls, body)
30313 if err != nil {
30314 return nil, err
30315 }
30316 req.Header = reqHeaders
30317 googleapi.Expand(req.URL, map[string]string{
30318 "profileId": strconv.FormatInt(c.profileId, 10),
30319 "id": strconv.FormatInt(c.id, 10),
30320 })
30321 return gensupport.SendRequest(c.ctx_, c.s.client, req)
30322 }
30323
30324
30325
30326
30327
30328
30329
30330
30331 func (c *EventTagsGetCall) Do(opts ...googleapi.CallOption) (*EventTag, error) {
30332 gensupport.SetOptions(c.urlParams_, opts...)
30333 res, err := c.doRequest("json")
30334 if res != nil && res.StatusCode == http.StatusNotModified {
30335 if res.Body != nil {
30336 res.Body.Close()
30337 }
30338 return nil, &googleapi.Error{
30339 Code: res.StatusCode,
30340 Header: res.Header,
30341 }
30342 }
30343 if err != nil {
30344 return nil, err
30345 }
30346 defer googleapi.CloseBody(res)
30347 if err := googleapi.CheckResponse(res); err != nil {
30348 return nil, err
30349 }
30350 ret := &EventTag{
30351 ServerResponse: googleapi.ServerResponse{
30352 Header: res.Header,
30353 HTTPStatusCode: res.StatusCode,
30354 },
30355 }
30356 target := &ret
30357 if err := gensupport.DecodeResponse(target, res); err != nil {
30358 return nil, err
30359 }
30360 return ret, nil
30361
30362
30363
30364
30365
30366
30367
30368
30369
30370
30371
30372
30373
30374
30375
30376
30377
30378
30379
30380
30381
30382
30383
30384
30385
30386
30387
30388
30389
30390
30391
30392
30393
30394 }
30395
30396
30397
30398 type EventTagsInsertCall struct {
30399 s *Service
30400 profileId int64
30401 eventtag *EventTag
30402 urlParams_ gensupport.URLParams
30403 ctx_ context.Context
30404 header_ http.Header
30405 }
30406
30407
30408 func (r *EventTagsService) Insert(profileId int64, eventtag *EventTag) *EventTagsInsertCall {
30409 c := &EventTagsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
30410 c.profileId = profileId
30411 c.eventtag = eventtag
30412 return c
30413 }
30414
30415
30416
30417
30418 func (c *EventTagsInsertCall) Fields(s ...googleapi.Field) *EventTagsInsertCall {
30419 c.urlParams_.Set("fields", googleapi.CombineFields(s))
30420 return c
30421 }
30422
30423
30424
30425
30426 func (c *EventTagsInsertCall) Context(ctx context.Context) *EventTagsInsertCall {
30427 c.ctx_ = ctx
30428 return c
30429 }
30430
30431
30432
30433 func (c *EventTagsInsertCall) Header() http.Header {
30434 if c.header_ == nil {
30435 c.header_ = make(http.Header)
30436 }
30437 return c.header_
30438 }
30439
30440 func (c *EventTagsInsertCall) doRequest(alt string) (*http.Response, error) {
30441 reqHeaders := make(http.Header)
30442 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
30443 for k, v := range c.header_ {
30444 reqHeaders[k] = v
30445 }
30446 reqHeaders.Set("User-Agent", c.s.userAgent())
30447 var body io.Reader = nil
30448 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventtag)
30449 if err != nil {
30450 return nil, err
30451 }
30452 reqHeaders.Set("Content-Type", "application/json")
30453 c.urlParams_.Set("alt", alt)
30454 c.urlParams_.Set("prettyPrint", "false")
30455 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/eventTags")
30456 urls += "?" + c.urlParams_.Encode()
30457 req, err := http.NewRequest("POST", urls, body)
30458 if err != nil {
30459 return nil, err
30460 }
30461 req.Header = reqHeaders
30462 googleapi.Expand(req.URL, map[string]string{
30463 "profileId": strconv.FormatInt(c.profileId, 10),
30464 })
30465 return gensupport.SendRequest(c.ctx_, c.s.client, req)
30466 }
30467
30468
30469
30470
30471
30472
30473
30474
30475 func (c *EventTagsInsertCall) Do(opts ...googleapi.CallOption) (*EventTag, error) {
30476 gensupport.SetOptions(c.urlParams_, opts...)
30477 res, err := c.doRequest("json")
30478 if res != nil && res.StatusCode == http.StatusNotModified {
30479 if res.Body != nil {
30480 res.Body.Close()
30481 }
30482 return nil, &googleapi.Error{
30483 Code: res.StatusCode,
30484 Header: res.Header,
30485 }
30486 }
30487 if err != nil {
30488 return nil, err
30489 }
30490 defer googleapi.CloseBody(res)
30491 if err := googleapi.CheckResponse(res); err != nil {
30492 return nil, err
30493 }
30494 ret := &EventTag{
30495 ServerResponse: googleapi.ServerResponse{
30496 Header: res.Header,
30497 HTTPStatusCode: res.StatusCode,
30498 },
30499 }
30500 target := &ret
30501 if err := gensupport.DecodeResponse(target, res); err != nil {
30502 return nil, err
30503 }
30504 return ret, nil
30505
30506
30507
30508
30509
30510
30511
30512
30513
30514
30515
30516
30517
30518
30519
30520
30521
30522
30523
30524
30525
30526
30527
30528
30529
30530
30531
30532
30533 }
30534
30535
30536
30537 type EventTagsListCall struct {
30538 s *Service
30539 profileId int64
30540 urlParams_ gensupport.URLParams
30541 ifNoneMatch_ string
30542 ctx_ context.Context
30543 header_ http.Header
30544 }
30545
30546
30547 func (r *EventTagsService) List(profileId int64) *EventTagsListCall {
30548 c := &EventTagsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
30549 c.profileId = profileId
30550 return c
30551 }
30552
30553
30554
30555 func (c *EventTagsListCall) AdId(adId int64) *EventTagsListCall {
30556 c.urlParams_.Set("adId", fmt.Sprint(adId))
30557 return c
30558 }
30559
30560
30561
30562 func (c *EventTagsListCall) AdvertiserId(advertiserId int64) *EventTagsListCall {
30563 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
30564 return c
30565 }
30566
30567
30568
30569 func (c *EventTagsListCall) CampaignId(campaignId int64) *EventTagsListCall {
30570 c.urlParams_.Set("campaignId", fmt.Sprint(campaignId))
30571 return c
30572 }
30573
30574
30575
30576
30577
30578
30579
30580
30581
30582 func (c *EventTagsListCall) DefinitionsOnly(definitionsOnly bool) *EventTagsListCall {
30583 c.urlParams_.Set("definitionsOnly", fmt.Sprint(definitionsOnly))
30584 return c
30585 }
30586
30587
30588
30589
30590
30591
30592
30593
30594
30595 func (c *EventTagsListCall) Enabled(enabled bool) *EventTagsListCall {
30596 c.urlParams_.Set("enabled", fmt.Sprint(enabled))
30597 return c
30598 }
30599
30600
30601
30602
30603
30604
30605
30606
30607
30608
30609
30610
30611 func (c *EventTagsListCall) EventTagTypes(eventTagTypes ...string) *EventTagsListCall {
30612 c.urlParams_.SetMulti("eventTagTypes", append([]string{}, eventTagTypes...))
30613 return c
30614 }
30615
30616
30617
30618 func (c *EventTagsListCall) Ids(ids ...int64) *EventTagsListCall {
30619 var ids_ []string
30620 for _, v := range ids {
30621 ids_ = append(ids_, fmt.Sprint(v))
30622 }
30623 c.urlParams_.SetMulti("ids", ids_)
30624 return c
30625 }
30626
30627
30628
30629
30630
30631
30632
30633
30634
30635 func (c *EventTagsListCall) SearchString(searchString string) *EventTagsListCall {
30636 c.urlParams_.Set("searchString", searchString)
30637 return c
30638 }
30639
30640
30641
30642
30643
30644
30645
30646
30647 func (c *EventTagsListCall) SortField(sortField string) *EventTagsListCall {
30648 c.urlParams_.Set("sortField", sortField)
30649 return c
30650 }
30651
30652
30653
30654
30655
30656
30657
30658
30659 func (c *EventTagsListCall) SortOrder(sortOrder string) *EventTagsListCall {
30660 c.urlParams_.Set("sortOrder", sortOrder)
30661 return c
30662 }
30663
30664
30665
30666
30667 func (c *EventTagsListCall) Fields(s ...googleapi.Field) *EventTagsListCall {
30668 c.urlParams_.Set("fields", googleapi.CombineFields(s))
30669 return c
30670 }
30671
30672
30673
30674
30675
30676
30677 func (c *EventTagsListCall) IfNoneMatch(entityTag string) *EventTagsListCall {
30678 c.ifNoneMatch_ = entityTag
30679 return c
30680 }
30681
30682
30683
30684
30685 func (c *EventTagsListCall) Context(ctx context.Context) *EventTagsListCall {
30686 c.ctx_ = ctx
30687 return c
30688 }
30689
30690
30691
30692 func (c *EventTagsListCall) Header() http.Header {
30693 if c.header_ == nil {
30694 c.header_ = make(http.Header)
30695 }
30696 return c.header_
30697 }
30698
30699 func (c *EventTagsListCall) doRequest(alt string) (*http.Response, error) {
30700 reqHeaders := make(http.Header)
30701 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
30702 for k, v := range c.header_ {
30703 reqHeaders[k] = v
30704 }
30705 reqHeaders.Set("User-Agent", c.s.userAgent())
30706 if c.ifNoneMatch_ != "" {
30707 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
30708 }
30709 var body io.Reader = nil
30710 c.urlParams_.Set("alt", alt)
30711 c.urlParams_.Set("prettyPrint", "false")
30712 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/eventTags")
30713 urls += "?" + c.urlParams_.Encode()
30714 req, err := http.NewRequest("GET", urls, body)
30715 if err != nil {
30716 return nil, err
30717 }
30718 req.Header = reqHeaders
30719 googleapi.Expand(req.URL, map[string]string{
30720 "profileId": strconv.FormatInt(c.profileId, 10),
30721 })
30722 return gensupport.SendRequest(c.ctx_, c.s.client, req)
30723 }
30724
30725
30726
30727
30728
30729
30730
30731
30732 func (c *EventTagsListCall) Do(opts ...googleapi.CallOption) (*EventTagsListResponse, error) {
30733 gensupport.SetOptions(c.urlParams_, opts...)
30734 res, err := c.doRequest("json")
30735 if res != nil && res.StatusCode == http.StatusNotModified {
30736 if res.Body != nil {
30737 res.Body.Close()
30738 }
30739 return nil, &googleapi.Error{
30740 Code: res.StatusCode,
30741 Header: res.Header,
30742 }
30743 }
30744 if err != nil {
30745 return nil, err
30746 }
30747 defer googleapi.CloseBody(res)
30748 if err := googleapi.CheckResponse(res); err != nil {
30749 return nil, err
30750 }
30751 ret := &EventTagsListResponse{
30752 ServerResponse: googleapi.ServerResponse{
30753 Header: res.Header,
30754 HTTPStatusCode: res.StatusCode,
30755 },
30756 }
30757 target := &ret
30758 if err := gensupport.DecodeResponse(target, res); err != nil {
30759 return nil, err
30760 }
30761 return ret, nil
30762
30763
30764
30765
30766
30767
30768
30769
30770
30771
30772
30773
30774
30775
30776
30777
30778
30779
30780
30781
30782
30783
30784
30785
30786
30787
30788
30789
30790
30791
30792
30793
30794
30795
30796
30797
30798
30799
30800
30801
30802
30803
30804
30805
30806
30807
30808
30809
30810
30811
30812
30813
30814
30815
30816
30817
30818
30819
30820
30821
30822
30823
30824
30825
30826
30827
30828
30829
30830
30831
30832
30833
30834
30835
30836
30837
30838
30839
30840
30841
30842
30843
30844
30845
30846
30847
30848
30849
30850
30851
30852
30853
30854
30855
30856
30857
30858
30859
30860
30861
30862
30863
30864
30865
30866
30867
30868
30869
30870
30871 }
30872
30873
30874
30875 type EventTagsPatchCall struct {
30876 s *Service
30877 profileId int64
30878 eventtag *EventTag
30879 urlParams_ gensupport.URLParams
30880 ctx_ context.Context
30881 header_ http.Header
30882 }
30883
30884
30885
30886 func (r *EventTagsService) Patch(profileId int64, id int64, eventtag *EventTag) *EventTagsPatchCall {
30887 c := &EventTagsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
30888 c.profileId = profileId
30889 c.urlParams_.Set("id", fmt.Sprint(id))
30890 c.eventtag = eventtag
30891 return c
30892 }
30893
30894
30895
30896
30897 func (c *EventTagsPatchCall) Fields(s ...googleapi.Field) *EventTagsPatchCall {
30898 c.urlParams_.Set("fields", googleapi.CombineFields(s))
30899 return c
30900 }
30901
30902
30903
30904
30905 func (c *EventTagsPatchCall) Context(ctx context.Context) *EventTagsPatchCall {
30906 c.ctx_ = ctx
30907 return c
30908 }
30909
30910
30911
30912 func (c *EventTagsPatchCall) Header() http.Header {
30913 if c.header_ == nil {
30914 c.header_ = make(http.Header)
30915 }
30916 return c.header_
30917 }
30918
30919 func (c *EventTagsPatchCall) doRequest(alt string) (*http.Response, error) {
30920 reqHeaders := make(http.Header)
30921 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
30922 for k, v := range c.header_ {
30923 reqHeaders[k] = v
30924 }
30925 reqHeaders.Set("User-Agent", c.s.userAgent())
30926 var body io.Reader = nil
30927 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventtag)
30928 if err != nil {
30929 return nil, err
30930 }
30931 reqHeaders.Set("Content-Type", "application/json")
30932 c.urlParams_.Set("alt", alt)
30933 c.urlParams_.Set("prettyPrint", "false")
30934 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/eventTags")
30935 urls += "?" + c.urlParams_.Encode()
30936 req, err := http.NewRequest("PATCH", urls, body)
30937 if err != nil {
30938 return nil, err
30939 }
30940 req.Header = reqHeaders
30941 googleapi.Expand(req.URL, map[string]string{
30942 "profileId": strconv.FormatInt(c.profileId, 10),
30943 })
30944 return gensupport.SendRequest(c.ctx_, c.s.client, req)
30945 }
30946
30947
30948
30949
30950
30951
30952
30953
30954 func (c *EventTagsPatchCall) Do(opts ...googleapi.CallOption) (*EventTag, error) {
30955 gensupport.SetOptions(c.urlParams_, opts...)
30956 res, err := c.doRequest("json")
30957 if res != nil && res.StatusCode == http.StatusNotModified {
30958 if res.Body != nil {
30959 res.Body.Close()
30960 }
30961 return nil, &googleapi.Error{
30962 Code: res.StatusCode,
30963 Header: res.Header,
30964 }
30965 }
30966 if err != nil {
30967 return nil, err
30968 }
30969 defer googleapi.CloseBody(res)
30970 if err := googleapi.CheckResponse(res); err != nil {
30971 return nil, err
30972 }
30973 ret := &EventTag{
30974 ServerResponse: googleapi.ServerResponse{
30975 Header: res.Header,
30976 HTTPStatusCode: res.StatusCode,
30977 },
30978 }
30979 target := &ret
30980 if err := gensupport.DecodeResponse(target, res); err != nil {
30981 return nil, err
30982 }
30983 return ret, nil
30984
30985
30986
30987
30988
30989
30990
30991
30992
30993
30994
30995
30996
30997
30998
30999
31000
31001
31002
31003
31004
31005
31006
31007
31008
31009
31010
31011
31012
31013
31014
31015
31016
31017
31018
31019
31020 }
31021
31022
31023
31024 type EventTagsUpdateCall struct {
31025 s *Service
31026 profileId int64
31027 eventtag *EventTag
31028 urlParams_ gensupport.URLParams
31029 ctx_ context.Context
31030 header_ http.Header
31031 }
31032
31033
31034 func (r *EventTagsService) Update(profileId int64, eventtag *EventTag) *EventTagsUpdateCall {
31035 c := &EventTagsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
31036 c.profileId = profileId
31037 c.eventtag = eventtag
31038 return c
31039 }
31040
31041
31042
31043
31044 func (c *EventTagsUpdateCall) Fields(s ...googleapi.Field) *EventTagsUpdateCall {
31045 c.urlParams_.Set("fields", googleapi.CombineFields(s))
31046 return c
31047 }
31048
31049
31050
31051
31052 func (c *EventTagsUpdateCall) Context(ctx context.Context) *EventTagsUpdateCall {
31053 c.ctx_ = ctx
31054 return c
31055 }
31056
31057
31058
31059 func (c *EventTagsUpdateCall) Header() http.Header {
31060 if c.header_ == nil {
31061 c.header_ = make(http.Header)
31062 }
31063 return c.header_
31064 }
31065
31066 func (c *EventTagsUpdateCall) doRequest(alt string) (*http.Response, error) {
31067 reqHeaders := make(http.Header)
31068 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
31069 for k, v := range c.header_ {
31070 reqHeaders[k] = v
31071 }
31072 reqHeaders.Set("User-Agent", c.s.userAgent())
31073 var body io.Reader = nil
31074 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventtag)
31075 if err != nil {
31076 return nil, err
31077 }
31078 reqHeaders.Set("Content-Type", "application/json")
31079 c.urlParams_.Set("alt", alt)
31080 c.urlParams_.Set("prettyPrint", "false")
31081 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/eventTags")
31082 urls += "?" + c.urlParams_.Encode()
31083 req, err := http.NewRequest("PUT", urls, body)
31084 if err != nil {
31085 return nil, err
31086 }
31087 req.Header = reqHeaders
31088 googleapi.Expand(req.URL, map[string]string{
31089 "profileId": strconv.FormatInt(c.profileId, 10),
31090 })
31091 return gensupport.SendRequest(c.ctx_, c.s.client, req)
31092 }
31093
31094
31095
31096
31097
31098
31099
31100
31101 func (c *EventTagsUpdateCall) Do(opts ...googleapi.CallOption) (*EventTag, error) {
31102 gensupport.SetOptions(c.urlParams_, opts...)
31103 res, err := c.doRequest("json")
31104 if res != nil && res.StatusCode == http.StatusNotModified {
31105 if res.Body != nil {
31106 res.Body.Close()
31107 }
31108 return nil, &googleapi.Error{
31109 Code: res.StatusCode,
31110 Header: res.Header,
31111 }
31112 }
31113 if err != nil {
31114 return nil, err
31115 }
31116 defer googleapi.CloseBody(res)
31117 if err := googleapi.CheckResponse(res); err != nil {
31118 return nil, err
31119 }
31120 ret := &EventTag{
31121 ServerResponse: googleapi.ServerResponse{
31122 Header: res.Header,
31123 HTTPStatusCode: res.StatusCode,
31124 },
31125 }
31126 target := &ret
31127 if err := gensupport.DecodeResponse(target, res); err != nil {
31128 return nil, err
31129 }
31130 return ret, nil
31131
31132
31133
31134
31135
31136
31137
31138
31139
31140
31141
31142
31143
31144
31145
31146
31147
31148
31149
31150
31151
31152
31153
31154
31155
31156
31157
31158
31159 }
31160
31161
31162
31163 type FilesGetCall struct {
31164 s *Service
31165 reportId int64
31166 fileId int64
31167 urlParams_ gensupport.URLParams
31168 ifNoneMatch_ string
31169 ctx_ context.Context
31170 header_ http.Header
31171 }
31172
31173
31174
31175 func (r *FilesService) Get(reportId int64, fileId int64) *FilesGetCall {
31176 c := &FilesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
31177 c.reportId = reportId
31178 c.fileId = fileId
31179 return c
31180 }
31181
31182
31183
31184
31185 func (c *FilesGetCall) Fields(s ...googleapi.Field) *FilesGetCall {
31186 c.urlParams_.Set("fields", googleapi.CombineFields(s))
31187 return c
31188 }
31189
31190
31191
31192
31193
31194
31195 func (c *FilesGetCall) IfNoneMatch(entityTag string) *FilesGetCall {
31196 c.ifNoneMatch_ = entityTag
31197 return c
31198 }
31199
31200
31201
31202
31203 func (c *FilesGetCall) Context(ctx context.Context) *FilesGetCall {
31204 c.ctx_ = ctx
31205 return c
31206 }
31207
31208
31209
31210 func (c *FilesGetCall) Header() http.Header {
31211 if c.header_ == nil {
31212 c.header_ = make(http.Header)
31213 }
31214 return c.header_
31215 }
31216
31217 func (c *FilesGetCall) doRequest(alt string) (*http.Response, error) {
31218 reqHeaders := make(http.Header)
31219 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
31220 for k, v := range c.header_ {
31221 reqHeaders[k] = v
31222 }
31223 reqHeaders.Set("User-Agent", c.s.userAgent())
31224 if c.ifNoneMatch_ != "" {
31225 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
31226 }
31227 var body io.Reader = nil
31228 c.urlParams_.Set("alt", alt)
31229 c.urlParams_.Set("prettyPrint", "false")
31230 urls := googleapi.ResolveRelative(c.s.BasePath, "reports/{reportId}/files/{fileId}")
31231 urls += "?" + c.urlParams_.Encode()
31232 req, err := http.NewRequest("GET", urls, body)
31233 if err != nil {
31234 return nil, err
31235 }
31236 req.Header = reqHeaders
31237 googleapi.Expand(req.URL, map[string]string{
31238 "reportId": strconv.FormatInt(c.reportId, 10),
31239 "fileId": strconv.FormatInt(c.fileId, 10),
31240 })
31241 return gensupport.SendRequest(c.ctx_, c.s.client, req)
31242 }
31243
31244
31245
31246
31247 func (c *FilesGetCall) Download(opts ...googleapi.CallOption) (*http.Response, error) {
31248 gensupport.SetOptions(c.urlParams_, opts...)
31249 res, err := c.doRequest("media")
31250 if err != nil {
31251 return nil, err
31252 }
31253 if err := googleapi.CheckMediaResponse(res); err != nil {
31254 res.Body.Close()
31255 return nil, err
31256 }
31257 return res, nil
31258 }
31259
31260
31261
31262
31263
31264
31265
31266
31267 func (c *FilesGetCall) Do(opts ...googleapi.CallOption) (*File, error) {
31268 gensupport.SetOptions(c.urlParams_, opts...)
31269 res, err := c.doRequest("json")
31270 if res != nil && res.StatusCode == http.StatusNotModified {
31271 if res.Body != nil {
31272 res.Body.Close()
31273 }
31274 return nil, &googleapi.Error{
31275 Code: res.StatusCode,
31276 Header: res.Header,
31277 }
31278 }
31279 if err != nil {
31280 return nil, err
31281 }
31282 defer googleapi.CloseBody(res)
31283 if err := googleapi.CheckResponse(res); err != nil {
31284 return nil, err
31285 }
31286 ret := &File{
31287 ServerResponse: googleapi.ServerResponse{
31288 Header: res.Header,
31289 HTTPStatusCode: res.StatusCode,
31290 },
31291 }
31292 target := &ret
31293 if err := gensupport.DecodeResponse(target, res); err != nil {
31294 return nil, err
31295 }
31296 return ret, nil
31297
31298
31299
31300
31301
31302
31303
31304
31305
31306
31307
31308
31309
31310
31311
31312
31313
31314
31315
31316
31317
31318
31319
31320
31321
31322
31323
31324
31325
31326
31327
31328
31329
31330
31331 }
31332
31333
31334
31335 type FilesListCall struct {
31336 s *Service
31337 profileId int64
31338 urlParams_ gensupport.URLParams
31339 ifNoneMatch_ string
31340 ctx_ context.Context
31341 header_ http.Header
31342 }
31343
31344
31345 func (r *FilesService) List(profileId int64) *FilesListCall {
31346 c := &FilesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
31347 c.profileId = profileId
31348 return c
31349 }
31350
31351
31352
31353 func (c *FilesListCall) MaxResults(maxResults int64) *FilesListCall {
31354 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
31355 return c
31356 }
31357
31358
31359
31360 func (c *FilesListCall) PageToken(pageToken string) *FilesListCall {
31361 c.urlParams_.Set("pageToken", pageToken)
31362 return c
31363 }
31364
31365
31366
31367
31368
31369
31370
31371
31372
31373 func (c *FilesListCall) Scope(scope string) *FilesListCall {
31374 c.urlParams_.Set("scope", scope)
31375 return c
31376 }
31377
31378
31379
31380
31381
31382
31383
31384
31385 func (c *FilesListCall) SortField(sortField string) *FilesListCall {
31386 c.urlParams_.Set("sortField", sortField)
31387 return c
31388 }
31389
31390
31391
31392
31393
31394
31395
31396
31397 func (c *FilesListCall) SortOrder(sortOrder string) *FilesListCall {
31398 c.urlParams_.Set("sortOrder", sortOrder)
31399 return c
31400 }
31401
31402
31403
31404
31405 func (c *FilesListCall) Fields(s ...googleapi.Field) *FilesListCall {
31406 c.urlParams_.Set("fields", googleapi.CombineFields(s))
31407 return c
31408 }
31409
31410
31411
31412
31413
31414
31415 func (c *FilesListCall) IfNoneMatch(entityTag string) *FilesListCall {
31416 c.ifNoneMatch_ = entityTag
31417 return c
31418 }
31419
31420
31421
31422
31423 func (c *FilesListCall) Context(ctx context.Context) *FilesListCall {
31424 c.ctx_ = ctx
31425 return c
31426 }
31427
31428
31429
31430 func (c *FilesListCall) Header() http.Header {
31431 if c.header_ == nil {
31432 c.header_ = make(http.Header)
31433 }
31434 return c.header_
31435 }
31436
31437 func (c *FilesListCall) doRequest(alt string) (*http.Response, error) {
31438 reqHeaders := make(http.Header)
31439 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
31440 for k, v := range c.header_ {
31441 reqHeaders[k] = v
31442 }
31443 reqHeaders.Set("User-Agent", c.s.userAgent())
31444 if c.ifNoneMatch_ != "" {
31445 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
31446 }
31447 var body io.Reader = nil
31448 c.urlParams_.Set("alt", alt)
31449 c.urlParams_.Set("prettyPrint", "false")
31450 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/files")
31451 urls += "?" + c.urlParams_.Encode()
31452 req, err := http.NewRequest("GET", urls, body)
31453 if err != nil {
31454 return nil, err
31455 }
31456 req.Header = reqHeaders
31457 googleapi.Expand(req.URL, map[string]string{
31458 "profileId": strconv.FormatInt(c.profileId, 10),
31459 })
31460 return gensupport.SendRequest(c.ctx_, c.s.client, req)
31461 }
31462
31463
31464
31465
31466
31467
31468
31469
31470 func (c *FilesListCall) Do(opts ...googleapi.CallOption) (*FileList, error) {
31471 gensupport.SetOptions(c.urlParams_, opts...)
31472 res, err := c.doRequest("json")
31473 if res != nil && res.StatusCode == http.StatusNotModified {
31474 if res.Body != nil {
31475 res.Body.Close()
31476 }
31477 return nil, &googleapi.Error{
31478 Code: res.StatusCode,
31479 Header: res.Header,
31480 }
31481 }
31482 if err != nil {
31483 return nil, err
31484 }
31485 defer googleapi.CloseBody(res)
31486 if err := googleapi.CheckResponse(res); err != nil {
31487 return nil, err
31488 }
31489 ret := &FileList{
31490 ServerResponse: googleapi.ServerResponse{
31491 Header: res.Header,
31492 HTTPStatusCode: res.StatusCode,
31493 },
31494 }
31495 target := &ret
31496 if err := gensupport.DecodeResponse(target, res); err != nil {
31497 return nil, err
31498 }
31499 return ret, nil
31500
31501
31502
31503
31504
31505
31506
31507
31508
31509
31510
31511
31512
31513
31514
31515
31516
31517
31518
31519
31520
31521
31522
31523
31524
31525
31526
31527
31528
31529
31530
31531
31532
31533
31534
31535
31536
31537
31538
31539
31540
31541
31542
31543
31544
31545
31546
31547
31548
31549
31550
31551
31552
31553
31554
31555
31556
31557
31558
31559
31560
31561
31562
31563
31564
31565
31566
31567
31568
31569
31570
31571
31572
31573
31574
31575
31576
31577
31578
31579
31580
31581
31582
31583 }
31584
31585
31586
31587
31588 func (c *FilesListCall) Pages(ctx context.Context, f func(*FileList) error) error {
31589 c.ctx_ = ctx
31590 defer c.PageToken(c.urlParams_.Get("pageToken"))
31591 for {
31592 x, err := c.Do()
31593 if err != nil {
31594 return err
31595 }
31596 if err := f(x); err != nil {
31597 return err
31598 }
31599 if x.NextPageToken == "" {
31600 return nil
31601 }
31602 c.PageToken(x.NextPageToken)
31603 }
31604 }
31605
31606
31607
31608 type FloodlightActivitiesDeleteCall struct {
31609 s *Service
31610 profileId int64
31611 id int64
31612 urlParams_ gensupport.URLParams
31613 ctx_ context.Context
31614 header_ http.Header
31615 }
31616
31617
31618 func (r *FloodlightActivitiesService) Delete(profileId int64, id int64) *FloodlightActivitiesDeleteCall {
31619 c := &FloodlightActivitiesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
31620 c.profileId = profileId
31621 c.id = id
31622 return c
31623 }
31624
31625
31626
31627
31628 func (c *FloodlightActivitiesDeleteCall) Fields(s ...googleapi.Field) *FloodlightActivitiesDeleteCall {
31629 c.urlParams_.Set("fields", googleapi.CombineFields(s))
31630 return c
31631 }
31632
31633
31634
31635
31636 func (c *FloodlightActivitiesDeleteCall) Context(ctx context.Context) *FloodlightActivitiesDeleteCall {
31637 c.ctx_ = ctx
31638 return c
31639 }
31640
31641
31642
31643 func (c *FloodlightActivitiesDeleteCall) Header() http.Header {
31644 if c.header_ == nil {
31645 c.header_ = make(http.Header)
31646 }
31647 return c.header_
31648 }
31649
31650 func (c *FloodlightActivitiesDeleteCall) doRequest(alt string) (*http.Response, error) {
31651 reqHeaders := make(http.Header)
31652 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
31653 for k, v := range c.header_ {
31654 reqHeaders[k] = v
31655 }
31656 reqHeaders.Set("User-Agent", c.s.userAgent())
31657 var body io.Reader = nil
31658 c.urlParams_.Set("alt", alt)
31659 c.urlParams_.Set("prettyPrint", "false")
31660 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivities/{id}")
31661 urls += "?" + c.urlParams_.Encode()
31662 req, err := http.NewRequest("DELETE", urls, body)
31663 if err != nil {
31664 return nil, err
31665 }
31666 req.Header = reqHeaders
31667 googleapi.Expand(req.URL, map[string]string{
31668 "profileId": strconv.FormatInt(c.profileId, 10),
31669 "id": strconv.FormatInt(c.id, 10),
31670 })
31671 return gensupport.SendRequest(c.ctx_, c.s.client, req)
31672 }
31673
31674
31675 func (c *FloodlightActivitiesDeleteCall) Do(opts ...googleapi.CallOption) error {
31676 gensupport.SetOptions(c.urlParams_, opts...)
31677 res, err := c.doRequest("json")
31678 if err != nil {
31679 return err
31680 }
31681 defer googleapi.CloseBody(res)
31682 if err := googleapi.CheckResponse(res); err != nil {
31683 return err
31684 }
31685 return nil
31686
31687
31688
31689
31690
31691
31692
31693
31694
31695
31696
31697
31698
31699
31700
31701
31702
31703
31704
31705
31706
31707
31708
31709
31710
31711
31712
31713
31714
31715
31716 }
31717
31718
31719
31720 type FloodlightActivitiesGeneratetagCall struct {
31721 s *Service
31722 profileId int64
31723 urlParams_ gensupport.URLParams
31724 ctx_ context.Context
31725 header_ http.Header
31726 }
31727
31728
31729 func (r *FloodlightActivitiesService) Generatetag(profileId int64) *FloodlightActivitiesGeneratetagCall {
31730 c := &FloodlightActivitiesGeneratetagCall{s: r.s, urlParams_: make(gensupport.URLParams)}
31731 c.profileId = profileId
31732 return c
31733 }
31734
31735
31736
31737
31738 func (c *FloodlightActivitiesGeneratetagCall) FloodlightActivityId(floodlightActivityId int64) *FloodlightActivitiesGeneratetagCall {
31739 c.urlParams_.Set("floodlightActivityId", fmt.Sprint(floodlightActivityId))
31740 return c
31741 }
31742
31743
31744
31745
31746 func (c *FloodlightActivitiesGeneratetagCall) Fields(s ...googleapi.Field) *FloodlightActivitiesGeneratetagCall {
31747 c.urlParams_.Set("fields", googleapi.CombineFields(s))
31748 return c
31749 }
31750
31751
31752
31753
31754 func (c *FloodlightActivitiesGeneratetagCall) Context(ctx context.Context) *FloodlightActivitiesGeneratetagCall {
31755 c.ctx_ = ctx
31756 return c
31757 }
31758
31759
31760
31761 func (c *FloodlightActivitiesGeneratetagCall) Header() http.Header {
31762 if c.header_ == nil {
31763 c.header_ = make(http.Header)
31764 }
31765 return c.header_
31766 }
31767
31768 func (c *FloodlightActivitiesGeneratetagCall) doRequest(alt string) (*http.Response, error) {
31769 reqHeaders := make(http.Header)
31770 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
31771 for k, v := range c.header_ {
31772 reqHeaders[k] = v
31773 }
31774 reqHeaders.Set("User-Agent", c.s.userAgent())
31775 var body io.Reader = nil
31776 c.urlParams_.Set("alt", alt)
31777 c.urlParams_.Set("prettyPrint", "false")
31778 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivities/generatetag")
31779 urls += "?" + c.urlParams_.Encode()
31780 req, err := http.NewRequest("POST", urls, body)
31781 if err != nil {
31782 return nil, err
31783 }
31784 req.Header = reqHeaders
31785 googleapi.Expand(req.URL, map[string]string{
31786 "profileId": strconv.FormatInt(c.profileId, 10),
31787 })
31788 return gensupport.SendRequest(c.ctx_, c.s.client, req)
31789 }
31790
31791
31792
31793
31794
31795
31796
31797
31798
31799 func (c *FloodlightActivitiesGeneratetagCall) Do(opts ...googleapi.CallOption) (*FloodlightActivitiesGenerateTagResponse, error) {
31800 gensupport.SetOptions(c.urlParams_, opts...)
31801 res, err := c.doRequest("json")
31802 if res != nil && res.StatusCode == http.StatusNotModified {
31803 if res.Body != nil {
31804 res.Body.Close()
31805 }
31806 return nil, &googleapi.Error{
31807 Code: res.StatusCode,
31808 Header: res.Header,
31809 }
31810 }
31811 if err != nil {
31812 return nil, err
31813 }
31814 defer googleapi.CloseBody(res)
31815 if err := googleapi.CheckResponse(res); err != nil {
31816 return nil, err
31817 }
31818 ret := &FloodlightActivitiesGenerateTagResponse{
31819 ServerResponse: googleapi.ServerResponse{
31820 Header: res.Header,
31821 HTTPStatusCode: res.StatusCode,
31822 },
31823 }
31824 target := &ret
31825 if err := gensupport.DecodeResponse(target, res); err != nil {
31826 return nil, err
31827 }
31828 return ret, nil
31829
31830
31831
31832
31833
31834
31835
31836
31837
31838
31839
31840
31841
31842
31843
31844
31845
31846
31847
31848
31849
31850
31851
31852
31853
31854
31855
31856
31857
31858
31859
31860 }
31861
31862
31863
31864 type FloodlightActivitiesGetCall struct {
31865 s *Service
31866 profileId int64
31867 id int64
31868 urlParams_ gensupport.URLParams
31869 ifNoneMatch_ string
31870 ctx_ context.Context
31871 header_ http.Header
31872 }
31873
31874
31875 func (r *FloodlightActivitiesService) Get(profileId int64, id int64) *FloodlightActivitiesGetCall {
31876 c := &FloodlightActivitiesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
31877 c.profileId = profileId
31878 c.id = id
31879 return c
31880 }
31881
31882
31883
31884
31885 func (c *FloodlightActivitiesGetCall) Fields(s ...googleapi.Field) *FloodlightActivitiesGetCall {
31886 c.urlParams_.Set("fields", googleapi.CombineFields(s))
31887 return c
31888 }
31889
31890
31891
31892
31893
31894
31895 func (c *FloodlightActivitiesGetCall) IfNoneMatch(entityTag string) *FloodlightActivitiesGetCall {
31896 c.ifNoneMatch_ = entityTag
31897 return c
31898 }
31899
31900
31901
31902
31903 func (c *FloodlightActivitiesGetCall) Context(ctx context.Context) *FloodlightActivitiesGetCall {
31904 c.ctx_ = ctx
31905 return c
31906 }
31907
31908
31909
31910 func (c *FloodlightActivitiesGetCall) Header() http.Header {
31911 if c.header_ == nil {
31912 c.header_ = make(http.Header)
31913 }
31914 return c.header_
31915 }
31916
31917 func (c *FloodlightActivitiesGetCall) doRequest(alt string) (*http.Response, error) {
31918 reqHeaders := make(http.Header)
31919 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
31920 for k, v := range c.header_ {
31921 reqHeaders[k] = v
31922 }
31923 reqHeaders.Set("User-Agent", c.s.userAgent())
31924 if c.ifNoneMatch_ != "" {
31925 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
31926 }
31927 var body io.Reader = nil
31928 c.urlParams_.Set("alt", alt)
31929 c.urlParams_.Set("prettyPrint", "false")
31930 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivities/{id}")
31931 urls += "?" + c.urlParams_.Encode()
31932 req, err := http.NewRequest("GET", urls, body)
31933 if err != nil {
31934 return nil, err
31935 }
31936 req.Header = reqHeaders
31937 googleapi.Expand(req.URL, map[string]string{
31938 "profileId": strconv.FormatInt(c.profileId, 10),
31939 "id": strconv.FormatInt(c.id, 10),
31940 })
31941 return gensupport.SendRequest(c.ctx_, c.s.client, req)
31942 }
31943
31944
31945
31946
31947
31948
31949
31950
31951 func (c *FloodlightActivitiesGetCall) Do(opts ...googleapi.CallOption) (*FloodlightActivity, error) {
31952 gensupport.SetOptions(c.urlParams_, opts...)
31953 res, err := c.doRequest("json")
31954 if res != nil && res.StatusCode == http.StatusNotModified {
31955 if res.Body != nil {
31956 res.Body.Close()
31957 }
31958 return nil, &googleapi.Error{
31959 Code: res.StatusCode,
31960 Header: res.Header,
31961 }
31962 }
31963 if err != nil {
31964 return nil, err
31965 }
31966 defer googleapi.CloseBody(res)
31967 if err := googleapi.CheckResponse(res); err != nil {
31968 return nil, err
31969 }
31970 ret := &FloodlightActivity{
31971 ServerResponse: googleapi.ServerResponse{
31972 Header: res.Header,
31973 HTTPStatusCode: res.StatusCode,
31974 },
31975 }
31976 target := &ret
31977 if err := gensupport.DecodeResponse(target, res); err != nil {
31978 return nil, err
31979 }
31980 return ret, nil
31981
31982
31983
31984
31985
31986
31987
31988
31989
31990
31991
31992
31993
31994
31995
31996
31997
31998
31999
32000
32001
32002
32003
32004
32005
32006
32007
32008
32009
32010
32011
32012
32013
32014 }
32015
32016
32017
32018 type FloodlightActivitiesInsertCall struct {
32019 s *Service
32020 profileId int64
32021 floodlightactivity *FloodlightActivity
32022 urlParams_ gensupport.URLParams
32023 ctx_ context.Context
32024 header_ http.Header
32025 }
32026
32027
32028 func (r *FloodlightActivitiesService) Insert(profileId int64, floodlightactivity *FloodlightActivity) *FloodlightActivitiesInsertCall {
32029 c := &FloodlightActivitiesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
32030 c.profileId = profileId
32031 c.floodlightactivity = floodlightactivity
32032 return c
32033 }
32034
32035
32036
32037
32038 func (c *FloodlightActivitiesInsertCall) Fields(s ...googleapi.Field) *FloodlightActivitiesInsertCall {
32039 c.urlParams_.Set("fields", googleapi.CombineFields(s))
32040 return c
32041 }
32042
32043
32044
32045
32046 func (c *FloodlightActivitiesInsertCall) Context(ctx context.Context) *FloodlightActivitiesInsertCall {
32047 c.ctx_ = ctx
32048 return c
32049 }
32050
32051
32052
32053 func (c *FloodlightActivitiesInsertCall) Header() http.Header {
32054 if c.header_ == nil {
32055 c.header_ = make(http.Header)
32056 }
32057 return c.header_
32058 }
32059
32060 func (c *FloodlightActivitiesInsertCall) doRequest(alt string) (*http.Response, error) {
32061 reqHeaders := make(http.Header)
32062 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
32063 for k, v := range c.header_ {
32064 reqHeaders[k] = v
32065 }
32066 reqHeaders.Set("User-Agent", c.s.userAgent())
32067 var body io.Reader = nil
32068 body, err := googleapi.WithoutDataWrapper.JSONReader(c.floodlightactivity)
32069 if err != nil {
32070 return nil, err
32071 }
32072 reqHeaders.Set("Content-Type", "application/json")
32073 c.urlParams_.Set("alt", alt)
32074 c.urlParams_.Set("prettyPrint", "false")
32075 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivities")
32076 urls += "?" + c.urlParams_.Encode()
32077 req, err := http.NewRequest("POST", urls, body)
32078 if err != nil {
32079 return nil, err
32080 }
32081 req.Header = reqHeaders
32082 googleapi.Expand(req.URL, map[string]string{
32083 "profileId": strconv.FormatInt(c.profileId, 10),
32084 })
32085 return gensupport.SendRequest(c.ctx_, c.s.client, req)
32086 }
32087
32088
32089
32090
32091
32092
32093
32094
32095 func (c *FloodlightActivitiesInsertCall) Do(opts ...googleapi.CallOption) (*FloodlightActivity, error) {
32096 gensupport.SetOptions(c.urlParams_, opts...)
32097 res, err := c.doRequest("json")
32098 if res != nil && res.StatusCode == http.StatusNotModified {
32099 if res.Body != nil {
32100 res.Body.Close()
32101 }
32102 return nil, &googleapi.Error{
32103 Code: res.StatusCode,
32104 Header: res.Header,
32105 }
32106 }
32107 if err != nil {
32108 return nil, err
32109 }
32110 defer googleapi.CloseBody(res)
32111 if err := googleapi.CheckResponse(res); err != nil {
32112 return nil, err
32113 }
32114 ret := &FloodlightActivity{
32115 ServerResponse: googleapi.ServerResponse{
32116 Header: res.Header,
32117 HTTPStatusCode: res.StatusCode,
32118 },
32119 }
32120 target := &ret
32121 if err := gensupport.DecodeResponse(target, res); err != nil {
32122 return nil, err
32123 }
32124 return ret, nil
32125
32126
32127
32128
32129
32130
32131
32132
32133
32134
32135
32136
32137
32138
32139
32140
32141
32142
32143
32144
32145
32146
32147
32148
32149
32150
32151
32152
32153 }
32154
32155
32156
32157 type FloodlightActivitiesListCall struct {
32158 s *Service
32159 profileId int64
32160 urlParams_ gensupport.URLParams
32161 ifNoneMatch_ string
32162 ctx_ context.Context
32163 header_ http.Header
32164 }
32165
32166
32167
32168 func (r *FloodlightActivitiesService) List(profileId int64) *FloodlightActivitiesListCall {
32169 c := &FloodlightActivitiesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
32170 c.profileId = profileId
32171 return c
32172 }
32173
32174
32175
32176
32177
32178 func (c *FloodlightActivitiesListCall) AdvertiserId(advertiserId int64) *FloodlightActivitiesListCall {
32179 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
32180 return c
32181 }
32182
32183
32184
32185
32186 func (c *FloodlightActivitiesListCall) FloodlightActivityGroupIds(floodlightActivityGroupIds ...int64) *FloodlightActivitiesListCall {
32187 var floodlightActivityGroupIds_ []string
32188 for _, v := range floodlightActivityGroupIds {
32189 floodlightActivityGroupIds_ = append(floodlightActivityGroupIds_, fmt.Sprint(v))
32190 }
32191 c.urlParams_.SetMulti("floodlightActivityGroupIds", floodlightActivityGroupIds_)
32192 return c
32193 }
32194
32195
32196
32197
32198 func (c *FloodlightActivitiesListCall) FloodlightActivityGroupName(floodlightActivityGroupName string) *FloodlightActivitiesListCall {
32199 c.urlParams_.Set("floodlightActivityGroupName", floodlightActivityGroupName)
32200 return c
32201 }
32202
32203
32204
32205
32206 func (c *FloodlightActivitiesListCall) FloodlightActivityGroupTagString(floodlightActivityGroupTagString string) *FloodlightActivitiesListCall {
32207 c.urlParams_.Set("floodlightActivityGroupTagString", floodlightActivityGroupTagString)
32208 return c
32209 }
32210
32211
32212
32213
32214
32215
32216
32217
32218
32219 func (c *FloodlightActivitiesListCall) FloodlightActivityGroupType(floodlightActivityGroupType string) *FloodlightActivitiesListCall {
32220 c.urlParams_.Set("floodlightActivityGroupType", floodlightActivityGroupType)
32221 return c
32222 }
32223
32224
32225
32226
32227
32228 func (c *FloodlightActivitiesListCall) FloodlightConfigurationId(floodlightConfigurationId int64) *FloodlightActivitiesListCall {
32229 c.urlParams_.Set("floodlightConfigurationId", fmt.Sprint(floodlightConfigurationId))
32230 return c
32231 }
32232
32233
32234
32235
32236 func (c *FloodlightActivitiesListCall) Ids(ids ...int64) *FloodlightActivitiesListCall {
32237 var ids_ []string
32238 for _, v := range ids {
32239 ids_ = append(ids_, fmt.Sprint(v))
32240 }
32241 c.urlParams_.SetMulti("ids", ids_)
32242 return c
32243 }
32244
32245
32246
32247 func (c *FloodlightActivitiesListCall) MaxResults(maxResults int64) *FloodlightActivitiesListCall {
32248 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
32249 return c
32250 }
32251
32252
32253
32254 func (c *FloodlightActivitiesListCall) PageToken(pageToken string) *FloodlightActivitiesListCall {
32255 c.urlParams_.Set("pageToken", pageToken)
32256 return c
32257 }
32258
32259
32260
32261
32262
32263
32264
32265
32266
32267
32268 func (c *FloodlightActivitiesListCall) SearchString(searchString string) *FloodlightActivitiesListCall {
32269 c.urlParams_.Set("searchString", searchString)
32270 return c
32271 }
32272
32273
32274
32275
32276
32277
32278
32279
32280 func (c *FloodlightActivitiesListCall) SortField(sortField string) *FloodlightActivitiesListCall {
32281 c.urlParams_.Set("sortField", sortField)
32282 return c
32283 }
32284
32285
32286
32287
32288
32289
32290
32291
32292 func (c *FloodlightActivitiesListCall) SortOrder(sortOrder string) *FloodlightActivitiesListCall {
32293 c.urlParams_.Set("sortOrder", sortOrder)
32294 return c
32295 }
32296
32297
32298
32299 func (c *FloodlightActivitiesListCall) TagString(tagString string) *FloodlightActivitiesListCall {
32300 c.urlParams_.Set("tagString", tagString)
32301 return c
32302 }
32303
32304
32305
32306
32307 func (c *FloodlightActivitiesListCall) Fields(s ...googleapi.Field) *FloodlightActivitiesListCall {
32308 c.urlParams_.Set("fields", googleapi.CombineFields(s))
32309 return c
32310 }
32311
32312
32313
32314
32315
32316
32317 func (c *FloodlightActivitiesListCall) IfNoneMatch(entityTag string) *FloodlightActivitiesListCall {
32318 c.ifNoneMatch_ = entityTag
32319 return c
32320 }
32321
32322
32323
32324
32325 func (c *FloodlightActivitiesListCall) Context(ctx context.Context) *FloodlightActivitiesListCall {
32326 c.ctx_ = ctx
32327 return c
32328 }
32329
32330
32331
32332 func (c *FloodlightActivitiesListCall) Header() http.Header {
32333 if c.header_ == nil {
32334 c.header_ = make(http.Header)
32335 }
32336 return c.header_
32337 }
32338
32339 func (c *FloodlightActivitiesListCall) doRequest(alt string) (*http.Response, error) {
32340 reqHeaders := make(http.Header)
32341 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
32342 for k, v := range c.header_ {
32343 reqHeaders[k] = v
32344 }
32345 reqHeaders.Set("User-Agent", c.s.userAgent())
32346 if c.ifNoneMatch_ != "" {
32347 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
32348 }
32349 var body io.Reader = nil
32350 c.urlParams_.Set("alt", alt)
32351 c.urlParams_.Set("prettyPrint", "false")
32352 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivities")
32353 urls += "?" + c.urlParams_.Encode()
32354 req, err := http.NewRequest("GET", urls, body)
32355 if err != nil {
32356 return nil, err
32357 }
32358 req.Header = reqHeaders
32359 googleapi.Expand(req.URL, map[string]string{
32360 "profileId": strconv.FormatInt(c.profileId, 10),
32361 })
32362 return gensupport.SendRequest(c.ctx_, c.s.client, req)
32363 }
32364
32365
32366
32367
32368
32369
32370
32371
32372 func (c *FloodlightActivitiesListCall) Do(opts ...googleapi.CallOption) (*FloodlightActivitiesListResponse, error) {
32373 gensupport.SetOptions(c.urlParams_, opts...)
32374 res, err := c.doRequest("json")
32375 if res != nil && res.StatusCode == http.StatusNotModified {
32376 if res.Body != nil {
32377 res.Body.Close()
32378 }
32379 return nil, &googleapi.Error{
32380 Code: res.StatusCode,
32381 Header: res.Header,
32382 }
32383 }
32384 if err != nil {
32385 return nil, err
32386 }
32387 defer googleapi.CloseBody(res)
32388 if err := googleapi.CheckResponse(res); err != nil {
32389 return nil, err
32390 }
32391 ret := &FloodlightActivitiesListResponse{
32392 ServerResponse: googleapi.ServerResponse{
32393 Header: res.Header,
32394 HTTPStatusCode: res.StatusCode,
32395 },
32396 }
32397 target := &ret
32398 if err := gensupport.DecodeResponse(target, res); err != nil {
32399 return nil, err
32400 }
32401 return ret, nil
32402
32403
32404
32405
32406
32407
32408
32409
32410
32411
32412
32413
32414
32415
32416
32417
32418
32419
32420
32421
32422
32423
32424
32425
32426
32427
32428
32429
32430
32431
32432
32433
32434
32435
32436
32437
32438
32439
32440
32441
32442
32443
32444
32445
32446
32447
32448
32449
32450
32451
32452
32453
32454
32455
32456
32457
32458
32459
32460
32461
32462
32463
32464
32465
32466
32467
32468
32469
32470
32471
32472
32473
32474
32475
32476
32477
32478
32479
32480
32481
32482
32483
32484
32485
32486
32487
32488
32489
32490
32491
32492
32493
32494
32495
32496
32497
32498
32499
32500
32501
32502
32503
32504
32505
32506
32507
32508
32509
32510
32511
32512
32513
32514
32515
32516
32517
32518
32519
32520
32521
32522
32523
32524
32525
32526
32527
32528 }
32529
32530
32531
32532
32533 func (c *FloodlightActivitiesListCall) Pages(ctx context.Context, f func(*FloodlightActivitiesListResponse) error) error {
32534 c.ctx_ = ctx
32535 defer c.PageToken(c.urlParams_.Get("pageToken"))
32536 for {
32537 x, err := c.Do()
32538 if err != nil {
32539 return err
32540 }
32541 if err := f(x); err != nil {
32542 return err
32543 }
32544 if x.NextPageToken == "" {
32545 return nil
32546 }
32547 c.PageToken(x.NextPageToken)
32548 }
32549 }
32550
32551
32552
32553 type FloodlightActivitiesPatchCall struct {
32554 s *Service
32555 profileId int64
32556 floodlightactivity *FloodlightActivity
32557 urlParams_ gensupport.URLParams
32558 ctx_ context.Context
32559 header_ http.Header
32560 }
32561
32562
32563
32564 func (r *FloodlightActivitiesService) Patch(profileId int64, id int64, floodlightactivity *FloodlightActivity) *FloodlightActivitiesPatchCall {
32565 c := &FloodlightActivitiesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
32566 c.profileId = profileId
32567 c.urlParams_.Set("id", fmt.Sprint(id))
32568 c.floodlightactivity = floodlightactivity
32569 return c
32570 }
32571
32572
32573
32574
32575 func (c *FloodlightActivitiesPatchCall) Fields(s ...googleapi.Field) *FloodlightActivitiesPatchCall {
32576 c.urlParams_.Set("fields", googleapi.CombineFields(s))
32577 return c
32578 }
32579
32580
32581
32582
32583 func (c *FloodlightActivitiesPatchCall) Context(ctx context.Context) *FloodlightActivitiesPatchCall {
32584 c.ctx_ = ctx
32585 return c
32586 }
32587
32588
32589
32590 func (c *FloodlightActivitiesPatchCall) Header() http.Header {
32591 if c.header_ == nil {
32592 c.header_ = make(http.Header)
32593 }
32594 return c.header_
32595 }
32596
32597 func (c *FloodlightActivitiesPatchCall) doRequest(alt string) (*http.Response, error) {
32598 reqHeaders := make(http.Header)
32599 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
32600 for k, v := range c.header_ {
32601 reqHeaders[k] = v
32602 }
32603 reqHeaders.Set("User-Agent", c.s.userAgent())
32604 var body io.Reader = nil
32605 body, err := googleapi.WithoutDataWrapper.JSONReader(c.floodlightactivity)
32606 if err != nil {
32607 return nil, err
32608 }
32609 reqHeaders.Set("Content-Type", "application/json")
32610 c.urlParams_.Set("alt", alt)
32611 c.urlParams_.Set("prettyPrint", "false")
32612 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivities")
32613 urls += "?" + c.urlParams_.Encode()
32614 req, err := http.NewRequest("PATCH", urls, body)
32615 if err != nil {
32616 return nil, err
32617 }
32618 req.Header = reqHeaders
32619 googleapi.Expand(req.URL, map[string]string{
32620 "profileId": strconv.FormatInt(c.profileId, 10),
32621 })
32622 return gensupport.SendRequest(c.ctx_, c.s.client, req)
32623 }
32624
32625
32626
32627
32628
32629
32630
32631
32632 func (c *FloodlightActivitiesPatchCall) Do(opts ...googleapi.CallOption) (*FloodlightActivity, error) {
32633 gensupport.SetOptions(c.urlParams_, opts...)
32634 res, err := c.doRequest("json")
32635 if res != nil && res.StatusCode == http.StatusNotModified {
32636 if res.Body != nil {
32637 res.Body.Close()
32638 }
32639 return nil, &googleapi.Error{
32640 Code: res.StatusCode,
32641 Header: res.Header,
32642 }
32643 }
32644 if err != nil {
32645 return nil, err
32646 }
32647 defer googleapi.CloseBody(res)
32648 if err := googleapi.CheckResponse(res); err != nil {
32649 return nil, err
32650 }
32651 ret := &FloodlightActivity{
32652 ServerResponse: googleapi.ServerResponse{
32653 Header: res.Header,
32654 HTTPStatusCode: res.StatusCode,
32655 },
32656 }
32657 target := &ret
32658 if err := gensupport.DecodeResponse(target, res); err != nil {
32659 return nil, err
32660 }
32661 return ret, nil
32662
32663
32664
32665
32666
32667
32668
32669
32670
32671
32672
32673
32674
32675
32676
32677
32678
32679
32680
32681
32682
32683
32684
32685
32686
32687
32688
32689
32690
32691
32692
32693
32694
32695
32696
32697
32698 }
32699
32700
32701
32702 type FloodlightActivitiesUpdateCall struct {
32703 s *Service
32704 profileId int64
32705 floodlightactivity *FloodlightActivity
32706 urlParams_ gensupport.URLParams
32707 ctx_ context.Context
32708 header_ http.Header
32709 }
32710
32711
32712 func (r *FloodlightActivitiesService) Update(profileId int64, floodlightactivity *FloodlightActivity) *FloodlightActivitiesUpdateCall {
32713 c := &FloodlightActivitiesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
32714 c.profileId = profileId
32715 c.floodlightactivity = floodlightactivity
32716 return c
32717 }
32718
32719
32720
32721
32722 func (c *FloodlightActivitiesUpdateCall) Fields(s ...googleapi.Field) *FloodlightActivitiesUpdateCall {
32723 c.urlParams_.Set("fields", googleapi.CombineFields(s))
32724 return c
32725 }
32726
32727
32728
32729
32730 func (c *FloodlightActivitiesUpdateCall) Context(ctx context.Context) *FloodlightActivitiesUpdateCall {
32731 c.ctx_ = ctx
32732 return c
32733 }
32734
32735
32736
32737 func (c *FloodlightActivitiesUpdateCall) Header() http.Header {
32738 if c.header_ == nil {
32739 c.header_ = make(http.Header)
32740 }
32741 return c.header_
32742 }
32743
32744 func (c *FloodlightActivitiesUpdateCall) doRequest(alt string) (*http.Response, error) {
32745 reqHeaders := make(http.Header)
32746 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
32747 for k, v := range c.header_ {
32748 reqHeaders[k] = v
32749 }
32750 reqHeaders.Set("User-Agent", c.s.userAgent())
32751 var body io.Reader = nil
32752 body, err := googleapi.WithoutDataWrapper.JSONReader(c.floodlightactivity)
32753 if err != nil {
32754 return nil, err
32755 }
32756 reqHeaders.Set("Content-Type", "application/json")
32757 c.urlParams_.Set("alt", alt)
32758 c.urlParams_.Set("prettyPrint", "false")
32759 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivities")
32760 urls += "?" + c.urlParams_.Encode()
32761 req, err := http.NewRequest("PUT", urls, body)
32762 if err != nil {
32763 return nil, err
32764 }
32765 req.Header = reqHeaders
32766 googleapi.Expand(req.URL, map[string]string{
32767 "profileId": strconv.FormatInt(c.profileId, 10),
32768 })
32769 return gensupport.SendRequest(c.ctx_, c.s.client, req)
32770 }
32771
32772
32773
32774
32775
32776
32777
32778
32779 func (c *FloodlightActivitiesUpdateCall) Do(opts ...googleapi.CallOption) (*FloodlightActivity, error) {
32780 gensupport.SetOptions(c.urlParams_, opts...)
32781 res, err := c.doRequest("json")
32782 if res != nil && res.StatusCode == http.StatusNotModified {
32783 if res.Body != nil {
32784 res.Body.Close()
32785 }
32786 return nil, &googleapi.Error{
32787 Code: res.StatusCode,
32788 Header: res.Header,
32789 }
32790 }
32791 if err != nil {
32792 return nil, err
32793 }
32794 defer googleapi.CloseBody(res)
32795 if err := googleapi.CheckResponse(res); err != nil {
32796 return nil, err
32797 }
32798 ret := &FloodlightActivity{
32799 ServerResponse: googleapi.ServerResponse{
32800 Header: res.Header,
32801 HTTPStatusCode: res.StatusCode,
32802 },
32803 }
32804 target := &ret
32805 if err := gensupport.DecodeResponse(target, res); err != nil {
32806 return nil, err
32807 }
32808 return ret, nil
32809
32810
32811
32812
32813
32814
32815
32816
32817
32818
32819
32820
32821
32822
32823
32824
32825
32826
32827
32828
32829
32830
32831
32832
32833
32834
32835
32836
32837 }
32838
32839
32840
32841 type FloodlightActivityGroupsGetCall struct {
32842 s *Service
32843 profileId int64
32844 id int64
32845 urlParams_ gensupport.URLParams
32846 ifNoneMatch_ string
32847 ctx_ context.Context
32848 header_ http.Header
32849 }
32850
32851
32852 func (r *FloodlightActivityGroupsService) Get(profileId int64, id int64) *FloodlightActivityGroupsGetCall {
32853 c := &FloodlightActivityGroupsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
32854 c.profileId = profileId
32855 c.id = id
32856 return c
32857 }
32858
32859
32860
32861
32862 func (c *FloodlightActivityGroupsGetCall) Fields(s ...googleapi.Field) *FloodlightActivityGroupsGetCall {
32863 c.urlParams_.Set("fields", googleapi.CombineFields(s))
32864 return c
32865 }
32866
32867
32868
32869
32870
32871
32872 func (c *FloodlightActivityGroupsGetCall) IfNoneMatch(entityTag string) *FloodlightActivityGroupsGetCall {
32873 c.ifNoneMatch_ = entityTag
32874 return c
32875 }
32876
32877
32878
32879
32880 func (c *FloodlightActivityGroupsGetCall) Context(ctx context.Context) *FloodlightActivityGroupsGetCall {
32881 c.ctx_ = ctx
32882 return c
32883 }
32884
32885
32886
32887 func (c *FloodlightActivityGroupsGetCall) Header() http.Header {
32888 if c.header_ == nil {
32889 c.header_ = make(http.Header)
32890 }
32891 return c.header_
32892 }
32893
32894 func (c *FloodlightActivityGroupsGetCall) doRequest(alt string) (*http.Response, error) {
32895 reqHeaders := make(http.Header)
32896 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
32897 for k, v := range c.header_ {
32898 reqHeaders[k] = v
32899 }
32900 reqHeaders.Set("User-Agent", c.s.userAgent())
32901 if c.ifNoneMatch_ != "" {
32902 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
32903 }
32904 var body io.Reader = nil
32905 c.urlParams_.Set("alt", alt)
32906 c.urlParams_.Set("prettyPrint", "false")
32907 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivityGroups/{id}")
32908 urls += "?" + c.urlParams_.Encode()
32909 req, err := http.NewRequest("GET", urls, body)
32910 if err != nil {
32911 return nil, err
32912 }
32913 req.Header = reqHeaders
32914 googleapi.Expand(req.URL, map[string]string{
32915 "profileId": strconv.FormatInt(c.profileId, 10),
32916 "id": strconv.FormatInt(c.id, 10),
32917 })
32918 return gensupport.SendRequest(c.ctx_, c.s.client, req)
32919 }
32920
32921
32922
32923
32924
32925
32926
32927
32928 func (c *FloodlightActivityGroupsGetCall) Do(opts ...googleapi.CallOption) (*FloodlightActivityGroup, error) {
32929 gensupport.SetOptions(c.urlParams_, opts...)
32930 res, err := c.doRequest("json")
32931 if res != nil && res.StatusCode == http.StatusNotModified {
32932 if res.Body != nil {
32933 res.Body.Close()
32934 }
32935 return nil, &googleapi.Error{
32936 Code: res.StatusCode,
32937 Header: res.Header,
32938 }
32939 }
32940 if err != nil {
32941 return nil, err
32942 }
32943 defer googleapi.CloseBody(res)
32944 if err := googleapi.CheckResponse(res); err != nil {
32945 return nil, err
32946 }
32947 ret := &FloodlightActivityGroup{
32948 ServerResponse: googleapi.ServerResponse{
32949 Header: res.Header,
32950 HTTPStatusCode: res.StatusCode,
32951 },
32952 }
32953 target := &ret
32954 if err := gensupport.DecodeResponse(target, res); err != nil {
32955 return nil, err
32956 }
32957 return ret, nil
32958
32959
32960
32961
32962
32963
32964
32965
32966
32967
32968
32969
32970
32971
32972
32973
32974
32975
32976
32977
32978
32979
32980
32981
32982
32983
32984
32985
32986
32987
32988
32989
32990
32991 }
32992
32993
32994
32995 type FloodlightActivityGroupsInsertCall struct {
32996 s *Service
32997 profileId int64
32998 floodlightactivitygroup *FloodlightActivityGroup
32999 urlParams_ gensupport.URLParams
33000 ctx_ context.Context
33001 header_ http.Header
33002 }
33003
33004
33005 func (r *FloodlightActivityGroupsService) Insert(profileId int64, floodlightactivitygroup *FloodlightActivityGroup) *FloodlightActivityGroupsInsertCall {
33006 c := &FloodlightActivityGroupsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
33007 c.profileId = profileId
33008 c.floodlightactivitygroup = floodlightactivitygroup
33009 return c
33010 }
33011
33012
33013
33014
33015 func (c *FloodlightActivityGroupsInsertCall) Fields(s ...googleapi.Field) *FloodlightActivityGroupsInsertCall {
33016 c.urlParams_.Set("fields", googleapi.CombineFields(s))
33017 return c
33018 }
33019
33020
33021
33022
33023 func (c *FloodlightActivityGroupsInsertCall) Context(ctx context.Context) *FloodlightActivityGroupsInsertCall {
33024 c.ctx_ = ctx
33025 return c
33026 }
33027
33028
33029
33030 func (c *FloodlightActivityGroupsInsertCall) Header() http.Header {
33031 if c.header_ == nil {
33032 c.header_ = make(http.Header)
33033 }
33034 return c.header_
33035 }
33036
33037 func (c *FloodlightActivityGroupsInsertCall) doRequest(alt string) (*http.Response, error) {
33038 reqHeaders := make(http.Header)
33039 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
33040 for k, v := range c.header_ {
33041 reqHeaders[k] = v
33042 }
33043 reqHeaders.Set("User-Agent", c.s.userAgent())
33044 var body io.Reader = nil
33045 body, err := googleapi.WithoutDataWrapper.JSONReader(c.floodlightactivitygroup)
33046 if err != nil {
33047 return nil, err
33048 }
33049 reqHeaders.Set("Content-Type", "application/json")
33050 c.urlParams_.Set("alt", alt)
33051 c.urlParams_.Set("prettyPrint", "false")
33052 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivityGroups")
33053 urls += "?" + c.urlParams_.Encode()
33054 req, err := http.NewRequest("POST", urls, body)
33055 if err != nil {
33056 return nil, err
33057 }
33058 req.Header = reqHeaders
33059 googleapi.Expand(req.URL, map[string]string{
33060 "profileId": strconv.FormatInt(c.profileId, 10),
33061 })
33062 return gensupport.SendRequest(c.ctx_, c.s.client, req)
33063 }
33064
33065
33066
33067
33068
33069
33070
33071
33072 func (c *FloodlightActivityGroupsInsertCall) Do(opts ...googleapi.CallOption) (*FloodlightActivityGroup, error) {
33073 gensupport.SetOptions(c.urlParams_, opts...)
33074 res, err := c.doRequest("json")
33075 if res != nil && res.StatusCode == http.StatusNotModified {
33076 if res.Body != nil {
33077 res.Body.Close()
33078 }
33079 return nil, &googleapi.Error{
33080 Code: res.StatusCode,
33081 Header: res.Header,
33082 }
33083 }
33084 if err != nil {
33085 return nil, err
33086 }
33087 defer googleapi.CloseBody(res)
33088 if err := googleapi.CheckResponse(res); err != nil {
33089 return nil, err
33090 }
33091 ret := &FloodlightActivityGroup{
33092 ServerResponse: googleapi.ServerResponse{
33093 Header: res.Header,
33094 HTTPStatusCode: res.StatusCode,
33095 },
33096 }
33097 target := &ret
33098 if err := gensupport.DecodeResponse(target, res); err != nil {
33099 return nil, err
33100 }
33101 return ret, nil
33102
33103
33104
33105
33106
33107
33108
33109
33110
33111
33112
33113
33114
33115
33116
33117
33118
33119
33120
33121
33122
33123
33124
33125
33126
33127
33128
33129
33130 }
33131
33132
33133
33134 type FloodlightActivityGroupsListCall struct {
33135 s *Service
33136 profileId int64
33137 urlParams_ gensupport.URLParams
33138 ifNoneMatch_ string
33139 ctx_ context.Context
33140 header_ http.Header
33141 }
33142
33143
33144
33145 func (r *FloodlightActivityGroupsService) List(profileId int64) *FloodlightActivityGroupsListCall {
33146 c := &FloodlightActivityGroupsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
33147 c.profileId = profileId
33148 return c
33149 }
33150
33151
33152
33153
33154
33155 func (c *FloodlightActivityGroupsListCall) AdvertiserId(advertiserId int64) *FloodlightActivityGroupsListCall {
33156 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
33157 return c
33158 }
33159
33160
33161
33162
33163
33164 func (c *FloodlightActivityGroupsListCall) FloodlightConfigurationId(floodlightConfigurationId int64) *FloodlightActivityGroupsListCall {
33165 c.urlParams_.Set("floodlightConfigurationId", fmt.Sprint(floodlightConfigurationId))
33166 return c
33167 }
33168
33169
33170
33171
33172 func (c *FloodlightActivityGroupsListCall) Ids(ids ...int64) *FloodlightActivityGroupsListCall {
33173 var ids_ []string
33174 for _, v := range ids {
33175 ids_ = append(ids_, fmt.Sprint(v))
33176 }
33177 c.urlParams_.SetMulti("ids", ids_)
33178 return c
33179 }
33180
33181
33182
33183 func (c *FloodlightActivityGroupsListCall) MaxResults(maxResults int64) *FloodlightActivityGroupsListCall {
33184 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
33185 return c
33186 }
33187
33188
33189
33190 func (c *FloodlightActivityGroupsListCall) PageToken(pageToken string) *FloodlightActivityGroupsListCall {
33191 c.urlParams_.Set("pageToken", pageToken)
33192 return c
33193 }
33194
33195
33196
33197
33198
33199
33200
33201
33202
33203
33204
33205 func (c *FloodlightActivityGroupsListCall) SearchString(searchString string) *FloodlightActivityGroupsListCall {
33206 c.urlParams_.Set("searchString", searchString)
33207 return c
33208 }
33209
33210
33211
33212
33213
33214
33215
33216
33217 func (c *FloodlightActivityGroupsListCall) SortField(sortField string) *FloodlightActivityGroupsListCall {
33218 c.urlParams_.Set("sortField", sortField)
33219 return c
33220 }
33221
33222
33223
33224
33225
33226
33227
33228
33229 func (c *FloodlightActivityGroupsListCall) SortOrder(sortOrder string) *FloodlightActivityGroupsListCall {
33230 c.urlParams_.Set("sortOrder", sortOrder)
33231 return c
33232 }
33233
33234
33235
33236
33237
33238
33239
33240
33241 func (c *FloodlightActivityGroupsListCall) Type(type_ string) *FloodlightActivityGroupsListCall {
33242 c.urlParams_.Set("type", type_)
33243 return c
33244 }
33245
33246
33247
33248
33249 func (c *FloodlightActivityGroupsListCall) Fields(s ...googleapi.Field) *FloodlightActivityGroupsListCall {
33250 c.urlParams_.Set("fields", googleapi.CombineFields(s))
33251 return c
33252 }
33253
33254
33255
33256
33257
33258
33259 func (c *FloodlightActivityGroupsListCall) IfNoneMatch(entityTag string) *FloodlightActivityGroupsListCall {
33260 c.ifNoneMatch_ = entityTag
33261 return c
33262 }
33263
33264
33265
33266
33267 func (c *FloodlightActivityGroupsListCall) Context(ctx context.Context) *FloodlightActivityGroupsListCall {
33268 c.ctx_ = ctx
33269 return c
33270 }
33271
33272
33273
33274 func (c *FloodlightActivityGroupsListCall) Header() http.Header {
33275 if c.header_ == nil {
33276 c.header_ = make(http.Header)
33277 }
33278 return c.header_
33279 }
33280
33281 func (c *FloodlightActivityGroupsListCall) doRequest(alt string) (*http.Response, error) {
33282 reqHeaders := make(http.Header)
33283 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
33284 for k, v := range c.header_ {
33285 reqHeaders[k] = v
33286 }
33287 reqHeaders.Set("User-Agent", c.s.userAgent())
33288 if c.ifNoneMatch_ != "" {
33289 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
33290 }
33291 var body io.Reader = nil
33292 c.urlParams_.Set("alt", alt)
33293 c.urlParams_.Set("prettyPrint", "false")
33294 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivityGroups")
33295 urls += "?" + c.urlParams_.Encode()
33296 req, err := http.NewRequest("GET", urls, body)
33297 if err != nil {
33298 return nil, err
33299 }
33300 req.Header = reqHeaders
33301 googleapi.Expand(req.URL, map[string]string{
33302 "profileId": strconv.FormatInt(c.profileId, 10),
33303 })
33304 return gensupport.SendRequest(c.ctx_, c.s.client, req)
33305 }
33306
33307
33308
33309
33310
33311
33312
33313
33314
33315 func (c *FloodlightActivityGroupsListCall) Do(opts ...googleapi.CallOption) (*FloodlightActivityGroupsListResponse, error) {
33316 gensupport.SetOptions(c.urlParams_, opts...)
33317 res, err := c.doRequest("json")
33318 if res != nil && res.StatusCode == http.StatusNotModified {
33319 if res.Body != nil {
33320 res.Body.Close()
33321 }
33322 return nil, &googleapi.Error{
33323 Code: res.StatusCode,
33324 Header: res.Header,
33325 }
33326 }
33327 if err != nil {
33328 return nil, err
33329 }
33330 defer googleapi.CloseBody(res)
33331 if err := googleapi.CheckResponse(res); err != nil {
33332 return nil, err
33333 }
33334 ret := &FloodlightActivityGroupsListResponse{
33335 ServerResponse: googleapi.ServerResponse{
33336 Header: res.Header,
33337 HTTPStatusCode: res.StatusCode,
33338 },
33339 }
33340 target := &ret
33341 if err := gensupport.DecodeResponse(target, res); err != nil {
33342 return nil, err
33343 }
33344 return ret, nil
33345
33346
33347
33348
33349
33350
33351
33352
33353
33354
33355
33356
33357
33358
33359
33360
33361
33362
33363
33364
33365
33366
33367
33368
33369
33370
33371
33372
33373
33374
33375
33376
33377
33378
33379
33380
33381
33382
33383
33384
33385
33386
33387
33388
33389
33390
33391
33392
33393
33394
33395
33396
33397
33398
33399
33400
33401
33402
33403
33404
33405
33406
33407
33408
33409
33410
33411
33412
33413
33414
33415
33416
33417
33418
33419
33420
33421
33422
33423
33424
33425
33426
33427
33428
33429
33430
33431
33432
33433
33434
33435
33436
33437
33438
33439
33440
33441
33442
33443
33444
33445
33446
33447
33448
33449 }
33450
33451
33452
33453
33454 func (c *FloodlightActivityGroupsListCall) Pages(ctx context.Context, f func(*FloodlightActivityGroupsListResponse) error) error {
33455 c.ctx_ = ctx
33456 defer c.PageToken(c.urlParams_.Get("pageToken"))
33457 for {
33458 x, err := c.Do()
33459 if err != nil {
33460 return err
33461 }
33462 if err := f(x); err != nil {
33463 return err
33464 }
33465 if x.NextPageToken == "" {
33466 return nil
33467 }
33468 c.PageToken(x.NextPageToken)
33469 }
33470 }
33471
33472
33473
33474 type FloodlightActivityGroupsPatchCall struct {
33475 s *Service
33476 profileId int64
33477 floodlightactivitygroup *FloodlightActivityGroup
33478 urlParams_ gensupport.URLParams
33479 ctx_ context.Context
33480 header_ http.Header
33481 }
33482
33483
33484
33485 func (r *FloodlightActivityGroupsService) Patch(profileId int64, id int64, floodlightactivitygroup *FloodlightActivityGroup) *FloodlightActivityGroupsPatchCall {
33486 c := &FloodlightActivityGroupsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
33487 c.profileId = profileId
33488 c.urlParams_.Set("id", fmt.Sprint(id))
33489 c.floodlightactivitygroup = floodlightactivitygroup
33490 return c
33491 }
33492
33493
33494
33495
33496 func (c *FloodlightActivityGroupsPatchCall) Fields(s ...googleapi.Field) *FloodlightActivityGroupsPatchCall {
33497 c.urlParams_.Set("fields", googleapi.CombineFields(s))
33498 return c
33499 }
33500
33501
33502
33503
33504 func (c *FloodlightActivityGroupsPatchCall) Context(ctx context.Context) *FloodlightActivityGroupsPatchCall {
33505 c.ctx_ = ctx
33506 return c
33507 }
33508
33509
33510
33511 func (c *FloodlightActivityGroupsPatchCall) Header() http.Header {
33512 if c.header_ == nil {
33513 c.header_ = make(http.Header)
33514 }
33515 return c.header_
33516 }
33517
33518 func (c *FloodlightActivityGroupsPatchCall) doRequest(alt string) (*http.Response, error) {
33519 reqHeaders := make(http.Header)
33520 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
33521 for k, v := range c.header_ {
33522 reqHeaders[k] = v
33523 }
33524 reqHeaders.Set("User-Agent", c.s.userAgent())
33525 var body io.Reader = nil
33526 body, err := googleapi.WithoutDataWrapper.JSONReader(c.floodlightactivitygroup)
33527 if err != nil {
33528 return nil, err
33529 }
33530 reqHeaders.Set("Content-Type", "application/json")
33531 c.urlParams_.Set("alt", alt)
33532 c.urlParams_.Set("prettyPrint", "false")
33533 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivityGroups")
33534 urls += "?" + c.urlParams_.Encode()
33535 req, err := http.NewRequest("PATCH", urls, body)
33536 if err != nil {
33537 return nil, err
33538 }
33539 req.Header = reqHeaders
33540 googleapi.Expand(req.URL, map[string]string{
33541 "profileId": strconv.FormatInt(c.profileId, 10),
33542 })
33543 return gensupport.SendRequest(c.ctx_, c.s.client, req)
33544 }
33545
33546
33547
33548
33549
33550
33551
33552
33553 func (c *FloodlightActivityGroupsPatchCall) Do(opts ...googleapi.CallOption) (*FloodlightActivityGroup, error) {
33554 gensupport.SetOptions(c.urlParams_, opts...)
33555 res, err := c.doRequest("json")
33556 if res != nil && res.StatusCode == http.StatusNotModified {
33557 if res.Body != nil {
33558 res.Body.Close()
33559 }
33560 return nil, &googleapi.Error{
33561 Code: res.StatusCode,
33562 Header: res.Header,
33563 }
33564 }
33565 if err != nil {
33566 return nil, err
33567 }
33568 defer googleapi.CloseBody(res)
33569 if err := googleapi.CheckResponse(res); err != nil {
33570 return nil, err
33571 }
33572 ret := &FloodlightActivityGroup{
33573 ServerResponse: googleapi.ServerResponse{
33574 Header: res.Header,
33575 HTTPStatusCode: res.StatusCode,
33576 },
33577 }
33578 target := &ret
33579 if err := gensupport.DecodeResponse(target, res); err != nil {
33580 return nil, err
33581 }
33582 return ret, nil
33583
33584
33585
33586
33587
33588
33589
33590
33591
33592
33593
33594
33595
33596
33597
33598
33599
33600
33601
33602
33603
33604
33605
33606
33607
33608
33609
33610
33611
33612
33613
33614
33615
33616
33617
33618
33619 }
33620
33621
33622
33623 type FloodlightActivityGroupsUpdateCall struct {
33624 s *Service
33625 profileId int64
33626 floodlightactivitygroup *FloodlightActivityGroup
33627 urlParams_ gensupport.URLParams
33628 ctx_ context.Context
33629 header_ http.Header
33630 }
33631
33632
33633 func (r *FloodlightActivityGroupsService) Update(profileId int64, floodlightactivitygroup *FloodlightActivityGroup) *FloodlightActivityGroupsUpdateCall {
33634 c := &FloodlightActivityGroupsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
33635 c.profileId = profileId
33636 c.floodlightactivitygroup = floodlightactivitygroup
33637 return c
33638 }
33639
33640
33641
33642
33643 func (c *FloodlightActivityGroupsUpdateCall) Fields(s ...googleapi.Field) *FloodlightActivityGroupsUpdateCall {
33644 c.urlParams_.Set("fields", googleapi.CombineFields(s))
33645 return c
33646 }
33647
33648
33649
33650
33651 func (c *FloodlightActivityGroupsUpdateCall) Context(ctx context.Context) *FloodlightActivityGroupsUpdateCall {
33652 c.ctx_ = ctx
33653 return c
33654 }
33655
33656
33657
33658 func (c *FloodlightActivityGroupsUpdateCall) Header() http.Header {
33659 if c.header_ == nil {
33660 c.header_ = make(http.Header)
33661 }
33662 return c.header_
33663 }
33664
33665 func (c *FloodlightActivityGroupsUpdateCall) doRequest(alt string) (*http.Response, error) {
33666 reqHeaders := make(http.Header)
33667 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
33668 for k, v := range c.header_ {
33669 reqHeaders[k] = v
33670 }
33671 reqHeaders.Set("User-Agent", c.s.userAgent())
33672 var body io.Reader = nil
33673 body, err := googleapi.WithoutDataWrapper.JSONReader(c.floodlightactivitygroup)
33674 if err != nil {
33675 return nil, err
33676 }
33677 reqHeaders.Set("Content-Type", "application/json")
33678 c.urlParams_.Set("alt", alt)
33679 c.urlParams_.Set("prettyPrint", "false")
33680 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightActivityGroups")
33681 urls += "?" + c.urlParams_.Encode()
33682 req, err := http.NewRequest("PUT", urls, body)
33683 if err != nil {
33684 return nil, err
33685 }
33686 req.Header = reqHeaders
33687 googleapi.Expand(req.URL, map[string]string{
33688 "profileId": strconv.FormatInt(c.profileId, 10),
33689 })
33690 return gensupport.SendRequest(c.ctx_, c.s.client, req)
33691 }
33692
33693
33694
33695
33696
33697
33698
33699
33700 func (c *FloodlightActivityGroupsUpdateCall) Do(opts ...googleapi.CallOption) (*FloodlightActivityGroup, error) {
33701 gensupport.SetOptions(c.urlParams_, opts...)
33702 res, err := c.doRequest("json")
33703 if res != nil && res.StatusCode == http.StatusNotModified {
33704 if res.Body != nil {
33705 res.Body.Close()
33706 }
33707 return nil, &googleapi.Error{
33708 Code: res.StatusCode,
33709 Header: res.Header,
33710 }
33711 }
33712 if err != nil {
33713 return nil, err
33714 }
33715 defer googleapi.CloseBody(res)
33716 if err := googleapi.CheckResponse(res); err != nil {
33717 return nil, err
33718 }
33719 ret := &FloodlightActivityGroup{
33720 ServerResponse: googleapi.ServerResponse{
33721 Header: res.Header,
33722 HTTPStatusCode: res.StatusCode,
33723 },
33724 }
33725 target := &ret
33726 if err := gensupport.DecodeResponse(target, res); err != nil {
33727 return nil, err
33728 }
33729 return ret, nil
33730
33731
33732
33733
33734
33735
33736
33737
33738
33739
33740
33741
33742
33743
33744
33745
33746
33747
33748
33749
33750
33751
33752
33753
33754
33755
33756
33757
33758 }
33759
33760
33761
33762 type FloodlightConfigurationsGetCall struct {
33763 s *Service
33764 profileId int64
33765 id int64
33766 urlParams_ gensupport.URLParams
33767 ifNoneMatch_ string
33768 ctx_ context.Context
33769 header_ http.Header
33770 }
33771
33772
33773 func (r *FloodlightConfigurationsService) Get(profileId int64, id int64) *FloodlightConfigurationsGetCall {
33774 c := &FloodlightConfigurationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
33775 c.profileId = profileId
33776 c.id = id
33777 return c
33778 }
33779
33780
33781
33782
33783 func (c *FloodlightConfigurationsGetCall) Fields(s ...googleapi.Field) *FloodlightConfigurationsGetCall {
33784 c.urlParams_.Set("fields", googleapi.CombineFields(s))
33785 return c
33786 }
33787
33788
33789
33790
33791
33792
33793 func (c *FloodlightConfigurationsGetCall) IfNoneMatch(entityTag string) *FloodlightConfigurationsGetCall {
33794 c.ifNoneMatch_ = entityTag
33795 return c
33796 }
33797
33798
33799
33800
33801 func (c *FloodlightConfigurationsGetCall) Context(ctx context.Context) *FloodlightConfigurationsGetCall {
33802 c.ctx_ = ctx
33803 return c
33804 }
33805
33806
33807
33808 func (c *FloodlightConfigurationsGetCall) Header() http.Header {
33809 if c.header_ == nil {
33810 c.header_ = make(http.Header)
33811 }
33812 return c.header_
33813 }
33814
33815 func (c *FloodlightConfigurationsGetCall) doRequest(alt string) (*http.Response, error) {
33816 reqHeaders := make(http.Header)
33817 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
33818 for k, v := range c.header_ {
33819 reqHeaders[k] = v
33820 }
33821 reqHeaders.Set("User-Agent", c.s.userAgent())
33822 if c.ifNoneMatch_ != "" {
33823 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
33824 }
33825 var body io.Reader = nil
33826 c.urlParams_.Set("alt", alt)
33827 c.urlParams_.Set("prettyPrint", "false")
33828 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightConfigurations/{id}")
33829 urls += "?" + c.urlParams_.Encode()
33830 req, err := http.NewRequest("GET", urls, body)
33831 if err != nil {
33832 return nil, err
33833 }
33834 req.Header = reqHeaders
33835 googleapi.Expand(req.URL, map[string]string{
33836 "profileId": strconv.FormatInt(c.profileId, 10),
33837 "id": strconv.FormatInt(c.id, 10),
33838 })
33839 return gensupport.SendRequest(c.ctx_, c.s.client, req)
33840 }
33841
33842
33843
33844
33845
33846
33847
33848
33849 func (c *FloodlightConfigurationsGetCall) Do(opts ...googleapi.CallOption) (*FloodlightConfiguration, error) {
33850 gensupport.SetOptions(c.urlParams_, opts...)
33851 res, err := c.doRequest("json")
33852 if res != nil && res.StatusCode == http.StatusNotModified {
33853 if res.Body != nil {
33854 res.Body.Close()
33855 }
33856 return nil, &googleapi.Error{
33857 Code: res.StatusCode,
33858 Header: res.Header,
33859 }
33860 }
33861 if err != nil {
33862 return nil, err
33863 }
33864 defer googleapi.CloseBody(res)
33865 if err := googleapi.CheckResponse(res); err != nil {
33866 return nil, err
33867 }
33868 ret := &FloodlightConfiguration{
33869 ServerResponse: googleapi.ServerResponse{
33870 Header: res.Header,
33871 HTTPStatusCode: res.StatusCode,
33872 },
33873 }
33874 target := &ret
33875 if err := gensupport.DecodeResponse(target, res); err != nil {
33876 return nil, err
33877 }
33878 return ret, nil
33879
33880
33881
33882
33883
33884
33885
33886
33887
33888
33889
33890
33891
33892
33893
33894
33895
33896
33897
33898
33899
33900
33901
33902
33903
33904
33905
33906
33907
33908
33909
33910
33911
33912 }
33913
33914
33915
33916 type FloodlightConfigurationsListCall struct {
33917 s *Service
33918 profileId int64
33919 urlParams_ gensupport.URLParams
33920 ifNoneMatch_ string
33921 ctx_ context.Context
33922 header_ http.Header
33923 }
33924
33925
33926
33927 func (r *FloodlightConfigurationsService) List(profileId int64) *FloodlightConfigurationsListCall {
33928 c := &FloodlightConfigurationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
33929 c.profileId = profileId
33930 return c
33931 }
33932
33933
33934
33935
33936 func (c *FloodlightConfigurationsListCall) Ids(ids ...int64) *FloodlightConfigurationsListCall {
33937 var ids_ []string
33938 for _, v := range ids {
33939 ids_ = append(ids_, fmt.Sprint(v))
33940 }
33941 c.urlParams_.SetMulti("ids", ids_)
33942 return c
33943 }
33944
33945
33946
33947
33948 func (c *FloodlightConfigurationsListCall) Fields(s ...googleapi.Field) *FloodlightConfigurationsListCall {
33949 c.urlParams_.Set("fields", googleapi.CombineFields(s))
33950 return c
33951 }
33952
33953
33954
33955
33956
33957
33958 func (c *FloodlightConfigurationsListCall) IfNoneMatch(entityTag string) *FloodlightConfigurationsListCall {
33959 c.ifNoneMatch_ = entityTag
33960 return c
33961 }
33962
33963
33964
33965
33966 func (c *FloodlightConfigurationsListCall) Context(ctx context.Context) *FloodlightConfigurationsListCall {
33967 c.ctx_ = ctx
33968 return c
33969 }
33970
33971
33972
33973 func (c *FloodlightConfigurationsListCall) Header() http.Header {
33974 if c.header_ == nil {
33975 c.header_ = make(http.Header)
33976 }
33977 return c.header_
33978 }
33979
33980 func (c *FloodlightConfigurationsListCall) doRequest(alt string) (*http.Response, error) {
33981 reqHeaders := make(http.Header)
33982 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
33983 for k, v := range c.header_ {
33984 reqHeaders[k] = v
33985 }
33986 reqHeaders.Set("User-Agent", c.s.userAgent())
33987 if c.ifNoneMatch_ != "" {
33988 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
33989 }
33990 var body io.Reader = nil
33991 c.urlParams_.Set("alt", alt)
33992 c.urlParams_.Set("prettyPrint", "false")
33993 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightConfigurations")
33994 urls += "?" + c.urlParams_.Encode()
33995 req, err := http.NewRequest("GET", urls, body)
33996 if err != nil {
33997 return nil, err
33998 }
33999 req.Header = reqHeaders
34000 googleapi.Expand(req.URL, map[string]string{
34001 "profileId": strconv.FormatInt(c.profileId, 10),
34002 })
34003 return gensupport.SendRequest(c.ctx_, c.s.client, req)
34004 }
34005
34006
34007
34008
34009
34010
34011
34012
34013
34014 func (c *FloodlightConfigurationsListCall) Do(opts ...googleapi.CallOption) (*FloodlightConfigurationsListResponse, error) {
34015 gensupport.SetOptions(c.urlParams_, opts...)
34016 res, err := c.doRequest("json")
34017 if res != nil && res.StatusCode == http.StatusNotModified {
34018 if res.Body != nil {
34019 res.Body.Close()
34020 }
34021 return nil, &googleapi.Error{
34022 Code: res.StatusCode,
34023 Header: res.Header,
34024 }
34025 }
34026 if err != nil {
34027 return nil, err
34028 }
34029 defer googleapi.CloseBody(res)
34030 if err := googleapi.CheckResponse(res); err != nil {
34031 return nil, err
34032 }
34033 ret := &FloodlightConfigurationsListResponse{
34034 ServerResponse: googleapi.ServerResponse{
34035 Header: res.Header,
34036 HTTPStatusCode: res.StatusCode,
34037 },
34038 }
34039 target := &ret
34040 if err := gensupport.DecodeResponse(target, res); err != nil {
34041 return nil, err
34042 }
34043 return ret, nil
34044
34045
34046
34047
34048
34049
34050
34051
34052
34053
34054
34055
34056
34057
34058
34059
34060
34061
34062
34063
34064
34065
34066
34067
34068
34069
34070
34071
34072
34073
34074
34075
34076 }
34077
34078
34079
34080 type FloodlightConfigurationsPatchCall struct {
34081 s *Service
34082 profileId int64
34083 floodlightconfiguration *FloodlightConfiguration
34084 urlParams_ gensupport.URLParams
34085 ctx_ context.Context
34086 header_ http.Header
34087 }
34088
34089
34090
34091 func (r *FloodlightConfigurationsService) Patch(profileId int64, id int64, floodlightconfiguration *FloodlightConfiguration) *FloodlightConfigurationsPatchCall {
34092 c := &FloodlightConfigurationsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
34093 c.profileId = profileId
34094 c.urlParams_.Set("id", fmt.Sprint(id))
34095 c.floodlightconfiguration = floodlightconfiguration
34096 return c
34097 }
34098
34099
34100
34101
34102 func (c *FloodlightConfigurationsPatchCall) Fields(s ...googleapi.Field) *FloodlightConfigurationsPatchCall {
34103 c.urlParams_.Set("fields", googleapi.CombineFields(s))
34104 return c
34105 }
34106
34107
34108
34109
34110 func (c *FloodlightConfigurationsPatchCall) Context(ctx context.Context) *FloodlightConfigurationsPatchCall {
34111 c.ctx_ = ctx
34112 return c
34113 }
34114
34115
34116
34117 func (c *FloodlightConfigurationsPatchCall) Header() http.Header {
34118 if c.header_ == nil {
34119 c.header_ = make(http.Header)
34120 }
34121 return c.header_
34122 }
34123
34124 func (c *FloodlightConfigurationsPatchCall) doRequest(alt string) (*http.Response, error) {
34125 reqHeaders := make(http.Header)
34126 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
34127 for k, v := range c.header_ {
34128 reqHeaders[k] = v
34129 }
34130 reqHeaders.Set("User-Agent", c.s.userAgent())
34131 var body io.Reader = nil
34132 body, err := googleapi.WithoutDataWrapper.JSONReader(c.floodlightconfiguration)
34133 if err != nil {
34134 return nil, err
34135 }
34136 reqHeaders.Set("Content-Type", "application/json")
34137 c.urlParams_.Set("alt", alt)
34138 c.urlParams_.Set("prettyPrint", "false")
34139 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightConfigurations")
34140 urls += "?" + c.urlParams_.Encode()
34141 req, err := http.NewRequest("PATCH", urls, body)
34142 if err != nil {
34143 return nil, err
34144 }
34145 req.Header = reqHeaders
34146 googleapi.Expand(req.URL, map[string]string{
34147 "profileId": strconv.FormatInt(c.profileId, 10),
34148 })
34149 return gensupport.SendRequest(c.ctx_, c.s.client, req)
34150 }
34151
34152
34153
34154
34155
34156
34157
34158
34159 func (c *FloodlightConfigurationsPatchCall) Do(opts ...googleapi.CallOption) (*FloodlightConfiguration, error) {
34160 gensupport.SetOptions(c.urlParams_, opts...)
34161 res, err := c.doRequest("json")
34162 if res != nil && res.StatusCode == http.StatusNotModified {
34163 if res.Body != nil {
34164 res.Body.Close()
34165 }
34166 return nil, &googleapi.Error{
34167 Code: res.StatusCode,
34168 Header: res.Header,
34169 }
34170 }
34171 if err != nil {
34172 return nil, err
34173 }
34174 defer googleapi.CloseBody(res)
34175 if err := googleapi.CheckResponse(res); err != nil {
34176 return nil, err
34177 }
34178 ret := &FloodlightConfiguration{
34179 ServerResponse: googleapi.ServerResponse{
34180 Header: res.Header,
34181 HTTPStatusCode: res.StatusCode,
34182 },
34183 }
34184 target := &ret
34185 if err := gensupport.DecodeResponse(target, res); err != nil {
34186 return nil, err
34187 }
34188 return ret, nil
34189
34190
34191
34192
34193
34194
34195
34196
34197
34198
34199
34200
34201
34202
34203
34204
34205
34206
34207
34208
34209
34210
34211
34212
34213
34214
34215
34216
34217
34218
34219
34220
34221
34222
34223
34224
34225 }
34226
34227
34228
34229 type FloodlightConfigurationsUpdateCall struct {
34230 s *Service
34231 profileId int64
34232 floodlightconfiguration *FloodlightConfiguration
34233 urlParams_ gensupport.URLParams
34234 ctx_ context.Context
34235 header_ http.Header
34236 }
34237
34238
34239 func (r *FloodlightConfigurationsService) Update(profileId int64, floodlightconfiguration *FloodlightConfiguration) *FloodlightConfigurationsUpdateCall {
34240 c := &FloodlightConfigurationsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
34241 c.profileId = profileId
34242 c.floodlightconfiguration = floodlightconfiguration
34243 return c
34244 }
34245
34246
34247
34248
34249 func (c *FloodlightConfigurationsUpdateCall) Fields(s ...googleapi.Field) *FloodlightConfigurationsUpdateCall {
34250 c.urlParams_.Set("fields", googleapi.CombineFields(s))
34251 return c
34252 }
34253
34254
34255
34256
34257 func (c *FloodlightConfigurationsUpdateCall) Context(ctx context.Context) *FloodlightConfigurationsUpdateCall {
34258 c.ctx_ = ctx
34259 return c
34260 }
34261
34262
34263
34264 func (c *FloodlightConfigurationsUpdateCall) Header() http.Header {
34265 if c.header_ == nil {
34266 c.header_ = make(http.Header)
34267 }
34268 return c.header_
34269 }
34270
34271 func (c *FloodlightConfigurationsUpdateCall) doRequest(alt string) (*http.Response, error) {
34272 reqHeaders := make(http.Header)
34273 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
34274 for k, v := range c.header_ {
34275 reqHeaders[k] = v
34276 }
34277 reqHeaders.Set("User-Agent", c.s.userAgent())
34278 var body io.Reader = nil
34279 body, err := googleapi.WithoutDataWrapper.JSONReader(c.floodlightconfiguration)
34280 if err != nil {
34281 return nil, err
34282 }
34283 reqHeaders.Set("Content-Type", "application/json")
34284 c.urlParams_.Set("alt", alt)
34285 c.urlParams_.Set("prettyPrint", "false")
34286 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/floodlightConfigurations")
34287 urls += "?" + c.urlParams_.Encode()
34288 req, err := http.NewRequest("PUT", urls, body)
34289 if err != nil {
34290 return nil, err
34291 }
34292 req.Header = reqHeaders
34293 googleapi.Expand(req.URL, map[string]string{
34294 "profileId": strconv.FormatInt(c.profileId, 10),
34295 })
34296 return gensupport.SendRequest(c.ctx_, c.s.client, req)
34297 }
34298
34299
34300
34301
34302
34303
34304
34305
34306 func (c *FloodlightConfigurationsUpdateCall) Do(opts ...googleapi.CallOption) (*FloodlightConfiguration, error) {
34307 gensupport.SetOptions(c.urlParams_, opts...)
34308 res, err := c.doRequest("json")
34309 if res != nil && res.StatusCode == http.StatusNotModified {
34310 if res.Body != nil {
34311 res.Body.Close()
34312 }
34313 return nil, &googleapi.Error{
34314 Code: res.StatusCode,
34315 Header: res.Header,
34316 }
34317 }
34318 if err != nil {
34319 return nil, err
34320 }
34321 defer googleapi.CloseBody(res)
34322 if err := googleapi.CheckResponse(res); err != nil {
34323 return nil, err
34324 }
34325 ret := &FloodlightConfiguration{
34326 ServerResponse: googleapi.ServerResponse{
34327 Header: res.Header,
34328 HTTPStatusCode: res.StatusCode,
34329 },
34330 }
34331 target := &ret
34332 if err := gensupport.DecodeResponse(target, res); err != nil {
34333 return nil, err
34334 }
34335 return ret, nil
34336
34337
34338
34339
34340
34341
34342
34343
34344
34345
34346
34347
34348
34349
34350
34351
34352
34353
34354
34355
34356
34357
34358
34359
34360
34361
34362
34363
34364 }
34365
34366
34367
34368 type InventoryItemsGetCall struct {
34369 s *Service
34370 profileId int64
34371 projectId int64
34372 id int64
34373 urlParams_ gensupport.URLParams
34374 ifNoneMatch_ string
34375 ctx_ context.Context
34376 header_ http.Header
34377 }
34378
34379
34380 func (r *InventoryItemsService) Get(profileId int64, projectId int64, id int64) *InventoryItemsGetCall {
34381 c := &InventoryItemsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
34382 c.profileId = profileId
34383 c.projectId = projectId
34384 c.id = id
34385 return c
34386 }
34387
34388
34389
34390
34391 func (c *InventoryItemsGetCall) Fields(s ...googleapi.Field) *InventoryItemsGetCall {
34392 c.urlParams_.Set("fields", googleapi.CombineFields(s))
34393 return c
34394 }
34395
34396
34397
34398
34399
34400
34401 func (c *InventoryItemsGetCall) IfNoneMatch(entityTag string) *InventoryItemsGetCall {
34402 c.ifNoneMatch_ = entityTag
34403 return c
34404 }
34405
34406
34407
34408
34409 func (c *InventoryItemsGetCall) Context(ctx context.Context) *InventoryItemsGetCall {
34410 c.ctx_ = ctx
34411 return c
34412 }
34413
34414
34415
34416 func (c *InventoryItemsGetCall) Header() http.Header {
34417 if c.header_ == nil {
34418 c.header_ = make(http.Header)
34419 }
34420 return c.header_
34421 }
34422
34423 func (c *InventoryItemsGetCall) doRequest(alt string) (*http.Response, error) {
34424 reqHeaders := make(http.Header)
34425 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
34426 for k, v := range c.header_ {
34427 reqHeaders[k] = v
34428 }
34429 reqHeaders.Set("User-Agent", c.s.userAgent())
34430 if c.ifNoneMatch_ != "" {
34431 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
34432 }
34433 var body io.Reader = nil
34434 c.urlParams_.Set("alt", alt)
34435 c.urlParams_.Set("prettyPrint", "false")
34436 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/projects/{projectId}/inventoryItems/{id}")
34437 urls += "?" + c.urlParams_.Encode()
34438 req, err := http.NewRequest("GET", urls, body)
34439 if err != nil {
34440 return nil, err
34441 }
34442 req.Header = reqHeaders
34443 googleapi.Expand(req.URL, map[string]string{
34444 "profileId": strconv.FormatInt(c.profileId, 10),
34445 "projectId": strconv.FormatInt(c.projectId, 10),
34446 "id": strconv.FormatInt(c.id, 10),
34447 })
34448 return gensupport.SendRequest(c.ctx_, c.s.client, req)
34449 }
34450
34451
34452
34453
34454
34455
34456
34457
34458 func (c *InventoryItemsGetCall) Do(opts ...googleapi.CallOption) (*InventoryItem, error) {
34459 gensupport.SetOptions(c.urlParams_, opts...)
34460 res, err := c.doRequest("json")
34461 if res != nil && res.StatusCode == http.StatusNotModified {
34462 if res.Body != nil {
34463 res.Body.Close()
34464 }
34465 return nil, &googleapi.Error{
34466 Code: res.StatusCode,
34467 Header: res.Header,
34468 }
34469 }
34470 if err != nil {
34471 return nil, err
34472 }
34473 defer googleapi.CloseBody(res)
34474 if err := googleapi.CheckResponse(res); err != nil {
34475 return nil, err
34476 }
34477 ret := &InventoryItem{
34478 ServerResponse: googleapi.ServerResponse{
34479 Header: res.Header,
34480 HTTPStatusCode: res.StatusCode,
34481 },
34482 }
34483 target := &ret
34484 if err := gensupport.DecodeResponse(target, res); err != nil {
34485 return nil, err
34486 }
34487 return ret, nil
34488
34489
34490
34491
34492
34493
34494
34495
34496
34497
34498
34499
34500
34501
34502
34503
34504
34505
34506
34507
34508
34509
34510
34511
34512
34513
34514
34515
34516
34517
34518
34519
34520
34521
34522
34523
34524
34525
34526
34527
34528
34529 }
34530
34531
34532
34533 type InventoryItemsListCall struct {
34534 s *Service
34535 profileId int64
34536 projectId int64
34537 urlParams_ gensupport.URLParams
34538 ifNoneMatch_ string
34539 ctx_ context.Context
34540 header_ http.Header
34541 }
34542
34543
34544
34545 func (r *InventoryItemsService) List(profileId int64, projectId int64) *InventoryItemsListCall {
34546 c := &InventoryItemsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
34547 c.profileId = profileId
34548 c.projectId = projectId
34549 return c
34550 }
34551
34552
34553
34554 func (c *InventoryItemsListCall) Ids(ids ...int64) *InventoryItemsListCall {
34555 var ids_ []string
34556 for _, v := range ids {
34557 ids_ = append(ids_, fmt.Sprint(v))
34558 }
34559 c.urlParams_.SetMulti("ids", ids_)
34560 return c
34561 }
34562
34563
34564
34565 func (c *InventoryItemsListCall) InPlan(inPlan bool) *InventoryItemsListCall {
34566 c.urlParams_.Set("inPlan", fmt.Sprint(inPlan))
34567 return c
34568 }
34569
34570
34571
34572 func (c *InventoryItemsListCall) MaxResults(maxResults int64) *InventoryItemsListCall {
34573 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
34574 return c
34575 }
34576
34577
34578
34579 func (c *InventoryItemsListCall) OrderId(orderId ...int64) *InventoryItemsListCall {
34580 var orderId_ []string
34581 for _, v := range orderId {
34582 orderId_ = append(orderId_, fmt.Sprint(v))
34583 }
34584 c.urlParams_.SetMulti("orderId", orderId_)
34585 return c
34586 }
34587
34588
34589
34590 func (c *InventoryItemsListCall) PageToken(pageToken string) *InventoryItemsListCall {
34591 c.urlParams_.Set("pageToken", pageToken)
34592 return c
34593 }
34594
34595
34596
34597 func (c *InventoryItemsListCall) SiteId(siteId ...int64) *InventoryItemsListCall {
34598 var siteId_ []string
34599 for _, v := range siteId {
34600 siteId_ = append(siteId_, fmt.Sprint(v))
34601 }
34602 c.urlParams_.SetMulti("siteId", siteId_)
34603 return c
34604 }
34605
34606
34607
34608
34609
34610
34611
34612
34613 func (c *InventoryItemsListCall) SortField(sortField string) *InventoryItemsListCall {
34614 c.urlParams_.Set("sortField", sortField)
34615 return c
34616 }
34617
34618
34619
34620
34621
34622
34623
34624
34625 func (c *InventoryItemsListCall) SortOrder(sortOrder string) *InventoryItemsListCall {
34626 c.urlParams_.Set("sortOrder", sortOrder)
34627 return c
34628 }
34629
34630
34631
34632
34633
34634
34635
34636
34637 func (c *InventoryItemsListCall) Type(type_ string) *InventoryItemsListCall {
34638 c.urlParams_.Set("type", type_)
34639 return c
34640 }
34641
34642
34643
34644
34645 func (c *InventoryItemsListCall) Fields(s ...googleapi.Field) *InventoryItemsListCall {
34646 c.urlParams_.Set("fields", googleapi.CombineFields(s))
34647 return c
34648 }
34649
34650
34651
34652
34653
34654
34655 func (c *InventoryItemsListCall) IfNoneMatch(entityTag string) *InventoryItemsListCall {
34656 c.ifNoneMatch_ = entityTag
34657 return c
34658 }
34659
34660
34661
34662
34663 func (c *InventoryItemsListCall) Context(ctx context.Context) *InventoryItemsListCall {
34664 c.ctx_ = ctx
34665 return c
34666 }
34667
34668
34669
34670 func (c *InventoryItemsListCall) Header() http.Header {
34671 if c.header_ == nil {
34672 c.header_ = make(http.Header)
34673 }
34674 return c.header_
34675 }
34676
34677 func (c *InventoryItemsListCall) doRequest(alt string) (*http.Response, error) {
34678 reqHeaders := make(http.Header)
34679 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
34680 for k, v := range c.header_ {
34681 reqHeaders[k] = v
34682 }
34683 reqHeaders.Set("User-Agent", c.s.userAgent())
34684 if c.ifNoneMatch_ != "" {
34685 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
34686 }
34687 var body io.Reader = nil
34688 c.urlParams_.Set("alt", alt)
34689 c.urlParams_.Set("prettyPrint", "false")
34690 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/projects/{projectId}/inventoryItems")
34691 urls += "?" + c.urlParams_.Encode()
34692 req, err := http.NewRequest("GET", urls, body)
34693 if err != nil {
34694 return nil, err
34695 }
34696 req.Header = reqHeaders
34697 googleapi.Expand(req.URL, map[string]string{
34698 "profileId": strconv.FormatInt(c.profileId, 10),
34699 "projectId": strconv.FormatInt(c.projectId, 10),
34700 })
34701 return gensupport.SendRequest(c.ctx_, c.s.client, req)
34702 }
34703
34704
34705
34706
34707
34708
34709
34710
34711 func (c *InventoryItemsListCall) Do(opts ...googleapi.CallOption) (*InventoryItemsListResponse, error) {
34712 gensupport.SetOptions(c.urlParams_, opts...)
34713 res, err := c.doRequest("json")
34714 if res != nil && res.StatusCode == http.StatusNotModified {
34715 if res.Body != nil {
34716 res.Body.Close()
34717 }
34718 return nil, &googleapi.Error{
34719 Code: res.StatusCode,
34720 Header: res.Header,
34721 }
34722 }
34723 if err != nil {
34724 return nil, err
34725 }
34726 defer googleapi.CloseBody(res)
34727 if err := googleapi.CheckResponse(res); err != nil {
34728 return nil, err
34729 }
34730 ret := &InventoryItemsListResponse{
34731 ServerResponse: googleapi.ServerResponse{
34732 Header: res.Header,
34733 HTTPStatusCode: res.StatusCode,
34734 },
34735 }
34736 target := &ret
34737 if err := gensupport.DecodeResponse(target, res); err != nil {
34738 return nil, err
34739 }
34740 return ret, nil
34741
34742
34743
34744
34745
34746
34747
34748
34749
34750
34751
34752
34753
34754
34755
34756
34757
34758
34759
34760
34761
34762
34763
34764
34765
34766
34767
34768
34769
34770
34771
34772
34773
34774
34775
34776
34777
34778
34779
34780
34781
34782
34783
34784
34785
34786
34787
34788
34789
34790
34791
34792
34793
34794
34795
34796
34797
34798
34799
34800
34801
34802
34803
34804
34805
34806
34807
34808
34809
34810
34811
34812
34813
34814
34815
34816
34817
34818
34819
34820
34821
34822
34823
34824
34825
34826
34827
34828
34829
34830
34831
34832
34833
34834
34835
34836
34837
34838
34839
34840
34841
34842
34843
34844
34845
34846
34847
34848
34849
34850
34851
34852
34853
34854
34855 }
34856
34857
34858
34859
34860 func (c *InventoryItemsListCall) Pages(ctx context.Context, f func(*InventoryItemsListResponse) error) error {
34861 c.ctx_ = ctx
34862 defer c.PageToken(c.urlParams_.Get("pageToken"))
34863 for {
34864 x, err := c.Do()
34865 if err != nil {
34866 return err
34867 }
34868 if err := f(x); err != nil {
34869 return err
34870 }
34871 if x.NextPageToken == "" {
34872 return nil
34873 }
34874 c.PageToken(x.NextPageToken)
34875 }
34876 }
34877
34878
34879
34880 type LanguagesListCall struct {
34881 s *Service
34882 profileId int64
34883 urlParams_ gensupport.URLParams
34884 ifNoneMatch_ string
34885 ctx_ context.Context
34886 header_ http.Header
34887 }
34888
34889
34890 func (r *LanguagesService) List(profileId int64) *LanguagesListCall {
34891 c := &LanguagesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
34892 c.profileId = profileId
34893 return c
34894 }
34895
34896
34897
34898
34899 func (c *LanguagesListCall) Fields(s ...googleapi.Field) *LanguagesListCall {
34900 c.urlParams_.Set("fields", googleapi.CombineFields(s))
34901 return c
34902 }
34903
34904
34905
34906
34907
34908
34909 func (c *LanguagesListCall) IfNoneMatch(entityTag string) *LanguagesListCall {
34910 c.ifNoneMatch_ = entityTag
34911 return c
34912 }
34913
34914
34915
34916
34917 func (c *LanguagesListCall) Context(ctx context.Context) *LanguagesListCall {
34918 c.ctx_ = ctx
34919 return c
34920 }
34921
34922
34923
34924 func (c *LanguagesListCall) Header() http.Header {
34925 if c.header_ == nil {
34926 c.header_ = make(http.Header)
34927 }
34928 return c.header_
34929 }
34930
34931 func (c *LanguagesListCall) doRequest(alt string) (*http.Response, error) {
34932 reqHeaders := make(http.Header)
34933 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
34934 for k, v := range c.header_ {
34935 reqHeaders[k] = v
34936 }
34937 reqHeaders.Set("User-Agent", c.s.userAgent())
34938 if c.ifNoneMatch_ != "" {
34939 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
34940 }
34941 var body io.Reader = nil
34942 c.urlParams_.Set("alt", alt)
34943 c.urlParams_.Set("prettyPrint", "false")
34944 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/languages")
34945 urls += "?" + c.urlParams_.Encode()
34946 req, err := http.NewRequest("GET", urls, body)
34947 if err != nil {
34948 return nil, err
34949 }
34950 req.Header = reqHeaders
34951 googleapi.Expand(req.URL, map[string]string{
34952 "profileId": strconv.FormatInt(c.profileId, 10),
34953 })
34954 return gensupport.SendRequest(c.ctx_, c.s.client, req)
34955 }
34956
34957
34958
34959
34960
34961
34962
34963
34964 func (c *LanguagesListCall) Do(opts ...googleapi.CallOption) (*LanguagesListResponse, error) {
34965 gensupport.SetOptions(c.urlParams_, opts...)
34966 res, err := c.doRequest("json")
34967 if res != nil && res.StatusCode == http.StatusNotModified {
34968 if res.Body != nil {
34969 res.Body.Close()
34970 }
34971 return nil, &googleapi.Error{
34972 Code: res.StatusCode,
34973 Header: res.Header,
34974 }
34975 }
34976 if err != nil {
34977 return nil, err
34978 }
34979 defer googleapi.CloseBody(res)
34980 if err := googleapi.CheckResponse(res); err != nil {
34981 return nil, err
34982 }
34983 ret := &LanguagesListResponse{
34984 ServerResponse: googleapi.ServerResponse{
34985 Header: res.Header,
34986 HTTPStatusCode: res.StatusCode,
34987 },
34988 }
34989 target := &ret
34990 if err := gensupport.DecodeResponse(target, res); err != nil {
34991 return nil, err
34992 }
34993 return ret, nil
34994
34995
34996
34997
34998
34999
35000
35001
35002
35003
35004
35005
35006
35007
35008
35009
35010
35011
35012
35013
35014
35015
35016
35017
35018
35019 }
35020
35021
35022
35023 type MetrosListCall struct {
35024 s *Service
35025 profileId int64
35026 urlParams_ gensupport.URLParams
35027 ifNoneMatch_ string
35028 ctx_ context.Context
35029 header_ http.Header
35030 }
35031
35032
35033 func (r *MetrosService) List(profileId int64) *MetrosListCall {
35034 c := &MetrosListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
35035 c.profileId = profileId
35036 return c
35037 }
35038
35039
35040
35041
35042 func (c *MetrosListCall) Fields(s ...googleapi.Field) *MetrosListCall {
35043 c.urlParams_.Set("fields", googleapi.CombineFields(s))
35044 return c
35045 }
35046
35047
35048
35049
35050
35051
35052 func (c *MetrosListCall) IfNoneMatch(entityTag string) *MetrosListCall {
35053 c.ifNoneMatch_ = entityTag
35054 return c
35055 }
35056
35057
35058
35059
35060 func (c *MetrosListCall) Context(ctx context.Context) *MetrosListCall {
35061 c.ctx_ = ctx
35062 return c
35063 }
35064
35065
35066
35067 func (c *MetrosListCall) Header() http.Header {
35068 if c.header_ == nil {
35069 c.header_ = make(http.Header)
35070 }
35071 return c.header_
35072 }
35073
35074 func (c *MetrosListCall) doRequest(alt string) (*http.Response, error) {
35075 reqHeaders := make(http.Header)
35076 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
35077 for k, v := range c.header_ {
35078 reqHeaders[k] = v
35079 }
35080 reqHeaders.Set("User-Agent", c.s.userAgent())
35081 if c.ifNoneMatch_ != "" {
35082 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
35083 }
35084 var body io.Reader = nil
35085 c.urlParams_.Set("alt", alt)
35086 c.urlParams_.Set("prettyPrint", "false")
35087 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/metros")
35088 urls += "?" + c.urlParams_.Encode()
35089 req, err := http.NewRequest("GET", urls, body)
35090 if err != nil {
35091 return nil, err
35092 }
35093 req.Header = reqHeaders
35094 googleapi.Expand(req.URL, map[string]string{
35095 "profileId": strconv.FormatInt(c.profileId, 10),
35096 })
35097 return gensupport.SendRequest(c.ctx_, c.s.client, req)
35098 }
35099
35100
35101
35102
35103
35104
35105
35106
35107 func (c *MetrosListCall) Do(opts ...googleapi.CallOption) (*MetrosListResponse, error) {
35108 gensupport.SetOptions(c.urlParams_, opts...)
35109 res, err := c.doRequest("json")
35110 if res != nil && res.StatusCode == http.StatusNotModified {
35111 if res.Body != nil {
35112 res.Body.Close()
35113 }
35114 return nil, &googleapi.Error{
35115 Code: res.StatusCode,
35116 Header: res.Header,
35117 }
35118 }
35119 if err != nil {
35120 return nil, err
35121 }
35122 defer googleapi.CloseBody(res)
35123 if err := googleapi.CheckResponse(res); err != nil {
35124 return nil, err
35125 }
35126 ret := &MetrosListResponse{
35127 ServerResponse: googleapi.ServerResponse{
35128 Header: res.Header,
35129 HTTPStatusCode: res.StatusCode,
35130 },
35131 }
35132 target := &ret
35133 if err := gensupport.DecodeResponse(target, res); err != nil {
35134 return nil, err
35135 }
35136 return ret, nil
35137
35138
35139
35140
35141
35142
35143
35144
35145
35146
35147
35148
35149
35150
35151
35152
35153
35154
35155
35156
35157
35158
35159
35160
35161
35162 }
35163
35164
35165
35166 type MobileAppsGetCall struct {
35167 s *Service
35168 profileId int64
35169 id string
35170 urlParams_ gensupport.URLParams
35171 ifNoneMatch_ string
35172 ctx_ context.Context
35173 header_ http.Header
35174 }
35175
35176
35177 func (r *MobileAppsService) Get(profileId int64, id string) *MobileAppsGetCall {
35178 c := &MobileAppsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
35179 c.profileId = profileId
35180 c.id = id
35181 return c
35182 }
35183
35184
35185
35186
35187 func (c *MobileAppsGetCall) Fields(s ...googleapi.Field) *MobileAppsGetCall {
35188 c.urlParams_.Set("fields", googleapi.CombineFields(s))
35189 return c
35190 }
35191
35192
35193
35194
35195
35196
35197 func (c *MobileAppsGetCall) IfNoneMatch(entityTag string) *MobileAppsGetCall {
35198 c.ifNoneMatch_ = entityTag
35199 return c
35200 }
35201
35202
35203
35204
35205 func (c *MobileAppsGetCall) Context(ctx context.Context) *MobileAppsGetCall {
35206 c.ctx_ = ctx
35207 return c
35208 }
35209
35210
35211
35212 func (c *MobileAppsGetCall) Header() http.Header {
35213 if c.header_ == nil {
35214 c.header_ = make(http.Header)
35215 }
35216 return c.header_
35217 }
35218
35219 func (c *MobileAppsGetCall) doRequest(alt string) (*http.Response, error) {
35220 reqHeaders := make(http.Header)
35221 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
35222 for k, v := range c.header_ {
35223 reqHeaders[k] = v
35224 }
35225 reqHeaders.Set("User-Agent", c.s.userAgent())
35226 if c.ifNoneMatch_ != "" {
35227 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
35228 }
35229 var body io.Reader = nil
35230 c.urlParams_.Set("alt", alt)
35231 c.urlParams_.Set("prettyPrint", "false")
35232 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/mobileApps/{id}")
35233 urls += "?" + c.urlParams_.Encode()
35234 req, err := http.NewRequest("GET", urls, body)
35235 if err != nil {
35236 return nil, err
35237 }
35238 req.Header = reqHeaders
35239 googleapi.Expand(req.URL, map[string]string{
35240 "profileId": strconv.FormatInt(c.profileId, 10),
35241 "id": c.id,
35242 })
35243 return gensupport.SendRequest(c.ctx_, c.s.client, req)
35244 }
35245
35246
35247
35248
35249
35250
35251
35252
35253 func (c *MobileAppsGetCall) Do(opts ...googleapi.CallOption) (*MobileApp, error) {
35254 gensupport.SetOptions(c.urlParams_, opts...)
35255 res, err := c.doRequest("json")
35256 if res != nil && res.StatusCode == http.StatusNotModified {
35257 if res.Body != nil {
35258 res.Body.Close()
35259 }
35260 return nil, &googleapi.Error{
35261 Code: res.StatusCode,
35262 Header: res.Header,
35263 }
35264 }
35265 if err != nil {
35266 return nil, err
35267 }
35268 defer googleapi.CloseBody(res)
35269 if err := googleapi.CheckResponse(res); err != nil {
35270 return nil, err
35271 }
35272 ret := &MobileApp{
35273 ServerResponse: googleapi.ServerResponse{
35274 Header: res.Header,
35275 HTTPStatusCode: res.StatusCode,
35276 },
35277 }
35278 target := &ret
35279 if err := gensupport.DecodeResponse(target, res); err != nil {
35280 return nil, err
35281 }
35282 return ret, nil
35283
35284
35285
35286
35287
35288
35289
35290
35291
35292
35293
35294
35295
35296
35297
35298
35299
35300
35301
35302
35303
35304
35305
35306
35307
35308
35309
35310
35311
35312
35313
35314
35315 }
35316
35317
35318
35319 type MobileAppsListCall struct {
35320 s *Service
35321 profileId int64
35322 urlParams_ gensupport.URLParams
35323 ifNoneMatch_ string
35324 ctx_ context.Context
35325 header_ http.Header
35326 }
35327
35328
35329 func (r *MobileAppsService) List(profileId int64) *MobileAppsListCall {
35330 c := &MobileAppsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
35331 c.profileId = profileId
35332 return c
35333 }
35334
35335
35336
35337
35338
35339
35340
35341
35342
35343 func (c *MobileAppsListCall) Directories(directories ...string) *MobileAppsListCall {
35344 c.urlParams_.SetMulti("directories", append([]string{}, directories...))
35345 return c
35346 }
35347
35348
35349
35350 func (c *MobileAppsListCall) Ids(ids ...string) *MobileAppsListCall {
35351 c.urlParams_.SetMulti("ids", append([]string{}, ids...))
35352 return c
35353 }
35354
35355
35356
35357 func (c *MobileAppsListCall) MaxResults(maxResults int64) *MobileAppsListCall {
35358 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
35359 return c
35360 }
35361
35362
35363
35364 func (c *MobileAppsListCall) PageToken(pageToken string) *MobileAppsListCall {
35365 c.urlParams_.Set("pageToken", pageToken)
35366 return c
35367 }
35368
35369
35370
35371
35372
35373
35374
35375
35376 func (c *MobileAppsListCall) SearchString(searchString string) *MobileAppsListCall {
35377 c.urlParams_.Set("searchString", searchString)
35378 return c
35379 }
35380
35381
35382
35383
35384 func (c *MobileAppsListCall) Fields(s ...googleapi.Field) *MobileAppsListCall {
35385 c.urlParams_.Set("fields", googleapi.CombineFields(s))
35386 return c
35387 }
35388
35389
35390
35391
35392
35393
35394 func (c *MobileAppsListCall) IfNoneMatch(entityTag string) *MobileAppsListCall {
35395 c.ifNoneMatch_ = entityTag
35396 return c
35397 }
35398
35399
35400
35401
35402 func (c *MobileAppsListCall) Context(ctx context.Context) *MobileAppsListCall {
35403 c.ctx_ = ctx
35404 return c
35405 }
35406
35407
35408
35409 func (c *MobileAppsListCall) Header() http.Header {
35410 if c.header_ == nil {
35411 c.header_ = make(http.Header)
35412 }
35413 return c.header_
35414 }
35415
35416 func (c *MobileAppsListCall) doRequest(alt string) (*http.Response, error) {
35417 reqHeaders := make(http.Header)
35418 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
35419 for k, v := range c.header_ {
35420 reqHeaders[k] = v
35421 }
35422 reqHeaders.Set("User-Agent", c.s.userAgent())
35423 if c.ifNoneMatch_ != "" {
35424 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
35425 }
35426 var body io.Reader = nil
35427 c.urlParams_.Set("alt", alt)
35428 c.urlParams_.Set("prettyPrint", "false")
35429 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/mobileApps")
35430 urls += "?" + c.urlParams_.Encode()
35431 req, err := http.NewRequest("GET", urls, body)
35432 if err != nil {
35433 return nil, err
35434 }
35435 req.Header = reqHeaders
35436 googleapi.Expand(req.URL, map[string]string{
35437 "profileId": strconv.FormatInt(c.profileId, 10),
35438 })
35439 return gensupport.SendRequest(c.ctx_, c.s.client, req)
35440 }
35441
35442
35443
35444
35445
35446
35447
35448
35449 func (c *MobileAppsListCall) Do(opts ...googleapi.CallOption) (*MobileAppsListResponse, error) {
35450 gensupport.SetOptions(c.urlParams_, opts...)
35451 res, err := c.doRequest("json")
35452 if res != nil && res.StatusCode == http.StatusNotModified {
35453 if res.Body != nil {
35454 res.Body.Close()
35455 }
35456 return nil, &googleapi.Error{
35457 Code: res.StatusCode,
35458 Header: res.Header,
35459 }
35460 }
35461 if err != nil {
35462 return nil, err
35463 }
35464 defer googleapi.CloseBody(res)
35465 if err := googleapi.CheckResponse(res); err != nil {
35466 return nil, err
35467 }
35468 ret := &MobileAppsListResponse{
35469 ServerResponse: googleapi.ServerResponse{
35470 Header: res.Header,
35471 HTTPStatusCode: res.StatusCode,
35472 },
35473 }
35474 target := &ret
35475 if err := gensupport.DecodeResponse(target, res); err != nil {
35476 return nil, err
35477 }
35478 return ret, nil
35479
35480
35481
35482
35483
35484
35485
35486
35487
35488
35489
35490
35491
35492
35493
35494
35495
35496
35497
35498
35499
35500
35501
35502
35503
35504
35505
35506
35507
35508
35509
35510
35511
35512
35513
35514
35515
35516
35517
35518
35519
35520
35521
35522
35523
35524
35525
35526
35527
35528
35529
35530
35531
35532
35533
35534
35535
35536
35537
35538
35539
35540
35541
35542
35543
35544
35545 }
35546
35547
35548
35549
35550 func (c *MobileAppsListCall) Pages(ctx context.Context, f func(*MobileAppsListResponse) error) error {
35551 c.ctx_ = ctx
35552 defer c.PageToken(c.urlParams_.Get("pageToken"))
35553 for {
35554 x, err := c.Do()
35555 if err != nil {
35556 return err
35557 }
35558 if err := f(x); err != nil {
35559 return err
35560 }
35561 if x.NextPageToken == "" {
35562 return nil
35563 }
35564 c.PageToken(x.NextPageToken)
35565 }
35566 }
35567
35568
35569
35570 type MobileCarriersGetCall struct {
35571 s *Service
35572 profileId int64
35573 id int64
35574 urlParams_ gensupport.URLParams
35575 ifNoneMatch_ string
35576 ctx_ context.Context
35577 header_ http.Header
35578 }
35579
35580
35581 func (r *MobileCarriersService) Get(profileId int64, id int64) *MobileCarriersGetCall {
35582 c := &MobileCarriersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
35583 c.profileId = profileId
35584 c.id = id
35585 return c
35586 }
35587
35588
35589
35590
35591 func (c *MobileCarriersGetCall) Fields(s ...googleapi.Field) *MobileCarriersGetCall {
35592 c.urlParams_.Set("fields", googleapi.CombineFields(s))
35593 return c
35594 }
35595
35596
35597
35598
35599
35600
35601 func (c *MobileCarriersGetCall) IfNoneMatch(entityTag string) *MobileCarriersGetCall {
35602 c.ifNoneMatch_ = entityTag
35603 return c
35604 }
35605
35606
35607
35608
35609 func (c *MobileCarriersGetCall) Context(ctx context.Context) *MobileCarriersGetCall {
35610 c.ctx_ = ctx
35611 return c
35612 }
35613
35614
35615
35616 func (c *MobileCarriersGetCall) Header() http.Header {
35617 if c.header_ == nil {
35618 c.header_ = make(http.Header)
35619 }
35620 return c.header_
35621 }
35622
35623 func (c *MobileCarriersGetCall) doRequest(alt string) (*http.Response, error) {
35624 reqHeaders := make(http.Header)
35625 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
35626 for k, v := range c.header_ {
35627 reqHeaders[k] = v
35628 }
35629 reqHeaders.Set("User-Agent", c.s.userAgent())
35630 if c.ifNoneMatch_ != "" {
35631 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
35632 }
35633 var body io.Reader = nil
35634 c.urlParams_.Set("alt", alt)
35635 c.urlParams_.Set("prettyPrint", "false")
35636 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/mobileCarriers/{id}")
35637 urls += "?" + c.urlParams_.Encode()
35638 req, err := http.NewRequest("GET", urls, body)
35639 if err != nil {
35640 return nil, err
35641 }
35642 req.Header = reqHeaders
35643 googleapi.Expand(req.URL, map[string]string{
35644 "profileId": strconv.FormatInt(c.profileId, 10),
35645 "id": strconv.FormatInt(c.id, 10),
35646 })
35647 return gensupport.SendRequest(c.ctx_, c.s.client, req)
35648 }
35649
35650
35651
35652
35653
35654
35655
35656
35657 func (c *MobileCarriersGetCall) Do(opts ...googleapi.CallOption) (*MobileCarrier, error) {
35658 gensupport.SetOptions(c.urlParams_, opts...)
35659 res, err := c.doRequest("json")
35660 if res != nil && res.StatusCode == http.StatusNotModified {
35661 if res.Body != nil {
35662 res.Body.Close()
35663 }
35664 return nil, &googleapi.Error{
35665 Code: res.StatusCode,
35666 Header: res.Header,
35667 }
35668 }
35669 if err != nil {
35670 return nil, err
35671 }
35672 defer googleapi.CloseBody(res)
35673 if err := googleapi.CheckResponse(res); err != nil {
35674 return nil, err
35675 }
35676 ret := &MobileCarrier{
35677 ServerResponse: googleapi.ServerResponse{
35678 Header: res.Header,
35679 HTTPStatusCode: res.StatusCode,
35680 },
35681 }
35682 target := &ret
35683 if err := gensupport.DecodeResponse(target, res); err != nil {
35684 return nil, err
35685 }
35686 return ret, nil
35687
35688
35689
35690
35691
35692
35693
35694
35695
35696
35697
35698
35699
35700
35701
35702
35703
35704
35705
35706
35707
35708
35709
35710
35711
35712
35713
35714
35715
35716
35717
35718
35719
35720 }
35721
35722
35723
35724 type MobileCarriersListCall struct {
35725 s *Service
35726 profileId int64
35727 urlParams_ gensupport.URLParams
35728 ifNoneMatch_ string
35729 ctx_ context.Context
35730 header_ http.Header
35731 }
35732
35733
35734 func (r *MobileCarriersService) List(profileId int64) *MobileCarriersListCall {
35735 c := &MobileCarriersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
35736 c.profileId = profileId
35737 return c
35738 }
35739
35740
35741
35742
35743 func (c *MobileCarriersListCall) Fields(s ...googleapi.Field) *MobileCarriersListCall {
35744 c.urlParams_.Set("fields", googleapi.CombineFields(s))
35745 return c
35746 }
35747
35748
35749
35750
35751
35752
35753 func (c *MobileCarriersListCall) IfNoneMatch(entityTag string) *MobileCarriersListCall {
35754 c.ifNoneMatch_ = entityTag
35755 return c
35756 }
35757
35758
35759
35760
35761 func (c *MobileCarriersListCall) Context(ctx context.Context) *MobileCarriersListCall {
35762 c.ctx_ = ctx
35763 return c
35764 }
35765
35766
35767
35768 func (c *MobileCarriersListCall) Header() http.Header {
35769 if c.header_ == nil {
35770 c.header_ = make(http.Header)
35771 }
35772 return c.header_
35773 }
35774
35775 func (c *MobileCarriersListCall) doRequest(alt string) (*http.Response, error) {
35776 reqHeaders := make(http.Header)
35777 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
35778 for k, v := range c.header_ {
35779 reqHeaders[k] = v
35780 }
35781 reqHeaders.Set("User-Agent", c.s.userAgent())
35782 if c.ifNoneMatch_ != "" {
35783 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
35784 }
35785 var body io.Reader = nil
35786 c.urlParams_.Set("alt", alt)
35787 c.urlParams_.Set("prettyPrint", "false")
35788 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/mobileCarriers")
35789 urls += "?" + c.urlParams_.Encode()
35790 req, err := http.NewRequest("GET", urls, body)
35791 if err != nil {
35792 return nil, err
35793 }
35794 req.Header = reqHeaders
35795 googleapi.Expand(req.URL, map[string]string{
35796 "profileId": strconv.FormatInt(c.profileId, 10),
35797 })
35798 return gensupport.SendRequest(c.ctx_, c.s.client, req)
35799 }
35800
35801
35802
35803
35804
35805
35806
35807
35808 func (c *MobileCarriersListCall) Do(opts ...googleapi.CallOption) (*MobileCarriersListResponse, error) {
35809 gensupport.SetOptions(c.urlParams_, opts...)
35810 res, err := c.doRequest("json")
35811 if res != nil && res.StatusCode == http.StatusNotModified {
35812 if res.Body != nil {
35813 res.Body.Close()
35814 }
35815 return nil, &googleapi.Error{
35816 Code: res.StatusCode,
35817 Header: res.Header,
35818 }
35819 }
35820 if err != nil {
35821 return nil, err
35822 }
35823 defer googleapi.CloseBody(res)
35824 if err := googleapi.CheckResponse(res); err != nil {
35825 return nil, err
35826 }
35827 ret := &MobileCarriersListResponse{
35828 ServerResponse: googleapi.ServerResponse{
35829 Header: res.Header,
35830 HTTPStatusCode: res.StatusCode,
35831 },
35832 }
35833 target := &ret
35834 if err := gensupport.DecodeResponse(target, res); err != nil {
35835 return nil, err
35836 }
35837 return ret, nil
35838
35839
35840
35841
35842
35843
35844
35845
35846
35847
35848
35849
35850
35851
35852
35853
35854
35855
35856
35857
35858
35859
35860
35861
35862
35863 }
35864
35865
35866
35867 type OperatingSystemVersionsGetCall struct {
35868 s *Service
35869 profileId int64
35870 id int64
35871 urlParams_ gensupport.URLParams
35872 ifNoneMatch_ string
35873 ctx_ context.Context
35874 header_ http.Header
35875 }
35876
35877
35878 func (r *OperatingSystemVersionsService) Get(profileId int64, id int64) *OperatingSystemVersionsGetCall {
35879 c := &OperatingSystemVersionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
35880 c.profileId = profileId
35881 c.id = id
35882 return c
35883 }
35884
35885
35886
35887
35888 func (c *OperatingSystemVersionsGetCall) Fields(s ...googleapi.Field) *OperatingSystemVersionsGetCall {
35889 c.urlParams_.Set("fields", googleapi.CombineFields(s))
35890 return c
35891 }
35892
35893
35894
35895
35896
35897
35898 func (c *OperatingSystemVersionsGetCall) IfNoneMatch(entityTag string) *OperatingSystemVersionsGetCall {
35899 c.ifNoneMatch_ = entityTag
35900 return c
35901 }
35902
35903
35904
35905
35906 func (c *OperatingSystemVersionsGetCall) Context(ctx context.Context) *OperatingSystemVersionsGetCall {
35907 c.ctx_ = ctx
35908 return c
35909 }
35910
35911
35912
35913 func (c *OperatingSystemVersionsGetCall) Header() http.Header {
35914 if c.header_ == nil {
35915 c.header_ = make(http.Header)
35916 }
35917 return c.header_
35918 }
35919
35920 func (c *OperatingSystemVersionsGetCall) doRequest(alt string) (*http.Response, error) {
35921 reqHeaders := make(http.Header)
35922 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
35923 for k, v := range c.header_ {
35924 reqHeaders[k] = v
35925 }
35926 reqHeaders.Set("User-Agent", c.s.userAgent())
35927 if c.ifNoneMatch_ != "" {
35928 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
35929 }
35930 var body io.Reader = nil
35931 c.urlParams_.Set("alt", alt)
35932 c.urlParams_.Set("prettyPrint", "false")
35933 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/operatingSystemVersions/{id}")
35934 urls += "?" + c.urlParams_.Encode()
35935 req, err := http.NewRequest("GET", urls, body)
35936 if err != nil {
35937 return nil, err
35938 }
35939 req.Header = reqHeaders
35940 googleapi.Expand(req.URL, map[string]string{
35941 "profileId": strconv.FormatInt(c.profileId, 10),
35942 "id": strconv.FormatInt(c.id, 10),
35943 })
35944 return gensupport.SendRequest(c.ctx_, c.s.client, req)
35945 }
35946
35947
35948
35949
35950
35951
35952
35953
35954 func (c *OperatingSystemVersionsGetCall) Do(opts ...googleapi.CallOption) (*OperatingSystemVersion, error) {
35955 gensupport.SetOptions(c.urlParams_, opts...)
35956 res, err := c.doRequest("json")
35957 if res != nil && res.StatusCode == http.StatusNotModified {
35958 if res.Body != nil {
35959 res.Body.Close()
35960 }
35961 return nil, &googleapi.Error{
35962 Code: res.StatusCode,
35963 Header: res.Header,
35964 }
35965 }
35966 if err != nil {
35967 return nil, err
35968 }
35969 defer googleapi.CloseBody(res)
35970 if err := googleapi.CheckResponse(res); err != nil {
35971 return nil, err
35972 }
35973 ret := &OperatingSystemVersion{
35974 ServerResponse: googleapi.ServerResponse{
35975 Header: res.Header,
35976 HTTPStatusCode: res.StatusCode,
35977 },
35978 }
35979 target := &ret
35980 if err := gensupport.DecodeResponse(target, res); err != nil {
35981 return nil, err
35982 }
35983 return ret, nil
35984
35985
35986
35987
35988
35989
35990
35991
35992
35993
35994
35995
35996
35997
35998
35999
36000
36001
36002
36003
36004
36005
36006
36007
36008
36009
36010
36011
36012
36013
36014
36015
36016
36017 }
36018
36019
36020
36021 type OperatingSystemVersionsListCall struct {
36022 s *Service
36023 profileId int64
36024 urlParams_ gensupport.URLParams
36025 ifNoneMatch_ string
36026 ctx_ context.Context
36027 header_ http.Header
36028 }
36029
36030
36031 func (r *OperatingSystemVersionsService) List(profileId int64) *OperatingSystemVersionsListCall {
36032 c := &OperatingSystemVersionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
36033 c.profileId = profileId
36034 return c
36035 }
36036
36037
36038
36039
36040 func (c *OperatingSystemVersionsListCall) Fields(s ...googleapi.Field) *OperatingSystemVersionsListCall {
36041 c.urlParams_.Set("fields", googleapi.CombineFields(s))
36042 return c
36043 }
36044
36045
36046
36047
36048
36049
36050 func (c *OperatingSystemVersionsListCall) IfNoneMatch(entityTag string) *OperatingSystemVersionsListCall {
36051 c.ifNoneMatch_ = entityTag
36052 return c
36053 }
36054
36055
36056
36057
36058 func (c *OperatingSystemVersionsListCall) Context(ctx context.Context) *OperatingSystemVersionsListCall {
36059 c.ctx_ = ctx
36060 return c
36061 }
36062
36063
36064
36065 func (c *OperatingSystemVersionsListCall) Header() http.Header {
36066 if c.header_ == nil {
36067 c.header_ = make(http.Header)
36068 }
36069 return c.header_
36070 }
36071
36072 func (c *OperatingSystemVersionsListCall) doRequest(alt string) (*http.Response, error) {
36073 reqHeaders := make(http.Header)
36074 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
36075 for k, v := range c.header_ {
36076 reqHeaders[k] = v
36077 }
36078 reqHeaders.Set("User-Agent", c.s.userAgent())
36079 if c.ifNoneMatch_ != "" {
36080 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
36081 }
36082 var body io.Reader = nil
36083 c.urlParams_.Set("alt", alt)
36084 c.urlParams_.Set("prettyPrint", "false")
36085 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/operatingSystemVersions")
36086 urls += "?" + c.urlParams_.Encode()
36087 req, err := http.NewRequest("GET", urls, body)
36088 if err != nil {
36089 return nil, err
36090 }
36091 req.Header = reqHeaders
36092 googleapi.Expand(req.URL, map[string]string{
36093 "profileId": strconv.FormatInt(c.profileId, 10),
36094 })
36095 return gensupport.SendRequest(c.ctx_, c.s.client, req)
36096 }
36097
36098
36099
36100
36101
36102
36103
36104
36105
36106 func (c *OperatingSystemVersionsListCall) Do(opts ...googleapi.CallOption) (*OperatingSystemVersionsListResponse, error) {
36107 gensupport.SetOptions(c.urlParams_, opts...)
36108 res, err := c.doRequest("json")
36109 if res != nil && res.StatusCode == http.StatusNotModified {
36110 if res.Body != nil {
36111 res.Body.Close()
36112 }
36113 return nil, &googleapi.Error{
36114 Code: res.StatusCode,
36115 Header: res.Header,
36116 }
36117 }
36118 if err != nil {
36119 return nil, err
36120 }
36121 defer googleapi.CloseBody(res)
36122 if err := googleapi.CheckResponse(res); err != nil {
36123 return nil, err
36124 }
36125 ret := &OperatingSystemVersionsListResponse{
36126 ServerResponse: googleapi.ServerResponse{
36127 Header: res.Header,
36128 HTTPStatusCode: res.StatusCode,
36129 },
36130 }
36131 target := &ret
36132 if err := gensupport.DecodeResponse(target, res); err != nil {
36133 return nil, err
36134 }
36135 return ret, nil
36136
36137
36138
36139
36140
36141
36142
36143
36144
36145
36146
36147
36148
36149
36150
36151
36152
36153
36154
36155
36156
36157
36158
36159
36160
36161 }
36162
36163
36164
36165 type OperatingSystemsGetCall struct {
36166 s *Service
36167 profileId int64
36168 dartId int64
36169 urlParams_ gensupport.URLParams
36170 ifNoneMatch_ string
36171 ctx_ context.Context
36172 header_ http.Header
36173 }
36174
36175
36176 func (r *OperatingSystemsService) Get(profileId int64, dartId int64) *OperatingSystemsGetCall {
36177 c := &OperatingSystemsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
36178 c.profileId = profileId
36179 c.dartId = dartId
36180 return c
36181 }
36182
36183
36184
36185
36186 func (c *OperatingSystemsGetCall) Fields(s ...googleapi.Field) *OperatingSystemsGetCall {
36187 c.urlParams_.Set("fields", googleapi.CombineFields(s))
36188 return c
36189 }
36190
36191
36192
36193
36194
36195
36196 func (c *OperatingSystemsGetCall) IfNoneMatch(entityTag string) *OperatingSystemsGetCall {
36197 c.ifNoneMatch_ = entityTag
36198 return c
36199 }
36200
36201
36202
36203
36204 func (c *OperatingSystemsGetCall) Context(ctx context.Context) *OperatingSystemsGetCall {
36205 c.ctx_ = ctx
36206 return c
36207 }
36208
36209
36210
36211 func (c *OperatingSystemsGetCall) Header() http.Header {
36212 if c.header_ == nil {
36213 c.header_ = make(http.Header)
36214 }
36215 return c.header_
36216 }
36217
36218 func (c *OperatingSystemsGetCall) doRequest(alt string) (*http.Response, error) {
36219 reqHeaders := make(http.Header)
36220 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
36221 for k, v := range c.header_ {
36222 reqHeaders[k] = v
36223 }
36224 reqHeaders.Set("User-Agent", c.s.userAgent())
36225 if c.ifNoneMatch_ != "" {
36226 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
36227 }
36228 var body io.Reader = nil
36229 c.urlParams_.Set("alt", alt)
36230 c.urlParams_.Set("prettyPrint", "false")
36231 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/operatingSystems/{dartId}")
36232 urls += "?" + c.urlParams_.Encode()
36233 req, err := http.NewRequest("GET", urls, body)
36234 if err != nil {
36235 return nil, err
36236 }
36237 req.Header = reqHeaders
36238 googleapi.Expand(req.URL, map[string]string{
36239 "profileId": strconv.FormatInt(c.profileId, 10),
36240 "dartId": strconv.FormatInt(c.dartId, 10),
36241 })
36242 return gensupport.SendRequest(c.ctx_, c.s.client, req)
36243 }
36244
36245
36246
36247
36248
36249
36250
36251
36252 func (c *OperatingSystemsGetCall) Do(opts ...googleapi.CallOption) (*OperatingSystem, error) {
36253 gensupport.SetOptions(c.urlParams_, opts...)
36254 res, err := c.doRequest("json")
36255 if res != nil && res.StatusCode == http.StatusNotModified {
36256 if res.Body != nil {
36257 res.Body.Close()
36258 }
36259 return nil, &googleapi.Error{
36260 Code: res.StatusCode,
36261 Header: res.Header,
36262 }
36263 }
36264 if err != nil {
36265 return nil, err
36266 }
36267 defer googleapi.CloseBody(res)
36268 if err := googleapi.CheckResponse(res); err != nil {
36269 return nil, err
36270 }
36271 ret := &OperatingSystem{
36272 ServerResponse: googleapi.ServerResponse{
36273 Header: res.Header,
36274 HTTPStatusCode: res.StatusCode,
36275 },
36276 }
36277 target := &ret
36278 if err := gensupport.DecodeResponse(target, res); err != nil {
36279 return nil, err
36280 }
36281 return ret, nil
36282
36283
36284
36285
36286
36287
36288
36289
36290
36291
36292
36293
36294
36295
36296
36297
36298
36299
36300
36301
36302
36303
36304
36305
36306
36307
36308
36309
36310
36311
36312
36313
36314
36315 }
36316
36317
36318
36319 type OperatingSystemsListCall struct {
36320 s *Service
36321 profileId int64
36322 urlParams_ gensupport.URLParams
36323 ifNoneMatch_ string
36324 ctx_ context.Context
36325 header_ http.Header
36326 }
36327
36328
36329 func (r *OperatingSystemsService) List(profileId int64) *OperatingSystemsListCall {
36330 c := &OperatingSystemsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
36331 c.profileId = profileId
36332 return c
36333 }
36334
36335
36336
36337
36338 func (c *OperatingSystemsListCall) Fields(s ...googleapi.Field) *OperatingSystemsListCall {
36339 c.urlParams_.Set("fields", googleapi.CombineFields(s))
36340 return c
36341 }
36342
36343
36344
36345
36346
36347
36348 func (c *OperatingSystemsListCall) IfNoneMatch(entityTag string) *OperatingSystemsListCall {
36349 c.ifNoneMatch_ = entityTag
36350 return c
36351 }
36352
36353
36354
36355
36356 func (c *OperatingSystemsListCall) Context(ctx context.Context) *OperatingSystemsListCall {
36357 c.ctx_ = ctx
36358 return c
36359 }
36360
36361
36362
36363 func (c *OperatingSystemsListCall) Header() http.Header {
36364 if c.header_ == nil {
36365 c.header_ = make(http.Header)
36366 }
36367 return c.header_
36368 }
36369
36370 func (c *OperatingSystemsListCall) doRequest(alt string) (*http.Response, error) {
36371 reqHeaders := make(http.Header)
36372 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
36373 for k, v := range c.header_ {
36374 reqHeaders[k] = v
36375 }
36376 reqHeaders.Set("User-Agent", c.s.userAgent())
36377 if c.ifNoneMatch_ != "" {
36378 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
36379 }
36380 var body io.Reader = nil
36381 c.urlParams_.Set("alt", alt)
36382 c.urlParams_.Set("prettyPrint", "false")
36383 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/operatingSystems")
36384 urls += "?" + c.urlParams_.Encode()
36385 req, err := http.NewRequest("GET", urls, body)
36386 if err != nil {
36387 return nil, err
36388 }
36389 req.Header = reqHeaders
36390 googleapi.Expand(req.URL, map[string]string{
36391 "profileId": strconv.FormatInt(c.profileId, 10),
36392 })
36393 return gensupport.SendRequest(c.ctx_, c.s.client, req)
36394 }
36395
36396
36397
36398
36399
36400
36401
36402
36403 func (c *OperatingSystemsListCall) Do(opts ...googleapi.CallOption) (*OperatingSystemsListResponse, error) {
36404 gensupport.SetOptions(c.urlParams_, opts...)
36405 res, err := c.doRequest("json")
36406 if res != nil && res.StatusCode == http.StatusNotModified {
36407 if res.Body != nil {
36408 res.Body.Close()
36409 }
36410 return nil, &googleapi.Error{
36411 Code: res.StatusCode,
36412 Header: res.Header,
36413 }
36414 }
36415 if err != nil {
36416 return nil, err
36417 }
36418 defer googleapi.CloseBody(res)
36419 if err := googleapi.CheckResponse(res); err != nil {
36420 return nil, err
36421 }
36422 ret := &OperatingSystemsListResponse{
36423 ServerResponse: googleapi.ServerResponse{
36424 Header: res.Header,
36425 HTTPStatusCode: res.StatusCode,
36426 },
36427 }
36428 target := &ret
36429 if err := gensupport.DecodeResponse(target, res); err != nil {
36430 return nil, err
36431 }
36432 return ret, nil
36433
36434
36435
36436
36437
36438
36439
36440
36441
36442
36443
36444
36445
36446
36447
36448
36449
36450
36451
36452
36453
36454
36455
36456
36457
36458 }
36459
36460
36461
36462 type OrderDocumentsGetCall struct {
36463 s *Service
36464 profileId int64
36465 projectId int64
36466 id int64
36467 urlParams_ gensupport.URLParams
36468 ifNoneMatch_ string
36469 ctx_ context.Context
36470 header_ http.Header
36471 }
36472
36473
36474 func (r *OrderDocumentsService) Get(profileId int64, projectId int64, id int64) *OrderDocumentsGetCall {
36475 c := &OrderDocumentsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
36476 c.profileId = profileId
36477 c.projectId = projectId
36478 c.id = id
36479 return c
36480 }
36481
36482
36483
36484
36485 func (c *OrderDocumentsGetCall) Fields(s ...googleapi.Field) *OrderDocumentsGetCall {
36486 c.urlParams_.Set("fields", googleapi.CombineFields(s))
36487 return c
36488 }
36489
36490
36491
36492
36493
36494
36495 func (c *OrderDocumentsGetCall) IfNoneMatch(entityTag string) *OrderDocumentsGetCall {
36496 c.ifNoneMatch_ = entityTag
36497 return c
36498 }
36499
36500
36501
36502
36503 func (c *OrderDocumentsGetCall) Context(ctx context.Context) *OrderDocumentsGetCall {
36504 c.ctx_ = ctx
36505 return c
36506 }
36507
36508
36509
36510 func (c *OrderDocumentsGetCall) Header() http.Header {
36511 if c.header_ == nil {
36512 c.header_ = make(http.Header)
36513 }
36514 return c.header_
36515 }
36516
36517 func (c *OrderDocumentsGetCall) doRequest(alt string) (*http.Response, error) {
36518 reqHeaders := make(http.Header)
36519 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
36520 for k, v := range c.header_ {
36521 reqHeaders[k] = v
36522 }
36523 reqHeaders.Set("User-Agent", c.s.userAgent())
36524 if c.ifNoneMatch_ != "" {
36525 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
36526 }
36527 var body io.Reader = nil
36528 c.urlParams_.Set("alt", alt)
36529 c.urlParams_.Set("prettyPrint", "false")
36530 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/projects/{projectId}/orderDocuments/{id}")
36531 urls += "?" + c.urlParams_.Encode()
36532 req, err := http.NewRequest("GET", urls, body)
36533 if err != nil {
36534 return nil, err
36535 }
36536 req.Header = reqHeaders
36537 googleapi.Expand(req.URL, map[string]string{
36538 "profileId": strconv.FormatInt(c.profileId, 10),
36539 "projectId": strconv.FormatInt(c.projectId, 10),
36540 "id": strconv.FormatInt(c.id, 10),
36541 })
36542 return gensupport.SendRequest(c.ctx_, c.s.client, req)
36543 }
36544
36545
36546
36547
36548
36549
36550
36551
36552 func (c *OrderDocumentsGetCall) Do(opts ...googleapi.CallOption) (*OrderDocument, error) {
36553 gensupport.SetOptions(c.urlParams_, opts...)
36554 res, err := c.doRequest("json")
36555 if res != nil && res.StatusCode == http.StatusNotModified {
36556 if res.Body != nil {
36557 res.Body.Close()
36558 }
36559 return nil, &googleapi.Error{
36560 Code: res.StatusCode,
36561 Header: res.Header,
36562 }
36563 }
36564 if err != nil {
36565 return nil, err
36566 }
36567 defer googleapi.CloseBody(res)
36568 if err := googleapi.CheckResponse(res); err != nil {
36569 return nil, err
36570 }
36571 ret := &OrderDocument{
36572 ServerResponse: googleapi.ServerResponse{
36573 Header: res.Header,
36574 HTTPStatusCode: res.StatusCode,
36575 },
36576 }
36577 target := &ret
36578 if err := gensupport.DecodeResponse(target, res); err != nil {
36579 return nil, err
36580 }
36581 return ret, nil
36582
36583
36584
36585
36586
36587
36588
36589
36590
36591
36592
36593
36594
36595
36596
36597
36598
36599
36600
36601
36602
36603
36604
36605
36606
36607
36608
36609
36610
36611
36612
36613
36614
36615
36616
36617
36618
36619
36620
36621
36622
36623 }
36624
36625
36626
36627 type OrderDocumentsListCall struct {
36628 s *Service
36629 profileId int64
36630 projectId int64
36631 urlParams_ gensupport.URLParams
36632 ifNoneMatch_ string
36633 ctx_ context.Context
36634 header_ http.Header
36635 }
36636
36637
36638
36639 func (r *OrderDocumentsService) List(profileId int64, projectId int64) *OrderDocumentsListCall {
36640 c := &OrderDocumentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
36641 c.profileId = profileId
36642 c.projectId = projectId
36643 return c
36644 }
36645
36646
36647
36648 func (c *OrderDocumentsListCall) Approved(approved bool) *OrderDocumentsListCall {
36649 c.urlParams_.Set("approved", fmt.Sprint(approved))
36650 return c
36651 }
36652
36653
36654
36655 func (c *OrderDocumentsListCall) Ids(ids ...int64) *OrderDocumentsListCall {
36656 var ids_ []string
36657 for _, v := range ids {
36658 ids_ = append(ids_, fmt.Sprint(v))
36659 }
36660 c.urlParams_.SetMulti("ids", ids_)
36661 return c
36662 }
36663
36664
36665
36666 func (c *OrderDocumentsListCall) MaxResults(maxResults int64) *OrderDocumentsListCall {
36667 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
36668 return c
36669 }
36670
36671
36672
36673 func (c *OrderDocumentsListCall) OrderId(orderId ...int64) *OrderDocumentsListCall {
36674 var orderId_ []string
36675 for _, v := range orderId {
36676 orderId_ = append(orderId_, fmt.Sprint(v))
36677 }
36678 c.urlParams_.SetMulti("orderId", orderId_)
36679 return c
36680 }
36681
36682
36683
36684 func (c *OrderDocumentsListCall) PageToken(pageToken string) *OrderDocumentsListCall {
36685 c.urlParams_.Set("pageToken", pageToken)
36686 return c
36687 }
36688
36689
36690
36691
36692
36693
36694
36695
36696
36697
36698 func (c *OrderDocumentsListCall) SearchString(searchString string) *OrderDocumentsListCall {
36699 c.urlParams_.Set("searchString", searchString)
36700 return c
36701 }
36702
36703
36704
36705 func (c *OrderDocumentsListCall) SiteId(siteId ...int64) *OrderDocumentsListCall {
36706 var siteId_ []string
36707 for _, v := range siteId {
36708 siteId_ = append(siteId_, fmt.Sprint(v))
36709 }
36710 c.urlParams_.SetMulti("siteId", siteId_)
36711 return c
36712 }
36713
36714
36715
36716
36717
36718
36719
36720
36721 func (c *OrderDocumentsListCall) SortField(sortField string) *OrderDocumentsListCall {
36722 c.urlParams_.Set("sortField", sortField)
36723 return c
36724 }
36725
36726
36727
36728
36729
36730
36731
36732
36733 func (c *OrderDocumentsListCall) SortOrder(sortOrder string) *OrderDocumentsListCall {
36734 c.urlParams_.Set("sortOrder", sortOrder)
36735 return c
36736 }
36737
36738
36739
36740
36741 func (c *OrderDocumentsListCall) Fields(s ...googleapi.Field) *OrderDocumentsListCall {
36742 c.urlParams_.Set("fields", googleapi.CombineFields(s))
36743 return c
36744 }
36745
36746
36747
36748
36749
36750
36751 func (c *OrderDocumentsListCall) IfNoneMatch(entityTag string) *OrderDocumentsListCall {
36752 c.ifNoneMatch_ = entityTag
36753 return c
36754 }
36755
36756
36757
36758
36759 func (c *OrderDocumentsListCall) Context(ctx context.Context) *OrderDocumentsListCall {
36760 c.ctx_ = ctx
36761 return c
36762 }
36763
36764
36765
36766 func (c *OrderDocumentsListCall) Header() http.Header {
36767 if c.header_ == nil {
36768 c.header_ = make(http.Header)
36769 }
36770 return c.header_
36771 }
36772
36773 func (c *OrderDocumentsListCall) doRequest(alt string) (*http.Response, error) {
36774 reqHeaders := make(http.Header)
36775 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
36776 for k, v := range c.header_ {
36777 reqHeaders[k] = v
36778 }
36779 reqHeaders.Set("User-Agent", c.s.userAgent())
36780 if c.ifNoneMatch_ != "" {
36781 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
36782 }
36783 var body io.Reader = nil
36784 c.urlParams_.Set("alt", alt)
36785 c.urlParams_.Set("prettyPrint", "false")
36786 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/projects/{projectId}/orderDocuments")
36787 urls += "?" + c.urlParams_.Encode()
36788 req, err := http.NewRequest("GET", urls, body)
36789 if err != nil {
36790 return nil, err
36791 }
36792 req.Header = reqHeaders
36793 googleapi.Expand(req.URL, map[string]string{
36794 "profileId": strconv.FormatInt(c.profileId, 10),
36795 "projectId": strconv.FormatInt(c.projectId, 10),
36796 })
36797 return gensupport.SendRequest(c.ctx_, c.s.client, req)
36798 }
36799
36800
36801
36802
36803
36804
36805
36806
36807 func (c *OrderDocumentsListCall) Do(opts ...googleapi.CallOption) (*OrderDocumentsListResponse, error) {
36808 gensupport.SetOptions(c.urlParams_, opts...)
36809 res, err := c.doRequest("json")
36810 if res != nil && res.StatusCode == http.StatusNotModified {
36811 if res.Body != nil {
36812 res.Body.Close()
36813 }
36814 return nil, &googleapi.Error{
36815 Code: res.StatusCode,
36816 Header: res.Header,
36817 }
36818 }
36819 if err != nil {
36820 return nil, err
36821 }
36822 defer googleapi.CloseBody(res)
36823 if err := googleapi.CheckResponse(res); err != nil {
36824 return nil, err
36825 }
36826 ret := &OrderDocumentsListResponse{
36827 ServerResponse: googleapi.ServerResponse{
36828 Header: res.Header,
36829 HTTPStatusCode: res.StatusCode,
36830 },
36831 }
36832 target := &ret
36833 if err := gensupport.DecodeResponse(target, res); err != nil {
36834 return nil, err
36835 }
36836 return ret, nil
36837
36838
36839
36840
36841
36842
36843
36844
36845
36846
36847
36848
36849
36850
36851
36852
36853
36854
36855
36856
36857
36858
36859
36860
36861
36862
36863
36864
36865
36866
36867
36868
36869
36870
36871
36872
36873
36874
36875
36876
36877
36878
36879
36880
36881
36882
36883
36884
36885
36886
36887
36888
36889
36890
36891
36892
36893
36894
36895
36896
36897
36898
36899
36900
36901
36902
36903
36904
36905
36906
36907
36908
36909
36910
36911
36912
36913
36914
36915
36916
36917
36918
36919
36920
36921
36922
36923
36924
36925
36926
36927
36928
36929
36930
36931
36932
36933
36934
36935
36936
36937
36938
36939
36940
36941
36942
36943 }
36944
36945
36946
36947
36948 func (c *OrderDocumentsListCall) Pages(ctx context.Context, f func(*OrderDocumentsListResponse) error) error {
36949 c.ctx_ = ctx
36950 defer c.PageToken(c.urlParams_.Get("pageToken"))
36951 for {
36952 x, err := c.Do()
36953 if err != nil {
36954 return err
36955 }
36956 if err := f(x); err != nil {
36957 return err
36958 }
36959 if x.NextPageToken == "" {
36960 return nil
36961 }
36962 c.PageToken(x.NextPageToken)
36963 }
36964 }
36965
36966
36967
36968 type OrdersGetCall struct {
36969 s *Service
36970 profileId int64
36971 projectId int64
36972 id int64
36973 urlParams_ gensupport.URLParams
36974 ifNoneMatch_ string
36975 ctx_ context.Context
36976 header_ http.Header
36977 }
36978
36979
36980 func (r *OrdersService) Get(profileId int64, projectId int64, id int64) *OrdersGetCall {
36981 c := &OrdersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
36982 c.profileId = profileId
36983 c.projectId = projectId
36984 c.id = id
36985 return c
36986 }
36987
36988
36989
36990
36991 func (c *OrdersGetCall) Fields(s ...googleapi.Field) *OrdersGetCall {
36992 c.urlParams_.Set("fields", googleapi.CombineFields(s))
36993 return c
36994 }
36995
36996
36997
36998
36999
37000
37001 func (c *OrdersGetCall) IfNoneMatch(entityTag string) *OrdersGetCall {
37002 c.ifNoneMatch_ = entityTag
37003 return c
37004 }
37005
37006
37007
37008
37009 func (c *OrdersGetCall) Context(ctx context.Context) *OrdersGetCall {
37010 c.ctx_ = ctx
37011 return c
37012 }
37013
37014
37015
37016 func (c *OrdersGetCall) Header() http.Header {
37017 if c.header_ == nil {
37018 c.header_ = make(http.Header)
37019 }
37020 return c.header_
37021 }
37022
37023 func (c *OrdersGetCall) doRequest(alt string) (*http.Response, error) {
37024 reqHeaders := make(http.Header)
37025 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
37026 for k, v := range c.header_ {
37027 reqHeaders[k] = v
37028 }
37029 reqHeaders.Set("User-Agent", c.s.userAgent())
37030 if c.ifNoneMatch_ != "" {
37031 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
37032 }
37033 var body io.Reader = nil
37034 c.urlParams_.Set("alt", alt)
37035 c.urlParams_.Set("prettyPrint", "false")
37036 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/projects/{projectId}/orders/{id}")
37037 urls += "?" + c.urlParams_.Encode()
37038 req, err := http.NewRequest("GET", urls, body)
37039 if err != nil {
37040 return nil, err
37041 }
37042 req.Header = reqHeaders
37043 googleapi.Expand(req.URL, map[string]string{
37044 "profileId": strconv.FormatInt(c.profileId, 10),
37045 "projectId": strconv.FormatInt(c.projectId, 10),
37046 "id": strconv.FormatInt(c.id, 10),
37047 })
37048 return gensupport.SendRequest(c.ctx_, c.s.client, req)
37049 }
37050
37051
37052
37053
37054
37055
37056
37057
37058 func (c *OrdersGetCall) Do(opts ...googleapi.CallOption) (*Order, error) {
37059 gensupport.SetOptions(c.urlParams_, opts...)
37060 res, err := c.doRequest("json")
37061 if res != nil && res.StatusCode == http.StatusNotModified {
37062 if res.Body != nil {
37063 res.Body.Close()
37064 }
37065 return nil, &googleapi.Error{
37066 Code: res.StatusCode,
37067 Header: res.Header,
37068 }
37069 }
37070 if err != nil {
37071 return nil, err
37072 }
37073 defer googleapi.CloseBody(res)
37074 if err := googleapi.CheckResponse(res); err != nil {
37075 return nil, err
37076 }
37077 ret := &Order{
37078 ServerResponse: googleapi.ServerResponse{
37079 Header: res.Header,
37080 HTTPStatusCode: res.StatusCode,
37081 },
37082 }
37083 target := &ret
37084 if err := gensupport.DecodeResponse(target, res); err != nil {
37085 return nil, err
37086 }
37087 return ret, nil
37088
37089
37090
37091
37092
37093
37094
37095
37096
37097
37098
37099
37100
37101
37102
37103
37104
37105
37106
37107
37108
37109
37110
37111
37112
37113
37114
37115
37116
37117
37118
37119
37120
37121
37122
37123
37124
37125
37126
37127
37128
37129 }
37130
37131
37132
37133 type OrdersListCall struct {
37134 s *Service
37135 profileId int64
37136 projectId int64
37137 urlParams_ gensupport.URLParams
37138 ifNoneMatch_ string
37139 ctx_ context.Context
37140 header_ http.Header
37141 }
37142
37143
37144
37145 func (r *OrdersService) List(profileId int64, projectId int64) *OrdersListCall {
37146 c := &OrdersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
37147 c.profileId = profileId
37148 c.projectId = projectId
37149 return c
37150 }
37151
37152
37153
37154 func (c *OrdersListCall) Ids(ids ...int64) *OrdersListCall {
37155 var ids_ []string
37156 for _, v := range ids {
37157 ids_ = append(ids_, fmt.Sprint(v))
37158 }
37159 c.urlParams_.SetMulti("ids", ids_)
37160 return c
37161 }
37162
37163
37164
37165 func (c *OrdersListCall) MaxResults(maxResults int64) *OrdersListCall {
37166 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
37167 return c
37168 }
37169
37170
37171
37172 func (c *OrdersListCall) PageToken(pageToken string) *OrdersListCall {
37173 c.urlParams_.Set("pageToken", pageToken)
37174 return c
37175 }
37176
37177
37178
37179
37180
37181
37182
37183
37184 func (c *OrdersListCall) SearchString(searchString string) *OrdersListCall {
37185 c.urlParams_.Set("searchString", searchString)
37186 return c
37187 }
37188
37189
37190
37191 func (c *OrdersListCall) SiteId(siteId ...int64) *OrdersListCall {
37192 var siteId_ []string
37193 for _, v := range siteId {
37194 siteId_ = append(siteId_, fmt.Sprint(v))
37195 }
37196 c.urlParams_.SetMulti("siteId", siteId_)
37197 return c
37198 }
37199
37200
37201
37202
37203
37204
37205
37206
37207 func (c *OrdersListCall) SortField(sortField string) *OrdersListCall {
37208 c.urlParams_.Set("sortField", sortField)
37209 return c
37210 }
37211
37212
37213
37214
37215
37216
37217
37218
37219 func (c *OrdersListCall) SortOrder(sortOrder string) *OrdersListCall {
37220 c.urlParams_.Set("sortOrder", sortOrder)
37221 return c
37222 }
37223
37224
37225
37226
37227 func (c *OrdersListCall) Fields(s ...googleapi.Field) *OrdersListCall {
37228 c.urlParams_.Set("fields", googleapi.CombineFields(s))
37229 return c
37230 }
37231
37232
37233
37234
37235
37236
37237 func (c *OrdersListCall) IfNoneMatch(entityTag string) *OrdersListCall {
37238 c.ifNoneMatch_ = entityTag
37239 return c
37240 }
37241
37242
37243
37244
37245 func (c *OrdersListCall) Context(ctx context.Context) *OrdersListCall {
37246 c.ctx_ = ctx
37247 return c
37248 }
37249
37250
37251
37252 func (c *OrdersListCall) Header() http.Header {
37253 if c.header_ == nil {
37254 c.header_ = make(http.Header)
37255 }
37256 return c.header_
37257 }
37258
37259 func (c *OrdersListCall) doRequest(alt string) (*http.Response, error) {
37260 reqHeaders := make(http.Header)
37261 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
37262 for k, v := range c.header_ {
37263 reqHeaders[k] = v
37264 }
37265 reqHeaders.Set("User-Agent", c.s.userAgent())
37266 if c.ifNoneMatch_ != "" {
37267 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
37268 }
37269 var body io.Reader = nil
37270 c.urlParams_.Set("alt", alt)
37271 c.urlParams_.Set("prettyPrint", "false")
37272 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/projects/{projectId}/orders")
37273 urls += "?" + c.urlParams_.Encode()
37274 req, err := http.NewRequest("GET", urls, body)
37275 if err != nil {
37276 return nil, err
37277 }
37278 req.Header = reqHeaders
37279 googleapi.Expand(req.URL, map[string]string{
37280 "profileId": strconv.FormatInt(c.profileId, 10),
37281 "projectId": strconv.FormatInt(c.projectId, 10),
37282 })
37283 return gensupport.SendRequest(c.ctx_, c.s.client, req)
37284 }
37285
37286
37287
37288
37289
37290
37291
37292
37293 func (c *OrdersListCall) Do(opts ...googleapi.CallOption) (*OrdersListResponse, error) {
37294 gensupport.SetOptions(c.urlParams_, opts...)
37295 res, err := c.doRequest("json")
37296 if res != nil && res.StatusCode == http.StatusNotModified {
37297 if res.Body != nil {
37298 res.Body.Close()
37299 }
37300 return nil, &googleapi.Error{
37301 Code: res.StatusCode,
37302 Header: res.Header,
37303 }
37304 }
37305 if err != nil {
37306 return nil, err
37307 }
37308 defer googleapi.CloseBody(res)
37309 if err := googleapi.CheckResponse(res); err != nil {
37310 return nil, err
37311 }
37312 ret := &OrdersListResponse{
37313 ServerResponse: googleapi.ServerResponse{
37314 Header: res.Header,
37315 HTTPStatusCode: res.StatusCode,
37316 },
37317 }
37318 target := &ret
37319 if err := gensupport.DecodeResponse(target, res); err != nil {
37320 return nil, err
37321 }
37322 return ret, nil
37323
37324
37325
37326
37327
37328
37329
37330
37331
37332
37333
37334
37335
37336
37337
37338
37339
37340
37341
37342
37343
37344
37345
37346
37347
37348
37349
37350
37351
37352
37353
37354
37355
37356
37357
37358
37359
37360
37361
37362
37363
37364
37365
37366
37367
37368
37369
37370
37371
37372
37373
37374
37375
37376
37377
37378
37379
37380
37381
37382
37383
37384
37385
37386
37387
37388
37389
37390
37391
37392
37393
37394
37395
37396
37397
37398
37399
37400
37401
37402
37403
37404
37405
37406
37407
37408
37409
37410
37411
37412
37413
37414
37415
37416
37417 }
37418
37419
37420
37421
37422 func (c *OrdersListCall) Pages(ctx context.Context, f func(*OrdersListResponse) error) error {
37423 c.ctx_ = ctx
37424 defer c.PageToken(c.urlParams_.Get("pageToken"))
37425 for {
37426 x, err := c.Do()
37427 if err != nil {
37428 return err
37429 }
37430 if err := f(x); err != nil {
37431 return err
37432 }
37433 if x.NextPageToken == "" {
37434 return nil
37435 }
37436 c.PageToken(x.NextPageToken)
37437 }
37438 }
37439
37440
37441
37442 type PlacementGroupsGetCall struct {
37443 s *Service
37444 profileId int64
37445 id int64
37446 urlParams_ gensupport.URLParams
37447 ifNoneMatch_ string
37448 ctx_ context.Context
37449 header_ http.Header
37450 }
37451
37452
37453 func (r *PlacementGroupsService) Get(profileId int64, id int64) *PlacementGroupsGetCall {
37454 c := &PlacementGroupsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
37455 c.profileId = profileId
37456 c.id = id
37457 return c
37458 }
37459
37460
37461
37462
37463 func (c *PlacementGroupsGetCall) Fields(s ...googleapi.Field) *PlacementGroupsGetCall {
37464 c.urlParams_.Set("fields", googleapi.CombineFields(s))
37465 return c
37466 }
37467
37468
37469
37470
37471
37472
37473 func (c *PlacementGroupsGetCall) IfNoneMatch(entityTag string) *PlacementGroupsGetCall {
37474 c.ifNoneMatch_ = entityTag
37475 return c
37476 }
37477
37478
37479
37480
37481 func (c *PlacementGroupsGetCall) Context(ctx context.Context) *PlacementGroupsGetCall {
37482 c.ctx_ = ctx
37483 return c
37484 }
37485
37486
37487
37488 func (c *PlacementGroupsGetCall) Header() http.Header {
37489 if c.header_ == nil {
37490 c.header_ = make(http.Header)
37491 }
37492 return c.header_
37493 }
37494
37495 func (c *PlacementGroupsGetCall) doRequest(alt string) (*http.Response, error) {
37496 reqHeaders := make(http.Header)
37497 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
37498 for k, v := range c.header_ {
37499 reqHeaders[k] = v
37500 }
37501 reqHeaders.Set("User-Agent", c.s.userAgent())
37502 if c.ifNoneMatch_ != "" {
37503 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
37504 }
37505 var body io.Reader = nil
37506 c.urlParams_.Set("alt", alt)
37507 c.urlParams_.Set("prettyPrint", "false")
37508 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementGroups/{id}")
37509 urls += "?" + c.urlParams_.Encode()
37510 req, err := http.NewRequest("GET", urls, body)
37511 if err != nil {
37512 return nil, err
37513 }
37514 req.Header = reqHeaders
37515 googleapi.Expand(req.URL, map[string]string{
37516 "profileId": strconv.FormatInt(c.profileId, 10),
37517 "id": strconv.FormatInt(c.id, 10),
37518 })
37519 return gensupport.SendRequest(c.ctx_, c.s.client, req)
37520 }
37521
37522
37523
37524
37525
37526
37527
37528
37529 func (c *PlacementGroupsGetCall) Do(opts ...googleapi.CallOption) (*PlacementGroup, error) {
37530 gensupport.SetOptions(c.urlParams_, opts...)
37531 res, err := c.doRequest("json")
37532 if res != nil && res.StatusCode == http.StatusNotModified {
37533 if res.Body != nil {
37534 res.Body.Close()
37535 }
37536 return nil, &googleapi.Error{
37537 Code: res.StatusCode,
37538 Header: res.Header,
37539 }
37540 }
37541 if err != nil {
37542 return nil, err
37543 }
37544 defer googleapi.CloseBody(res)
37545 if err := googleapi.CheckResponse(res); err != nil {
37546 return nil, err
37547 }
37548 ret := &PlacementGroup{
37549 ServerResponse: googleapi.ServerResponse{
37550 Header: res.Header,
37551 HTTPStatusCode: res.StatusCode,
37552 },
37553 }
37554 target := &ret
37555 if err := gensupport.DecodeResponse(target, res); err != nil {
37556 return nil, err
37557 }
37558 return ret, nil
37559
37560
37561
37562
37563
37564
37565
37566
37567
37568
37569
37570
37571
37572
37573
37574
37575
37576
37577
37578
37579
37580
37581
37582
37583
37584
37585
37586
37587
37588
37589
37590
37591
37592 }
37593
37594
37595
37596 type PlacementGroupsInsertCall struct {
37597 s *Service
37598 profileId int64
37599 placementgroup *PlacementGroup
37600 urlParams_ gensupport.URLParams
37601 ctx_ context.Context
37602 header_ http.Header
37603 }
37604
37605
37606 func (r *PlacementGroupsService) Insert(profileId int64, placementgroup *PlacementGroup) *PlacementGroupsInsertCall {
37607 c := &PlacementGroupsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
37608 c.profileId = profileId
37609 c.placementgroup = placementgroup
37610 return c
37611 }
37612
37613
37614
37615
37616 func (c *PlacementGroupsInsertCall) Fields(s ...googleapi.Field) *PlacementGroupsInsertCall {
37617 c.urlParams_.Set("fields", googleapi.CombineFields(s))
37618 return c
37619 }
37620
37621
37622
37623
37624 func (c *PlacementGroupsInsertCall) Context(ctx context.Context) *PlacementGroupsInsertCall {
37625 c.ctx_ = ctx
37626 return c
37627 }
37628
37629
37630
37631 func (c *PlacementGroupsInsertCall) Header() http.Header {
37632 if c.header_ == nil {
37633 c.header_ = make(http.Header)
37634 }
37635 return c.header_
37636 }
37637
37638 func (c *PlacementGroupsInsertCall) doRequest(alt string) (*http.Response, error) {
37639 reqHeaders := make(http.Header)
37640 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
37641 for k, v := range c.header_ {
37642 reqHeaders[k] = v
37643 }
37644 reqHeaders.Set("User-Agent", c.s.userAgent())
37645 var body io.Reader = nil
37646 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placementgroup)
37647 if err != nil {
37648 return nil, err
37649 }
37650 reqHeaders.Set("Content-Type", "application/json")
37651 c.urlParams_.Set("alt", alt)
37652 c.urlParams_.Set("prettyPrint", "false")
37653 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementGroups")
37654 urls += "?" + c.urlParams_.Encode()
37655 req, err := http.NewRequest("POST", urls, body)
37656 if err != nil {
37657 return nil, err
37658 }
37659 req.Header = reqHeaders
37660 googleapi.Expand(req.URL, map[string]string{
37661 "profileId": strconv.FormatInt(c.profileId, 10),
37662 })
37663 return gensupport.SendRequest(c.ctx_, c.s.client, req)
37664 }
37665
37666
37667
37668
37669
37670
37671
37672
37673 func (c *PlacementGroupsInsertCall) Do(opts ...googleapi.CallOption) (*PlacementGroup, error) {
37674 gensupport.SetOptions(c.urlParams_, opts...)
37675 res, err := c.doRequest("json")
37676 if res != nil && res.StatusCode == http.StatusNotModified {
37677 if res.Body != nil {
37678 res.Body.Close()
37679 }
37680 return nil, &googleapi.Error{
37681 Code: res.StatusCode,
37682 Header: res.Header,
37683 }
37684 }
37685 if err != nil {
37686 return nil, err
37687 }
37688 defer googleapi.CloseBody(res)
37689 if err := googleapi.CheckResponse(res); err != nil {
37690 return nil, err
37691 }
37692 ret := &PlacementGroup{
37693 ServerResponse: googleapi.ServerResponse{
37694 Header: res.Header,
37695 HTTPStatusCode: res.StatusCode,
37696 },
37697 }
37698 target := &ret
37699 if err := gensupport.DecodeResponse(target, res); err != nil {
37700 return nil, err
37701 }
37702 return ret, nil
37703
37704
37705
37706
37707
37708
37709
37710
37711
37712
37713
37714
37715
37716
37717
37718
37719
37720
37721
37722
37723
37724
37725
37726
37727
37728
37729
37730
37731 }
37732
37733
37734
37735 type PlacementGroupsListCall struct {
37736 s *Service
37737 profileId int64
37738 urlParams_ gensupport.URLParams
37739 ifNoneMatch_ string
37740 ctx_ context.Context
37741 header_ http.Header
37742 }
37743
37744
37745
37746 func (r *PlacementGroupsService) List(profileId int64) *PlacementGroupsListCall {
37747 c := &PlacementGroupsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
37748 c.profileId = profileId
37749 return c
37750 }
37751
37752
37753
37754 func (c *PlacementGroupsListCall) AdvertiserIds(advertiserIds ...int64) *PlacementGroupsListCall {
37755 var advertiserIds_ []string
37756 for _, v := range advertiserIds {
37757 advertiserIds_ = append(advertiserIds_, fmt.Sprint(v))
37758 }
37759 c.urlParams_.SetMulti("advertiserIds", advertiserIds_)
37760 return c
37761 }
37762
37763
37764
37765
37766 func (c *PlacementGroupsListCall) Archived(archived bool) *PlacementGroupsListCall {
37767 c.urlParams_.Set("archived", fmt.Sprint(archived))
37768 return c
37769 }
37770
37771
37772
37773 func (c *PlacementGroupsListCall) CampaignIds(campaignIds ...int64) *PlacementGroupsListCall {
37774 var campaignIds_ []string
37775 for _, v := range campaignIds {
37776 campaignIds_ = append(campaignIds_, fmt.Sprint(v))
37777 }
37778 c.urlParams_.SetMulti("campaignIds", campaignIds_)
37779 return c
37780 }
37781
37782
37783
37784
37785 func (c *PlacementGroupsListCall) ContentCategoryIds(contentCategoryIds ...int64) *PlacementGroupsListCall {
37786 var contentCategoryIds_ []string
37787 for _, v := range contentCategoryIds {
37788 contentCategoryIds_ = append(contentCategoryIds_, fmt.Sprint(v))
37789 }
37790 c.urlParams_.SetMulti("contentCategoryIds", contentCategoryIds_)
37791 return c
37792 }
37793
37794
37795
37796
37797 func (c *PlacementGroupsListCall) DirectorySiteIds(directorySiteIds ...int64) *PlacementGroupsListCall {
37798 var directorySiteIds_ []string
37799 for _, v := range directorySiteIds {
37800 directorySiteIds_ = append(directorySiteIds_, fmt.Sprint(v))
37801 }
37802 c.urlParams_.SetMulti("directorySiteIds", directorySiteIds_)
37803 return c
37804 }
37805
37806
37807
37808 func (c *PlacementGroupsListCall) Ids(ids ...int64) *PlacementGroupsListCall {
37809 var ids_ []string
37810 for _, v := range ids {
37811 ids_ = append(ids_, fmt.Sprint(v))
37812 }
37813 c.urlParams_.SetMulti("ids", ids_)
37814 return c
37815 }
37816
37817
37818
37819
37820 func (c *PlacementGroupsListCall) MaxEndDate(maxEndDate string) *PlacementGroupsListCall {
37821 c.urlParams_.Set("maxEndDate", maxEndDate)
37822 return c
37823 }
37824
37825
37826
37827 func (c *PlacementGroupsListCall) MaxResults(maxResults int64) *PlacementGroupsListCall {
37828 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
37829 return c
37830 }
37831
37832
37833
37834
37835 func (c *PlacementGroupsListCall) MaxStartDate(maxStartDate string) *PlacementGroupsListCall {
37836 c.urlParams_.Set("maxStartDate", maxStartDate)
37837 return c
37838 }
37839
37840
37841
37842
37843 func (c *PlacementGroupsListCall) MinEndDate(minEndDate string) *PlacementGroupsListCall {
37844 c.urlParams_.Set("minEndDate", minEndDate)
37845 return c
37846 }
37847
37848
37849
37850
37851 func (c *PlacementGroupsListCall) MinStartDate(minStartDate string) *PlacementGroupsListCall {
37852 c.urlParams_.Set("minStartDate", minStartDate)
37853 return c
37854 }
37855
37856
37857
37858 func (c *PlacementGroupsListCall) PageToken(pageToken string) *PlacementGroupsListCall {
37859 c.urlParams_.Set("pageToken", pageToken)
37860 return c
37861 }
37862
37863
37864
37865
37866
37867
37868
37869
37870
37871
37872
37873
37874
37875 func (c *PlacementGroupsListCall) PlacementGroupType(placementGroupType string) *PlacementGroupsListCall {
37876 c.urlParams_.Set("placementGroupType", placementGroupType)
37877 return c
37878 }
37879
37880
37881
37882
37883 func (c *PlacementGroupsListCall) PlacementStrategyIds(placementStrategyIds ...int64) *PlacementGroupsListCall {
37884 var placementStrategyIds_ []string
37885 for _, v := range placementStrategyIds {
37886 placementStrategyIds_ = append(placementStrategyIds_, fmt.Sprint(v))
37887 }
37888 c.urlParams_.SetMulti("placementStrategyIds", placementStrategyIds_)
37889 return c
37890 }
37891
37892
37893
37894
37895
37896
37897
37898
37899
37900
37901
37902
37903 func (c *PlacementGroupsListCall) PricingTypes(pricingTypes ...string) *PlacementGroupsListCall {
37904 c.urlParams_.SetMulti("pricingTypes", append([]string{}, pricingTypes...))
37905 return c
37906 }
37907
37908
37909
37910
37911
37912
37913
37914
37915
37916
37917 func (c *PlacementGroupsListCall) SearchString(searchString string) *PlacementGroupsListCall {
37918 c.urlParams_.Set("searchString", searchString)
37919 return c
37920 }
37921
37922
37923
37924 func (c *PlacementGroupsListCall) SiteIds(siteIds ...int64) *PlacementGroupsListCall {
37925 var siteIds_ []string
37926 for _, v := range siteIds {
37927 siteIds_ = append(siteIds_, fmt.Sprint(v))
37928 }
37929 c.urlParams_.SetMulti("siteIds", siteIds_)
37930 return c
37931 }
37932
37933
37934
37935
37936
37937
37938
37939
37940 func (c *PlacementGroupsListCall) SortField(sortField string) *PlacementGroupsListCall {
37941 c.urlParams_.Set("sortField", sortField)
37942 return c
37943 }
37944
37945
37946
37947
37948
37949
37950
37951
37952 func (c *PlacementGroupsListCall) SortOrder(sortOrder string) *PlacementGroupsListCall {
37953 c.urlParams_.Set("sortOrder", sortOrder)
37954 return c
37955 }
37956
37957
37958
37959
37960 func (c *PlacementGroupsListCall) Fields(s ...googleapi.Field) *PlacementGroupsListCall {
37961 c.urlParams_.Set("fields", googleapi.CombineFields(s))
37962 return c
37963 }
37964
37965
37966
37967
37968
37969
37970 func (c *PlacementGroupsListCall) IfNoneMatch(entityTag string) *PlacementGroupsListCall {
37971 c.ifNoneMatch_ = entityTag
37972 return c
37973 }
37974
37975
37976
37977
37978 func (c *PlacementGroupsListCall) Context(ctx context.Context) *PlacementGroupsListCall {
37979 c.ctx_ = ctx
37980 return c
37981 }
37982
37983
37984
37985 func (c *PlacementGroupsListCall) Header() http.Header {
37986 if c.header_ == nil {
37987 c.header_ = make(http.Header)
37988 }
37989 return c.header_
37990 }
37991
37992 func (c *PlacementGroupsListCall) doRequest(alt string) (*http.Response, error) {
37993 reqHeaders := make(http.Header)
37994 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
37995 for k, v := range c.header_ {
37996 reqHeaders[k] = v
37997 }
37998 reqHeaders.Set("User-Agent", c.s.userAgent())
37999 if c.ifNoneMatch_ != "" {
38000 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
38001 }
38002 var body io.Reader = nil
38003 c.urlParams_.Set("alt", alt)
38004 c.urlParams_.Set("prettyPrint", "false")
38005 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementGroups")
38006 urls += "?" + c.urlParams_.Encode()
38007 req, err := http.NewRequest("GET", urls, body)
38008 if err != nil {
38009 return nil, err
38010 }
38011 req.Header = reqHeaders
38012 googleapi.Expand(req.URL, map[string]string{
38013 "profileId": strconv.FormatInt(c.profileId, 10),
38014 })
38015 return gensupport.SendRequest(c.ctx_, c.s.client, req)
38016 }
38017
38018
38019
38020
38021
38022
38023
38024
38025 func (c *PlacementGroupsListCall) Do(opts ...googleapi.CallOption) (*PlacementGroupsListResponse, error) {
38026 gensupport.SetOptions(c.urlParams_, opts...)
38027 res, err := c.doRequest("json")
38028 if res != nil && res.StatusCode == http.StatusNotModified {
38029 if res.Body != nil {
38030 res.Body.Close()
38031 }
38032 return nil, &googleapi.Error{
38033 Code: res.StatusCode,
38034 Header: res.Header,
38035 }
38036 }
38037 if err != nil {
38038 return nil, err
38039 }
38040 defer googleapi.CloseBody(res)
38041 if err := googleapi.CheckResponse(res); err != nil {
38042 return nil, err
38043 }
38044 ret := &PlacementGroupsListResponse{
38045 ServerResponse: googleapi.ServerResponse{
38046 Header: res.Header,
38047 HTTPStatusCode: res.StatusCode,
38048 },
38049 }
38050 target := &ret
38051 if err := gensupport.DecodeResponse(target, res); err != nil {
38052 return nil, err
38053 }
38054 return ret, nil
38055
38056
38057
38058
38059
38060
38061
38062
38063
38064
38065
38066
38067
38068
38069
38070
38071
38072
38073
38074
38075
38076
38077
38078
38079
38080
38081
38082
38083
38084
38085
38086
38087
38088
38089
38090
38091
38092
38093
38094
38095
38096
38097
38098
38099
38100
38101
38102
38103
38104
38105
38106
38107
38108
38109
38110
38111
38112
38113
38114
38115
38116
38117
38118
38119
38120
38121
38122
38123
38124
38125
38126
38127
38128
38129
38130
38131
38132
38133
38134
38135
38136
38137
38138
38139
38140
38141
38142
38143
38144
38145
38146
38147
38148
38149
38150
38151
38152
38153
38154
38155
38156
38157
38158
38159
38160
38161
38162
38163
38164
38165
38166
38167
38168
38169
38170
38171
38172
38173
38174
38175
38176
38177
38178
38179
38180
38181
38182
38183
38184
38185
38186
38187
38188
38189
38190
38191
38192
38193
38194
38195
38196
38197
38198
38199
38200
38201
38202
38203
38204
38205
38206
38207
38208
38209
38210
38211
38212
38213
38214
38215
38216
38217
38218
38219
38220
38221
38222
38223
38224
38225
38226
38227
38228
38229
38230
38231
38232
38233
38234
38235
38236 }
38237
38238
38239
38240
38241 func (c *PlacementGroupsListCall) Pages(ctx context.Context, f func(*PlacementGroupsListResponse) error) error {
38242 c.ctx_ = ctx
38243 defer c.PageToken(c.urlParams_.Get("pageToken"))
38244 for {
38245 x, err := c.Do()
38246 if err != nil {
38247 return err
38248 }
38249 if err := f(x); err != nil {
38250 return err
38251 }
38252 if x.NextPageToken == "" {
38253 return nil
38254 }
38255 c.PageToken(x.NextPageToken)
38256 }
38257 }
38258
38259
38260
38261 type PlacementGroupsPatchCall struct {
38262 s *Service
38263 profileId int64
38264 placementgroup *PlacementGroup
38265 urlParams_ gensupport.URLParams
38266 ctx_ context.Context
38267 header_ http.Header
38268 }
38269
38270
38271
38272 func (r *PlacementGroupsService) Patch(profileId int64, id int64, placementgroup *PlacementGroup) *PlacementGroupsPatchCall {
38273 c := &PlacementGroupsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
38274 c.profileId = profileId
38275 c.urlParams_.Set("id", fmt.Sprint(id))
38276 c.placementgroup = placementgroup
38277 return c
38278 }
38279
38280
38281
38282
38283 func (c *PlacementGroupsPatchCall) Fields(s ...googleapi.Field) *PlacementGroupsPatchCall {
38284 c.urlParams_.Set("fields", googleapi.CombineFields(s))
38285 return c
38286 }
38287
38288
38289
38290
38291 func (c *PlacementGroupsPatchCall) Context(ctx context.Context) *PlacementGroupsPatchCall {
38292 c.ctx_ = ctx
38293 return c
38294 }
38295
38296
38297
38298 func (c *PlacementGroupsPatchCall) Header() http.Header {
38299 if c.header_ == nil {
38300 c.header_ = make(http.Header)
38301 }
38302 return c.header_
38303 }
38304
38305 func (c *PlacementGroupsPatchCall) doRequest(alt string) (*http.Response, error) {
38306 reqHeaders := make(http.Header)
38307 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
38308 for k, v := range c.header_ {
38309 reqHeaders[k] = v
38310 }
38311 reqHeaders.Set("User-Agent", c.s.userAgent())
38312 var body io.Reader = nil
38313 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placementgroup)
38314 if err != nil {
38315 return nil, err
38316 }
38317 reqHeaders.Set("Content-Type", "application/json")
38318 c.urlParams_.Set("alt", alt)
38319 c.urlParams_.Set("prettyPrint", "false")
38320 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementGroups")
38321 urls += "?" + c.urlParams_.Encode()
38322 req, err := http.NewRequest("PATCH", urls, body)
38323 if err != nil {
38324 return nil, err
38325 }
38326 req.Header = reqHeaders
38327 googleapi.Expand(req.URL, map[string]string{
38328 "profileId": strconv.FormatInt(c.profileId, 10),
38329 })
38330 return gensupport.SendRequest(c.ctx_, c.s.client, req)
38331 }
38332
38333
38334
38335
38336
38337
38338
38339
38340 func (c *PlacementGroupsPatchCall) Do(opts ...googleapi.CallOption) (*PlacementGroup, error) {
38341 gensupport.SetOptions(c.urlParams_, opts...)
38342 res, err := c.doRequest("json")
38343 if res != nil && res.StatusCode == http.StatusNotModified {
38344 if res.Body != nil {
38345 res.Body.Close()
38346 }
38347 return nil, &googleapi.Error{
38348 Code: res.StatusCode,
38349 Header: res.Header,
38350 }
38351 }
38352 if err != nil {
38353 return nil, err
38354 }
38355 defer googleapi.CloseBody(res)
38356 if err := googleapi.CheckResponse(res); err != nil {
38357 return nil, err
38358 }
38359 ret := &PlacementGroup{
38360 ServerResponse: googleapi.ServerResponse{
38361 Header: res.Header,
38362 HTTPStatusCode: res.StatusCode,
38363 },
38364 }
38365 target := &ret
38366 if err := gensupport.DecodeResponse(target, res); err != nil {
38367 return nil, err
38368 }
38369 return ret, nil
38370
38371
38372
38373
38374
38375
38376
38377
38378
38379
38380
38381
38382
38383
38384
38385
38386
38387
38388
38389
38390
38391
38392
38393
38394
38395
38396
38397
38398
38399
38400
38401
38402
38403
38404
38405
38406 }
38407
38408
38409
38410 type PlacementGroupsUpdateCall struct {
38411 s *Service
38412 profileId int64
38413 placementgroup *PlacementGroup
38414 urlParams_ gensupport.URLParams
38415 ctx_ context.Context
38416 header_ http.Header
38417 }
38418
38419
38420 func (r *PlacementGroupsService) Update(profileId int64, placementgroup *PlacementGroup) *PlacementGroupsUpdateCall {
38421 c := &PlacementGroupsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
38422 c.profileId = profileId
38423 c.placementgroup = placementgroup
38424 return c
38425 }
38426
38427
38428
38429
38430 func (c *PlacementGroupsUpdateCall) Fields(s ...googleapi.Field) *PlacementGroupsUpdateCall {
38431 c.urlParams_.Set("fields", googleapi.CombineFields(s))
38432 return c
38433 }
38434
38435
38436
38437
38438 func (c *PlacementGroupsUpdateCall) Context(ctx context.Context) *PlacementGroupsUpdateCall {
38439 c.ctx_ = ctx
38440 return c
38441 }
38442
38443
38444
38445 func (c *PlacementGroupsUpdateCall) Header() http.Header {
38446 if c.header_ == nil {
38447 c.header_ = make(http.Header)
38448 }
38449 return c.header_
38450 }
38451
38452 func (c *PlacementGroupsUpdateCall) doRequest(alt string) (*http.Response, error) {
38453 reqHeaders := make(http.Header)
38454 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
38455 for k, v := range c.header_ {
38456 reqHeaders[k] = v
38457 }
38458 reqHeaders.Set("User-Agent", c.s.userAgent())
38459 var body io.Reader = nil
38460 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placementgroup)
38461 if err != nil {
38462 return nil, err
38463 }
38464 reqHeaders.Set("Content-Type", "application/json")
38465 c.urlParams_.Set("alt", alt)
38466 c.urlParams_.Set("prettyPrint", "false")
38467 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementGroups")
38468 urls += "?" + c.urlParams_.Encode()
38469 req, err := http.NewRequest("PUT", urls, body)
38470 if err != nil {
38471 return nil, err
38472 }
38473 req.Header = reqHeaders
38474 googleapi.Expand(req.URL, map[string]string{
38475 "profileId": strconv.FormatInt(c.profileId, 10),
38476 })
38477 return gensupport.SendRequest(c.ctx_, c.s.client, req)
38478 }
38479
38480
38481
38482
38483
38484
38485
38486
38487 func (c *PlacementGroupsUpdateCall) Do(opts ...googleapi.CallOption) (*PlacementGroup, error) {
38488 gensupport.SetOptions(c.urlParams_, opts...)
38489 res, err := c.doRequest("json")
38490 if res != nil && res.StatusCode == http.StatusNotModified {
38491 if res.Body != nil {
38492 res.Body.Close()
38493 }
38494 return nil, &googleapi.Error{
38495 Code: res.StatusCode,
38496 Header: res.Header,
38497 }
38498 }
38499 if err != nil {
38500 return nil, err
38501 }
38502 defer googleapi.CloseBody(res)
38503 if err := googleapi.CheckResponse(res); err != nil {
38504 return nil, err
38505 }
38506 ret := &PlacementGroup{
38507 ServerResponse: googleapi.ServerResponse{
38508 Header: res.Header,
38509 HTTPStatusCode: res.StatusCode,
38510 },
38511 }
38512 target := &ret
38513 if err := gensupport.DecodeResponse(target, res); err != nil {
38514 return nil, err
38515 }
38516 return ret, nil
38517
38518
38519
38520
38521
38522
38523
38524
38525
38526
38527
38528
38529
38530
38531
38532
38533
38534
38535
38536
38537
38538
38539
38540
38541
38542
38543
38544
38545 }
38546
38547
38548
38549 type PlacementStrategiesDeleteCall struct {
38550 s *Service
38551 profileId int64
38552 id int64
38553 urlParams_ gensupport.URLParams
38554 ctx_ context.Context
38555 header_ http.Header
38556 }
38557
38558
38559 func (r *PlacementStrategiesService) Delete(profileId int64, id int64) *PlacementStrategiesDeleteCall {
38560 c := &PlacementStrategiesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
38561 c.profileId = profileId
38562 c.id = id
38563 return c
38564 }
38565
38566
38567
38568
38569 func (c *PlacementStrategiesDeleteCall) Fields(s ...googleapi.Field) *PlacementStrategiesDeleteCall {
38570 c.urlParams_.Set("fields", googleapi.CombineFields(s))
38571 return c
38572 }
38573
38574
38575
38576
38577 func (c *PlacementStrategiesDeleteCall) Context(ctx context.Context) *PlacementStrategiesDeleteCall {
38578 c.ctx_ = ctx
38579 return c
38580 }
38581
38582
38583
38584 func (c *PlacementStrategiesDeleteCall) Header() http.Header {
38585 if c.header_ == nil {
38586 c.header_ = make(http.Header)
38587 }
38588 return c.header_
38589 }
38590
38591 func (c *PlacementStrategiesDeleteCall) doRequest(alt string) (*http.Response, error) {
38592 reqHeaders := make(http.Header)
38593 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
38594 for k, v := range c.header_ {
38595 reqHeaders[k] = v
38596 }
38597 reqHeaders.Set("User-Agent", c.s.userAgent())
38598 var body io.Reader = nil
38599 c.urlParams_.Set("alt", alt)
38600 c.urlParams_.Set("prettyPrint", "false")
38601 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementStrategies/{id}")
38602 urls += "?" + c.urlParams_.Encode()
38603 req, err := http.NewRequest("DELETE", urls, body)
38604 if err != nil {
38605 return nil, err
38606 }
38607 req.Header = reqHeaders
38608 googleapi.Expand(req.URL, map[string]string{
38609 "profileId": strconv.FormatInt(c.profileId, 10),
38610 "id": strconv.FormatInt(c.id, 10),
38611 })
38612 return gensupport.SendRequest(c.ctx_, c.s.client, req)
38613 }
38614
38615
38616 func (c *PlacementStrategiesDeleteCall) Do(opts ...googleapi.CallOption) error {
38617 gensupport.SetOptions(c.urlParams_, opts...)
38618 res, err := c.doRequest("json")
38619 if err != nil {
38620 return err
38621 }
38622 defer googleapi.CloseBody(res)
38623 if err := googleapi.CheckResponse(res); err != nil {
38624 return err
38625 }
38626 return nil
38627
38628
38629
38630
38631
38632
38633
38634
38635
38636
38637
38638
38639
38640
38641
38642
38643
38644
38645
38646
38647
38648
38649
38650
38651
38652
38653
38654
38655
38656
38657 }
38658
38659
38660
38661 type PlacementStrategiesGetCall struct {
38662 s *Service
38663 profileId int64
38664 id int64
38665 urlParams_ gensupport.URLParams
38666 ifNoneMatch_ string
38667 ctx_ context.Context
38668 header_ http.Header
38669 }
38670
38671
38672 func (r *PlacementStrategiesService) Get(profileId int64, id int64) *PlacementStrategiesGetCall {
38673 c := &PlacementStrategiesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
38674 c.profileId = profileId
38675 c.id = id
38676 return c
38677 }
38678
38679
38680
38681
38682 func (c *PlacementStrategiesGetCall) Fields(s ...googleapi.Field) *PlacementStrategiesGetCall {
38683 c.urlParams_.Set("fields", googleapi.CombineFields(s))
38684 return c
38685 }
38686
38687
38688
38689
38690
38691
38692 func (c *PlacementStrategiesGetCall) IfNoneMatch(entityTag string) *PlacementStrategiesGetCall {
38693 c.ifNoneMatch_ = entityTag
38694 return c
38695 }
38696
38697
38698
38699
38700 func (c *PlacementStrategiesGetCall) Context(ctx context.Context) *PlacementStrategiesGetCall {
38701 c.ctx_ = ctx
38702 return c
38703 }
38704
38705
38706
38707 func (c *PlacementStrategiesGetCall) Header() http.Header {
38708 if c.header_ == nil {
38709 c.header_ = make(http.Header)
38710 }
38711 return c.header_
38712 }
38713
38714 func (c *PlacementStrategiesGetCall) doRequest(alt string) (*http.Response, error) {
38715 reqHeaders := make(http.Header)
38716 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
38717 for k, v := range c.header_ {
38718 reqHeaders[k] = v
38719 }
38720 reqHeaders.Set("User-Agent", c.s.userAgent())
38721 if c.ifNoneMatch_ != "" {
38722 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
38723 }
38724 var body io.Reader = nil
38725 c.urlParams_.Set("alt", alt)
38726 c.urlParams_.Set("prettyPrint", "false")
38727 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementStrategies/{id}")
38728 urls += "?" + c.urlParams_.Encode()
38729 req, err := http.NewRequest("GET", urls, body)
38730 if err != nil {
38731 return nil, err
38732 }
38733 req.Header = reqHeaders
38734 googleapi.Expand(req.URL, map[string]string{
38735 "profileId": strconv.FormatInt(c.profileId, 10),
38736 "id": strconv.FormatInt(c.id, 10),
38737 })
38738 return gensupport.SendRequest(c.ctx_, c.s.client, req)
38739 }
38740
38741
38742
38743
38744
38745
38746
38747
38748 func (c *PlacementStrategiesGetCall) Do(opts ...googleapi.CallOption) (*PlacementStrategy, error) {
38749 gensupport.SetOptions(c.urlParams_, opts...)
38750 res, err := c.doRequest("json")
38751 if res != nil && res.StatusCode == http.StatusNotModified {
38752 if res.Body != nil {
38753 res.Body.Close()
38754 }
38755 return nil, &googleapi.Error{
38756 Code: res.StatusCode,
38757 Header: res.Header,
38758 }
38759 }
38760 if err != nil {
38761 return nil, err
38762 }
38763 defer googleapi.CloseBody(res)
38764 if err := googleapi.CheckResponse(res); err != nil {
38765 return nil, err
38766 }
38767 ret := &PlacementStrategy{
38768 ServerResponse: googleapi.ServerResponse{
38769 Header: res.Header,
38770 HTTPStatusCode: res.StatusCode,
38771 },
38772 }
38773 target := &ret
38774 if err := gensupport.DecodeResponse(target, res); err != nil {
38775 return nil, err
38776 }
38777 return ret, nil
38778
38779
38780
38781
38782
38783
38784
38785
38786
38787
38788
38789
38790
38791
38792
38793
38794
38795
38796
38797
38798
38799
38800
38801
38802
38803
38804
38805
38806
38807
38808
38809
38810
38811 }
38812
38813
38814
38815 type PlacementStrategiesInsertCall struct {
38816 s *Service
38817 profileId int64
38818 placementstrategy *PlacementStrategy
38819 urlParams_ gensupport.URLParams
38820 ctx_ context.Context
38821 header_ http.Header
38822 }
38823
38824
38825 func (r *PlacementStrategiesService) Insert(profileId int64, placementstrategy *PlacementStrategy) *PlacementStrategiesInsertCall {
38826 c := &PlacementStrategiesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
38827 c.profileId = profileId
38828 c.placementstrategy = placementstrategy
38829 return c
38830 }
38831
38832
38833
38834
38835 func (c *PlacementStrategiesInsertCall) Fields(s ...googleapi.Field) *PlacementStrategiesInsertCall {
38836 c.urlParams_.Set("fields", googleapi.CombineFields(s))
38837 return c
38838 }
38839
38840
38841
38842
38843 func (c *PlacementStrategiesInsertCall) Context(ctx context.Context) *PlacementStrategiesInsertCall {
38844 c.ctx_ = ctx
38845 return c
38846 }
38847
38848
38849
38850 func (c *PlacementStrategiesInsertCall) Header() http.Header {
38851 if c.header_ == nil {
38852 c.header_ = make(http.Header)
38853 }
38854 return c.header_
38855 }
38856
38857 func (c *PlacementStrategiesInsertCall) doRequest(alt string) (*http.Response, error) {
38858 reqHeaders := make(http.Header)
38859 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
38860 for k, v := range c.header_ {
38861 reqHeaders[k] = v
38862 }
38863 reqHeaders.Set("User-Agent", c.s.userAgent())
38864 var body io.Reader = nil
38865 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placementstrategy)
38866 if err != nil {
38867 return nil, err
38868 }
38869 reqHeaders.Set("Content-Type", "application/json")
38870 c.urlParams_.Set("alt", alt)
38871 c.urlParams_.Set("prettyPrint", "false")
38872 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementStrategies")
38873 urls += "?" + c.urlParams_.Encode()
38874 req, err := http.NewRequest("POST", urls, body)
38875 if err != nil {
38876 return nil, err
38877 }
38878 req.Header = reqHeaders
38879 googleapi.Expand(req.URL, map[string]string{
38880 "profileId": strconv.FormatInt(c.profileId, 10),
38881 })
38882 return gensupport.SendRequest(c.ctx_, c.s.client, req)
38883 }
38884
38885
38886
38887
38888
38889
38890
38891
38892 func (c *PlacementStrategiesInsertCall) Do(opts ...googleapi.CallOption) (*PlacementStrategy, error) {
38893 gensupport.SetOptions(c.urlParams_, opts...)
38894 res, err := c.doRequest("json")
38895 if res != nil && res.StatusCode == http.StatusNotModified {
38896 if res.Body != nil {
38897 res.Body.Close()
38898 }
38899 return nil, &googleapi.Error{
38900 Code: res.StatusCode,
38901 Header: res.Header,
38902 }
38903 }
38904 if err != nil {
38905 return nil, err
38906 }
38907 defer googleapi.CloseBody(res)
38908 if err := googleapi.CheckResponse(res); err != nil {
38909 return nil, err
38910 }
38911 ret := &PlacementStrategy{
38912 ServerResponse: googleapi.ServerResponse{
38913 Header: res.Header,
38914 HTTPStatusCode: res.StatusCode,
38915 },
38916 }
38917 target := &ret
38918 if err := gensupport.DecodeResponse(target, res); err != nil {
38919 return nil, err
38920 }
38921 return ret, nil
38922
38923
38924
38925
38926
38927
38928
38929
38930
38931
38932
38933
38934
38935
38936
38937
38938
38939
38940
38941
38942
38943
38944
38945
38946
38947
38948
38949
38950 }
38951
38952
38953
38954 type PlacementStrategiesListCall struct {
38955 s *Service
38956 profileId int64
38957 urlParams_ gensupport.URLParams
38958 ifNoneMatch_ string
38959 ctx_ context.Context
38960 header_ http.Header
38961 }
38962
38963
38964
38965 func (r *PlacementStrategiesService) List(profileId int64) *PlacementStrategiesListCall {
38966 c := &PlacementStrategiesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
38967 c.profileId = profileId
38968 return c
38969 }
38970
38971
38972
38973 func (c *PlacementStrategiesListCall) Ids(ids ...int64) *PlacementStrategiesListCall {
38974 var ids_ []string
38975 for _, v := range ids {
38976 ids_ = append(ids_, fmt.Sprint(v))
38977 }
38978 c.urlParams_.SetMulti("ids", ids_)
38979 return c
38980 }
38981
38982
38983
38984 func (c *PlacementStrategiesListCall) MaxResults(maxResults int64) *PlacementStrategiesListCall {
38985 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
38986 return c
38987 }
38988
38989
38990
38991 func (c *PlacementStrategiesListCall) PageToken(pageToken string) *PlacementStrategiesListCall {
38992 c.urlParams_.Set("pageToken", pageToken)
38993 return c
38994 }
38995
38996
38997
38998
38999
39000
39001
39002
39003
39004
39005 func (c *PlacementStrategiesListCall) SearchString(searchString string) *PlacementStrategiesListCall {
39006 c.urlParams_.Set("searchString", searchString)
39007 return c
39008 }
39009
39010
39011
39012
39013
39014
39015
39016
39017 func (c *PlacementStrategiesListCall) SortField(sortField string) *PlacementStrategiesListCall {
39018 c.urlParams_.Set("sortField", sortField)
39019 return c
39020 }
39021
39022
39023
39024
39025
39026
39027
39028
39029 func (c *PlacementStrategiesListCall) SortOrder(sortOrder string) *PlacementStrategiesListCall {
39030 c.urlParams_.Set("sortOrder", sortOrder)
39031 return c
39032 }
39033
39034
39035
39036
39037 func (c *PlacementStrategiesListCall) Fields(s ...googleapi.Field) *PlacementStrategiesListCall {
39038 c.urlParams_.Set("fields", googleapi.CombineFields(s))
39039 return c
39040 }
39041
39042
39043
39044
39045
39046
39047 func (c *PlacementStrategiesListCall) IfNoneMatch(entityTag string) *PlacementStrategiesListCall {
39048 c.ifNoneMatch_ = entityTag
39049 return c
39050 }
39051
39052
39053
39054
39055 func (c *PlacementStrategiesListCall) Context(ctx context.Context) *PlacementStrategiesListCall {
39056 c.ctx_ = ctx
39057 return c
39058 }
39059
39060
39061
39062 func (c *PlacementStrategiesListCall) Header() http.Header {
39063 if c.header_ == nil {
39064 c.header_ = make(http.Header)
39065 }
39066 return c.header_
39067 }
39068
39069 func (c *PlacementStrategiesListCall) doRequest(alt string) (*http.Response, error) {
39070 reqHeaders := make(http.Header)
39071 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
39072 for k, v := range c.header_ {
39073 reqHeaders[k] = v
39074 }
39075 reqHeaders.Set("User-Agent", c.s.userAgent())
39076 if c.ifNoneMatch_ != "" {
39077 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
39078 }
39079 var body io.Reader = nil
39080 c.urlParams_.Set("alt", alt)
39081 c.urlParams_.Set("prettyPrint", "false")
39082 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementStrategies")
39083 urls += "?" + c.urlParams_.Encode()
39084 req, err := http.NewRequest("GET", urls, body)
39085 if err != nil {
39086 return nil, err
39087 }
39088 req.Header = reqHeaders
39089 googleapi.Expand(req.URL, map[string]string{
39090 "profileId": strconv.FormatInt(c.profileId, 10),
39091 })
39092 return gensupport.SendRequest(c.ctx_, c.s.client, req)
39093 }
39094
39095
39096
39097
39098
39099
39100
39101
39102 func (c *PlacementStrategiesListCall) Do(opts ...googleapi.CallOption) (*PlacementStrategiesListResponse, error) {
39103 gensupport.SetOptions(c.urlParams_, opts...)
39104 res, err := c.doRequest("json")
39105 if res != nil && res.StatusCode == http.StatusNotModified {
39106 if res.Body != nil {
39107 res.Body.Close()
39108 }
39109 return nil, &googleapi.Error{
39110 Code: res.StatusCode,
39111 Header: res.Header,
39112 }
39113 }
39114 if err != nil {
39115 return nil, err
39116 }
39117 defer googleapi.CloseBody(res)
39118 if err := googleapi.CheckResponse(res); err != nil {
39119 return nil, err
39120 }
39121 ret := &PlacementStrategiesListResponse{
39122 ServerResponse: googleapi.ServerResponse{
39123 Header: res.Header,
39124 HTTPStatusCode: res.StatusCode,
39125 },
39126 }
39127 target := &ret
39128 if err := gensupport.DecodeResponse(target, res); err != nil {
39129 return nil, err
39130 }
39131 return ret, nil
39132
39133
39134
39135
39136
39137
39138
39139
39140
39141
39142
39143
39144
39145
39146
39147
39148
39149
39150
39151
39152
39153
39154
39155
39156
39157
39158
39159
39160
39161
39162
39163
39164
39165
39166
39167
39168
39169
39170
39171
39172
39173
39174
39175
39176
39177
39178
39179
39180
39181
39182
39183
39184
39185
39186
39187
39188
39189
39190
39191
39192
39193
39194
39195
39196
39197
39198
39199
39200
39201
39202
39203
39204
39205
39206
39207
39208
39209
39210
39211 }
39212
39213
39214
39215
39216 func (c *PlacementStrategiesListCall) Pages(ctx context.Context, f func(*PlacementStrategiesListResponse) error) error {
39217 c.ctx_ = ctx
39218 defer c.PageToken(c.urlParams_.Get("pageToken"))
39219 for {
39220 x, err := c.Do()
39221 if err != nil {
39222 return err
39223 }
39224 if err := f(x); err != nil {
39225 return err
39226 }
39227 if x.NextPageToken == "" {
39228 return nil
39229 }
39230 c.PageToken(x.NextPageToken)
39231 }
39232 }
39233
39234
39235
39236 type PlacementStrategiesPatchCall struct {
39237 s *Service
39238 profileId int64
39239 placementstrategy *PlacementStrategy
39240 urlParams_ gensupport.URLParams
39241 ctx_ context.Context
39242 header_ http.Header
39243 }
39244
39245
39246
39247 func (r *PlacementStrategiesService) Patch(profileId int64, id int64, placementstrategy *PlacementStrategy) *PlacementStrategiesPatchCall {
39248 c := &PlacementStrategiesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
39249 c.profileId = profileId
39250 c.urlParams_.Set("id", fmt.Sprint(id))
39251 c.placementstrategy = placementstrategy
39252 return c
39253 }
39254
39255
39256
39257
39258 func (c *PlacementStrategiesPatchCall) Fields(s ...googleapi.Field) *PlacementStrategiesPatchCall {
39259 c.urlParams_.Set("fields", googleapi.CombineFields(s))
39260 return c
39261 }
39262
39263
39264
39265
39266 func (c *PlacementStrategiesPatchCall) Context(ctx context.Context) *PlacementStrategiesPatchCall {
39267 c.ctx_ = ctx
39268 return c
39269 }
39270
39271
39272
39273 func (c *PlacementStrategiesPatchCall) Header() http.Header {
39274 if c.header_ == nil {
39275 c.header_ = make(http.Header)
39276 }
39277 return c.header_
39278 }
39279
39280 func (c *PlacementStrategiesPatchCall) doRequest(alt string) (*http.Response, error) {
39281 reqHeaders := make(http.Header)
39282 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
39283 for k, v := range c.header_ {
39284 reqHeaders[k] = v
39285 }
39286 reqHeaders.Set("User-Agent", c.s.userAgent())
39287 var body io.Reader = nil
39288 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placementstrategy)
39289 if err != nil {
39290 return nil, err
39291 }
39292 reqHeaders.Set("Content-Type", "application/json")
39293 c.urlParams_.Set("alt", alt)
39294 c.urlParams_.Set("prettyPrint", "false")
39295 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementStrategies")
39296 urls += "?" + c.urlParams_.Encode()
39297 req, err := http.NewRequest("PATCH", urls, body)
39298 if err != nil {
39299 return nil, err
39300 }
39301 req.Header = reqHeaders
39302 googleapi.Expand(req.URL, map[string]string{
39303 "profileId": strconv.FormatInt(c.profileId, 10),
39304 })
39305 return gensupport.SendRequest(c.ctx_, c.s.client, req)
39306 }
39307
39308
39309
39310
39311
39312
39313
39314
39315 func (c *PlacementStrategiesPatchCall) Do(opts ...googleapi.CallOption) (*PlacementStrategy, error) {
39316 gensupport.SetOptions(c.urlParams_, opts...)
39317 res, err := c.doRequest("json")
39318 if res != nil && res.StatusCode == http.StatusNotModified {
39319 if res.Body != nil {
39320 res.Body.Close()
39321 }
39322 return nil, &googleapi.Error{
39323 Code: res.StatusCode,
39324 Header: res.Header,
39325 }
39326 }
39327 if err != nil {
39328 return nil, err
39329 }
39330 defer googleapi.CloseBody(res)
39331 if err := googleapi.CheckResponse(res); err != nil {
39332 return nil, err
39333 }
39334 ret := &PlacementStrategy{
39335 ServerResponse: googleapi.ServerResponse{
39336 Header: res.Header,
39337 HTTPStatusCode: res.StatusCode,
39338 },
39339 }
39340 target := &ret
39341 if err := gensupport.DecodeResponse(target, res); err != nil {
39342 return nil, err
39343 }
39344 return ret, nil
39345
39346
39347
39348
39349
39350
39351
39352
39353
39354
39355
39356
39357
39358
39359
39360
39361
39362
39363
39364
39365
39366
39367
39368
39369
39370
39371
39372
39373
39374
39375
39376
39377
39378
39379
39380
39381 }
39382
39383
39384
39385 type PlacementStrategiesUpdateCall struct {
39386 s *Service
39387 profileId int64
39388 placementstrategy *PlacementStrategy
39389 urlParams_ gensupport.URLParams
39390 ctx_ context.Context
39391 header_ http.Header
39392 }
39393
39394
39395 func (r *PlacementStrategiesService) Update(profileId int64, placementstrategy *PlacementStrategy) *PlacementStrategiesUpdateCall {
39396 c := &PlacementStrategiesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
39397 c.profileId = profileId
39398 c.placementstrategy = placementstrategy
39399 return c
39400 }
39401
39402
39403
39404
39405 func (c *PlacementStrategiesUpdateCall) Fields(s ...googleapi.Field) *PlacementStrategiesUpdateCall {
39406 c.urlParams_.Set("fields", googleapi.CombineFields(s))
39407 return c
39408 }
39409
39410
39411
39412
39413 func (c *PlacementStrategiesUpdateCall) Context(ctx context.Context) *PlacementStrategiesUpdateCall {
39414 c.ctx_ = ctx
39415 return c
39416 }
39417
39418
39419
39420 func (c *PlacementStrategiesUpdateCall) Header() http.Header {
39421 if c.header_ == nil {
39422 c.header_ = make(http.Header)
39423 }
39424 return c.header_
39425 }
39426
39427 func (c *PlacementStrategiesUpdateCall) doRequest(alt string) (*http.Response, error) {
39428 reqHeaders := make(http.Header)
39429 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
39430 for k, v := range c.header_ {
39431 reqHeaders[k] = v
39432 }
39433 reqHeaders.Set("User-Agent", c.s.userAgent())
39434 var body io.Reader = nil
39435 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placementstrategy)
39436 if err != nil {
39437 return nil, err
39438 }
39439 reqHeaders.Set("Content-Type", "application/json")
39440 c.urlParams_.Set("alt", alt)
39441 c.urlParams_.Set("prettyPrint", "false")
39442 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placementStrategies")
39443 urls += "?" + c.urlParams_.Encode()
39444 req, err := http.NewRequest("PUT", urls, body)
39445 if err != nil {
39446 return nil, err
39447 }
39448 req.Header = reqHeaders
39449 googleapi.Expand(req.URL, map[string]string{
39450 "profileId": strconv.FormatInt(c.profileId, 10),
39451 })
39452 return gensupport.SendRequest(c.ctx_, c.s.client, req)
39453 }
39454
39455
39456
39457
39458
39459
39460
39461
39462 func (c *PlacementStrategiesUpdateCall) Do(opts ...googleapi.CallOption) (*PlacementStrategy, error) {
39463 gensupport.SetOptions(c.urlParams_, opts...)
39464 res, err := c.doRequest("json")
39465 if res != nil && res.StatusCode == http.StatusNotModified {
39466 if res.Body != nil {
39467 res.Body.Close()
39468 }
39469 return nil, &googleapi.Error{
39470 Code: res.StatusCode,
39471 Header: res.Header,
39472 }
39473 }
39474 if err != nil {
39475 return nil, err
39476 }
39477 defer googleapi.CloseBody(res)
39478 if err := googleapi.CheckResponse(res); err != nil {
39479 return nil, err
39480 }
39481 ret := &PlacementStrategy{
39482 ServerResponse: googleapi.ServerResponse{
39483 Header: res.Header,
39484 HTTPStatusCode: res.StatusCode,
39485 },
39486 }
39487 target := &ret
39488 if err := gensupport.DecodeResponse(target, res); err != nil {
39489 return nil, err
39490 }
39491 return ret, nil
39492
39493
39494
39495
39496
39497
39498
39499
39500
39501
39502
39503
39504
39505
39506
39507
39508
39509
39510
39511
39512
39513
39514
39515
39516
39517
39518
39519
39520 }
39521
39522
39523
39524 type PlacementsGeneratetagsCall struct {
39525 s *Service
39526 profileId int64
39527 urlParams_ gensupport.URLParams
39528 ctx_ context.Context
39529 header_ http.Header
39530 }
39531
39532
39533 func (r *PlacementsService) Generatetags(profileId int64) *PlacementsGeneratetagsCall {
39534 c := &PlacementsGeneratetagsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
39535 c.profileId = profileId
39536 return c
39537 }
39538
39539
39540
39541 func (c *PlacementsGeneratetagsCall) CampaignId(campaignId int64) *PlacementsGeneratetagsCall {
39542 c.urlParams_.Set("campaignId", fmt.Sprint(campaignId))
39543 return c
39544 }
39545
39546
39547
39548 func (c *PlacementsGeneratetagsCall) PlacementIds(placementIds ...int64) *PlacementsGeneratetagsCall {
39549 var placementIds_ []string
39550 for _, v := range placementIds {
39551 placementIds_ = append(placementIds_, fmt.Sprint(v))
39552 }
39553 c.urlParams_.SetMulti("placementIds", placementIds_)
39554 return c
39555 }
39556
39557
39558
39559
39560
39561
39562
39563
39564
39565
39566
39567
39568
39569
39570
39571
39572
39573
39574
39575
39576
39577
39578
39579
39580
39581
39582
39583
39584 func (c *PlacementsGeneratetagsCall) TagFormats(tagFormats ...string) *PlacementsGeneratetagsCall {
39585 c.urlParams_.SetMulti("tagFormats", append([]string{}, tagFormats...))
39586 return c
39587 }
39588
39589
39590
39591
39592 func (c *PlacementsGeneratetagsCall) Fields(s ...googleapi.Field) *PlacementsGeneratetagsCall {
39593 c.urlParams_.Set("fields", googleapi.CombineFields(s))
39594 return c
39595 }
39596
39597
39598
39599
39600 func (c *PlacementsGeneratetagsCall) Context(ctx context.Context) *PlacementsGeneratetagsCall {
39601 c.ctx_ = ctx
39602 return c
39603 }
39604
39605
39606
39607 func (c *PlacementsGeneratetagsCall) Header() http.Header {
39608 if c.header_ == nil {
39609 c.header_ = make(http.Header)
39610 }
39611 return c.header_
39612 }
39613
39614 func (c *PlacementsGeneratetagsCall) doRequest(alt string) (*http.Response, error) {
39615 reqHeaders := make(http.Header)
39616 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
39617 for k, v := range c.header_ {
39618 reqHeaders[k] = v
39619 }
39620 reqHeaders.Set("User-Agent", c.s.userAgent())
39621 var body io.Reader = nil
39622 c.urlParams_.Set("alt", alt)
39623 c.urlParams_.Set("prettyPrint", "false")
39624 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placements/generatetags")
39625 urls += "?" + c.urlParams_.Encode()
39626 req, err := http.NewRequest("POST", urls, body)
39627 if err != nil {
39628 return nil, err
39629 }
39630 req.Header = reqHeaders
39631 googleapi.Expand(req.URL, map[string]string{
39632 "profileId": strconv.FormatInt(c.profileId, 10),
39633 })
39634 return gensupport.SendRequest(c.ctx_, c.s.client, req)
39635 }
39636
39637
39638
39639
39640
39641
39642
39643
39644 func (c *PlacementsGeneratetagsCall) Do(opts ...googleapi.CallOption) (*PlacementsGenerateTagsResponse, error) {
39645 gensupport.SetOptions(c.urlParams_, opts...)
39646 res, err := c.doRequest("json")
39647 if res != nil && res.StatusCode == http.StatusNotModified {
39648 if res.Body != nil {
39649 res.Body.Close()
39650 }
39651 return nil, &googleapi.Error{
39652 Code: res.StatusCode,
39653 Header: res.Header,
39654 }
39655 }
39656 if err != nil {
39657 return nil, err
39658 }
39659 defer googleapi.CloseBody(res)
39660 if err := googleapi.CheckResponse(res); err != nil {
39661 return nil, err
39662 }
39663 ret := &PlacementsGenerateTagsResponse{
39664 ServerResponse: googleapi.ServerResponse{
39665 Header: res.Header,
39666 HTTPStatusCode: res.StatusCode,
39667 },
39668 }
39669 target := &ret
39670 if err := gensupport.DecodeResponse(target, res); err != nil {
39671 return nil, err
39672 }
39673 return ret, nil
39674
39675
39676
39677
39678
39679
39680
39681
39682
39683
39684
39685
39686
39687
39688
39689
39690
39691
39692
39693
39694
39695
39696
39697
39698
39699
39700
39701
39702
39703
39704
39705
39706
39707
39708
39709
39710
39711
39712
39713
39714
39715
39716
39717
39718
39719
39720
39721
39722
39723
39724
39725
39726
39727
39728
39729
39730
39731
39732
39733
39734
39735
39736
39737
39738
39739
39740
39741
39742
39743
39744
39745
39746
39747
39748
39749
39750
39751
39752
39753
39754
39755
39756
39757
39758
39759
39760 }
39761
39762
39763
39764 type PlacementsGetCall struct {
39765 s *Service
39766 profileId int64
39767 id int64
39768 urlParams_ gensupport.URLParams
39769 ifNoneMatch_ string
39770 ctx_ context.Context
39771 header_ http.Header
39772 }
39773
39774
39775 func (r *PlacementsService) Get(profileId int64, id int64) *PlacementsGetCall {
39776 c := &PlacementsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
39777 c.profileId = profileId
39778 c.id = id
39779 return c
39780 }
39781
39782
39783
39784
39785 func (c *PlacementsGetCall) Fields(s ...googleapi.Field) *PlacementsGetCall {
39786 c.urlParams_.Set("fields", googleapi.CombineFields(s))
39787 return c
39788 }
39789
39790
39791
39792
39793
39794
39795 func (c *PlacementsGetCall) IfNoneMatch(entityTag string) *PlacementsGetCall {
39796 c.ifNoneMatch_ = entityTag
39797 return c
39798 }
39799
39800
39801
39802
39803 func (c *PlacementsGetCall) Context(ctx context.Context) *PlacementsGetCall {
39804 c.ctx_ = ctx
39805 return c
39806 }
39807
39808
39809
39810 func (c *PlacementsGetCall) Header() http.Header {
39811 if c.header_ == nil {
39812 c.header_ = make(http.Header)
39813 }
39814 return c.header_
39815 }
39816
39817 func (c *PlacementsGetCall) doRequest(alt string) (*http.Response, error) {
39818 reqHeaders := make(http.Header)
39819 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
39820 for k, v := range c.header_ {
39821 reqHeaders[k] = v
39822 }
39823 reqHeaders.Set("User-Agent", c.s.userAgent())
39824 if c.ifNoneMatch_ != "" {
39825 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
39826 }
39827 var body io.Reader = nil
39828 c.urlParams_.Set("alt", alt)
39829 c.urlParams_.Set("prettyPrint", "false")
39830 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placements/{id}")
39831 urls += "?" + c.urlParams_.Encode()
39832 req, err := http.NewRequest("GET", urls, body)
39833 if err != nil {
39834 return nil, err
39835 }
39836 req.Header = reqHeaders
39837 googleapi.Expand(req.URL, map[string]string{
39838 "profileId": strconv.FormatInt(c.profileId, 10),
39839 "id": strconv.FormatInt(c.id, 10),
39840 })
39841 return gensupport.SendRequest(c.ctx_, c.s.client, req)
39842 }
39843
39844
39845
39846
39847
39848
39849
39850
39851 func (c *PlacementsGetCall) Do(opts ...googleapi.CallOption) (*Placement, error) {
39852 gensupport.SetOptions(c.urlParams_, opts...)
39853 res, err := c.doRequest("json")
39854 if res != nil && res.StatusCode == http.StatusNotModified {
39855 if res.Body != nil {
39856 res.Body.Close()
39857 }
39858 return nil, &googleapi.Error{
39859 Code: res.StatusCode,
39860 Header: res.Header,
39861 }
39862 }
39863 if err != nil {
39864 return nil, err
39865 }
39866 defer googleapi.CloseBody(res)
39867 if err := googleapi.CheckResponse(res); err != nil {
39868 return nil, err
39869 }
39870 ret := &Placement{
39871 ServerResponse: googleapi.ServerResponse{
39872 Header: res.Header,
39873 HTTPStatusCode: res.StatusCode,
39874 },
39875 }
39876 target := &ret
39877 if err := gensupport.DecodeResponse(target, res); err != nil {
39878 return nil, err
39879 }
39880 return ret, nil
39881
39882
39883
39884
39885
39886
39887
39888
39889
39890
39891
39892
39893
39894
39895
39896
39897
39898
39899
39900
39901
39902
39903
39904
39905
39906
39907
39908
39909
39910
39911
39912
39913
39914 }
39915
39916
39917
39918 type PlacementsInsertCall struct {
39919 s *Service
39920 profileId int64
39921 placement *Placement
39922 urlParams_ gensupport.URLParams
39923 ctx_ context.Context
39924 header_ http.Header
39925 }
39926
39927
39928 func (r *PlacementsService) Insert(profileId int64, placement *Placement) *PlacementsInsertCall {
39929 c := &PlacementsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
39930 c.profileId = profileId
39931 c.placement = placement
39932 return c
39933 }
39934
39935
39936
39937
39938 func (c *PlacementsInsertCall) Fields(s ...googleapi.Field) *PlacementsInsertCall {
39939 c.urlParams_.Set("fields", googleapi.CombineFields(s))
39940 return c
39941 }
39942
39943
39944
39945
39946 func (c *PlacementsInsertCall) Context(ctx context.Context) *PlacementsInsertCall {
39947 c.ctx_ = ctx
39948 return c
39949 }
39950
39951
39952
39953 func (c *PlacementsInsertCall) Header() http.Header {
39954 if c.header_ == nil {
39955 c.header_ = make(http.Header)
39956 }
39957 return c.header_
39958 }
39959
39960 func (c *PlacementsInsertCall) doRequest(alt string) (*http.Response, error) {
39961 reqHeaders := make(http.Header)
39962 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
39963 for k, v := range c.header_ {
39964 reqHeaders[k] = v
39965 }
39966 reqHeaders.Set("User-Agent", c.s.userAgent())
39967 var body io.Reader = nil
39968 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placement)
39969 if err != nil {
39970 return nil, err
39971 }
39972 reqHeaders.Set("Content-Type", "application/json")
39973 c.urlParams_.Set("alt", alt)
39974 c.urlParams_.Set("prettyPrint", "false")
39975 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placements")
39976 urls += "?" + c.urlParams_.Encode()
39977 req, err := http.NewRequest("POST", urls, body)
39978 if err != nil {
39979 return nil, err
39980 }
39981 req.Header = reqHeaders
39982 googleapi.Expand(req.URL, map[string]string{
39983 "profileId": strconv.FormatInt(c.profileId, 10),
39984 })
39985 return gensupport.SendRequest(c.ctx_, c.s.client, req)
39986 }
39987
39988
39989
39990
39991
39992
39993
39994
39995 func (c *PlacementsInsertCall) Do(opts ...googleapi.CallOption) (*Placement, error) {
39996 gensupport.SetOptions(c.urlParams_, opts...)
39997 res, err := c.doRequest("json")
39998 if res != nil && res.StatusCode == http.StatusNotModified {
39999 if res.Body != nil {
40000 res.Body.Close()
40001 }
40002 return nil, &googleapi.Error{
40003 Code: res.StatusCode,
40004 Header: res.Header,
40005 }
40006 }
40007 if err != nil {
40008 return nil, err
40009 }
40010 defer googleapi.CloseBody(res)
40011 if err := googleapi.CheckResponse(res); err != nil {
40012 return nil, err
40013 }
40014 ret := &Placement{
40015 ServerResponse: googleapi.ServerResponse{
40016 Header: res.Header,
40017 HTTPStatusCode: res.StatusCode,
40018 },
40019 }
40020 target := &ret
40021 if err := gensupport.DecodeResponse(target, res); err != nil {
40022 return nil, err
40023 }
40024 return ret, nil
40025
40026
40027
40028
40029
40030
40031
40032
40033
40034
40035
40036
40037
40038
40039
40040
40041
40042
40043
40044
40045
40046
40047
40048
40049
40050
40051
40052
40053 }
40054
40055
40056
40057 type PlacementsListCall struct {
40058 s *Service
40059 profileId int64
40060 urlParams_ gensupport.URLParams
40061 ifNoneMatch_ string
40062 ctx_ context.Context
40063 header_ http.Header
40064 }
40065
40066
40067
40068 func (r *PlacementsService) List(profileId int64) *PlacementsListCall {
40069 c := &PlacementsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
40070 c.profileId = profileId
40071 return c
40072 }
40073
40074
40075
40076 func (c *PlacementsListCall) AdvertiserIds(advertiserIds ...int64) *PlacementsListCall {
40077 var advertiserIds_ []string
40078 for _, v := range advertiserIds {
40079 advertiserIds_ = append(advertiserIds_, fmt.Sprint(v))
40080 }
40081 c.urlParams_.SetMulti("advertiserIds", advertiserIds_)
40082 return c
40083 }
40084
40085
40086
40087
40088 func (c *PlacementsListCall) Archived(archived bool) *PlacementsListCall {
40089 c.urlParams_.Set("archived", fmt.Sprint(archived))
40090 return c
40091 }
40092
40093
40094
40095 func (c *PlacementsListCall) CampaignIds(campaignIds ...int64) *PlacementsListCall {
40096 var campaignIds_ []string
40097 for _, v := range campaignIds {
40098 campaignIds_ = append(campaignIds_, fmt.Sprint(v))
40099 }
40100 c.urlParams_.SetMulti("campaignIds", campaignIds_)
40101 return c
40102 }
40103
40104
40105
40106
40107
40108
40109
40110
40111
40112
40113
40114
40115
40116
40117
40118
40119
40120 func (c *PlacementsListCall) Compatibilities(compatibilities ...string) *PlacementsListCall {
40121 c.urlParams_.SetMulti("compatibilities", append([]string{}, compatibilities...))
40122 return c
40123 }
40124
40125
40126
40127
40128 func (c *PlacementsListCall) ContentCategoryIds(contentCategoryIds ...int64) *PlacementsListCall {
40129 var contentCategoryIds_ []string
40130 for _, v := range contentCategoryIds {
40131 contentCategoryIds_ = append(contentCategoryIds_, fmt.Sprint(v))
40132 }
40133 c.urlParams_.SetMulti("contentCategoryIds", contentCategoryIds_)
40134 return c
40135 }
40136
40137
40138
40139
40140 func (c *PlacementsListCall) DirectorySiteIds(directorySiteIds ...int64) *PlacementsListCall {
40141 var directorySiteIds_ []string
40142 for _, v := range directorySiteIds {
40143 directorySiteIds_ = append(directorySiteIds_, fmt.Sprint(v))
40144 }
40145 c.urlParams_.SetMulti("directorySiteIds", directorySiteIds_)
40146 return c
40147 }
40148
40149
40150
40151 func (c *PlacementsListCall) GroupIds(groupIds ...int64) *PlacementsListCall {
40152 var groupIds_ []string
40153 for _, v := range groupIds {
40154 groupIds_ = append(groupIds_, fmt.Sprint(v))
40155 }
40156 c.urlParams_.SetMulti("groupIds", groupIds_)
40157 return c
40158 }
40159
40160
40161
40162 func (c *PlacementsListCall) Ids(ids ...int64) *PlacementsListCall {
40163 var ids_ []string
40164 for _, v := range ids {
40165 ids_ = append(ids_, fmt.Sprint(v))
40166 }
40167 c.urlParams_.SetMulti("ids", ids_)
40168 return c
40169 }
40170
40171
40172
40173
40174 func (c *PlacementsListCall) MaxEndDate(maxEndDate string) *PlacementsListCall {
40175 c.urlParams_.Set("maxEndDate", maxEndDate)
40176 return c
40177 }
40178
40179
40180
40181 func (c *PlacementsListCall) MaxResults(maxResults int64) *PlacementsListCall {
40182 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
40183 return c
40184 }
40185
40186
40187
40188
40189 func (c *PlacementsListCall) MaxStartDate(maxStartDate string) *PlacementsListCall {
40190 c.urlParams_.Set("maxStartDate", maxStartDate)
40191 return c
40192 }
40193
40194
40195
40196
40197 func (c *PlacementsListCall) MinEndDate(minEndDate string) *PlacementsListCall {
40198 c.urlParams_.Set("minEndDate", minEndDate)
40199 return c
40200 }
40201
40202
40203
40204
40205 func (c *PlacementsListCall) MinStartDate(minStartDate string) *PlacementsListCall {
40206 c.urlParams_.Set("minStartDate", minStartDate)
40207 return c
40208 }
40209
40210
40211
40212 func (c *PlacementsListCall) PageToken(pageToken string) *PlacementsListCall {
40213 c.urlParams_.Set("pageToken", pageToken)
40214 return c
40215 }
40216
40217
40218
40219
40220
40221
40222
40223
40224 func (c *PlacementsListCall) PaymentSource(paymentSource string) *PlacementsListCall {
40225 c.urlParams_.Set("paymentSource", paymentSource)
40226 return c
40227 }
40228
40229
40230
40231
40232 func (c *PlacementsListCall) PlacementStrategyIds(placementStrategyIds ...int64) *PlacementsListCall {
40233 var placementStrategyIds_ []string
40234 for _, v := range placementStrategyIds {
40235 placementStrategyIds_ = append(placementStrategyIds_, fmt.Sprint(v))
40236 }
40237 c.urlParams_.SetMulti("placementStrategyIds", placementStrategyIds_)
40238 return c
40239 }
40240
40241
40242
40243
40244
40245
40246
40247
40248
40249
40250
40251
40252 func (c *PlacementsListCall) PricingTypes(pricingTypes ...string) *PlacementsListCall {
40253 c.urlParams_.SetMulti("pricingTypes", append([]string{}, pricingTypes...))
40254 return c
40255 }
40256
40257
40258
40259
40260
40261
40262
40263
40264
40265 func (c *PlacementsListCall) SearchString(searchString string) *PlacementsListCall {
40266 c.urlParams_.Set("searchString", searchString)
40267 return c
40268 }
40269
40270
40271
40272 func (c *PlacementsListCall) SiteIds(siteIds ...int64) *PlacementsListCall {
40273 var siteIds_ []string
40274 for _, v := range siteIds {
40275 siteIds_ = append(siteIds_, fmt.Sprint(v))
40276 }
40277 c.urlParams_.SetMulti("siteIds", siteIds_)
40278 return c
40279 }
40280
40281
40282
40283 func (c *PlacementsListCall) SizeIds(sizeIds ...int64) *PlacementsListCall {
40284 var sizeIds_ []string
40285 for _, v := range sizeIds {
40286 sizeIds_ = append(sizeIds_, fmt.Sprint(v))
40287 }
40288 c.urlParams_.SetMulti("sizeIds", sizeIds_)
40289 return c
40290 }
40291
40292
40293
40294
40295
40296
40297
40298
40299 func (c *PlacementsListCall) SortField(sortField string) *PlacementsListCall {
40300 c.urlParams_.Set("sortField", sortField)
40301 return c
40302 }
40303
40304
40305
40306
40307
40308
40309
40310
40311 func (c *PlacementsListCall) SortOrder(sortOrder string) *PlacementsListCall {
40312 c.urlParams_.Set("sortOrder", sortOrder)
40313 return c
40314 }
40315
40316
40317
40318
40319 func (c *PlacementsListCall) Fields(s ...googleapi.Field) *PlacementsListCall {
40320 c.urlParams_.Set("fields", googleapi.CombineFields(s))
40321 return c
40322 }
40323
40324
40325
40326
40327
40328
40329 func (c *PlacementsListCall) IfNoneMatch(entityTag string) *PlacementsListCall {
40330 c.ifNoneMatch_ = entityTag
40331 return c
40332 }
40333
40334
40335
40336
40337 func (c *PlacementsListCall) Context(ctx context.Context) *PlacementsListCall {
40338 c.ctx_ = ctx
40339 return c
40340 }
40341
40342
40343
40344 func (c *PlacementsListCall) Header() http.Header {
40345 if c.header_ == nil {
40346 c.header_ = make(http.Header)
40347 }
40348 return c.header_
40349 }
40350
40351 func (c *PlacementsListCall) doRequest(alt string) (*http.Response, error) {
40352 reqHeaders := make(http.Header)
40353 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
40354 for k, v := range c.header_ {
40355 reqHeaders[k] = v
40356 }
40357 reqHeaders.Set("User-Agent", c.s.userAgent())
40358 if c.ifNoneMatch_ != "" {
40359 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
40360 }
40361 var body io.Reader = nil
40362 c.urlParams_.Set("alt", alt)
40363 c.urlParams_.Set("prettyPrint", "false")
40364 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placements")
40365 urls += "?" + c.urlParams_.Encode()
40366 req, err := http.NewRequest("GET", urls, body)
40367 if err != nil {
40368 return nil, err
40369 }
40370 req.Header = reqHeaders
40371 googleapi.Expand(req.URL, map[string]string{
40372 "profileId": strconv.FormatInt(c.profileId, 10),
40373 })
40374 return gensupport.SendRequest(c.ctx_, c.s.client, req)
40375 }
40376
40377
40378
40379
40380
40381
40382
40383
40384 func (c *PlacementsListCall) Do(opts ...googleapi.CallOption) (*PlacementsListResponse, error) {
40385 gensupport.SetOptions(c.urlParams_, opts...)
40386 res, err := c.doRequest("json")
40387 if res != nil && res.StatusCode == http.StatusNotModified {
40388 if res.Body != nil {
40389 res.Body.Close()
40390 }
40391 return nil, &googleapi.Error{
40392 Code: res.StatusCode,
40393 Header: res.Header,
40394 }
40395 }
40396 if err != nil {
40397 return nil, err
40398 }
40399 defer googleapi.CloseBody(res)
40400 if err := googleapi.CheckResponse(res); err != nil {
40401 return nil, err
40402 }
40403 ret := &PlacementsListResponse{
40404 ServerResponse: googleapi.ServerResponse{
40405 Header: res.Header,
40406 HTTPStatusCode: res.StatusCode,
40407 },
40408 }
40409 target := &ret
40410 if err := gensupport.DecodeResponse(target, res); err != nil {
40411 return nil, err
40412 }
40413 return ret, nil
40414
40415
40416
40417
40418
40419
40420
40421
40422
40423
40424
40425
40426
40427
40428
40429
40430
40431
40432
40433
40434
40435
40436
40437
40438
40439
40440
40441
40442
40443
40444
40445
40446
40447
40448
40449
40450
40451
40452
40453
40454
40455
40456
40457
40458
40459
40460
40461
40462
40463
40464
40465
40466
40467
40468
40469
40470
40471
40472
40473
40474
40475
40476
40477
40478
40479
40480
40481
40482
40483
40484
40485
40486
40487
40488
40489
40490
40491
40492
40493
40494
40495
40496
40497
40498
40499
40500
40501
40502
40503
40504
40505
40506
40507
40508
40509
40510
40511
40512
40513
40514
40515
40516
40517
40518
40519
40520
40521
40522
40523
40524
40525
40526
40527
40528
40529
40530
40531
40532
40533
40534
40535
40536
40537
40538
40539
40540
40541
40542
40543
40544
40545
40546
40547
40548
40549
40550
40551
40552
40553
40554
40555
40556
40557
40558
40559
40560
40561
40562
40563
40564
40565
40566
40567
40568
40569
40570
40571
40572
40573
40574
40575
40576
40577
40578
40579
40580
40581
40582
40583
40584
40585
40586
40587
40588
40589
40590
40591
40592
40593
40594
40595
40596
40597
40598
40599
40600
40601
40602
40603
40604
40605
40606
40607
40608
40609
40610
40611
40612
40613
40614
40615
40616
40617
40618
40619
40620
40621
40622
40623
40624
40625
40626
40627
40628
40629
40630
40631 }
40632
40633
40634
40635
40636 func (c *PlacementsListCall) Pages(ctx context.Context, f func(*PlacementsListResponse) error) error {
40637 c.ctx_ = ctx
40638 defer c.PageToken(c.urlParams_.Get("pageToken"))
40639 for {
40640 x, err := c.Do()
40641 if err != nil {
40642 return err
40643 }
40644 if err := f(x); err != nil {
40645 return err
40646 }
40647 if x.NextPageToken == "" {
40648 return nil
40649 }
40650 c.PageToken(x.NextPageToken)
40651 }
40652 }
40653
40654
40655
40656 type PlacementsPatchCall struct {
40657 s *Service
40658 profileId int64
40659 placement *Placement
40660 urlParams_ gensupport.URLParams
40661 ctx_ context.Context
40662 header_ http.Header
40663 }
40664
40665
40666
40667 func (r *PlacementsService) Patch(profileId int64, id int64, placement *Placement) *PlacementsPatchCall {
40668 c := &PlacementsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
40669 c.profileId = profileId
40670 c.urlParams_.Set("id", fmt.Sprint(id))
40671 c.placement = placement
40672 return c
40673 }
40674
40675
40676
40677
40678 func (c *PlacementsPatchCall) Fields(s ...googleapi.Field) *PlacementsPatchCall {
40679 c.urlParams_.Set("fields", googleapi.CombineFields(s))
40680 return c
40681 }
40682
40683
40684
40685
40686 func (c *PlacementsPatchCall) Context(ctx context.Context) *PlacementsPatchCall {
40687 c.ctx_ = ctx
40688 return c
40689 }
40690
40691
40692
40693 func (c *PlacementsPatchCall) Header() http.Header {
40694 if c.header_ == nil {
40695 c.header_ = make(http.Header)
40696 }
40697 return c.header_
40698 }
40699
40700 func (c *PlacementsPatchCall) doRequest(alt string) (*http.Response, error) {
40701 reqHeaders := make(http.Header)
40702 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
40703 for k, v := range c.header_ {
40704 reqHeaders[k] = v
40705 }
40706 reqHeaders.Set("User-Agent", c.s.userAgent())
40707 var body io.Reader = nil
40708 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placement)
40709 if err != nil {
40710 return nil, err
40711 }
40712 reqHeaders.Set("Content-Type", "application/json")
40713 c.urlParams_.Set("alt", alt)
40714 c.urlParams_.Set("prettyPrint", "false")
40715 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placements")
40716 urls += "?" + c.urlParams_.Encode()
40717 req, err := http.NewRequest("PATCH", urls, body)
40718 if err != nil {
40719 return nil, err
40720 }
40721 req.Header = reqHeaders
40722 googleapi.Expand(req.URL, map[string]string{
40723 "profileId": strconv.FormatInt(c.profileId, 10),
40724 })
40725 return gensupport.SendRequest(c.ctx_, c.s.client, req)
40726 }
40727
40728
40729
40730
40731
40732
40733
40734
40735 func (c *PlacementsPatchCall) Do(opts ...googleapi.CallOption) (*Placement, error) {
40736 gensupport.SetOptions(c.urlParams_, opts...)
40737 res, err := c.doRequest("json")
40738 if res != nil && res.StatusCode == http.StatusNotModified {
40739 if res.Body != nil {
40740 res.Body.Close()
40741 }
40742 return nil, &googleapi.Error{
40743 Code: res.StatusCode,
40744 Header: res.Header,
40745 }
40746 }
40747 if err != nil {
40748 return nil, err
40749 }
40750 defer googleapi.CloseBody(res)
40751 if err := googleapi.CheckResponse(res); err != nil {
40752 return nil, err
40753 }
40754 ret := &Placement{
40755 ServerResponse: googleapi.ServerResponse{
40756 Header: res.Header,
40757 HTTPStatusCode: res.StatusCode,
40758 },
40759 }
40760 target := &ret
40761 if err := gensupport.DecodeResponse(target, res); err != nil {
40762 return nil, err
40763 }
40764 return ret, nil
40765
40766
40767
40768
40769
40770
40771
40772
40773
40774
40775
40776
40777
40778
40779
40780
40781
40782
40783
40784
40785
40786
40787
40788
40789
40790
40791
40792
40793
40794
40795
40796
40797
40798
40799
40800
40801 }
40802
40803
40804
40805 type PlacementsUpdateCall struct {
40806 s *Service
40807 profileId int64
40808 placement *Placement
40809 urlParams_ gensupport.URLParams
40810 ctx_ context.Context
40811 header_ http.Header
40812 }
40813
40814
40815 func (r *PlacementsService) Update(profileId int64, placement *Placement) *PlacementsUpdateCall {
40816 c := &PlacementsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
40817 c.profileId = profileId
40818 c.placement = placement
40819 return c
40820 }
40821
40822
40823
40824
40825 func (c *PlacementsUpdateCall) Fields(s ...googleapi.Field) *PlacementsUpdateCall {
40826 c.urlParams_.Set("fields", googleapi.CombineFields(s))
40827 return c
40828 }
40829
40830
40831
40832
40833 func (c *PlacementsUpdateCall) Context(ctx context.Context) *PlacementsUpdateCall {
40834 c.ctx_ = ctx
40835 return c
40836 }
40837
40838
40839
40840 func (c *PlacementsUpdateCall) Header() http.Header {
40841 if c.header_ == nil {
40842 c.header_ = make(http.Header)
40843 }
40844 return c.header_
40845 }
40846
40847 func (c *PlacementsUpdateCall) doRequest(alt string) (*http.Response, error) {
40848 reqHeaders := make(http.Header)
40849 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
40850 for k, v := range c.header_ {
40851 reqHeaders[k] = v
40852 }
40853 reqHeaders.Set("User-Agent", c.s.userAgent())
40854 var body io.Reader = nil
40855 body, err := googleapi.WithoutDataWrapper.JSONReader(c.placement)
40856 if err != nil {
40857 return nil, err
40858 }
40859 reqHeaders.Set("Content-Type", "application/json")
40860 c.urlParams_.Set("alt", alt)
40861 c.urlParams_.Set("prettyPrint", "false")
40862 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/placements")
40863 urls += "?" + c.urlParams_.Encode()
40864 req, err := http.NewRequest("PUT", urls, body)
40865 if err != nil {
40866 return nil, err
40867 }
40868 req.Header = reqHeaders
40869 googleapi.Expand(req.URL, map[string]string{
40870 "profileId": strconv.FormatInt(c.profileId, 10),
40871 })
40872 return gensupport.SendRequest(c.ctx_, c.s.client, req)
40873 }
40874
40875
40876
40877
40878
40879
40880
40881
40882 func (c *PlacementsUpdateCall) Do(opts ...googleapi.CallOption) (*Placement, error) {
40883 gensupport.SetOptions(c.urlParams_, opts...)
40884 res, err := c.doRequest("json")
40885 if res != nil && res.StatusCode == http.StatusNotModified {
40886 if res.Body != nil {
40887 res.Body.Close()
40888 }
40889 return nil, &googleapi.Error{
40890 Code: res.StatusCode,
40891 Header: res.Header,
40892 }
40893 }
40894 if err != nil {
40895 return nil, err
40896 }
40897 defer googleapi.CloseBody(res)
40898 if err := googleapi.CheckResponse(res); err != nil {
40899 return nil, err
40900 }
40901 ret := &Placement{
40902 ServerResponse: googleapi.ServerResponse{
40903 Header: res.Header,
40904 HTTPStatusCode: res.StatusCode,
40905 },
40906 }
40907 target := &ret
40908 if err := gensupport.DecodeResponse(target, res); err != nil {
40909 return nil, err
40910 }
40911 return ret, nil
40912
40913
40914
40915
40916
40917
40918
40919
40920
40921
40922
40923
40924
40925
40926
40927
40928
40929
40930
40931
40932
40933
40934
40935
40936
40937
40938
40939
40940 }
40941
40942
40943
40944 type PlatformTypesGetCall struct {
40945 s *Service
40946 profileId int64
40947 id int64
40948 urlParams_ gensupport.URLParams
40949 ifNoneMatch_ string
40950 ctx_ context.Context
40951 header_ http.Header
40952 }
40953
40954
40955 func (r *PlatformTypesService) Get(profileId int64, id int64) *PlatformTypesGetCall {
40956 c := &PlatformTypesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
40957 c.profileId = profileId
40958 c.id = id
40959 return c
40960 }
40961
40962
40963
40964
40965 func (c *PlatformTypesGetCall) Fields(s ...googleapi.Field) *PlatformTypesGetCall {
40966 c.urlParams_.Set("fields", googleapi.CombineFields(s))
40967 return c
40968 }
40969
40970
40971
40972
40973
40974
40975 func (c *PlatformTypesGetCall) IfNoneMatch(entityTag string) *PlatformTypesGetCall {
40976 c.ifNoneMatch_ = entityTag
40977 return c
40978 }
40979
40980
40981
40982
40983 func (c *PlatformTypesGetCall) Context(ctx context.Context) *PlatformTypesGetCall {
40984 c.ctx_ = ctx
40985 return c
40986 }
40987
40988
40989
40990 func (c *PlatformTypesGetCall) Header() http.Header {
40991 if c.header_ == nil {
40992 c.header_ = make(http.Header)
40993 }
40994 return c.header_
40995 }
40996
40997 func (c *PlatformTypesGetCall) doRequest(alt string) (*http.Response, error) {
40998 reqHeaders := make(http.Header)
40999 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
41000 for k, v := range c.header_ {
41001 reqHeaders[k] = v
41002 }
41003 reqHeaders.Set("User-Agent", c.s.userAgent())
41004 if c.ifNoneMatch_ != "" {
41005 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
41006 }
41007 var body io.Reader = nil
41008 c.urlParams_.Set("alt", alt)
41009 c.urlParams_.Set("prettyPrint", "false")
41010 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/platformTypes/{id}")
41011 urls += "?" + c.urlParams_.Encode()
41012 req, err := http.NewRequest("GET", urls, body)
41013 if err != nil {
41014 return nil, err
41015 }
41016 req.Header = reqHeaders
41017 googleapi.Expand(req.URL, map[string]string{
41018 "profileId": strconv.FormatInt(c.profileId, 10),
41019 "id": strconv.FormatInt(c.id, 10),
41020 })
41021 return gensupport.SendRequest(c.ctx_, c.s.client, req)
41022 }
41023
41024
41025
41026
41027
41028
41029
41030
41031 func (c *PlatformTypesGetCall) Do(opts ...googleapi.CallOption) (*PlatformType, error) {
41032 gensupport.SetOptions(c.urlParams_, opts...)
41033 res, err := c.doRequest("json")
41034 if res != nil && res.StatusCode == http.StatusNotModified {
41035 if res.Body != nil {
41036 res.Body.Close()
41037 }
41038 return nil, &googleapi.Error{
41039 Code: res.StatusCode,
41040 Header: res.Header,
41041 }
41042 }
41043 if err != nil {
41044 return nil, err
41045 }
41046 defer googleapi.CloseBody(res)
41047 if err := googleapi.CheckResponse(res); err != nil {
41048 return nil, err
41049 }
41050 ret := &PlatformType{
41051 ServerResponse: googleapi.ServerResponse{
41052 Header: res.Header,
41053 HTTPStatusCode: res.StatusCode,
41054 },
41055 }
41056 target := &ret
41057 if err := gensupport.DecodeResponse(target, res); err != nil {
41058 return nil, err
41059 }
41060 return ret, nil
41061
41062
41063
41064
41065
41066
41067
41068
41069
41070
41071
41072
41073
41074
41075
41076
41077
41078
41079
41080
41081
41082
41083
41084
41085
41086
41087
41088
41089
41090
41091
41092
41093
41094 }
41095
41096
41097
41098 type PlatformTypesListCall struct {
41099 s *Service
41100 profileId int64
41101 urlParams_ gensupport.URLParams
41102 ifNoneMatch_ string
41103 ctx_ context.Context
41104 header_ http.Header
41105 }
41106
41107
41108 func (r *PlatformTypesService) List(profileId int64) *PlatformTypesListCall {
41109 c := &PlatformTypesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
41110 c.profileId = profileId
41111 return c
41112 }
41113
41114
41115
41116
41117 func (c *PlatformTypesListCall) Fields(s ...googleapi.Field) *PlatformTypesListCall {
41118 c.urlParams_.Set("fields", googleapi.CombineFields(s))
41119 return c
41120 }
41121
41122
41123
41124
41125
41126
41127 func (c *PlatformTypesListCall) IfNoneMatch(entityTag string) *PlatformTypesListCall {
41128 c.ifNoneMatch_ = entityTag
41129 return c
41130 }
41131
41132
41133
41134
41135 func (c *PlatformTypesListCall) Context(ctx context.Context) *PlatformTypesListCall {
41136 c.ctx_ = ctx
41137 return c
41138 }
41139
41140
41141
41142 func (c *PlatformTypesListCall) Header() http.Header {
41143 if c.header_ == nil {
41144 c.header_ = make(http.Header)
41145 }
41146 return c.header_
41147 }
41148
41149 func (c *PlatformTypesListCall) doRequest(alt string) (*http.Response, error) {
41150 reqHeaders := make(http.Header)
41151 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
41152 for k, v := range c.header_ {
41153 reqHeaders[k] = v
41154 }
41155 reqHeaders.Set("User-Agent", c.s.userAgent())
41156 if c.ifNoneMatch_ != "" {
41157 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
41158 }
41159 var body io.Reader = nil
41160 c.urlParams_.Set("alt", alt)
41161 c.urlParams_.Set("prettyPrint", "false")
41162 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/platformTypes")
41163 urls += "?" + c.urlParams_.Encode()
41164 req, err := http.NewRequest("GET", urls, body)
41165 if err != nil {
41166 return nil, err
41167 }
41168 req.Header = reqHeaders
41169 googleapi.Expand(req.URL, map[string]string{
41170 "profileId": strconv.FormatInt(c.profileId, 10),
41171 })
41172 return gensupport.SendRequest(c.ctx_, c.s.client, req)
41173 }
41174
41175
41176
41177
41178
41179
41180
41181
41182 func (c *PlatformTypesListCall) Do(opts ...googleapi.CallOption) (*PlatformTypesListResponse, error) {
41183 gensupport.SetOptions(c.urlParams_, opts...)
41184 res, err := c.doRequest("json")
41185 if res != nil && res.StatusCode == http.StatusNotModified {
41186 if res.Body != nil {
41187 res.Body.Close()
41188 }
41189 return nil, &googleapi.Error{
41190 Code: res.StatusCode,
41191 Header: res.Header,
41192 }
41193 }
41194 if err != nil {
41195 return nil, err
41196 }
41197 defer googleapi.CloseBody(res)
41198 if err := googleapi.CheckResponse(res); err != nil {
41199 return nil, err
41200 }
41201 ret := &PlatformTypesListResponse{
41202 ServerResponse: googleapi.ServerResponse{
41203 Header: res.Header,
41204 HTTPStatusCode: res.StatusCode,
41205 },
41206 }
41207 target := &ret
41208 if err := gensupport.DecodeResponse(target, res); err != nil {
41209 return nil, err
41210 }
41211 return ret, nil
41212
41213
41214
41215
41216
41217
41218
41219
41220
41221
41222
41223
41224
41225
41226
41227
41228
41229
41230
41231
41232
41233
41234
41235
41236
41237 }
41238
41239
41240
41241 type PostalCodesGetCall struct {
41242 s *Service
41243 profileId int64
41244 code string
41245 urlParams_ gensupport.URLParams
41246 ifNoneMatch_ string
41247 ctx_ context.Context
41248 header_ http.Header
41249 }
41250
41251
41252 func (r *PostalCodesService) Get(profileId int64, code string) *PostalCodesGetCall {
41253 c := &PostalCodesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
41254 c.profileId = profileId
41255 c.code = code
41256 return c
41257 }
41258
41259
41260
41261
41262 func (c *PostalCodesGetCall) Fields(s ...googleapi.Field) *PostalCodesGetCall {
41263 c.urlParams_.Set("fields", googleapi.CombineFields(s))
41264 return c
41265 }
41266
41267
41268
41269
41270
41271
41272 func (c *PostalCodesGetCall) IfNoneMatch(entityTag string) *PostalCodesGetCall {
41273 c.ifNoneMatch_ = entityTag
41274 return c
41275 }
41276
41277
41278
41279
41280 func (c *PostalCodesGetCall) Context(ctx context.Context) *PostalCodesGetCall {
41281 c.ctx_ = ctx
41282 return c
41283 }
41284
41285
41286
41287 func (c *PostalCodesGetCall) Header() http.Header {
41288 if c.header_ == nil {
41289 c.header_ = make(http.Header)
41290 }
41291 return c.header_
41292 }
41293
41294 func (c *PostalCodesGetCall) doRequest(alt string) (*http.Response, error) {
41295 reqHeaders := make(http.Header)
41296 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
41297 for k, v := range c.header_ {
41298 reqHeaders[k] = v
41299 }
41300 reqHeaders.Set("User-Agent", c.s.userAgent())
41301 if c.ifNoneMatch_ != "" {
41302 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
41303 }
41304 var body io.Reader = nil
41305 c.urlParams_.Set("alt", alt)
41306 c.urlParams_.Set("prettyPrint", "false")
41307 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/postalCodes/{code}")
41308 urls += "?" + c.urlParams_.Encode()
41309 req, err := http.NewRequest("GET", urls, body)
41310 if err != nil {
41311 return nil, err
41312 }
41313 req.Header = reqHeaders
41314 googleapi.Expand(req.URL, map[string]string{
41315 "profileId": strconv.FormatInt(c.profileId, 10),
41316 "code": c.code,
41317 })
41318 return gensupport.SendRequest(c.ctx_, c.s.client, req)
41319 }
41320
41321
41322
41323
41324
41325
41326
41327
41328 func (c *PostalCodesGetCall) Do(opts ...googleapi.CallOption) (*PostalCode, error) {
41329 gensupport.SetOptions(c.urlParams_, opts...)
41330 res, err := c.doRequest("json")
41331 if res != nil && res.StatusCode == http.StatusNotModified {
41332 if res.Body != nil {
41333 res.Body.Close()
41334 }
41335 return nil, &googleapi.Error{
41336 Code: res.StatusCode,
41337 Header: res.Header,
41338 }
41339 }
41340 if err != nil {
41341 return nil, err
41342 }
41343 defer googleapi.CloseBody(res)
41344 if err := googleapi.CheckResponse(res); err != nil {
41345 return nil, err
41346 }
41347 ret := &PostalCode{
41348 ServerResponse: googleapi.ServerResponse{
41349 Header: res.Header,
41350 HTTPStatusCode: res.StatusCode,
41351 },
41352 }
41353 target := &ret
41354 if err := gensupport.DecodeResponse(target, res); err != nil {
41355 return nil, err
41356 }
41357 return ret, nil
41358
41359
41360
41361
41362
41363
41364
41365
41366
41367
41368
41369
41370
41371
41372
41373
41374
41375
41376
41377
41378
41379
41380
41381
41382
41383
41384
41385
41386
41387
41388
41389
41390 }
41391
41392
41393
41394 type PostalCodesListCall struct {
41395 s *Service
41396 profileId int64
41397 urlParams_ gensupport.URLParams
41398 ifNoneMatch_ string
41399 ctx_ context.Context
41400 header_ http.Header
41401 }
41402
41403
41404 func (r *PostalCodesService) List(profileId int64) *PostalCodesListCall {
41405 c := &PostalCodesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
41406 c.profileId = profileId
41407 return c
41408 }
41409
41410
41411
41412
41413 func (c *PostalCodesListCall) Fields(s ...googleapi.Field) *PostalCodesListCall {
41414 c.urlParams_.Set("fields", googleapi.CombineFields(s))
41415 return c
41416 }
41417
41418
41419
41420
41421
41422
41423 func (c *PostalCodesListCall) IfNoneMatch(entityTag string) *PostalCodesListCall {
41424 c.ifNoneMatch_ = entityTag
41425 return c
41426 }
41427
41428
41429
41430
41431 func (c *PostalCodesListCall) Context(ctx context.Context) *PostalCodesListCall {
41432 c.ctx_ = ctx
41433 return c
41434 }
41435
41436
41437
41438 func (c *PostalCodesListCall) Header() http.Header {
41439 if c.header_ == nil {
41440 c.header_ = make(http.Header)
41441 }
41442 return c.header_
41443 }
41444
41445 func (c *PostalCodesListCall) doRequest(alt string) (*http.Response, error) {
41446 reqHeaders := make(http.Header)
41447 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
41448 for k, v := range c.header_ {
41449 reqHeaders[k] = v
41450 }
41451 reqHeaders.Set("User-Agent", c.s.userAgent())
41452 if c.ifNoneMatch_ != "" {
41453 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
41454 }
41455 var body io.Reader = nil
41456 c.urlParams_.Set("alt", alt)
41457 c.urlParams_.Set("prettyPrint", "false")
41458 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/postalCodes")
41459 urls += "?" + c.urlParams_.Encode()
41460 req, err := http.NewRequest("GET", urls, body)
41461 if err != nil {
41462 return nil, err
41463 }
41464 req.Header = reqHeaders
41465 googleapi.Expand(req.URL, map[string]string{
41466 "profileId": strconv.FormatInt(c.profileId, 10),
41467 })
41468 return gensupport.SendRequest(c.ctx_, c.s.client, req)
41469 }
41470
41471
41472
41473
41474
41475
41476
41477
41478 func (c *PostalCodesListCall) Do(opts ...googleapi.CallOption) (*PostalCodesListResponse, error) {
41479 gensupport.SetOptions(c.urlParams_, opts...)
41480 res, err := c.doRequest("json")
41481 if res != nil && res.StatusCode == http.StatusNotModified {
41482 if res.Body != nil {
41483 res.Body.Close()
41484 }
41485 return nil, &googleapi.Error{
41486 Code: res.StatusCode,
41487 Header: res.Header,
41488 }
41489 }
41490 if err != nil {
41491 return nil, err
41492 }
41493 defer googleapi.CloseBody(res)
41494 if err := googleapi.CheckResponse(res); err != nil {
41495 return nil, err
41496 }
41497 ret := &PostalCodesListResponse{
41498 ServerResponse: googleapi.ServerResponse{
41499 Header: res.Header,
41500 HTTPStatusCode: res.StatusCode,
41501 },
41502 }
41503 target := &ret
41504 if err := gensupport.DecodeResponse(target, res); err != nil {
41505 return nil, err
41506 }
41507 return ret, nil
41508
41509
41510
41511
41512
41513
41514
41515
41516
41517
41518
41519
41520
41521
41522
41523
41524
41525
41526
41527
41528
41529
41530
41531
41532
41533 }
41534
41535
41536
41537 type ProjectsGetCall struct {
41538 s *Service
41539 profileId int64
41540 id int64
41541 urlParams_ gensupport.URLParams
41542 ifNoneMatch_ string
41543 ctx_ context.Context
41544 header_ http.Header
41545 }
41546
41547
41548 func (r *ProjectsService) Get(profileId int64, id int64) *ProjectsGetCall {
41549 c := &ProjectsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
41550 c.profileId = profileId
41551 c.id = id
41552 return c
41553 }
41554
41555
41556
41557
41558 func (c *ProjectsGetCall) Fields(s ...googleapi.Field) *ProjectsGetCall {
41559 c.urlParams_.Set("fields", googleapi.CombineFields(s))
41560 return c
41561 }
41562
41563
41564
41565
41566
41567
41568 func (c *ProjectsGetCall) IfNoneMatch(entityTag string) *ProjectsGetCall {
41569 c.ifNoneMatch_ = entityTag
41570 return c
41571 }
41572
41573
41574
41575
41576 func (c *ProjectsGetCall) Context(ctx context.Context) *ProjectsGetCall {
41577 c.ctx_ = ctx
41578 return c
41579 }
41580
41581
41582
41583 func (c *ProjectsGetCall) Header() http.Header {
41584 if c.header_ == nil {
41585 c.header_ = make(http.Header)
41586 }
41587 return c.header_
41588 }
41589
41590 func (c *ProjectsGetCall) doRequest(alt string) (*http.Response, error) {
41591 reqHeaders := make(http.Header)
41592 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
41593 for k, v := range c.header_ {
41594 reqHeaders[k] = v
41595 }
41596 reqHeaders.Set("User-Agent", c.s.userAgent())
41597 if c.ifNoneMatch_ != "" {
41598 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
41599 }
41600 var body io.Reader = nil
41601 c.urlParams_.Set("alt", alt)
41602 c.urlParams_.Set("prettyPrint", "false")
41603 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/projects/{id}")
41604 urls += "?" + c.urlParams_.Encode()
41605 req, err := http.NewRequest("GET", urls, body)
41606 if err != nil {
41607 return nil, err
41608 }
41609 req.Header = reqHeaders
41610 googleapi.Expand(req.URL, map[string]string{
41611 "profileId": strconv.FormatInt(c.profileId, 10),
41612 "id": strconv.FormatInt(c.id, 10),
41613 })
41614 return gensupport.SendRequest(c.ctx_, c.s.client, req)
41615 }
41616
41617
41618
41619
41620
41621
41622
41623
41624 func (c *ProjectsGetCall) Do(opts ...googleapi.CallOption) (*Project, error) {
41625 gensupport.SetOptions(c.urlParams_, opts...)
41626 res, err := c.doRequest("json")
41627 if res != nil && res.StatusCode == http.StatusNotModified {
41628 if res.Body != nil {
41629 res.Body.Close()
41630 }
41631 return nil, &googleapi.Error{
41632 Code: res.StatusCode,
41633 Header: res.Header,
41634 }
41635 }
41636 if err != nil {
41637 return nil, err
41638 }
41639 defer googleapi.CloseBody(res)
41640 if err := googleapi.CheckResponse(res); err != nil {
41641 return nil, err
41642 }
41643 ret := &Project{
41644 ServerResponse: googleapi.ServerResponse{
41645 Header: res.Header,
41646 HTTPStatusCode: res.StatusCode,
41647 },
41648 }
41649 target := &ret
41650 if err := gensupport.DecodeResponse(target, res); err != nil {
41651 return nil, err
41652 }
41653 return ret, nil
41654
41655
41656
41657
41658
41659
41660
41661
41662
41663
41664
41665
41666
41667
41668
41669
41670
41671
41672
41673
41674
41675
41676
41677
41678
41679
41680
41681
41682
41683
41684
41685
41686
41687 }
41688
41689
41690
41691 type ProjectsListCall struct {
41692 s *Service
41693 profileId int64
41694 urlParams_ gensupport.URLParams
41695 ifNoneMatch_ string
41696 ctx_ context.Context
41697 header_ http.Header
41698 }
41699
41700
41701
41702 func (r *ProjectsService) List(profileId int64) *ProjectsListCall {
41703 c := &ProjectsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
41704 c.profileId = profileId
41705 return c
41706 }
41707
41708
41709
41710 func (c *ProjectsListCall) AdvertiserIds(advertiserIds ...int64) *ProjectsListCall {
41711 var advertiserIds_ []string
41712 for _, v := range advertiserIds {
41713 advertiserIds_ = append(advertiserIds_, fmt.Sprint(v))
41714 }
41715 c.urlParams_.SetMulti("advertiserIds", advertiserIds_)
41716 return c
41717 }
41718
41719
41720
41721 func (c *ProjectsListCall) Ids(ids ...int64) *ProjectsListCall {
41722 var ids_ []string
41723 for _, v := range ids {
41724 ids_ = append(ids_, fmt.Sprint(v))
41725 }
41726 c.urlParams_.SetMulti("ids", ids_)
41727 return c
41728 }
41729
41730
41731
41732 func (c *ProjectsListCall) MaxResults(maxResults int64) *ProjectsListCall {
41733 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
41734 return c
41735 }
41736
41737
41738
41739 func (c *ProjectsListCall) PageToken(pageToken string) *ProjectsListCall {
41740 c.urlParams_.Set("pageToken", pageToken)
41741 return c
41742 }
41743
41744
41745
41746
41747
41748
41749
41750
41751
41752 func (c *ProjectsListCall) SearchString(searchString string) *ProjectsListCall {
41753 c.urlParams_.Set("searchString", searchString)
41754 return c
41755 }
41756
41757
41758
41759
41760
41761
41762
41763
41764 func (c *ProjectsListCall) SortField(sortField string) *ProjectsListCall {
41765 c.urlParams_.Set("sortField", sortField)
41766 return c
41767 }
41768
41769
41770
41771
41772
41773
41774
41775
41776 func (c *ProjectsListCall) SortOrder(sortOrder string) *ProjectsListCall {
41777 c.urlParams_.Set("sortOrder", sortOrder)
41778 return c
41779 }
41780
41781
41782
41783
41784 func (c *ProjectsListCall) Fields(s ...googleapi.Field) *ProjectsListCall {
41785 c.urlParams_.Set("fields", googleapi.CombineFields(s))
41786 return c
41787 }
41788
41789
41790
41791
41792
41793
41794 func (c *ProjectsListCall) IfNoneMatch(entityTag string) *ProjectsListCall {
41795 c.ifNoneMatch_ = entityTag
41796 return c
41797 }
41798
41799
41800
41801
41802 func (c *ProjectsListCall) Context(ctx context.Context) *ProjectsListCall {
41803 c.ctx_ = ctx
41804 return c
41805 }
41806
41807
41808
41809 func (c *ProjectsListCall) Header() http.Header {
41810 if c.header_ == nil {
41811 c.header_ = make(http.Header)
41812 }
41813 return c.header_
41814 }
41815
41816 func (c *ProjectsListCall) doRequest(alt string) (*http.Response, error) {
41817 reqHeaders := make(http.Header)
41818 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
41819 for k, v := range c.header_ {
41820 reqHeaders[k] = v
41821 }
41822 reqHeaders.Set("User-Agent", c.s.userAgent())
41823 if c.ifNoneMatch_ != "" {
41824 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
41825 }
41826 var body io.Reader = nil
41827 c.urlParams_.Set("alt", alt)
41828 c.urlParams_.Set("prettyPrint", "false")
41829 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/projects")
41830 urls += "?" + c.urlParams_.Encode()
41831 req, err := http.NewRequest("GET", urls, body)
41832 if err != nil {
41833 return nil, err
41834 }
41835 req.Header = reqHeaders
41836 googleapi.Expand(req.URL, map[string]string{
41837 "profileId": strconv.FormatInt(c.profileId, 10),
41838 })
41839 return gensupport.SendRequest(c.ctx_, c.s.client, req)
41840 }
41841
41842
41843
41844
41845
41846
41847
41848
41849 func (c *ProjectsListCall) Do(opts ...googleapi.CallOption) (*ProjectsListResponse, error) {
41850 gensupport.SetOptions(c.urlParams_, opts...)
41851 res, err := c.doRequest("json")
41852 if res != nil && res.StatusCode == http.StatusNotModified {
41853 if res.Body != nil {
41854 res.Body.Close()
41855 }
41856 return nil, &googleapi.Error{
41857 Code: res.StatusCode,
41858 Header: res.Header,
41859 }
41860 }
41861 if err != nil {
41862 return nil, err
41863 }
41864 defer googleapi.CloseBody(res)
41865 if err := googleapi.CheckResponse(res); err != nil {
41866 return nil, err
41867 }
41868 ret := &ProjectsListResponse{
41869 ServerResponse: googleapi.ServerResponse{
41870 Header: res.Header,
41871 HTTPStatusCode: res.StatusCode,
41872 },
41873 }
41874 target := &ret
41875 if err := gensupport.DecodeResponse(target, res); err != nil {
41876 return nil, err
41877 }
41878 return ret, nil
41879
41880
41881
41882
41883
41884
41885
41886
41887
41888
41889
41890
41891
41892
41893
41894
41895
41896
41897
41898
41899
41900
41901
41902
41903
41904
41905
41906
41907
41908
41909
41910
41911
41912
41913
41914
41915
41916
41917
41918
41919
41920
41921
41922
41923
41924
41925
41926
41927
41928
41929
41930
41931
41932
41933
41934
41935
41936
41937
41938
41939
41940
41941
41942
41943
41944
41945
41946
41947
41948
41949
41950
41951
41952
41953
41954
41955
41956
41957
41958
41959
41960
41961
41962
41963
41964
41965 }
41966
41967
41968
41969
41970 func (c *ProjectsListCall) Pages(ctx context.Context, f func(*ProjectsListResponse) error) error {
41971 c.ctx_ = ctx
41972 defer c.PageToken(c.urlParams_.Get("pageToken"))
41973 for {
41974 x, err := c.Do()
41975 if err != nil {
41976 return err
41977 }
41978 if err := f(x); err != nil {
41979 return err
41980 }
41981 if x.NextPageToken == "" {
41982 return nil
41983 }
41984 c.PageToken(x.NextPageToken)
41985 }
41986 }
41987
41988
41989
41990 type RegionsListCall struct {
41991 s *Service
41992 profileId int64
41993 urlParams_ gensupport.URLParams
41994 ifNoneMatch_ string
41995 ctx_ context.Context
41996 header_ http.Header
41997 }
41998
41999
42000 func (r *RegionsService) List(profileId int64) *RegionsListCall {
42001 c := &RegionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
42002 c.profileId = profileId
42003 return c
42004 }
42005
42006
42007
42008
42009 func (c *RegionsListCall) Fields(s ...googleapi.Field) *RegionsListCall {
42010 c.urlParams_.Set("fields", googleapi.CombineFields(s))
42011 return c
42012 }
42013
42014
42015
42016
42017
42018
42019 func (c *RegionsListCall) IfNoneMatch(entityTag string) *RegionsListCall {
42020 c.ifNoneMatch_ = entityTag
42021 return c
42022 }
42023
42024
42025
42026
42027 func (c *RegionsListCall) Context(ctx context.Context) *RegionsListCall {
42028 c.ctx_ = ctx
42029 return c
42030 }
42031
42032
42033
42034 func (c *RegionsListCall) Header() http.Header {
42035 if c.header_ == nil {
42036 c.header_ = make(http.Header)
42037 }
42038 return c.header_
42039 }
42040
42041 func (c *RegionsListCall) doRequest(alt string) (*http.Response, error) {
42042 reqHeaders := make(http.Header)
42043 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
42044 for k, v := range c.header_ {
42045 reqHeaders[k] = v
42046 }
42047 reqHeaders.Set("User-Agent", c.s.userAgent())
42048 if c.ifNoneMatch_ != "" {
42049 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
42050 }
42051 var body io.Reader = nil
42052 c.urlParams_.Set("alt", alt)
42053 c.urlParams_.Set("prettyPrint", "false")
42054 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/regions")
42055 urls += "?" + c.urlParams_.Encode()
42056 req, err := http.NewRequest("GET", urls, body)
42057 if err != nil {
42058 return nil, err
42059 }
42060 req.Header = reqHeaders
42061 googleapi.Expand(req.URL, map[string]string{
42062 "profileId": strconv.FormatInt(c.profileId, 10),
42063 })
42064 return gensupport.SendRequest(c.ctx_, c.s.client, req)
42065 }
42066
42067
42068
42069
42070
42071
42072
42073
42074 func (c *RegionsListCall) Do(opts ...googleapi.CallOption) (*RegionsListResponse, error) {
42075 gensupport.SetOptions(c.urlParams_, opts...)
42076 res, err := c.doRequest("json")
42077 if res != nil && res.StatusCode == http.StatusNotModified {
42078 if res.Body != nil {
42079 res.Body.Close()
42080 }
42081 return nil, &googleapi.Error{
42082 Code: res.StatusCode,
42083 Header: res.Header,
42084 }
42085 }
42086 if err != nil {
42087 return nil, err
42088 }
42089 defer googleapi.CloseBody(res)
42090 if err := googleapi.CheckResponse(res); err != nil {
42091 return nil, err
42092 }
42093 ret := &RegionsListResponse{
42094 ServerResponse: googleapi.ServerResponse{
42095 Header: res.Header,
42096 HTTPStatusCode: res.StatusCode,
42097 },
42098 }
42099 target := &ret
42100 if err := gensupport.DecodeResponse(target, res); err != nil {
42101 return nil, err
42102 }
42103 return ret, nil
42104
42105
42106
42107
42108
42109
42110
42111
42112
42113
42114
42115
42116
42117
42118
42119
42120
42121
42122
42123
42124
42125
42126
42127
42128
42129 }
42130
42131
42132
42133 type RemarketingListSharesGetCall struct {
42134 s *Service
42135 profileId int64
42136 remarketingListId int64
42137 urlParams_ gensupport.URLParams
42138 ifNoneMatch_ string
42139 ctx_ context.Context
42140 header_ http.Header
42141 }
42142
42143
42144 func (r *RemarketingListSharesService) Get(profileId int64, remarketingListId int64) *RemarketingListSharesGetCall {
42145 c := &RemarketingListSharesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
42146 c.profileId = profileId
42147 c.remarketingListId = remarketingListId
42148 return c
42149 }
42150
42151
42152
42153
42154 func (c *RemarketingListSharesGetCall) Fields(s ...googleapi.Field) *RemarketingListSharesGetCall {
42155 c.urlParams_.Set("fields", googleapi.CombineFields(s))
42156 return c
42157 }
42158
42159
42160
42161
42162
42163
42164 func (c *RemarketingListSharesGetCall) IfNoneMatch(entityTag string) *RemarketingListSharesGetCall {
42165 c.ifNoneMatch_ = entityTag
42166 return c
42167 }
42168
42169
42170
42171
42172 func (c *RemarketingListSharesGetCall) Context(ctx context.Context) *RemarketingListSharesGetCall {
42173 c.ctx_ = ctx
42174 return c
42175 }
42176
42177
42178
42179 func (c *RemarketingListSharesGetCall) Header() http.Header {
42180 if c.header_ == nil {
42181 c.header_ = make(http.Header)
42182 }
42183 return c.header_
42184 }
42185
42186 func (c *RemarketingListSharesGetCall) doRequest(alt string) (*http.Response, error) {
42187 reqHeaders := make(http.Header)
42188 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
42189 for k, v := range c.header_ {
42190 reqHeaders[k] = v
42191 }
42192 reqHeaders.Set("User-Agent", c.s.userAgent())
42193 if c.ifNoneMatch_ != "" {
42194 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
42195 }
42196 var body io.Reader = nil
42197 c.urlParams_.Set("alt", alt)
42198 c.urlParams_.Set("prettyPrint", "false")
42199 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/remarketingListShares/{remarketingListId}")
42200 urls += "?" + c.urlParams_.Encode()
42201 req, err := http.NewRequest("GET", urls, body)
42202 if err != nil {
42203 return nil, err
42204 }
42205 req.Header = reqHeaders
42206 googleapi.Expand(req.URL, map[string]string{
42207 "profileId": strconv.FormatInt(c.profileId, 10),
42208 "remarketingListId": strconv.FormatInt(c.remarketingListId, 10),
42209 })
42210 return gensupport.SendRequest(c.ctx_, c.s.client, req)
42211 }
42212
42213
42214
42215
42216
42217
42218
42219
42220 func (c *RemarketingListSharesGetCall) Do(opts ...googleapi.CallOption) (*RemarketingListShare, error) {
42221 gensupport.SetOptions(c.urlParams_, opts...)
42222 res, err := c.doRequest("json")
42223 if res != nil && res.StatusCode == http.StatusNotModified {
42224 if res.Body != nil {
42225 res.Body.Close()
42226 }
42227 return nil, &googleapi.Error{
42228 Code: res.StatusCode,
42229 Header: res.Header,
42230 }
42231 }
42232 if err != nil {
42233 return nil, err
42234 }
42235 defer googleapi.CloseBody(res)
42236 if err := googleapi.CheckResponse(res); err != nil {
42237 return nil, err
42238 }
42239 ret := &RemarketingListShare{
42240 ServerResponse: googleapi.ServerResponse{
42241 Header: res.Header,
42242 HTTPStatusCode: res.StatusCode,
42243 },
42244 }
42245 target := &ret
42246 if err := gensupport.DecodeResponse(target, res); err != nil {
42247 return nil, err
42248 }
42249 return ret, nil
42250
42251
42252
42253
42254
42255
42256
42257
42258
42259
42260
42261
42262
42263
42264
42265
42266
42267
42268
42269
42270
42271
42272
42273
42274
42275
42276
42277
42278
42279
42280
42281
42282
42283 }
42284
42285
42286
42287 type RemarketingListSharesPatchCall struct {
42288 s *Service
42289 profileId int64
42290 remarketinglistshare *RemarketingListShare
42291 urlParams_ gensupport.URLParams
42292 ctx_ context.Context
42293 header_ http.Header
42294 }
42295
42296
42297
42298 func (r *RemarketingListSharesService) Patch(profileId int64, remarketingListId int64, remarketinglistshare *RemarketingListShare) *RemarketingListSharesPatchCall {
42299 c := &RemarketingListSharesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
42300 c.profileId = profileId
42301 c.urlParams_.Set("remarketingListId", fmt.Sprint(remarketingListId))
42302 c.remarketinglistshare = remarketinglistshare
42303 return c
42304 }
42305
42306
42307
42308
42309 func (c *RemarketingListSharesPatchCall) Fields(s ...googleapi.Field) *RemarketingListSharesPatchCall {
42310 c.urlParams_.Set("fields", googleapi.CombineFields(s))
42311 return c
42312 }
42313
42314
42315
42316
42317 func (c *RemarketingListSharesPatchCall) Context(ctx context.Context) *RemarketingListSharesPatchCall {
42318 c.ctx_ = ctx
42319 return c
42320 }
42321
42322
42323
42324 func (c *RemarketingListSharesPatchCall) Header() http.Header {
42325 if c.header_ == nil {
42326 c.header_ = make(http.Header)
42327 }
42328 return c.header_
42329 }
42330
42331 func (c *RemarketingListSharesPatchCall) doRequest(alt string) (*http.Response, error) {
42332 reqHeaders := make(http.Header)
42333 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
42334 for k, v := range c.header_ {
42335 reqHeaders[k] = v
42336 }
42337 reqHeaders.Set("User-Agent", c.s.userAgent())
42338 var body io.Reader = nil
42339 body, err := googleapi.WithoutDataWrapper.JSONReader(c.remarketinglistshare)
42340 if err != nil {
42341 return nil, err
42342 }
42343 reqHeaders.Set("Content-Type", "application/json")
42344 c.urlParams_.Set("alt", alt)
42345 c.urlParams_.Set("prettyPrint", "false")
42346 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/remarketingListShares")
42347 urls += "?" + c.urlParams_.Encode()
42348 req, err := http.NewRequest("PATCH", urls, body)
42349 if err != nil {
42350 return nil, err
42351 }
42352 req.Header = reqHeaders
42353 googleapi.Expand(req.URL, map[string]string{
42354 "profileId": strconv.FormatInt(c.profileId, 10),
42355 })
42356 return gensupport.SendRequest(c.ctx_, c.s.client, req)
42357 }
42358
42359
42360
42361
42362
42363
42364
42365
42366 func (c *RemarketingListSharesPatchCall) Do(opts ...googleapi.CallOption) (*RemarketingListShare, error) {
42367 gensupport.SetOptions(c.urlParams_, opts...)
42368 res, err := c.doRequest("json")
42369 if res != nil && res.StatusCode == http.StatusNotModified {
42370 if res.Body != nil {
42371 res.Body.Close()
42372 }
42373 return nil, &googleapi.Error{
42374 Code: res.StatusCode,
42375 Header: res.Header,
42376 }
42377 }
42378 if err != nil {
42379 return nil, err
42380 }
42381 defer googleapi.CloseBody(res)
42382 if err := googleapi.CheckResponse(res); err != nil {
42383 return nil, err
42384 }
42385 ret := &RemarketingListShare{
42386 ServerResponse: googleapi.ServerResponse{
42387 Header: res.Header,
42388 HTTPStatusCode: res.StatusCode,
42389 },
42390 }
42391 target := &ret
42392 if err := gensupport.DecodeResponse(target, res); err != nil {
42393 return nil, err
42394 }
42395 return ret, nil
42396
42397
42398
42399
42400
42401
42402
42403
42404
42405
42406
42407
42408
42409
42410
42411
42412
42413
42414
42415
42416
42417
42418
42419
42420
42421
42422
42423
42424
42425
42426
42427
42428
42429
42430
42431
42432 }
42433
42434
42435
42436 type RemarketingListSharesUpdateCall struct {
42437 s *Service
42438 profileId int64
42439 remarketinglistshare *RemarketingListShare
42440 urlParams_ gensupport.URLParams
42441 ctx_ context.Context
42442 header_ http.Header
42443 }
42444
42445
42446 func (r *RemarketingListSharesService) Update(profileId int64, remarketinglistshare *RemarketingListShare) *RemarketingListSharesUpdateCall {
42447 c := &RemarketingListSharesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
42448 c.profileId = profileId
42449 c.remarketinglistshare = remarketinglistshare
42450 return c
42451 }
42452
42453
42454
42455
42456 func (c *RemarketingListSharesUpdateCall) Fields(s ...googleapi.Field) *RemarketingListSharesUpdateCall {
42457 c.urlParams_.Set("fields", googleapi.CombineFields(s))
42458 return c
42459 }
42460
42461
42462
42463
42464 func (c *RemarketingListSharesUpdateCall) Context(ctx context.Context) *RemarketingListSharesUpdateCall {
42465 c.ctx_ = ctx
42466 return c
42467 }
42468
42469
42470
42471 func (c *RemarketingListSharesUpdateCall) Header() http.Header {
42472 if c.header_ == nil {
42473 c.header_ = make(http.Header)
42474 }
42475 return c.header_
42476 }
42477
42478 func (c *RemarketingListSharesUpdateCall) doRequest(alt string) (*http.Response, error) {
42479 reqHeaders := make(http.Header)
42480 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
42481 for k, v := range c.header_ {
42482 reqHeaders[k] = v
42483 }
42484 reqHeaders.Set("User-Agent", c.s.userAgent())
42485 var body io.Reader = nil
42486 body, err := googleapi.WithoutDataWrapper.JSONReader(c.remarketinglistshare)
42487 if err != nil {
42488 return nil, err
42489 }
42490 reqHeaders.Set("Content-Type", "application/json")
42491 c.urlParams_.Set("alt", alt)
42492 c.urlParams_.Set("prettyPrint", "false")
42493 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/remarketingListShares")
42494 urls += "?" + c.urlParams_.Encode()
42495 req, err := http.NewRequest("PUT", urls, body)
42496 if err != nil {
42497 return nil, err
42498 }
42499 req.Header = reqHeaders
42500 googleapi.Expand(req.URL, map[string]string{
42501 "profileId": strconv.FormatInt(c.profileId, 10),
42502 })
42503 return gensupport.SendRequest(c.ctx_, c.s.client, req)
42504 }
42505
42506
42507
42508
42509
42510
42511
42512
42513 func (c *RemarketingListSharesUpdateCall) Do(opts ...googleapi.CallOption) (*RemarketingListShare, error) {
42514 gensupport.SetOptions(c.urlParams_, opts...)
42515 res, err := c.doRequest("json")
42516 if res != nil && res.StatusCode == http.StatusNotModified {
42517 if res.Body != nil {
42518 res.Body.Close()
42519 }
42520 return nil, &googleapi.Error{
42521 Code: res.StatusCode,
42522 Header: res.Header,
42523 }
42524 }
42525 if err != nil {
42526 return nil, err
42527 }
42528 defer googleapi.CloseBody(res)
42529 if err := googleapi.CheckResponse(res); err != nil {
42530 return nil, err
42531 }
42532 ret := &RemarketingListShare{
42533 ServerResponse: googleapi.ServerResponse{
42534 Header: res.Header,
42535 HTTPStatusCode: res.StatusCode,
42536 },
42537 }
42538 target := &ret
42539 if err := gensupport.DecodeResponse(target, res); err != nil {
42540 return nil, err
42541 }
42542 return ret, nil
42543
42544
42545
42546
42547
42548
42549
42550
42551
42552
42553
42554
42555
42556
42557
42558
42559
42560
42561
42562
42563
42564
42565
42566
42567
42568
42569
42570
42571 }
42572
42573
42574
42575 type RemarketingListsGetCall struct {
42576 s *Service
42577 profileId int64
42578 id int64
42579 urlParams_ gensupport.URLParams
42580 ifNoneMatch_ string
42581 ctx_ context.Context
42582 header_ http.Header
42583 }
42584
42585
42586 func (r *RemarketingListsService) Get(profileId int64, id int64) *RemarketingListsGetCall {
42587 c := &RemarketingListsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
42588 c.profileId = profileId
42589 c.id = id
42590 return c
42591 }
42592
42593
42594
42595
42596 func (c *RemarketingListsGetCall) Fields(s ...googleapi.Field) *RemarketingListsGetCall {
42597 c.urlParams_.Set("fields", googleapi.CombineFields(s))
42598 return c
42599 }
42600
42601
42602
42603
42604
42605
42606 func (c *RemarketingListsGetCall) IfNoneMatch(entityTag string) *RemarketingListsGetCall {
42607 c.ifNoneMatch_ = entityTag
42608 return c
42609 }
42610
42611
42612
42613
42614 func (c *RemarketingListsGetCall) Context(ctx context.Context) *RemarketingListsGetCall {
42615 c.ctx_ = ctx
42616 return c
42617 }
42618
42619
42620
42621 func (c *RemarketingListsGetCall) Header() http.Header {
42622 if c.header_ == nil {
42623 c.header_ = make(http.Header)
42624 }
42625 return c.header_
42626 }
42627
42628 func (c *RemarketingListsGetCall) doRequest(alt string) (*http.Response, error) {
42629 reqHeaders := make(http.Header)
42630 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
42631 for k, v := range c.header_ {
42632 reqHeaders[k] = v
42633 }
42634 reqHeaders.Set("User-Agent", c.s.userAgent())
42635 if c.ifNoneMatch_ != "" {
42636 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
42637 }
42638 var body io.Reader = nil
42639 c.urlParams_.Set("alt", alt)
42640 c.urlParams_.Set("prettyPrint", "false")
42641 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/remarketingLists/{id}")
42642 urls += "?" + c.urlParams_.Encode()
42643 req, err := http.NewRequest("GET", urls, body)
42644 if err != nil {
42645 return nil, err
42646 }
42647 req.Header = reqHeaders
42648 googleapi.Expand(req.URL, map[string]string{
42649 "profileId": strconv.FormatInt(c.profileId, 10),
42650 "id": strconv.FormatInt(c.id, 10),
42651 })
42652 return gensupport.SendRequest(c.ctx_, c.s.client, req)
42653 }
42654
42655
42656
42657
42658
42659
42660
42661
42662 func (c *RemarketingListsGetCall) Do(opts ...googleapi.CallOption) (*RemarketingList, error) {
42663 gensupport.SetOptions(c.urlParams_, opts...)
42664 res, err := c.doRequest("json")
42665 if res != nil && res.StatusCode == http.StatusNotModified {
42666 if res.Body != nil {
42667 res.Body.Close()
42668 }
42669 return nil, &googleapi.Error{
42670 Code: res.StatusCode,
42671 Header: res.Header,
42672 }
42673 }
42674 if err != nil {
42675 return nil, err
42676 }
42677 defer googleapi.CloseBody(res)
42678 if err := googleapi.CheckResponse(res); err != nil {
42679 return nil, err
42680 }
42681 ret := &RemarketingList{
42682 ServerResponse: googleapi.ServerResponse{
42683 Header: res.Header,
42684 HTTPStatusCode: res.StatusCode,
42685 },
42686 }
42687 target := &ret
42688 if err := gensupport.DecodeResponse(target, res); err != nil {
42689 return nil, err
42690 }
42691 return ret, nil
42692
42693
42694
42695
42696
42697
42698
42699
42700
42701
42702
42703
42704
42705
42706
42707
42708
42709
42710
42711
42712
42713
42714
42715
42716
42717
42718
42719
42720
42721
42722
42723
42724
42725 }
42726
42727
42728
42729 type RemarketingListsInsertCall struct {
42730 s *Service
42731 profileId int64
42732 remarketinglist *RemarketingList
42733 urlParams_ gensupport.URLParams
42734 ctx_ context.Context
42735 header_ http.Header
42736 }
42737
42738
42739 func (r *RemarketingListsService) Insert(profileId int64, remarketinglist *RemarketingList) *RemarketingListsInsertCall {
42740 c := &RemarketingListsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
42741 c.profileId = profileId
42742 c.remarketinglist = remarketinglist
42743 return c
42744 }
42745
42746
42747
42748
42749 func (c *RemarketingListsInsertCall) Fields(s ...googleapi.Field) *RemarketingListsInsertCall {
42750 c.urlParams_.Set("fields", googleapi.CombineFields(s))
42751 return c
42752 }
42753
42754
42755
42756
42757 func (c *RemarketingListsInsertCall) Context(ctx context.Context) *RemarketingListsInsertCall {
42758 c.ctx_ = ctx
42759 return c
42760 }
42761
42762
42763
42764 func (c *RemarketingListsInsertCall) Header() http.Header {
42765 if c.header_ == nil {
42766 c.header_ = make(http.Header)
42767 }
42768 return c.header_
42769 }
42770
42771 func (c *RemarketingListsInsertCall) doRequest(alt string) (*http.Response, error) {
42772 reqHeaders := make(http.Header)
42773 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
42774 for k, v := range c.header_ {
42775 reqHeaders[k] = v
42776 }
42777 reqHeaders.Set("User-Agent", c.s.userAgent())
42778 var body io.Reader = nil
42779 body, err := googleapi.WithoutDataWrapper.JSONReader(c.remarketinglist)
42780 if err != nil {
42781 return nil, err
42782 }
42783 reqHeaders.Set("Content-Type", "application/json")
42784 c.urlParams_.Set("alt", alt)
42785 c.urlParams_.Set("prettyPrint", "false")
42786 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/remarketingLists")
42787 urls += "?" + c.urlParams_.Encode()
42788 req, err := http.NewRequest("POST", urls, body)
42789 if err != nil {
42790 return nil, err
42791 }
42792 req.Header = reqHeaders
42793 googleapi.Expand(req.URL, map[string]string{
42794 "profileId": strconv.FormatInt(c.profileId, 10),
42795 })
42796 return gensupport.SendRequest(c.ctx_, c.s.client, req)
42797 }
42798
42799
42800
42801
42802
42803
42804
42805
42806 func (c *RemarketingListsInsertCall) Do(opts ...googleapi.CallOption) (*RemarketingList, error) {
42807 gensupport.SetOptions(c.urlParams_, opts...)
42808 res, err := c.doRequest("json")
42809 if res != nil && res.StatusCode == http.StatusNotModified {
42810 if res.Body != nil {
42811 res.Body.Close()
42812 }
42813 return nil, &googleapi.Error{
42814 Code: res.StatusCode,
42815 Header: res.Header,
42816 }
42817 }
42818 if err != nil {
42819 return nil, err
42820 }
42821 defer googleapi.CloseBody(res)
42822 if err := googleapi.CheckResponse(res); err != nil {
42823 return nil, err
42824 }
42825 ret := &RemarketingList{
42826 ServerResponse: googleapi.ServerResponse{
42827 Header: res.Header,
42828 HTTPStatusCode: res.StatusCode,
42829 },
42830 }
42831 target := &ret
42832 if err := gensupport.DecodeResponse(target, res); err != nil {
42833 return nil, err
42834 }
42835 return ret, nil
42836
42837
42838
42839
42840
42841
42842
42843
42844
42845
42846
42847
42848
42849
42850
42851
42852
42853
42854
42855
42856
42857
42858
42859
42860
42861
42862
42863
42864 }
42865
42866
42867
42868 type RemarketingListsListCall struct {
42869 s *Service
42870 profileId int64
42871 urlParams_ gensupport.URLParams
42872 ifNoneMatch_ string
42873 ctx_ context.Context
42874 header_ http.Header
42875 }
42876
42877
42878
42879 func (r *RemarketingListsService) List(profileId int64, advertiserId int64) *RemarketingListsListCall {
42880 c := &RemarketingListsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
42881 c.profileId = profileId
42882 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
42883 return c
42884 }
42885
42886
42887
42888 func (c *RemarketingListsListCall) Active(active bool) *RemarketingListsListCall {
42889 c.urlParams_.Set("active", fmt.Sprint(active))
42890 return c
42891 }
42892
42893
42894
42895
42896 func (c *RemarketingListsListCall) FloodlightActivityId(floodlightActivityId int64) *RemarketingListsListCall {
42897 c.urlParams_.Set("floodlightActivityId", fmt.Sprint(floodlightActivityId))
42898 return c
42899 }
42900
42901
42902
42903 func (c *RemarketingListsListCall) MaxResults(maxResults int64) *RemarketingListsListCall {
42904 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
42905 return c
42906 }
42907
42908
42909
42910
42911
42912
42913
42914
42915
42916 func (c *RemarketingListsListCall) Name(name string) *RemarketingListsListCall {
42917 c.urlParams_.Set("name", name)
42918 return c
42919 }
42920
42921
42922
42923 func (c *RemarketingListsListCall) PageToken(pageToken string) *RemarketingListsListCall {
42924 c.urlParams_.Set("pageToken", pageToken)
42925 return c
42926 }
42927
42928
42929
42930
42931
42932
42933
42934
42935 func (c *RemarketingListsListCall) SortField(sortField string) *RemarketingListsListCall {
42936 c.urlParams_.Set("sortField", sortField)
42937 return c
42938 }
42939
42940
42941
42942
42943
42944
42945
42946
42947 func (c *RemarketingListsListCall) SortOrder(sortOrder string) *RemarketingListsListCall {
42948 c.urlParams_.Set("sortOrder", sortOrder)
42949 return c
42950 }
42951
42952
42953
42954
42955 func (c *RemarketingListsListCall) Fields(s ...googleapi.Field) *RemarketingListsListCall {
42956 c.urlParams_.Set("fields", googleapi.CombineFields(s))
42957 return c
42958 }
42959
42960
42961
42962
42963
42964
42965 func (c *RemarketingListsListCall) IfNoneMatch(entityTag string) *RemarketingListsListCall {
42966 c.ifNoneMatch_ = entityTag
42967 return c
42968 }
42969
42970
42971
42972
42973 func (c *RemarketingListsListCall) Context(ctx context.Context) *RemarketingListsListCall {
42974 c.ctx_ = ctx
42975 return c
42976 }
42977
42978
42979
42980 func (c *RemarketingListsListCall) Header() http.Header {
42981 if c.header_ == nil {
42982 c.header_ = make(http.Header)
42983 }
42984 return c.header_
42985 }
42986
42987 func (c *RemarketingListsListCall) doRequest(alt string) (*http.Response, error) {
42988 reqHeaders := make(http.Header)
42989 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
42990 for k, v := range c.header_ {
42991 reqHeaders[k] = v
42992 }
42993 reqHeaders.Set("User-Agent", c.s.userAgent())
42994 if c.ifNoneMatch_ != "" {
42995 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
42996 }
42997 var body io.Reader = nil
42998 c.urlParams_.Set("alt", alt)
42999 c.urlParams_.Set("prettyPrint", "false")
43000 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/remarketingLists")
43001 urls += "?" + c.urlParams_.Encode()
43002 req, err := http.NewRequest("GET", urls, body)
43003 if err != nil {
43004 return nil, err
43005 }
43006 req.Header = reqHeaders
43007 googleapi.Expand(req.URL, map[string]string{
43008 "profileId": strconv.FormatInt(c.profileId, 10),
43009 })
43010 return gensupport.SendRequest(c.ctx_, c.s.client, req)
43011 }
43012
43013
43014
43015
43016
43017
43018
43019
43020 func (c *RemarketingListsListCall) Do(opts ...googleapi.CallOption) (*RemarketingListsListResponse, error) {
43021 gensupport.SetOptions(c.urlParams_, opts...)
43022 res, err := c.doRequest("json")
43023 if res != nil && res.StatusCode == http.StatusNotModified {
43024 if res.Body != nil {
43025 res.Body.Close()
43026 }
43027 return nil, &googleapi.Error{
43028 Code: res.StatusCode,
43029 Header: res.Header,
43030 }
43031 }
43032 if err != nil {
43033 return nil, err
43034 }
43035 defer googleapi.CloseBody(res)
43036 if err := googleapi.CheckResponse(res); err != nil {
43037 return nil, err
43038 }
43039 ret := &RemarketingListsListResponse{
43040 ServerResponse: googleapi.ServerResponse{
43041 Header: res.Header,
43042 HTTPStatusCode: res.StatusCode,
43043 },
43044 }
43045 target := &ret
43046 if err := gensupport.DecodeResponse(target, res); err != nil {
43047 return nil, err
43048 }
43049 return ret, nil
43050
43051
43052
43053
43054
43055
43056
43057
43058
43059
43060
43061
43062
43063
43064
43065
43066
43067
43068
43069
43070
43071
43072
43073
43074
43075
43076
43077
43078
43079
43080
43081
43082
43083
43084
43085
43086
43087
43088
43089
43090
43091
43092
43093
43094
43095
43096
43097
43098
43099
43100
43101
43102
43103
43104
43105
43106
43107
43108
43109
43110
43111
43112
43113
43114
43115
43116
43117
43118
43119
43120
43121
43122
43123
43124
43125
43126
43127
43128
43129
43130
43131
43132
43133
43134
43135
43136
43137
43138
43139
43140
43141 }
43142
43143
43144
43145
43146 func (c *RemarketingListsListCall) Pages(ctx context.Context, f func(*RemarketingListsListResponse) error) error {
43147 c.ctx_ = ctx
43148 defer c.PageToken(c.urlParams_.Get("pageToken"))
43149 for {
43150 x, err := c.Do()
43151 if err != nil {
43152 return err
43153 }
43154 if err := f(x); err != nil {
43155 return err
43156 }
43157 if x.NextPageToken == "" {
43158 return nil
43159 }
43160 c.PageToken(x.NextPageToken)
43161 }
43162 }
43163
43164
43165
43166 type RemarketingListsPatchCall struct {
43167 s *Service
43168 profileId int64
43169 remarketinglist *RemarketingList
43170 urlParams_ gensupport.URLParams
43171 ctx_ context.Context
43172 header_ http.Header
43173 }
43174
43175
43176
43177 func (r *RemarketingListsService) Patch(profileId int64, id int64, remarketinglist *RemarketingList) *RemarketingListsPatchCall {
43178 c := &RemarketingListsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
43179 c.profileId = profileId
43180 c.urlParams_.Set("id", fmt.Sprint(id))
43181 c.remarketinglist = remarketinglist
43182 return c
43183 }
43184
43185
43186
43187
43188 func (c *RemarketingListsPatchCall) Fields(s ...googleapi.Field) *RemarketingListsPatchCall {
43189 c.urlParams_.Set("fields", googleapi.CombineFields(s))
43190 return c
43191 }
43192
43193
43194
43195
43196 func (c *RemarketingListsPatchCall) Context(ctx context.Context) *RemarketingListsPatchCall {
43197 c.ctx_ = ctx
43198 return c
43199 }
43200
43201
43202
43203 func (c *RemarketingListsPatchCall) Header() http.Header {
43204 if c.header_ == nil {
43205 c.header_ = make(http.Header)
43206 }
43207 return c.header_
43208 }
43209
43210 func (c *RemarketingListsPatchCall) doRequest(alt string) (*http.Response, error) {
43211 reqHeaders := make(http.Header)
43212 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
43213 for k, v := range c.header_ {
43214 reqHeaders[k] = v
43215 }
43216 reqHeaders.Set("User-Agent", c.s.userAgent())
43217 var body io.Reader = nil
43218 body, err := googleapi.WithoutDataWrapper.JSONReader(c.remarketinglist)
43219 if err != nil {
43220 return nil, err
43221 }
43222 reqHeaders.Set("Content-Type", "application/json")
43223 c.urlParams_.Set("alt", alt)
43224 c.urlParams_.Set("prettyPrint", "false")
43225 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/remarketingLists")
43226 urls += "?" + c.urlParams_.Encode()
43227 req, err := http.NewRequest("PATCH", urls, body)
43228 if err != nil {
43229 return nil, err
43230 }
43231 req.Header = reqHeaders
43232 googleapi.Expand(req.URL, map[string]string{
43233 "profileId": strconv.FormatInt(c.profileId, 10),
43234 })
43235 return gensupport.SendRequest(c.ctx_, c.s.client, req)
43236 }
43237
43238
43239
43240
43241
43242
43243
43244
43245 func (c *RemarketingListsPatchCall) Do(opts ...googleapi.CallOption) (*RemarketingList, error) {
43246 gensupport.SetOptions(c.urlParams_, opts...)
43247 res, err := c.doRequest("json")
43248 if res != nil && res.StatusCode == http.StatusNotModified {
43249 if res.Body != nil {
43250 res.Body.Close()
43251 }
43252 return nil, &googleapi.Error{
43253 Code: res.StatusCode,
43254 Header: res.Header,
43255 }
43256 }
43257 if err != nil {
43258 return nil, err
43259 }
43260 defer googleapi.CloseBody(res)
43261 if err := googleapi.CheckResponse(res); err != nil {
43262 return nil, err
43263 }
43264 ret := &RemarketingList{
43265 ServerResponse: googleapi.ServerResponse{
43266 Header: res.Header,
43267 HTTPStatusCode: res.StatusCode,
43268 },
43269 }
43270 target := &ret
43271 if err := gensupport.DecodeResponse(target, res); err != nil {
43272 return nil, err
43273 }
43274 return ret, nil
43275
43276
43277
43278
43279
43280
43281
43282
43283
43284
43285
43286
43287
43288
43289
43290
43291
43292
43293
43294
43295
43296
43297
43298
43299
43300
43301
43302
43303
43304
43305
43306
43307
43308
43309
43310
43311 }
43312
43313
43314
43315 type RemarketingListsUpdateCall struct {
43316 s *Service
43317 profileId int64
43318 remarketinglist *RemarketingList
43319 urlParams_ gensupport.URLParams
43320 ctx_ context.Context
43321 header_ http.Header
43322 }
43323
43324
43325 func (r *RemarketingListsService) Update(profileId int64, remarketinglist *RemarketingList) *RemarketingListsUpdateCall {
43326 c := &RemarketingListsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
43327 c.profileId = profileId
43328 c.remarketinglist = remarketinglist
43329 return c
43330 }
43331
43332
43333
43334
43335 func (c *RemarketingListsUpdateCall) Fields(s ...googleapi.Field) *RemarketingListsUpdateCall {
43336 c.urlParams_.Set("fields", googleapi.CombineFields(s))
43337 return c
43338 }
43339
43340
43341
43342
43343 func (c *RemarketingListsUpdateCall) Context(ctx context.Context) *RemarketingListsUpdateCall {
43344 c.ctx_ = ctx
43345 return c
43346 }
43347
43348
43349
43350 func (c *RemarketingListsUpdateCall) Header() http.Header {
43351 if c.header_ == nil {
43352 c.header_ = make(http.Header)
43353 }
43354 return c.header_
43355 }
43356
43357 func (c *RemarketingListsUpdateCall) doRequest(alt string) (*http.Response, error) {
43358 reqHeaders := make(http.Header)
43359 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
43360 for k, v := range c.header_ {
43361 reqHeaders[k] = v
43362 }
43363 reqHeaders.Set("User-Agent", c.s.userAgent())
43364 var body io.Reader = nil
43365 body, err := googleapi.WithoutDataWrapper.JSONReader(c.remarketinglist)
43366 if err != nil {
43367 return nil, err
43368 }
43369 reqHeaders.Set("Content-Type", "application/json")
43370 c.urlParams_.Set("alt", alt)
43371 c.urlParams_.Set("prettyPrint", "false")
43372 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/remarketingLists")
43373 urls += "?" + c.urlParams_.Encode()
43374 req, err := http.NewRequest("PUT", urls, body)
43375 if err != nil {
43376 return nil, err
43377 }
43378 req.Header = reqHeaders
43379 googleapi.Expand(req.URL, map[string]string{
43380 "profileId": strconv.FormatInt(c.profileId, 10),
43381 })
43382 return gensupport.SendRequest(c.ctx_, c.s.client, req)
43383 }
43384
43385
43386
43387
43388
43389
43390
43391
43392 func (c *RemarketingListsUpdateCall) Do(opts ...googleapi.CallOption) (*RemarketingList, error) {
43393 gensupport.SetOptions(c.urlParams_, opts...)
43394 res, err := c.doRequest("json")
43395 if res != nil && res.StatusCode == http.StatusNotModified {
43396 if res.Body != nil {
43397 res.Body.Close()
43398 }
43399 return nil, &googleapi.Error{
43400 Code: res.StatusCode,
43401 Header: res.Header,
43402 }
43403 }
43404 if err != nil {
43405 return nil, err
43406 }
43407 defer googleapi.CloseBody(res)
43408 if err := googleapi.CheckResponse(res); err != nil {
43409 return nil, err
43410 }
43411 ret := &RemarketingList{
43412 ServerResponse: googleapi.ServerResponse{
43413 Header: res.Header,
43414 HTTPStatusCode: res.StatusCode,
43415 },
43416 }
43417 target := &ret
43418 if err := gensupport.DecodeResponse(target, res); err != nil {
43419 return nil, err
43420 }
43421 return ret, nil
43422
43423
43424
43425
43426
43427
43428
43429
43430
43431
43432
43433
43434
43435
43436
43437
43438
43439
43440
43441
43442
43443
43444
43445
43446
43447
43448
43449
43450 }
43451
43452
43453
43454 type ReportsDeleteCall struct {
43455 s *Service
43456 profileId int64
43457 reportId int64
43458 urlParams_ gensupport.URLParams
43459 ctx_ context.Context
43460 header_ http.Header
43461 }
43462
43463
43464 func (r *ReportsService) Delete(profileId int64, reportId int64) *ReportsDeleteCall {
43465 c := &ReportsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
43466 c.profileId = profileId
43467 c.reportId = reportId
43468 return c
43469 }
43470
43471
43472
43473
43474 func (c *ReportsDeleteCall) Fields(s ...googleapi.Field) *ReportsDeleteCall {
43475 c.urlParams_.Set("fields", googleapi.CombineFields(s))
43476 return c
43477 }
43478
43479
43480
43481
43482 func (c *ReportsDeleteCall) Context(ctx context.Context) *ReportsDeleteCall {
43483 c.ctx_ = ctx
43484 return c
43485 }
43486
43487
43488
43489 func (c *ReportsDeleteCall) Header() http.Header {
43490 if c.header_ == nil {
43491 c.header_ = make(http.Header)
43492 }
43493 return c.header_
43494 }
43495
43496 func (c *ReportsDeleteCall) doRequest(alt string) (*http.Response, error) {
43497 reqHeaders := make(http.Header)
43498 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
43499 for k, v := range c.header_ {
43500 reqHeaders[k] = v
43501 }
43502 reqHeaders.Set("User-Agent", c.s.userAgent())
43503 var body io.Reader = nil
43504 c.urlParams_.Set("alt", alt)
43505 c.urlParams_.Set("prettyPrint", "false")
43506 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/{reportId}")
43507 urls += "?" + c.urlParams_.Encode()
43508 req, err := http.NewRequest("DELETE", urls, body)
43509 if err != nil {
43510 return nil, err
43511 }
43512 req.Header = reqHeaders
43513 googleapi.Expand(req.URL, map[string]string{
43514 "profileId": strconv.FormatInt(c.profileId, 10),
43515 "reportId": strconv.FormatInt(c.reportId, 10),
43516 })
43517 return gensupport.SendRequest(c.ctx_, c.s.client, req)
43518 }
43519
43520
43521 func (c *ReportsDeleteCall) Do(opts ...googleapi.CallOption) error {
43522 gensupport.SetOptions(c.urlParams_, opts...)
43523 res, err := c.doRequest("json")
43524 if err != nil {
43525 return err
43526 }
43527 defer googleapi.CloseBody(res)
43528 if err := googleapi.CheckResponse(res); err != nil {
43529 return err
43530 }
43531 return nil
43532
43533
43534
43535
43536
43537
43538
43539
43540
43541
43542
43543
43544
43545
43546
43547
43548
43549
43550
43551
43552
43553
43554
43555
43556
43557
43558
43559
43560
43561
43562 }
43563
43564
43565
43566 type ReportsGetCall struct {
43567 s *Service
43568 profileId int64
43569 reportId int64
43570 urlParams_ gensupport.URLParams
43571 ifNoneMatch_ string
43572 ctx_ context.Context
43573 header_ http.Header
43574 }
43575
43576
43577 func (r *ReportsService) Get(profileId int64, reportId int64) *ReportsGetCall {
43578 c := &ReportsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
43579 c.profileId = profileId
43580 c.reportId = reportId
43581 return c
43582 }
43583
43584
43585
43586
43587 func (c *ReportsGetCall) Fields(s ...googleapi.Field) *ReportsGetCall {
43588 c.urlParams_.Set("fields", googleapi.CombineFields(s))
43589 return c
43590 }
43591
43592
43593
43594
43595
43596
43597 func (c *ReportsGetCall) IfNoneMatch(entityTag string) *ReportsGetCall {
43598 c.ifNoneMatch_ = entityTag
43599 return c
43600 }
43601
43602
43603
43604
43605 func (c *ReportsGetCall) Context(ctx context.Context) *ReportsGetCall {
43606 c.ctx_ = ctx
43607 return c
43608 }
43609
43610
43611
43612 func (c *ReportsGetCall) Header() http.Header {
43613 if c.header_ == nil {
43614 c.header_ = make(http.Header)
43615 }
43616 return c.header_
43617 }
43618
43619 func (c *ReportsGetCall) doRequest(alt string) (*http.Response, error) {
43620 reqHeaders := make(http.Header)
43621 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
43622 for k, v := range c.header_ {
43623 reqHeaders[k] = v
43624 }
43625 reqHeaders.Set("User-Agent", c.s.userAgent())
43626 if c.ifNoneMatch_ != "" {
43627 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
43628 }
43629 var body io.Reader = nil
43630 c.urlParams_.Set("alt", alt)
43631 c.urlParams_.Set("prettyPrint", "false")
43632 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/{reportId}")
43633 urls += "?" + c.urlParams_.Encode()
43634 req, err := http.NewRequest("GET", urls, body)
43635 if err != nil {
43636 return nil, err
43637 }
43638 req.Header = reqHeaders
43639 googleapi.Expand(req.URL, map[string]string{
43640 "profileId": strconv.FormatInt(c.profileId, 10),
43641 "reportId": strconv.FormatInt(c.reportId, 10),
43642 })
43643 return gensupport.SendRequest(c.ctx_, c.s.client, req)
43644 }
43645
43646
43647
43648
43649
43650
43651
43652
43653 func (c *ReportsGetCall) Do(opts ...googleapi.CallOption) (*Report, error) {
43654 gensupport.SetOptions(c.urlParams_, opts...)
43655 res, err := c.doRequest("json")
43656 if res != nil && res.StatusCode == http.StatusNotModified {
43657 if res.Body != nil {
43658 res.Body.Close()
43659 }
43660 return nil, &googleapi.Error{
43661 Code: res.StatusCode,
43662 Header: res.Header,
43663 }
43664 }
43665 if err != nil {
43666 return nil, err
43667 }
43668 defer googleapi.CloseBody(res)
43669 if err := googleapi.CheckResponse(res); err != nil {
43670 return nil, err
43671 }
43672 ret := &Report{
43673 ServerResponse: googleapi.ServerResponse{
43674 Header: res.Header,
43675 HTTPStatusCode: res.StatusCode,
43676 },
43677 }
43678 target := &ret
43679 if err := gensupport.DecodeResponse(target, res); err != nil {
43680 return nil, err
43681 }
43682 return ret, nil
43683
43684
43685
43686
43687
43688
43689
43690
43691
43692
43693
43694
43695
43696
43697
43698
43699
43700
43701
43702
43703
43704
43705
43706
43707
43708
43709
43710
43711
43712
43713
43714
43715
43716 }
43717
43718
43719
43720 type ReportsInsertCall struct {
43721 s *Service
43722 profileId int64
43723 report *Report
43724 urlParams_ gensupport.URLParams
43725 ctx_ context.Context
43726 header_ http.Header
43727 }
43728
43729
43730 func (r *ReportsService) Insert(profileId int64, report *Report) *ReportsInsertCall {
43731 c := &ReportsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
43732 c.profileId = profileId
43733 c.report = report
43734 return c
43735 }
43736
43737
43738
43739
43740 func (c *ReportsInsertCall) Fields(s ...googleapi.Field) *ReportsInsertCall {
43741 c.urlParams_.Set("fields", googleapi.CombineFields(s))
43742 return c
43743 }
43744
43745
43746
43747
43748 func (c *ReportsInsertCall) Context(ctx context.Context) *ReportsInsertCall {
43749 c.ctx_ = ctx
43750 return c
43751 }
43752
43753
43754
43755 func (c *ReportsInsertCall) Header() http.Header {
43756 if c.header_ == nil {
43757 c.header_ = make(http.Header)
43758 }
43759 return c.header_
43760 }
43761
43762 func (c *ReportsInsertCall) doRequest(alt string) (*http.Response, error) {
43763 reqHeaders := make(http.Header)
43764 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
43765 for k, v := range c.header_ {
43766 reqHeaders[k] = v
43767 }
43768 reqHeaders.Set("User-Agent", c.s.userAgent())
43769 var body io.Reader = nil
43770 body, err := googleapi.WithoutDataWrapper.JSONReader(c.report)
43771 if err != nil {
43772 return nil, err
43773 }
43774 reqHeaders.Set("Content-Type", "application/json")
43775 c.urlParams_.Set("alt", alt)
43776 c.urlParams_.Set("prettyPrint", "false")
43777 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports")
43778 urls += "?" + c.urlParams_.Encode()
43779 req, err := http.NewRequest("POST", urls, body)
43780 if err != nil {
43781 return nil, err
43782 }
43783 req.Header = reqHeaders
43784 googleapi.Expand(req.URL, map[string]string{
43785 "profileId": strconv.FormatInt(c.profileId, 10),
43786 })
43787 return gensupport.SendRequest(c.ctx_, c.s.client, req)
43788 }
43789
43790
43791
43792
43793
43794
43795
43796
43797 func (c *ReportsInsertCall) Do(opts ...googleapi.CallOption) (*Report, error) {
43798 gensupport.SetOptions(c.urlParams_, opts...)
43799 res, err := c.doRequest("json")
43800 if res != nil && res.StatusCode == http.StatusNotModified {
43801 if res.Body != nil {
43802 res.Body.Close()
43803 }
43804 return nil, &googleapi.Error{
43805 Code: res.StatusCode,
43806 Header: res.Header,
43807 }
43808 }
43809 if err != nil {
43810 return nil, err
43811 }
43812 defer googleapi.CloseBody(res)
43813 if err := googleapi.CheckResponse(res); err != nil {
43814 return nil, err
43815 }
43816 ret := &Report{
43817 ServerResponse: googleapi.ServerResponse{
43818 Header: res.Header,
43819 HTTPStatusCode: res.StatusCode,
43820 },
43821 }
43822 target := &ret
43823 if err := gensupport.DecodeResponse(target, res); err != nil {
43824 return nil, err
43825 }
43826 return ret, nil
43827
43828
43829
43830
43831
43832
43833
43834
43835
43836
43837
43838
43839
43840
43841
43842
43843
43844
43845
43846
43847
43848
43849
43850
43851
43852
43853
43854
43855 }
43856
43857
43858
43859 type ReportsListCall struct {
43860 s *Service
43861 profileId int64
43862 urlParams_ gensupport.URLParams
43863 ifNoneMatch_ string
43864 ctx_ context.Context
43865 header_ http.Header
43866 }
43867
43868
43869 func (r *ReportsService) List(profileId int64) *ReportsListCall {
43870 c := &ReportsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
43871 c.profileId = profileId
43872 return c
43873 }
43874
43875
43876
43877 func (c *ReportsListCall) MaxResults(maxResults int64) *ReportsListCall {
43878 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
43879 return c
43880 }
43881
43882
43883
43884 func (c *ReportsListCall) PageToken(pageToken string) *ReportsListCall {
43885 c.urlParams_.Set("pageToken", pageToken)
43886 return c
43887 }
43888
43889
43890
43891
43892
43893
43894
43895
43896 func (c *ReportsListCall) Scope(scope string) *ReportsListCall {
43897 c.urlParams_.Set("scope", scope)
43898 return c
43899 }
43900
43901
43902
43903
43904
43905
43906
43907
43908
43909 func (c *ReportsListCall) SortField(sortField string) *ReportsListCall {
43910 c.urlParams_.Set("sortField", sortField)
43911 return c
43912 }
43913
43914
43915
43916
43917
43918
43919
43920
43921 func (c *ReportsListCall) SortOrder(sortOrder string) *ReportsListCall {
43922 c.urlParams_.Set("sortOrder", sortOrder)
43923 return c
43924 }
43925
43926
43927
43928
43929 func (c *ReportsListCall) Fields(s ...googleapi.Field) *ReportsListCall {
43930 c.urlParams_.Set("fields", googleapi.CombineFields(s))
43931 return c
43932 }
43933
43934
43935
43936
43937
43938
43939 func (c *ReportsListCall) IfNoneMatch(entityTag string) *ReportsListCall {
43940 c.ifNoneMatch_ = entityTag
43941 return c
43942 }
43943
43944
43945
43946
43947 func (c *ReportsListCall) Context(ctx context.Context) *ReportsListCall {
43948 c.ctx_ = ctx
43949 return c
43950 }
43951
43952
43953
43954 func (c *ReportsListCall) Header() http.Header {
43955 if c.header_ == nil {
43956 c.header_ = make(http.Header)
43957 }
43958 return c.header_
43959 }
43960
43961 func (c *ReportsListCall) doRequest(alt string) (*http.Response, error) {
43962 reqHeaders := make(http.Header)
43963 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
43964 for k, v := range c.header_ {
43965 reqHeaders[k] = v
43966 }
43967 reqHeaders.Set("User-Agent", c.s.userAgent())
43968 if c.ifNoneMatch_ != "" {
43969 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
43970 }
43971 var body io.Reader = nil
43972 c.urlParams_.Set("alt", alt)
43973 c.urlParams_.Set("prettyPrint", "false")
43974 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports")
43975 urls += "?" + c.urlParams_.Encode()
43976 req, err := http.NewRequest("GET", urls, body)
43977 if err != nil {
43978 return nil, err
43979 }
43980 req.Header = reqHeaders
43981 googleapi.Expand(req.URL, map[string]string{
43982 "profileId": strconv.FormatInt(c.profileId, 10),
43983 })
43984 return gensupport.SendRequest(c.ctx_, c.s.client, req)
43985 }
43986
43987
43988
43989
43990
43991
43992
43993
43994 func (c *ReportsListCall) Do(opts ...googleapi.CallOption) (*ReportList, error) {
43995 gensupport.SetOptions(c.urlParams_, opts...)
43996 res, err := c.doRequest("json")
43997 if res != nil && res.StatusCode == http.StatusNotModified {
43998 if res.Body != nil {
43999 res.Body.Close()
44000 }
44001 return nil, &googleapi.Error{
44002 Code: res.StatusCode,
44003 Header: res.Header,
44004 }
44005 }
44006 if err != nil {
44007 return nil, err
44008 }
44009 defer googleapi.CloseBody(res)
44010 if err := googleapi.CheckResponse(res); err != nil {
44011 return nil, err
44012 }
44013 ret := &ReportList{
44014 ServerResponse: googleapi.ServerResponse{
44015 Header: res.Header,
44016 HTTPStatusCode: res.StatusCode,
44017 },
44018 }
44019 target := &ret
44020 if err := gensupport.DecodeResponse(target, res); err != nil {
44021 return nil, err
44022 }
44023 return ret, nil
44024
44025
44026
44027
44028
44029
44030
44031
44032
44033
44034
44035
44036
44037
44038
44039
44040
44041
44042
44043
44044
44045
44046
44047
44048
44049
44050
44051
44052
44053
44054
44055
44056
44057
44058
44059
44060
44061
44062
44063
44064
44065
44066
44067
44068
44069
44070
44071
44072
44073
44074
44075
44076
44077
44078
44079
44080
44081
44082
44083
44084
44085
44086
44087
44088
44089
44090
44091
44092
44093
44094
44095
44096
44097
44098
44099
44100
44101
44102
44103
44104
44105
44106
44107 }
44108
44109
44110
44111
44112 func (c *ReportsListCall) Pages(ctx context.Context, f func(*ReportList) error) error {
44113 c.ctx_ = ctx
44114 defer c.PageToken(c.urlParams_.Get("pageToken"))
44115 for {
44116 x, err := c.Do()
44117 if err != nil {
44118 return err
44119 }
44120 if err := f(x); err != nil {
44121 return err
44122 }
44123 if x.NextPageToken == "" {
44124 return nil
44125 }
44126 c.PageToken(x.NextPageToken)
44127 }
44128 }
44129
44130
44131
44132 type ReportsPatchCall struct {
44133 s *Service
44134 profileId int64
44135 reportId int64
44136 report *Report
44137 urlParams_ gensupport.URLParams
44138 ctx_ context.Context
44139 header_ http.Header
44140 }
44141
44142
44143 func (r *ReportsService) Patch(profileId int64, reportId int64, report *Report) *ReportsPatchCall {
44144 c := &ReportsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
44145 c.profileId = profileId
44146 c.reportId = reportId
44147 c.report = report
44148 return c
44149 }
44150
44151
44152
44153
44154 func (c *ReportsPatchCall) Fields(s ...googleapi.Field) *ReportsPatchCall {
44155 c.urlParams_.Set("fields", googleapi.CombineFields(s))
44156 return c
44157 }
44158
44159
44160
44161
44162 func (c *ReportsPatchCall) Context(ctx context.Context) *ReportsPatchCall {
44163 c.ctx_ = ctx
44164 return c
44165 }
44166
44167
44168
44169 func (c *ReportsPatchCall) Header() http.Header {
44170 if c.header_ == nil {
44171 c.header_ = make(http.Header)
44172 }
44173 return c.header_
44174 }
44175
44176 func (c *ReportsPatchCall) doRequest(alt string) (*http.Response, error) {
44177 reqHeaders := make(http.Header)
44178 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
44179 for k, v := range c.header_ {
44180 reqHeaders[k] = v
44181 }
44182 reqHeaders.Set("User-Agent", c.s.userAgent())
44183 var body io.Reader = nil
44184 body, err := googleapi.WithoutDataWrapper.JSONReader(c.report)
44185 if err != nil {
44186 return nil, err
44187 }
44188 reqHeaders.Set("Content-Type", "application/json")
44189 c.urlParams_.Set("alt", alt)
44190 c.urlParams_.Set("prettyPrint", "false")
44191 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/{reportId}")
44192 urls += "?" + c.urlParams_.Encode()
44193 req, err := http.NewRequest("PATCH", urls, body)
44194 if err != nil {
44195 return nil, err
44196 }
44197 req.Header = reqHeaders
44198 googleapi.Expand(req.URL, map[string]string{
44199 "profileId": strconv.FormatInt(c.profileId, 10),
44200 "reportId": strconv.FormatInt(c.reportId, 10),
44201 })
44202 return gensupport.SendRequest(c.ctx_, c.s.client, req)
44203 }
44204
44205
44206
44207
44208
44209
44210
44211
44212 func (c *ReportsPatchCall) Do(opts ...googleapi.CallOption) (*Report, error) {
44213 gensupport.SetOptions(c.urlParams_, opts...)
44214 res, err := c.doRequest("json")
44215 if res != nil && res.StatusCode == http.StatusNotModified {
44216 if res.Body != nil {
44217 res.Body.Close()
44218 }
44219 return nil, &googleapi.Error{
44220 Code: res.StatusCode,
44221 Header: res.Header,
44222 }
44223 }
44224 if err != nil {
44225 return nil, err
44226 }
44227 defer googleapi.CloseBody(res)
44228 if err := googleapi.CheckResponse(res); err != nil {
44229 return nil, err
44230 }
44231 ret := &Report{
44232 ServerResponse: googleapi.ServerResponse{
44233 Header: res.Header,
44234 HTTPStatusCode: res.StatusCode,
44235 },
44236 }
44237 target := &ret
44238 if err := gensupport.DecodeResponse(target, res); err != nil {
44239 return nil, err
44240 }
44241 return ret, nil
44242
44243
44244
44245
44246
44247
44248
44249
44250
44251
44252
44253
44254
44255
44256
44257
44258
44259
44260
44261
44262
44263
44264
44265
44266
44267
44268
44269
44270
44271
44272
44273
44274
44275
44276
44277
44278 }
44279
44280
44281
44282 type ReportsRunCall struct {
44283 s *Service
44284 profileId int64
44285 reportId int64
44286 urlParams_ gensupport.URLParams
44287 ctx_ context.Context
44288 header_ http.Header
44289 }
44290
44291
44292 func (r *ReportsService) Run(profileId int64, reportId int64) *ReportsRunCall {
44293 c := &ReportsRunCall{s: r.s, urlParams_: make(gensupport.URLParams)}
44294 c.profileId = profileId
44295 c.reportId = reportId
44296 return c
44297 }
44298
44299
44300
44301 func (c *ReportsRunCall) Synchronous(synchronous bool) *ReportsRunCall {
44302 c.urlParams_.Set("synchronous", fmt.Sprint(synchronous))
44303 return c
44304 }
44305
44306
44307
44308
44309 func (c *ReportsRunCall) Fields(s ...googleapi.Field) *ReportsRunCall {
44310 c.urlParams_.Set("fields", googleapi.CombineFields(s))
44311 return c
44312 }
44313
44314
44315
44316
44317 func (c *ReportsRunCall) Context(ctx context.Context) *ReportsRunCall {
44318 c.ctx_ = ctx
44319 return c
44320 }
44321
44322
44323
44324 func (c *ReportsRunCall) Header() http.Header {
44325 if c.header_ == nil {
44326 c.header_ = make(http.Header)
44327 }
44328 return c.header_
44329 }
44330
44331 func (c *ReportsRunCall) doRequest(alt string) (*http.Response, error) {
44332 reqHeaders := make(http.Header)
44333 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
44334 for k, v := range c.header_ {
44335 reqHeaders[k] = v
44336 }
44337 reqHeaders.Set("User-Agent", c.s.userAgent())
44338 var body io.Reader = nil
44339 c.urlParams_.Set("alt", alt)
44340 c.urlParams_.Set("prettyPrint", "false")
44341 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/{reportId}/run")
44342 urls += "?" + c.urlParams_.Encode()
44343 req, err := http.NewRequest("POST", urls, body)
44344 if err != nil {
44345 return nil, err
44346 }
44347 req.Header = reqHeaders
44348 googleapi.Expand(req.URL, map[string]string{
44349 "profileId": strconv.FormatInt(c.profileId, 10),
44350 "reportId": strconv.FormatInt(c.reportId, 10),
44351 })
44352 return gensupport.SendRequest(c.ctx_, c.s.client, req)
44353 }
44354
44355
44356
44357
44358
44359
44360
44361
44362 func (c *ReportsRunCall) Do(opts ...googleapi.CallOption) (*File, error) {
44363 gensupport.SetOptions(c.urlParams_, opts...)
44364 res, err := c.doRequest("json")
44365 if res != nil && res.StatusCode == http.StatusNotModified {
44366 if res.Body != nil {
44367 res.Body.Close()
44368 }
44369 return nil, &googleapi.Error{
44370 Code: res.StatusCode,
44371 Header: res.Header,
44372 }
44373 }
44374 if err != nil {
44375 return nil, err
44376 }
44377 defer googleapi.CloseBody(res)
44378 if err := googleapi.CheckResponse(res); err != nil {
44379 return nil, err
44380 }
44381 ret := &File{
44382 ServerResponse: googleapi.ServerResponse{
44383 Header: res.Header,
44384 HTTPStatusCode: res.StatusCode,
44385 },
44386 }
44387 target := &ret
44388 if err := gensupport.DecodeResponse(target, res); err != nil {
44389 return nil, err
44390 }
44391 return ret, nil
44392
44393
44394
44395
44396
44397
44398
44399
44400
44401
44402
44403
44404
44405
44406
44407
44408
44409
44410
44411
44412
44413
44414
44415
44416
44417
44418
44419
44420
44421
44422
44423
44424
44425
44426
44427
44428
44429
44430
44431 }
44432
44433
44434
44435 type ReportsUpdateCall struct {
44436 s *Service
44437 profileId int64
44438 reportId int64
44439 report *Report
44440 urlParams_ gensupport.URLParams
44441 ctx_ context.Context
44442 header_ http.Header
44443 }
44444
44445
44446 func (r *ReportsService) Update(profileId int64, reportId int64, report *Report) *ReportsUpdateCall {
44447 c := &ReportsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
44448 c.profileId = profileId
44449 c.reportId = reportId
44450 c.report = report
44451 return c
44452 }
44453
44454
44455
44456
44457 func (c *ReportsUpdateCall) Fields(s ...googleapi.Field) *ReportsUpdateCall {
44458 c.urlParams_.Set("fields", googleapi.CombineFields(s))
44459 return c
44460 }
44461
44462
44463
44464
44465 func (c *ReportsUpdateCall) Context(ctx context.Context) *ReportsUpdateCall {
44466 c.ctx_ = ctx
44467 return c
44468 }
44469
44470
44471
44472 func (c *ReportsUpdateCall) Header() http.Header {
44473 if c.header_ == nil {
44474 c.header_ = make(http.Header)
44475 }
44476 return c.header_
44477 }
44478
44479 func (c *ReportsUpdateCall) doRequest(alt string) (*http.Response, error) {
44480 reqHeaders := make(http.Header)
44481 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
44482 for k, v := range c.header_ {
44483 reqHeaders[k] = v
44484 }
44485 reqHeaders.Set("User-Agent", c.s.userAgent())
44486 var body io.Reader = nil
44487 body, err := googleapi.WithoutDataWrapper.JSONReader(c.report)
44488 if err != nil {
44489 return nil, err
44490 }
44491 reqHeaders.Set("Content-Type", "application/json")
44492 c.urlParams_.Set("alt", alt)
44493 c.urlParams_.Set("prettyPrint", "false")
44494 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/{reportId}")
44495 urls += "?" + c.urlParams_.Encode()
44496 req, err := http.NewRequest("PUT", urls, body)
44497 if err != nil {
44498 return nil, err
44499 }
44500 req.Header = reqHeaders
44501 googleapi.Expand(req.URL, map[string]string{
44502 "profileId": strconv.FormatInt(c.profileId, 10),
44503 "reportId": strconv.FormatInt(c.reportId, 10),
44504 })
44505 return gensupport.SendRequest(c.ctx_, c.s.client, req)
44506 }
44507
44508
44509
44510
44511
44512
44513
44514
44515 func (c *ReportsUpdateCall) Do(opts ...googleapi.CallOption) (*Report, error) {
44516 gensupport.SetOptions(c.urlParams_, opts...)
44517 res, err := c.doRequest("json")
44518 if res != nil && res.StatusCode == http.StatusNotModified {
44519 if res.Body != nil {
44520 res.Body.Close()
44521 }
44522 return nil, &googleapi.Error{
44523 Code: res.StatusCode,
44524 Header: res.Header,
44525 }
44526 }
44527 if err != nil {
44528 return nil, err
44529 }
44530 defer googleapi.CloseBody(res)
44531 if err := googleapi.CheckResponse(res); err != nil {
44532 return nil, err
44533 }
44534 ret := &Report{
44535 ServerResponse: googleapi.ServerResponse{
44536 Header: res.Header,
44537 HTTPStatusCode: res.StatusCode,
44538 },
44539 }
44540 target := &ret
44541 if err := gensupport.DecodeResponse(target, res); err != nil {
44542 return nil, err
44543 }
44544 return ret, nil
44545
44546
44547
44548
44549
44550
44551
44552
44553
44554
44555
44556
44557
44558
44559
44560
44561
44562
44563
44564
44565
44566
44567
44568
44569
44570
44571
44572
44573
44574
44575
44576
44577
44578
44579
44580
44581 }
44582
44583
44584
44585 type ReportsCompatibleFieldsQueryCall struct {
44586 s *Service
44587 profileId int64
44588 report *Report
44589 urlParams_ gensupport.URLParams
44590 ctx_ context.Context
44591 header_ http.Header
44592 }
44593
44594
44595
44596
44597 func (r *ReportsCompatibleFieldsService) Query(profileId int64, report *Report) *ReportsCompatibleFieldsQueryCall {
44598 c := &ReportsCompatibleFieldsQueryCall{s: r.s, urlParams_: make(gensupport.URLParams)}
44599 c.profileId = profileId
44600 c.report = report
44601 return c
44602 }
44603
44604
44605
44606
44607 func (c *ReportsCompatibleFieldsQueryCall) Fields(s ...googleapi.Field) *ReportsCompatibleFieldsQueryCall {
44608 c.urlParams_.Set("fields", googleapi.CombineFields(s))
44609 return c
44610 }
44611
44612
44613
44614
44615 func (c *ReportsCompatibleFieldsQueryCall) Context(ctx context.Context) *ReportsCompatibleFieldsQueryCall {
44616 c.ctx_ = ctx
44617 return c
44618 }
44619
44620
44621
44622 func (c *ReportsCompatibleFieldsQueryCall) Header() http.Header {
44623 if c.header_ == nil {
44624 c.header_ = make(http.Header)
44625 }
44626 return c.header_
44627 }
44628
44629 func (c *ReportsCompatibleFieldsQueryCall) doRequest(alt string) (*http.Response, error) {
44630 reqHeaders := make(http.Header)
44631 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
44632 for k, v := range c.header_ {
44633 reqHeaders[k] = v
44634 }
44635 reqHeaders.Set("User-Agent", c.s.userAgent())
44636 var body io.Reader = nil
44637 body, err := googleapi.WithoutDataWrapper.JSONReader(c.report)
44638 if err != nil {
44639 return nil, err
44640 }
44641 reqHeaders.Set("Content-Type", "application/json")
44642 c.urlParams_.Set("alt", alt)
44643 c.urlParams_.Set("prettyPrint", "false")
44644 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/compatiblefields/query")
44645 urls += "?" + c.urlParams_.Encode()
44646 req, err := http.NewRequest("POST", urls, body)
44647 if err != nil {
44648 return nil, err
44649 }
44650 req.Header = reqHeaders
44651 googleapi.Expand(req.URL, map[string]string{
44652 "profileId": strconv.FormatInt(c.profileId, 10),
44653 })
44654 return gensupport.SendRequest(c.ctx_, c.s.client, req)
44655 }
44656
44657
44658
44659
44660
44661
44662
44663
44664 func (c *ReportsCompatibleFieldsQueryCall) Do(opts ...googleapi.CallOption) (*CompatibleFields, error) {
44665 gensupport.SetOptions(c.urlParams_, opts...)
44666 res, err := c.doRequest("json")
44667 if res != nil && res.StatusCode == http.StatusNotModified {
44668 if res.Body != nil {
44669 res.Body.Close()
44670 }
44671 return nil, &googleapi.Error{
44672 Code: res.StatusCode,
44673 Header: res.Header,
44674 }
44675 }
44676 if err != nil {
44677 return nil, err
44678 }
44679 defer googleapi.CloseBody(res)
44680 if err := googleapi.CheckResponse(res); err != nil {
44681 return nil, err
44682 }
44683 ret := &CompatibleFields{
44684 ServerResponse: googleapi.ServerResponse{
44685 Header: res.Header,
44686 HTTPStatusCode: res.StatusCode,
44687 },
44688 }
44689 target := &ret
44690 if err := gensupport.DecodeResponse(target, res); err != nil {
44691 return nil, err
44692 }
44693 return ret, nil
44694
44695
44696
44697
44698
44699
44700
44701
44702
44703
44704
44705
44706
44707
44708
44709
44710
44711
44712
44713
44714
44715
44716
44717
44718
44719
44720
44721
44722 }
44723
44724
44725
44726 type ReportsFilesGetCall struct {
44727 s *Service
44728 profileId int64
44729 reportId int64
44730 fileId int64
44731 urlParams_ gensupport.URLParams
44732 ifNoneMatch_ string
44733 ctx_ context.Context
44734 header_ http.Header
44735 }
44736
44737
44738 func (r *ReportsFilesService) Get(profileId int64, reportId int64, fileId int64) *ReportsFilesGetCall {
44739 c := &ReportsFilesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
44740 c.profileId = profileId
44741 c.reportId = reportId
44742 c.fileId = fileId
44743 return c
44744 }
44745
44746
44747
44748
44749 func (c *ReportsFilesGetCall) Fields(s ...googleapi.Field) *ReportsFilesGetCall {
44750 c.urlParams_.Set("fields", googleapi.CombineFields(s))
44751 return c
44752 }
44753
44754
44755
44756
44757
44758
44759 func (c *ReportsFilesGetCall) IfNoneMatch(entityTag string) *ReportsFilesGetCall {
44760 c.ifNoneMatch_ = entityTag
44761 return c
44762 }
44763
44764
44765
44766
44767 func (c *ReportsFilesGetCall) Context(ctx context.Context) *ReportsFilesGetCall {
44768 c.ctx_ = ctx
44769 return c
44770 }
44771
44772
44773
44774 func (c *ReportsFilesGetCall) Header() http.Header {
44775 if c.header_ == nil {
44776 c.header_ = make(http.Header)
44777 }
44778 return c.header_
44779 }
44780
44781 func (c *ReportsFilesGetCall) doRequest(alt string) (*http.Response, error) {
44782 reqHeaders := make(http.Header)
44783 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
44784 for k, v := range c.header_ {
44785 reqHeaders[k] = v
44786 }
44787 reqHeaders.Set("User-Agent", c.s.userAgent())
44788 if c.ifNoneMatch_ != "" {
44789 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
44790 }
44791 var body io.Reader = nil
44792 c.urlParams_.Set("alt", alt)
44793 c.urlParams_.Set("prettyPrint", "false")
44794 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/{reportId}/files/{fileId}")
44795 urls += "?" + c.urlParams_.Encode()
44796 req, err := http.NewRequest("GET", urls, body)
44797 if err != nil {
44798 return nil, err
44799 }
44800 req.Header = reqHeaders
44801 googleapi.Expand(req.URL, map[string]string{
44802 "profileId": strconv.FormatInt(c.profileId, 10),
44803 "reportId": strconv.FormatInt(c.reportId, 10),
44804 "fileId": strconv.FormatInt(c.fileId, 10),
44805 })
44806 return gensupport.SendRequest(c.ctx_, c.s.client, req)
44807 }
44808
44809
44810
44811
44812 func (c *ReportsFilesGetCall) Download(opts ...googleapi.CallOption) (*http.Response, error) {
44813 gensupport.SetOptions(c.urlParams_, opts...)
44814 res, err := c.doRequest("media")
44815 if err != nil {
44816 return nil, err
44817 }
44818 if err := googleapi.CheckMediaResponse(res); err != nil {
44819 res.Body.Close()
44820 return nil, err
44821 }
44822 return res, nil
44823 }
44824
44825
44826
44827
44828
44829
44830
44831
44832 func (c *ReportsFilesGetCall) Do(opts ...googleapi.CallOption) (*File, error) {
44833 gensupport.SetOptions(c.urlParams_, opts...)
44834 res, err := c.doRequest("json")
44835 if res != nil && res.StatusCode == http.StatusNotModified {
44836 if res.Body != nil {
44837 res.Body.Close()
44838 }
44839 return nil, &googleapi.Error{
44840 Code: res.StatusCode,
44841 Header: res.Header,
44842 }
44843 }
44844 if err != nil {
44845 return nil, err
44846 }
44847 defer googleapi.CloseBody(res)
44848 if err := googleapi.CheckResponse(res); err != nil {
44849 return nil, err
44850 }
44851 ret := &File{
44852 ServerResponse: googleapi.ServerResponse{
44853 Header: res.Header,
44854 HTTPStatusCode: res.StatusCode,
44855 },
44856 }
44857 target := &ret
44858 if err := gensupport.DecodeResponse(target, res); err != nil {
44859 return nil, err
44860 }
44861 return ret, nil
44862
44863
44864
44865
44866
44867
44868
44869
44870
44871
44872
44873
44874
44875
44876
44877
44878
44879
44880
44881
44882
44883
44884
44885
44886
44887
44888
44889
44890
44891
44892
44893
44894
44895
44896
44897
44898
44899
44900
44901
44902
44903
44904 }
44905
44906
44907
44908 type ReportsFilesListCall struct {
44909 s *Service
44910 profileId int64
44911 reportId int64
44912 urlParams_ gensupport.URLParams
44913 ifNoneMatch_ string
44914 ctx_ context.Context
44915 header_ http.Header
44916 }
44917
44918
44919 func (r *ReportsFilesService) List(profileId int64, reportId int64) *ReportsFilesListCall {
44920 c := &ReportsFilesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
44921 c.profileId = profileId
44922 c.reportId = reportId
44923 return c
44924 }
44925
44926
44927
44928 func (c *ReportsFilesListCall) MaxResults(maxResults int64) *ReportsFilesListCall {
44929 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
44930 return c
44931 }
44932
44933
44934
44935 func (c *ReportsFilesListCall) PageToken(pageToken string) *ReportsFilesListCall {
44936 c.urlParams_.Set("pageToken", pageToken)
44937 return c
44938 }
44939
44940
44941
44942
44943
44944
44945
44946
44947 func (c *ReportsFilesListCall) SortField(sortField string) *ReportsFilesListCall {
44948 c.urlParams_.Set("sortField", sortField)
44949 return c
44950 }
44951
44952
44953
44954
44955
44956
44957
44958
44959 func (c *ReportsFilesListCall) SortOrder(sortOrder string) *ReportsFilesListCall {
44960 c.urlParams_.Set("sortOrder", sortOrder)
44961 return c
44962 }
44963
44964
44965
44966
44967 func (c *ReportsFilesListCall) Fields(s ...googleapi.Field) *ReportsFilesListCall {
44968 c.urlParams_.Set("fields", googleapi.CombineFields(s))
44969 return c
44970 }
44971
44972
44973
44974
44975
44976
44977 func (c *ReportsFilesListCall) IfNoneMatch(entityTag string) *ReportsFilesListCall {
44978 c.ifNoneMatch_ = entityTag
44979 return c
44980 }
44981
44982
44983
44984
44985 func (c *ReportsFilesListCall) Context(ctx context.Context) *ReportsFilesListCall {
44986 c.ctx_ = ctx
44987 return c
44988 }
44989
44990
44991
44992 func (c *ReportsFilesListCall) Header() http.Header {
44993 if c.header_ == nil {
44994 c.header_ = make(http.Header)
44995 }
44996 return c.header_
44997 }
44998
44999 func (c *ReportsFilesListCall) doRequest(alt string) (*http.Response, error) {
45000 reqHeaders := make(http.Header)
45001 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
45002 for k, v := range c.header_ {
45003 reqHeaders[k] = v
45004 }
45005 reqHeaders.Set("User-Agent", c.s.userAgent())
45006 if c.ifNoneMatch_ != "" {
45007 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
45008 }
45009 var body io.Reader = nil
45010 c.urlParams_.Set("alt", alt)
45011 c.urlParams_.Set("prettyPrint", "false")
45012 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/reports/{reportId}/files")
45013 urls += "?" + c.urlParams_.Encode()
45014 req, err := http.NewRequest("GET", urls, body)
45015 if err != nil {
45016 return nil, err
45017 }
45018 req.Header = reqHeaders
45019 googleapi.Expand(req.URL, map[string]string{
45020 "profileId": strconv.FormatInt(c.profileId, 10),
45021 "reportId": strconv.FormatInt(c.reportId, 10),
45022 })
45023 return gensupport.SendRequest(c.ctx_, c.s.client, req)
45024 }
45025
45026
45027
45028
45029
45030
45031
45032
45033 func (c *ReportsFilesListCall) Do(opts ...googleapi.CallOption) (*FileList, error) {
45034 gensupport.SetOptions(c.urlParams_, opts...)
45035 res, err := c.doRequest("json")
45036 if res != nil && res.StatusCode == http.StatusNotModified {
45037 if res.Body != nil {
45038 res.Body.Close()
45039 }
45040 return nil, &googleapi.Error{
45041 Code: res.StatusCode,
45042 Header: res.Header,
45043 }
45044 }
45045 if err != nil {
45046 return nil, err
45047 }
45048 defer googleapi.CloseBody(res)
45049 if err := googleapi.CheckResponse(res); err != nil {
45050 return nil, err
45051 }
45052 ret := &FileList{
45053 ServerResponse: googleapi.ServerResponse{
45054 Header: res.Header,
45055 HTTPStatusCode: res.StatusCode,
45056 },
45057 }
45058 target := &ret
45059 if err := gensupport.DecodeResponse(target, res); err != nil {
45060 return nil, err
45061 }
45062 return ret, nil
45063
45064
45065
45066
45067
45068
45069
45070
45071
45072
45073
45074
45075
45076
45077
45078
45079
45080
45081
45082
45083
45084
45085
45086
45087
45088
45089
45090
45091
45092
45093
45094
45095
45096
45097
45098
45099
45100
45101
45102
45103
45104
45105
45106
45107
45108
45109
45110
45111
45112
45113
45114
45115
45116
45117
45118
45119
45120
45121
45122
45123
45124
45125
45126
45127
45128
45129
45130
45131
45132
45133
45134
45135
45136
45137
45138 }
45139
45140
45141
45142
45143 func (c *ReportsFilesListCall) Pages(ctx context.Context, f func(*FileList) error) error {
45144 c.ctx_ = ctx
45145 defer c.PageToken(c.urlParams_.Get("pageToken"))
45146 for {
45147 x, err := c.Do()
45148 if err != nil {
45149 return err
45150 }
45151 if err := f(x); err != nil {
45152 return err
45153 }
45154 if x.NextPageToken == "" {
45155 return nil
45156 }
45157 c.PageToken(x.NextPageToken)
45158 }
45159 }
45160
45161
45162
45163 type SitesGetCall struct {
45164 s *Service
45165 profileId int64
45166 id int64
45167 urlParams_ gensupport.URLParams
45168 ifNoneMatch_ string
45169 ctx_ context.Context
45170 header_ http.Header
45171 }
45172
45173
45174 func (r *SitesService) Get(profileId int64, id int64) *SitesGetCall {
45175 c := &SitesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
45176 c.profileId = profileId
45177 c.id = id
45178 return c
45179 }
45180
45181
45182
45183
45184 func (c *SitesGetCall) Fields(s ...googleapi.Field) *SitesGetCall {
45185 c.urlParams_.Set("fields", googleapi.CombineFields(s))
45186 return c
45187 }
45188
45189
45190
45191
45192
45193
45194 func (c *SitesGetCall) IfNoneMatch(entityTag string) *SitesGetCall {
45195 c.ifNoneMatch_ = entityTag
45196 return c
45197 }
45198
45199
45200
45201
45202 func (c *SitesGetCall) Context(ctx context.Context) *SitesGetCall {
45203 c.ctx_ = ctx
45204 return c
45205 }
45206
45207
45208
45209 func (c *SitesGetCall) Header() http.Header {
45210 if c.header_ == nil {
45211 c.header_ = make(http.Header)
45212 }
45213 return c.header_
45214 }
45215
45216 func (c *SitesGetCall) doRequest(alt string) (*http.Response, error) {
45217 reqHeaders := make(http.Header)
45218 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
45219 for k, v := range c.header_ {
45220 reqHeaders[k] = v
45221 }
45222 reqHeaders.Set("User-Agent", c.s.userAgent())
45223 if c.ifNoneMatch_ != "" {
45224 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
45225 }
45226 var body io.Reader = nil
45227 c.urlParams_.Set("alt", alt)
45228 c.urlParams_.Set("prettyPrint", "false")
45229 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/sites/{id}")
45230 urls += "?" + c.urlParams_.Encode()
45231 req, err := http.NewRequest("GET", urls, body)
45232 if err != nil {
45233 return nil, err
45234 }
45235 req.Header = reqHeaders
45236 googleapi.Expand(req.URL, map[string]string{
45237 "profileId": strconv.FormatInt(c.profileId, 10),
45238 "id": strconv.FormatInt(c.id, 10),
45239 })
45240 return gensupport.SendRequest(c.ctx_, c.s.client, req)
45241 }
45242
45243
45244
45245
45246
45247
45248
45249
45250 func (c *SitesGetCall) Do(opts ...googleapi.CallOption) (*Site, error) {
45251 gensupport.SetOptions(c.urlParams_, opts...)
45252 res, err := c.doRequest("json")
45253 if res != nil && res.StatusCode == http.StatusNotModified {
45254 if res.Body != nil {
45255 res.Body.Close()
45256 }
45257 return nil, &googleapi.Error{
45258 Code: res.StatusCode,
45259 Header: res.Header,
45260 }
45261 }
45262 if err != nil {
45263 return nil, err
45264 }
45265 defer googleapi.CloseBody(res)
45266 if err := googleapi.CheckResponse(res); err != nil {
45267 return nil, err
45268 }
45269 ret := &Site{
45270 ServerResponse: googleapi.ServerResponse{
45271 Header: res.Header,
45272 HTTPStatusCode: res.StatusCode,
45273 },
45274 }
45275 target := &ret
45276 if err := gensupport.DecodeResponse(target, res); err != nil {
45277 return nil, err
45278 }
45279 return ret, nil
45280
45281
45282
45283
45284
45285
45286
45287
45288
45289
45290
45291
45292
45293
45294
45295
45296
45297
45298
45299
45300
45301
45302
45303
45304
45305
45306
45307
45308
45309
45310
45311
45312
45313 }
45314
45315
45316
45317 type SitesInsertCall struct {
45318 s *Service
45319 profileId int64
45320 site *Site
45321 urlParams_ gensupport.URLParams
45322 ctx_ context.Context
45323 header_ http.Header
45324 }
45325
45326
45327 func (r *SitesService) Insert(profileId int64, site *Site) *SitesInsertCall {
45328 c := &SitesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
45329 c.profileId = profileId
45330 c.site = site
45331 return c
45332 }
45333
45334
45335
45336
45337 func (c *SitesInsertCall) Fields(s ...googleapi.Field) *SitesInsertCall {
45338 c.urlParams_.Set("fields", googleapi.CombineFields(s))
45339 return c
45340 }
45341
45342
45343
45344
45345 func (c *SitesInsertCall) Context(ctx context.Context) *SitesInsertCall {
45346 c.ctx_ = ctx
45347 return c
45348 }
45349
45350
45351
45352 func (c *SitesInsertCall) Header() http.Header {
45353 if c.header_ == nil {
45354 c.header_ = make(http.Header)
45355 }
45356 return c.header_
45357 }
45358
45359 func (c *SitesInsertCall) doRequest(alt string) (*http.Response, error) {
45360 reqHeaders := make(http.Header)
45361 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
45362 for k, v := range c.header_ {
45363 reqHeaders[k] = v
45364 }
45365 reqHeaders.Set("User-Agent", c.s.userAgent())
45366 var body io.Reader = nil
45367 body, err := googleapi.WithoutDataWrapper.JSONReader(c.site)
45368 if err != nil {
45369 return nil, err
45370 }
45371 reqHeaders.Set("Content-Type", "application/json")
45372 c.urlParams_.Set("alt", alt)
45373 c.urlParams_.Set("prettyPrint", "false")
45374 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/sites")
45375 urls += "?" + c.urlParams_.Encode()
45376 req, err := http.NewRequest("POST", urls, body)
45377 if err != nil {
45378 return nil, err
45379 }
45380 req.Header = reqHeaders
45381 googleapi.Expand(req.URL, map[string]string{
45382 "profileId": strconv.FormatInt(c.profileId, 10),
45383 })
45384 return gensupport.SendRequest(c.ctx_, c.s.client, req)
45385 }
45386
45387
45388
45389
45390
45391
45392
45393
45394 func (c *SitesInsertCall) Do(opts ...googleapi.CallOption) (*Site, error) {
45395 gensupport.SetOptions(c.urlParams_, opts...)
45396 res, err := c.doRequest("json")
45397 if res != nil && res.StatusCode == http.StatusNotModified {
45398 if res.Body != nil {
45399 res.Body.Close()
45400 }
45401 return nil, &googleapi.Error{
45402 Code: res.StatusCode,
45403 Header: res.Header,
45404 }
45405 }
45406 if err != nil {
45407 return nil, err
45408 }
45409 defer googleapi.CloseBody(res)
45410 if err := googleapi.CheckResponse(res); err != nil {
45411 return nil, err
45412 }
45413 ret := &Site{
45414 ServerResponse: googleapi.ServerResponse{
45415 Header: res.Header,
45416 HTTPStatusCode: res.StatusCode,
45417 },
45418 }
45419 target := &ret
45420 if err := gensupport.DecodeResponse(target, res); err != nil {
45421 return nil, err
45422 }
45423 return ret, nil
45424
45425
45426
45427
45428
45429
45430
45431
45432
45433
45434
45435
45436
45437
45438
45439
45440
45441
45442
45443
45444
45445
45446
45447
45448
45449
45450
45451
45452 }
45453
45454
45455
45456 type SitesListCall struct {
45457 s *Service
45458 profileId int64
45459 urlParams_ gensupport.URLParams
45460 ifNoneMatch_ string
45461 ctx_ context.Context
45462 header_ http.Header
45463 }
45464
45465
45466
45467 func (r *SitesService) List(profileId int64) *SitesListCall {
45468 c := &SitesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
45469 c.profileId = profileId
45470 return c
45471 }
45472
45473
45474
45475
45476 func (c *SitesListCall) AcceptsInStreamVideoPlacements(acceptsInStreamVideoPlacements bool) *SitesListCall {
45477 c.urlParams_.Set("acceptsInStreamVideoPlacements", fmt.Sprint(acceptsInStreamVideoPlacements))
45478 return c
45479 }
45480
45481
45482
45483
45484 func (c *SitesListCall) AcceptsInterstitialPlacements(acceptsInterstitialPlacements bool) *SitesListCall {
45485 c.urlParams_.Set("acceptsInterstitialPlacements", fmt.Sprint(acceptsInterstitialPlacements))
45486 return c
45487 }
45488
45489
45490
45491
45492 func (c *SitesListCall) AcceptsPublisherPaidPlacements(acceptsPublisherPaidPlacements bool) *SitesListCall {
45493 c.urlParams_.Set("acceptsPublisherPaidPlacements", fmt.Sprint(acceptsPublisherPaidPlacements))
45494 return c
45495 }
45496
45497
45498
45499 func (c *SitesListCall) AdWordsSite(adWordsSite bool) *SitesListCall {
45500 c.urlParams_.Set("adWordsSite", fmt.Sprint(adWordsSite))
45501 return c
45502 }
45503
45504
45505
45506 func (c *SitesListCall) Approved(approved bool) *SitesListCall {
45507 c.urlParams_.Set("approved", fmt.Sprint(approved))
45508 return c
45509 }
45510
45511
45512
45513 func (c *SitesListCall) CampaignIds(campaignIds ...int64) *SitesListCall {
45514 var campaignIds_ []string
45515 for _, v := range campaignIds {
45516 campaignIds_ = append(campaignIds_, fmt.Sprint(v))
45517 }
45518 c.urlParams_.SetMulti("campaignIds", campaignIds_)
45519 return c
45520 }
45521
45522
45523
45524 func (c *SitesListCall) DirectorySiteIds(directorySiteIds ...int64) *SitesListCall {
45525 var directorySiteIds_ []string
45526 for _, v := range directorySiteIds {
45527 directorySiteIds_ = append(directorySiteIds_, fmt.Sprint(v))
45528 }
45529 c.urlParams_.SetMulti("directorySiteIds", directorySiteIds_)
45530 return c
45531 }
45532
45533
45534
45535 func (c *SitesListCall) Ids(ids ...int64) *SitesListCall {
45536 var ids_ []string
45537 for _, v := range ids {
45538 ids_ = append(ids_, fmt.Sprint(v))
45539 }
45540 c.urlParams_.SetMulti("ids", ids_)
45541 return c
45542 }
45543
45544
45545
45546 func (c *SitesListCall) MaxResults(maxResults int64) *SitesListCall {
45547 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
45548 return c
45549 }
45550
45551
45552
45553 func (c *SitesListCall) PageToken(pageToken string) *SitesListCall {
45554 c.urlParams_.Set("pageToken", pageToken)
45555 return c
45556 }
45557
45558
45559
45560
45561
45562
45563
45564
45565 func (c *SitesListCall) SearchString(searchString string) *SitesListCall {
45566 c.urlParams_.Set("searchString", searchString)
45567 return c
45568 }
45569
45570
45571
45572
45573
45574
45575
45576
45577 func (c *SitesListCall) SortField(sortField string) *SitesListCall {
45578 c.urlParams_.Set("sortField", sortField)
45579 return c
45580 }
45581
45582
45583
45584
45585
45586
45587
45588
45589 func (c *SitesListCall) SortOrder(sortOrder string) *SitesListCall {
45590 c.urlParams_.Set("sortOrder", sortOrder)
45591 return c
45592 }
45593
45594
45595
45596 func (c *SitesListCall) SubaccountId(subaccountId int64) *SitesListCall {
45597 c.urlParams_.Set("subaccountId", fmt.Sprint(subaccountId))
45598 return c
45599 }
45600
45601
45602
45603 func (c *SitesListCall) UnmappedSite(unmappedSite bool) *SitesListCall {
45604 c.urlParams_.Set("unmappedSite", fmt.Sprint(unmappedSite))
45605 return c
45606 }
45607
45608
45609
45610
45611 func (c *SitesListCall) Fields(s ...googleapi.Field) *SitesListCall {
45612 c.urlParams_.Set("fields", googleapi.CombineFields(s))
45613 return c
45614 }
45615
45616
45617
45618
45619
45620
45621 func (c *SitesListCall) IfNoneMatch(entityTag string) *SitesListCall {
45622 c.ifNoneMatch_ = entityTag
45623 return c
45624 }
45625
45626
45627
45628
45629 func (c *SitesListCall) Context(ctx context.Context) *SitesListCall {
45630 c.ctx_ = ctx
45631 return c
45632 }
45633
45634
45635
45636 func (c *SitesListCall) Header() http.Header {
45637 if c.header_ == nil {
45638 c.header_ = make(http.Header)
45639 }
45640 return c.header_
45641 }
45642
45643 func (c *SitesListCall) doRequest(alt string) (*http.Response, error) {
45644 reqHeaders := make(http.Header)
45645 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
45646 for k, v := range c.header_ {
45647 reqHeaders[k] = v
45648 }
45649 reqHeaders.Set("User-Agent", c.s.userAgent())
45650 if c.ifNoneMatch_ != "" {
45651 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
45652 }
45653 var body io.Reader = nil
45654 c.urlParams_.Set("alt", alt)
45655 c.urlParams_.Set("prettyPrint", "false")
45656 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/sites")
45657 urls += "?" + c.urlParams_.Encode()
45658 req, err := http.NewRequest("GET", urls, body)
45659 if err != nil {
45660 return nil, err
45661 }
45662 req.Header = reqHeaders
45663 googleapi.Expand(req.URL, map[string]string{
45664 "profileId": strconv.FormatInt(c.profileId, 10),
45665 })
45666 return gensupport.SendRequest(c.ctx_, c.s.client, req)
45667 }
45668
45669
45670
45671
45672
45673
45674
45675
45676 func (c *SitesListCall) Do(opts ...googleapi.CallOption) (*SitesListResponse, error) {
45677 gensupport.SetOptions(c.urlParams_, opts...)
45678 res, err := c.doRequest("json")
45679 if res != nil && res.StatusCode == http.StatusNotModified {
45680 if res.Body != nil {
45681 res.Body.Close()
45682 }
45683 return nil, &googleapi.Error{
45684 Code: res.StatusCode,
45685 Header: res.Header,
45686 }
45687 }
45688 if err != nil {
45689 return nil, err
45690 }
45691 defer googleapi.CloseBody(res)
45692 if err := googleapi.CheckResponse(res); err != nil {
45693 return nil, err
45694 }
45695 ret := &SitesListResponse{
45696 ServerResponse: googleapi.ServerResponse{
45697 Header: res.Header,
45698 HTTPStatusCode: res.StatusCode,
45699 },
45700 }
45701 target := &ret
45702 if err := gensupport.DecodeResponse(target, res); err != nil {
45703 return nil, err
45704 }
45705 return ret, nil
45706
45707
45708
45709
45710
45711
45712
45713
45714
45715
45716
45717
45718
45719
45720
45721
45722
45723
45724
45725
45726
45727
45728
45729
45730
45731
45732
45733
45734
45735
45736
45737
45738
45739
45740
45741
45742
45743
45744
45745
45746
45747
45748
45749
45750
45751
45752
45753
45754
45755
45756
45757
45758
45759
45760
45761
45762
45763
45764
45765
45766
45767
45768
45769
45770
45771
45772
45773
45774
45775
45776
45777
45778
45779
45780
45781
45782
45783
45784
45785
45786
45787
45788
45789
45790
45791
45792
45793
45794
45795
45796
45797
45798
45799
45800
45801
45802
45803
45804
45805
45806
45807
45808
45809
45810
45811
45812
45813
45814
45815
45816
45817
45818
45819
45820
45821
45822
45823
45824
45825
45826
45827
45828
45829
45830
45831
45832
45833
45834
45835 }
45836
45837
45838
45839
45840 func (c *SitesListCall) Pages(ctx context.Context, f func(*SitesListResponse) error) error {
45841 c.ctx_ = ctx
45842 defer c.PageToken(c.urlParams_.Get("pageToken"))
45843 for {
45844 x, err := c.Do()
45845 if err != nil {
45846 return err
45847 }
45848 if err := f(x); err != nil {
45849 return err
45850 }
45851 if x.NextPageToken == "" {
45852 return nil
45853 }
45854 c.PageToken(x.NextPageToken)
45855 }
45856 }
45857
45858
45859
45860 type SitesPatchCall struct {
45861 s *Service
45862 profileId int64
45863 site *Site
45864 urlParams_ gensupport.URLParams
45865 ctx_ context.Context
45866 header_ http.Header
45867 }
45868
45869
45870
45871 func (r *SitesService) Patch(profileId int64, id int64, site *Site) *SitesPatchCall {
45872 c := &SitesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
45873 c.profileId = profileId
45874 c.urlParams_.Set("id", fmt.Sprint(id))
45875 c.site = site
45876 return c
45877 }
45878
45879
45880
45881
45882 func (c *SitesPatchCall) Fields(s ...googleapi.Field) *SitesPatchCall {
45883 c.urlParams_.Set("fields", googleapi.CombineFields(s))
45884 return c
45885 }
45886
45887
45888
45889
45890 func (c *SitesPatchCall) Context(ctx context.Context) *SitesPatchCall {
45891 c.ctx_ = ctx
45892 return c
45893 }
45894
45895
45896
45897 func (c *SitesPatchCall) Header() http.Header {
45898 if c.header_ == nil {
45899 c.header_ = make(http.Header)
45900 }
45901 return c.header_
45902 }
45903
45904 func (c *SitesPatchCall) doRequest(alt string) (*http.Response, error) {
45905 reqHeaders := make(http.Header)
45906 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
45907 for k, v := range c.header_ {
45908 reqHeaders[k] = v
45909 }
45910 reqHeaders.Set("User-Agent", c.s.userAgent())
45911 var body io.Reader = nil
45912 body, err := googleapi.WithoutDataWrapper.JSONReader(c.site)
45913 if err != nil {
45914 return nil, err
45915 }
45916 reqHeaders.Set("Content-Type", "application/json")
45917 c.urlParams_.Set("alt", alt)
45918 c.urlParams_.Set("prettyPrint", "false")
45919 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/sites")
45920 urls += "?" + c.urlParams_.Encode()
45921 req, err := http.NewRequest("PATCH", urls, body)
45922 if err != nil {
45923 return nil, err
45924 }
45925 req.Header = reqHeaders
45926 googleapi.Expand(req.URL, map[string]string{
45927 "profileId": strconv.FormatInt(c.profileId, 10),
45928 })
45929 return gensupport.SendRequest(c.ctx_, c.s.client, req)
45930 }
45931
45932
45933
45934
45935
45936
45937
45938
45939 func (c *SitesPatchCall) Do(opts ...googleapi.CallOption) (*Site, error) {
45940 gensupport.SetOptions(c.urlParams_, opts...)
45941 res, err := c.doRequest("json")
45942 if res != nil && res.StatusCode == http.StatusNotModified {
45943 if res.Body != nil {
45944 res.Body.Close()
45945 }
45946 return nil, &googleapi.Error{
45947 Code: res.StatusCode,
45948 Header: res.Header,
45949 }
45950 }
45951 if err != nil {
45952 return nil, err
45953 }
45954 defer googleapi.CloseBody(res)
45955 if err := googleapi.CheckResponse(res); err != nil {
45956 return nil, err
45957 }
45958 ret := &Site{
45959 ServerResponse: googleapi.ServerResponse{
45960 Header: res.Header,
45961 HTTPStatusCode: res.StatusCode,
45962 },
45963 }
45964 target := &ret
45965 if err := gensupport.DecodeResponse(target, res); err != nil {
45966 return nil, err
45967 }
45968 return ret, nil
45969
45970
45971
45972
45973
45974
45975
45976
45977
45978
45979
45980
45981
45982
45983
45984
45985
45986
45987
45988
45989
45990
45991
45992
45993
45994
45995
45996
45997
45998
45999
46000
46001
46002
46003
46004
46005 }
46006
46007
46008
46009 type SitesUpdateCall struct {
46010 s *Service
46011 profileId int64
46012 site *Site
46013 urlParams_ gensupport.URLParams
46014 ctx_ context.Context
46015 header_ http.Header
46016 }
46017
46018
46019 func (r *SitesService) Update(profileId int64, site *Site) *SitesUpdateCall {
46020 c := &SitesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
46021 c.profileId = profileId
46022 c.site = site
46023 return c
46024 }
46025
46026
46027
46028
46029 func (c *SitesUpdateCall) Fields(s ...googleapi.Field) *SitesUpdateCall {
46030 c.urlParams_.Set("fields", googleapi.CombineFields(s))
46031 return c
46032 }
46033
46034
46035
46036
46037 func (c *SitesUpdateCall) Context(ctx context.Context) *SitesUpdateCall {
46038 c.ctx_ = ctx
46039 return c
46040 }
46041
46042
46043
46044 func (c *SitesUpdateCall) Header() http.Header {
46045 if c.header_ == nil {
46046 c.header_ = make(http.Header)
46047 }
46048 return c.header_
46049 }
46050
46051 func (c *SitesUpdateCall) doRequest(alt string) (*http.Response, error) {
46052 reqHeaders := make(http.Header)
46053 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
46054 for k, v := range c.header_ {
46055 reqHeaders[k] = v
46056 }
46057 reqHeaders.Set("User-Agent", c.s.userAgent())
46058 var body io.Reader = nil
46059 body, err := googleapi.WithoutDataWrapper.JSONReader(c.site)
46060 if err != nil {
46061 return nil, err
46062 }
46063 reqHeaders.Set("Content-Type", "application/json")
46064 c.urlParams_.Set("alt", alt)
46065 c.urlParams_.Set("prettyPrint", "false")
46066 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/sites")
46067 urls += "?" + c.urlParams_.Encode()
46068 req, err := http.NewRequest("PUT", urls, body)
46069 if err != nil {
46070 return nil, err
46071 }
46072 req.Header = reqHeaders
46073 googleapi.Expand(req.URL, map[string]string{
46074 "profileId": strconv.FormatInt(c.profileId, 10),
46075 })
46076 return gensupport.SendRequest(c.ctx_, c.s.client, req)
46077 }
46078
46079
46080
46081
46082
46083
46084
46085
46086 func (c *SitesUpdateCall) Do(opts ...googleapi.CallOption) (*Site, error) {
46087 gensupport.SetOptions(c.urlParams_, opts...)
46088 res, err := c.doRequest("json")
46089 if res != nil && res.StatusCode == http.StatusNotModified {
46090 if res.Body != nil {
46091 res.Body.Close()
46092 }
46093 return nil, &googleapi.Error{
46094 Code: res.StatusCode,
46095 Header: res.Header,
46096 }
46097 }
46098 if err != nil {
46099 return nil, err
46100 }
46101 defer googleapi.CloseBody(res)
46102 if err := googleapi.CheckResponse(res); err != nil {
46103 return nil, err
46104 }
46105 ret := &Site{
46106 ServerResponse: googleapi.ServerResponse{
46107 Header: res.Header,
46108 HTTPStatusCode: res.StatusCode,
46109 },
46110 }
46111 target := &ret
46112 if err := gensupport.DecodeResponse(target, res); err != nil {
46113 return nil, err
46114 }
46115 return ret, nil
46116
46117
46118
46119
46120
46121
46122
46123
46124
46125
46126
46127
46128
46129
46130
46131
46132
46133
46134
46135
46136
46137
46138
46139
46140
46141
46142
46143
46144 }
46145
46146
46147
46148 type SizesGetCall struct {
46149 s *Service
46150 profileId int64
46151 id int64
46152 urlParams_ gensupport.URLParams
46153 ifNoneMatch_ string
46154 ctx_ context.Context
46155 header_ http.Header
46156 }
46157
46158
46159 func (r *SizesService) Get(profileId int64, id int64) *SizesGetCall {
46160 c := &SizesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
46161 c.profileId = profileId
46162 c.id = id
46163 return c
46164 }
46165
46166
46167
46168
46169 func (c *SizesGetCall) Fields(s ...googleapi.Field) *SizesGetCall {
46170 c.urlParams_.Set("fields", googleapi.CombineFields(s))
46171 return c
46172 }
46173
46174
46175
46176
46177
46178
46179 func (c *SizesGetCall) IfNoneMatch(entityTag string) *SizesGetCall {
46180 c.ifNoneMatch_ = entityTag
46181 return c
46182 }
46183
46184
46185
46186
46187 func (c *SizesGetCall) Context(ctx context.Context) *SizesGetCall {
46188 c.ctx_ = ctx
46189 return c
46190 }
46191
46192
46193
46194 func (c *SizesGetCall) Header() http.Header {
46195 if c.header_ == nil {
46196 c.header_ = make(http.Header)
46197 }
46198 return c.header_
46199 }
46200
46201 func (c *SizesGetCall) doRequest(alt string) (*http.Response, error) {
46202 reqHeaders := make(http.Header)
46203 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
46204 for k, v := range c.header_ {
46205 reqHeaders[k] = v
46206 }
46207 reqHeaders.Set("User-Agent", c.s.userAgent())
46208 if c.ifNoneMatch_ != "" {
46209 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
46210 }
46211 var body io.Reader = nil
46212 c.urlParams_.Set("alt", alt)
46213 c.urlParams_.Set("prettyPrint", "false")
46214 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/sizes/{id}")
46215 urls += "?" + c.urlParams_.Encode()
46216 req, err := http.NewRequest("GET", urls, body)
46217 if err != nil {
46218 return nil, err
46219 }
46220 req.Header = reqHeaders
46221 googleapi.Expand(req.URL, map[string]string{
46222 "profileId": strconv.FormatInt(c.profileId, 10),
46223 "id": strconv.FormatInt(c.id, 10),
46224 })
46225 return gensupport.SendRequest(c.ctx_, c.s.client, req)
46226 }
46227
46228
46229
46230
46231
46232
46233
46234
46235 func (c *SizesGetCall) Do(opts ...googleapi.CallOption) (*Size, error) {
46236 gensupport.SetOptions(c.urlParams_, opts...)
46237 res, err := c.doRequest("json")
46238 if res != nil && res.StatusCode == http.StatusNotModified {
46239 if res.Body != nil {
46240 res.Body.Close()
46241 }
46242 return nil, &googleapi.Error{
46243 Code: res.StatusCode,
46244 Header: res.Header,
46245 }
46246 }
46247 if err != nil {
46248 return nil, err
46249 }
46250 defer googleapi.CloseBody(res)
46251 if err := googleapi.CheckResponse(res); err != nil {
46252 return nil, err
46253 }
46254 ret := &Size{
46255 ServerResponse: googleapi.ServerResponse{
46256 Header: res.Header,
46257 HTTPStatusCode: res.StatusCode,
46258 },
46259 }
46260 target := &ret
46261 if err := gensupport.DecodeResponse(target, res); err != nil {
46262 return nil, err
46263 }
46264 return ret, nil
46265
46266
46267
46268
46269
46270
46271
46272
46273
46274
46275
46276
46277
46278
46279
46280
46281
46282
46283
46284
46285
46286
46287
46288
46289
46290
46291
46292
46293
46294
46295
46296
46297
46298 }
46299
46300
46301
46302 type SizesInsertCall struct {
46303 s *Service
46304 profileId int64
46305 size *Size
46306 urlParams_ gensupport.URLParams
46307 ctx_ context.Context
46308 header_ http.Header
46309 }
46310
46311
46312 func (r *SizesService) Insert(profileId int64, size *Size) *SizesInsertCall {
46313 c := &SizesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
46314 c.profileId = profileId
46315 c.size = size
46316 return c
46317 }
46318
46319
46320
46321
46322 func (c *SizesInsertCall) Fields(s ...googleapi.Field) *SizesInsertCall {
46323 c.urlParams_.Set("fields", googleapi.CombineFields(s))
46324 return c
46325 }
46326
46327
46328
46329
46330 func (c *SizesInsertCall) Context(ctx context.Context) *SizesInsertCall {
46331 c.ctx_ = ctx
46332 return c
46333 }
46334
46335
46336
46337 func (c *SizesInsertCall) Header() http.Header {
46338 if c.header_ == nil {
46339 c.header_ = make(http.Header)
46340 }
46341 return c.header_
46342 }
46343
46344 func (c *SizesInsertCall) doRequest(alt string) (*http.Response, error) {
46345 reqHeaders := make(http.Header)
46346 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
46347 for k, v := range c.header_ {
46348 reqHeaders[k] = v
46349 }
46350 reqHeaders.Set("User-Agent", c.s.userAgent())
46351 var body io.Reader = nil
46352 body, err := googleapi.WithoutDataWrapper.JSONReader(c.size)
46353 if err != nil {
46354 return nil, err
46355 }
46356 reqHeaders.Set("Content-Type", "application/json")
46357 c.urlParams_.Set("alt", alt)
46358 c.urlParams_.Set("prettyPrint", "false")
46359 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/sizes")
46360 urls += "?" + c.urlParams_.Encode()
46361 req, err := http.NewRequest("POST", urls, body)
46362 if err != nil {
46363 return nil, err
46364 }
46365 req.Header = reqHeaders
46366 googleapi.Expand(req.URL, map[string]string{
46367 "profileId": strconv.FormatInt(c.profileId, 10),
46368 })
46369 return gensupport.SendRequest(c.ctx_, c.s.client, req)
46370 }
46371
46372
46373
46374
46375
46376
46377
46378
46379 func (c *SizesInsertCall) Do(opts ...googleapi.CallOption) (*Size, error) {
46380 gensupport.SetOptions(c.urlParams_, opts...)
46381 res, err := c.doRequest("json")
46382 if res != nil && res.StatusCode == http.StatusNotModified {
46383 if res.Body != nil {
46384 res.Body.Close()
46385 }
46386 return nil, &googleapi.Error{
46387 Code: res.StatusCode,
46388 Header: res.Header,
46389 }
46390 }
46391 if err != nil {
46392 return nil, err
46393 }
46394 defer googleapi.CloseBody(res)
46395 if err := googleapi.CheckResponse(res); err != nil {
46396 return nil, err
46397 }
46398 ret := &Size{
46399 ServerResponse: googleapi.ServerResponse{
46400 Header: res.Header,
46401 HTTPStatusCode: res.StatusCode,
46402 },
46403 }
46404 target := &ret
46405 if err := gensupport.DecodeResponse(target, res); err != nil {
46406 return nil, err
46407 }
46408 return ret, nil
46409
46410
46411
46412
46413
46414
46415
46416
46417
46418
46419
46420
46421
46422
46423
46424
46425
46426
46427
46428
46429
46430
46431
46432
46433
46434
46435
46436
46437 }
46438
46439
46440
46441 type SizesListCall struct {
46442 s *Service
46443 profileId int64
46444 urlParams_ gensupport.URLParams
46445 ifNoneMatch_ string
46446 ctx_ context.Context
46447 header_ http.Header
46448 }
46449
46450
46451
46452
46453
46454 func (r *SizesService) List(profileId int64) *SizesListCall {
46455 c := &SizesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
46456 c.profileId = profileId
46457 return c
46458 }
46459
46460
46461
46462 func (c *SizesListCall) Height(height int64) *SizesListCall {
46463 c.urlParams_.Set("height", fmt.Sprint(height))
46464 return c
46465 }
46466
46467
46468
46469 func (c *SizesListCall) IabStandard(iabStandard bool) *SizesListCall {
46470 c.urlParams_.Set("iabStandard", fmt.Sprint(iabStandard))
46471 return c
46472 }
46473
46474
46475
46476 func (c *SizesListCall) Ids(ids ...int64) *SizesListCall {
46477 var ids_ []string
46478 for _, v := range ids {
46479 ids_ = append(ids_, fmt.Sprint(v))
46480 }
46481 c.urlParams_.SetMulti("ids", ids_)
46482 return c
46483 }
46484
46485
46486
46487 func (c *SizesListCall) Width(width int64) *SizesListCall {
46488 c.urlParams_.Set("width", fmt.Sprint(width))
46489 return c
46490 }
46491
46492
46493
46494
46495 func (c *SizesListCall) Fields(s ...googleapi.Field) *SizesListCall {
46496 c.urlParams_.Set("fields", googleapi.CombineFields(s))
46497 return c
46498 }
46499
46500
46501
46502
46503
46504
46505 func (c *SizesListCall) IfNoneMatch(entityTag string) *SizesListCall {
46506 c.ifNoneMatch_ = entityTag
46507 return c
46508 }
46509
46510
46511
46512
46513 func (c *SizesListCall) Context(ctx context.Context) *SizesListCall {
46514 c.ctx_ = ctx
46515 return c
46516 }
46517
46518
46519
46520 func (c *SizesListCall) Header() http.Header {
46521 if c.header_ == nil {
46522 c.header_ = make(http.Header)
46523 }
46524 return c.header_
46525 }
46526
46527 func (c *SizesListCall) doRequest(alt string) (*http.Response, error) {
46528 reqHeaders := make(http.Header)
46529 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
46530 for k, v := range c.header_ {
46531 reqHeaders[k] = v
46532 }
46533 reqHeaders.Set("User-Agent", c.s.userAgent())
46534 if c.ifNoneMatch_ != "" {
46535 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
46536 }
46537 var body io.Reader = nil
46538 c.urlParams_.Set("alt", alt)
46539 c.urlParams_.Set("prettyPrint", "false")
46540 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/sizes")
46541 urls += "?" + c.urlParams_.Encode()
46542 req, err := http.NewRequest("GET", urls, body)
46543 if err != nil {
46544 return nil, err
46545 }
46546 req.Header = reqHeaders
46547 googleapi.Expand(req.URL, map[string]string{
46548 "profileId": strconv.FormatInt(c.profileId, 10),
46549 })
46550 return gensupport.SendRequest(c.ctx_, c.s.client, req)
46551 }
46552
46553
46554
46555
46556
46557
46558
46559
46560 func (c *SizesListCall) Do(opts ...googleapi.CallOption) (*SizesListResponse, error) {
46561 gensupport.SetOptions(c.urlParams_, opts...)
46562 res, err := c.doRequest("json")
46563 if res != nil && res.StatusCode == http.StatusNotModified {
46564 if res.Body != nil {
46565 res.Body.Close()
46566 }
46567 return nil, &googleapi.Error{
46568 Code: res.StatusCode,
46569 Header: res.Header,
46570 }
46571 }
46572 if err != nil {
46573 return nil, err
46574 }
46575 defer googleapi.CloseBody(res)
46576 if err := googleapi.CheckResponse(res); err != nil {
46577 return nil, err
46578 }
46579 ret := &SizesListResponse{
46580 ServerResponse: googleapi.ServerResponse{
46581 Header: res.Header,
46582 HTTPStatusCode: res.StatusCode,
46583 },
46584 }
46585 target := &ret
46586 if err := gensupport.DecodeResponse(target, res); err != nil {
46587 return nil, err
46588 }
46589 return ret, nil
46590
46591
46592
46593
46594
46595
46596
46597
46598
46599
46600
46601
46602
46603
46604
46605
46606
46607
46608
46609
46610
46611
46612
46613
46614
46615
46616
46617
46618
46619
46620
46621
46622
46623
46624
46625
46626
46627
46628
46629
46630
46631
46632
46633
46634
46635
46636
46637
46638
46639
46640
46641
46642
46643 }
46644
46645
46646
46647 type SubaccountsGetCall struct {
46648 s *Service
46649 profileId int64
46650 id int64
46651 urlParams_ gensupport.URLParams
46652 ifNoneMatch_ string
46653 ctx_ context.Context
46654 header_ http.Header
46655 }
46656
46657
46658 func (r *SubaccountsService) Get(profileId int64, id int64) *SubaccountsGetCall {
46659 c := &SubaccountsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
46660 c.profileId = profileId
46661 c.id = id
46662 return c
46663 }
46664
46665
46666
46667
46668 func (c *SubaccountsGetCall) Fields(s ...googleapi.Field) *SubaccountsGetCall {
46669 c.urlParams_.Set("fields", googleapi.CombineFields(s))
46670 return c
46671 }
46672
46673
46674
46675
46676
46677
46678 func (c *SubaccountsGetCall) IfNoneMatch(entityTag string) *SubaccountsGetCall {
46679 c.ifNoneMatch_ = entityTag
46680 return c
46681 }
46682
46683
46684
46685
46686 func (c *SubaccountsGetCall) Context(ctx context.Context) *SubaccountsGetCall {
46687 c.ctx_ = ctx
46688 return c
46689 }
46690
46691
46692
46693 func (c *SubaccountsGetCall) Header() http.Header {
46694 if c.header_ == nil {
46695 c.header_ = make(http.Header)
46696 }
46697 return c.header_
46698 }
46699
46700 func (c *SubaccountsGetCall) doRequest(alt string) (*http.Response, error) {
46701 reqHeaders := make(http.Header)
46702 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
46703 for k, v := range c.header_ {
46704 reqHeaders[k] = v
46705 }
46706 reqHeaders.Set("User-Agent", c.s.userAgent())
46707 if c.ifNoneMatch_ != "" {
46708 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
46709 }
46710 var body io.Reader = nil
46711 c.urlParams_.Set("alt", alt)
46712 c.urlParams_.Set("prettyPrint", "false")
46713 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/subaccounts/{id}")
46714 urls += "?" + c.urlParams_.Encode()
46715 req, err := http.NewRequest("GET", urls, body)
46716 if err != nil {
46717 return nil, err
46718 }
46719 req.Header = reqHeaders
46720 googleapi.Expand(req.URL, map[string]string{
46721 "profileId": strconv.FormatInt(c.profileId, 10),
46722 "id": strconv.FormatInt(c.id, 10),
46723 })
46724 return gensupport.SendRequest(c.ctx_, c.s.client, req)
46725 }
46726
46727
46728
46729
46730
46731
46732
46733
46734 func (c *SubaccountsGetCall) Do(opts ...googleapi.CallOption) (*Subaccount, error) {
46735 gensupport.SetOptions(c.urlParams_, opts...)
46736 res, err := c.doRequest("json")
46737 if res != nil && res.StatusCode == http.StatusNotModified {
46738 if res.Body != nil {
46739 res.Body.Close()
46740 }
46741 return nil, &googleapi.Error{
46742 Code: res.StatusCode,
46743 Header: res.Header,
46744 }
46745 }
46746 if err != nil {
46747 return nil, err
46748 }
46749 defer googleapi.CloseBody(res)
46750 if err := googleapi.CheckResponse(res); err != nil {
46751 return nil, err
46752 }
46753 ret := &Subaccount{
46754 ServerResponse: googleapi.ServerResponse{
46755 Header: res.Header,
46756 HTTPStatusCode: res.StatusCode,
46757 },
46758 }
46759 target := &ret
46760 if err := gensupport.DecodeResponse(target, res); err != nil {
46761 return nil, err
46762 }
46763 return ret, nil
46764
46765
46766
46767
46768
46769
46770
46771
46772
46773
46774
46775
46776
46777
46778
46779
46780
46781
46782
46783
46784
46785
46786
46787
46788
46789
46790
46791
46792
46793
46794
46795
46796
46797 }
46798
46799
46800
46801 type SubaccountsInsertCall struct {
46802 s *Service
46803 profileId int64
46804 subaccount *Subaccount
46805 urlParams_ gensupport.URLParams
46806 ctx_ context.Context
46807 header_ http.Header
46808 }
46809
46810
46811 func (r *SubaccountsService) Insert(profileId int64, subaccount *Subaccount) *SubaccountsInsertCall {
46812 c := &SubaccountsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
46813 c.profileId = profileId
46814 c.subaccount = subaccount
46815 return c
46816 }
46817
46818
46819
46820
46821 func (c *SubaccountsInsertCall) Fields(s ...googleapi.Field) *SubaccountsInsertCall {
46822 c.urlParams_.Set("fields", googleapi.CombineFields(s))
46823 return c
46824 }
46825
46826
46827
46828
46829 func (c *SubaccountsInsertCall) Context(ctx context.Context) *SubaccountsInsertCall {
46830 c.ctx_ = ctx
46831 return c
46832 }
46833
46834
46835
46836 func (c *SubaccountsInsertCall) Header() http.Header {
46837 if c.header_ == nil {
46838 c.header_ = make(http.Header)
46839 }
46840 return c.header_
46841 }
46842
46843 func (c *SubaccountsInsertCall) doRequest(alt string) (*http.Response, error) {
46844 reqHeaders := make(http.Header)
46845 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
46846 for k, v := range c.header_ {
46847 reqHeaders[k] = v
46848 }
46849 reqHeaders.Set("User-Agent", c.s.userAgent())
46850 var body io.Reader = nil
46851 body, err := googleapi.WithoutDataWrapper.JSONReader(c.subaccount)
46852 if err != nil {
46853 return nil, err
46854 }
46855 reqHeaders.Set("Content-Type", "application/json")
46856 c.urlParams_.Set("alt", alt)
46857 c.urlParams_.Set("prettyPrint", "false")
46858 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/subaccounts")
46859 urls += "?" + c.urlParams_.Encode()
46860 req, err := http.NewRequest("POST", urls, body)
46861 if err != nil {
46862 return nil, err
46863 }
46864 req.Header = reqHeaders
46865 googleapi.Expand(req.URL, map[string]string{
46866 "profileId": strconv.FormatInt(c.profileId, 10),
46867 })
46868 return gensupport.SendRequest(c.ctx_, c.s.client, req)
46869 }
46870
46871
46872
46873
46874
46875
46876
46877
46878 func (c *SubaccountsInsertCall) Do(opts ...googleapi.CallOption) (*Subaccount, error) {
46879 gensupport.SetOptions(c.urlParams_, opts...)
46880 res, err := c.doRequest("json")
46881 if res != nil && res.StatusCode == http.StatusNotModified {
46882 if res.Body != nil {
46883 res.Body.Close()
46884 }
46885 return nil, &googleapi.Error{
46886 Code: res.StatusCode,
46887 Header: res.Header,
46888 }
46889 }
46890 if err != nil {
46891 return nil, err
46892 }
46893 defer googleapi.CloseBody(res)
46894 if err := googleapi.CheckResponse(res); err != nil {
46895 return nil, err
46896 }
46897 ret := &Subaccount{
46898 ServerResponse: googleapi.ServerResponse{
46899 Header: res.Header,
46900 HTTPStatusCode: res.StatusCode,
46901 },
46902 }
46903 target := &ret
46904 if err := gensupport.DecodeResponse(target, res); err != nil {
46905 return nil, err
46906 }
46907 return ret, nil
46908
46909
46910
46911
46912
46913
46914
46915
46916
46917
46918
46919
46920
46921
46922
46923
46924
46925
46926
46927
46928
46929
46930
46931
46932
46933
46934
46935
46936 }
46937
46938
46939
46940 type SubaccountsListCall struct {
46941 s *Service
46942 profileId int64
46943 urlParams_ gensupport.URLParams
46944 ifNoneMatch_ string
46945 ctx_ context.Context
46946 header_ http.Header
46947 }
46948
46949
46950
46951 func (r *SubaccountsService) List(profileId int64) *SubaccountsListCall {
46952 c := &SubaccountsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
46953 c.profileId = profileId
46954 return c
46955 }
46956
46957
46958
46959 func (c *SubaccountsListCall) Ids(ids ...int64) *SubaccountsListCall {
46960 var ids_ []string
46961 for _, v := range ids {
46962 ids_ = append(ids_, fmt.Sprint(v))
46963 }
46964 c.urlParams_.SetMulti("ids", ids_)
46965 return c
46966 }
46967
46968
46969
46970 func (c *SubaccountsListCall) MaxResults(maxResults int64) *SubaccountsListCall {
46971 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
46972 return c
46973 }
46974
46975
46976
46977 func (c *SubaccountsListCall) PageToken(pageToken string) *SubaccountsListCall {
46978 c.urlParams_.Set("pageToken", pageToken)
46979 return c
46980 }
46981
46982
46983
46984
46985
46986
46987
46988
46989
46990 func (c *SubaccountsListCall) SearchString(searchString string) *SubaccountsListCall {
46991 c.urlParams_.Set("searchString", searchString)
46992 return c
46993 }
46994
46995
46996
46997
46998
46999
47000
47001
47002 func (c *SubaccountsListCall) SortField(sortField string) *SubaccountsListCall {
47003 c.urlParams_.Set("sortField", sortField)
47004 return c
47005 }
47006
47007
47008
47009
47010
47011
47012
47013
47014 func (c *SubaccountsListCall) SortOrder(sortOrder string) *SubaccountsListCall {
47015 c.urlParams_.Set("sortOrder", sortOrder)
47016 return c
47017 }
47018
47019
47020
47021
47022 func (c *SubaccountsListCall) Fields(s ...googleapi.Field) *SubaccountsListCall {
47023 c.urlParams_.Set("fields", googleapi.CombineFields(s))
47024 return c
47025 }
47026
47027
47028
47029
47030
47031
47032 func (c *SubaccountsListCall) IfNoneMatch(entityTag string) *SubaccountsListCall {
47033 c.ifNoneMatch_ = entityTag
47034 return c
47035 }
47036
47037
47038
47039
47040 func (c *SubaccountsListCall) Context(ctx context.Context) *SubaccountsListCall {
47041 c.ctx_ = ctx
47042 return c
47043 }
47044
47045
47046
47047 func (c *SubaccountsListCall) Header() http.Header {
47048 if c.header_ == nil {
47049 c.header_ = make(http.Header)
47050 }
47051 return c.header_
47052 }
47053
47054 func (c *SubaccountsListCall) doRequest(alt string) (*http.Response, error) {
47055 reqHeaders := make(http.Header)
47056 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
47057 for k, v := range c.header_ {
47058 reqHeaders[k] = v
47059 }
47060 reqHeaders.Set("User-Agent", c.s.userAgent())
47061 if c.ifNoneMatch_ != "" {
47062 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
47063 }
47064 var body io.Reader = nil
47065 c.urlParams_.Set("alt", alt)
47066 c.urlParams_.Set("prettyPrint", "false")
47067 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/subaccounts")
47068 urls += "?" + c.urlParams_.Encode()
47069 req, err := http.NewRequest("GET", urls, body)
47070 if err != nil {
47071 return nil, err
47072 }
47073 req.Header = reqHeaders
47074 googleapi.Expand(req.URL, map[string]string{
47075 "profileId": strconv.FormatInt(c.profileId, 10),
47076 })
47077 return gensupport.SendRequest(c.ctx_, c.s.client, req)
47078 }
47079
47080
47081
47082
47083
47084
47085
47086
47087 func (c *SubaccountsListCall) Do(opts ...googleapi.CallOption) (*SubaccountsListResponse, error) {
47088 gensupport.SetOptions(c.urlParams_, opts...)
47089 res, err := c.doRequest("json")
47090 if res != nil && res.StatusCode == http.StatusNotModified {
47091 if res.Body != nil {
47092 res.Body.Close()
47093 }
47094 return nil, &googleapi.Error{
47095 Code: res.StatusCode,
47096 Header: res.Header,
47097 }
47098 }
47099 if err != nil {
47100 return nil, err
47101 }
47102 defer googleapi.CloseBody(res)
47103 if err := googleapi.CheckResponse(res); err != nil {
47104 return nil, err
47105 }
47106 ret := &SubaccountsListResponse{
47107 ServerResponse: googleapi.ServerResponse{
47108 Header: res.Header,
47109 HTTPStatusCode: res.StatusCode,
47110 },
47111 }
47112 target := &ret
47113 if err := gensupport.DecodeResponse(target, res); err != nil {
47114 return nil, err
47115 }
47116 return ret, nil
47117
47118
47119
47120
47121
47122
47123
47124
47125
47126
47127
47128
47129
47130
47131
47132
47133
47134
47135
47136
47137
47138
47139
47140
47141
47142
47143
47144
47145
47146
47147
47148
47149
47150
47151
47152
47153
47154
47155
47156
47157
47158
47159
47160
47161
47162
47163
47164
47165
47166
47167
47168
47169
47170
47171
47172
47173
47174
47175
47176
47177
47178
47179
47180
47181
47182
47183
47184
47185
47186
47187
47188
47189
47190
47191
47192
47193
47194
47195
47196 }
47197
47198
47199
47200
47201 func (c *SubaccountsListCall) Pages(ctx context.Context, f func(*SubaccountsListResponse) error) error {
47202 c.ctx_ = ctx
47203 defer c.PageToken(c.urlParams_.Get("pageToken"))
47204 for {
47205 x, err := c.Do()
47206 if err != nil {
47207 return err
47208 }
47209 if err := f(x); err != nil {
47210 return err
47211 }
47212 if x.NextPageToken == "" {
47213 return nil
47214 }
47215 c.PageToken(x.NextPageToken)
47216 }
47217 }
47218
47219
47220
47221 type SubaccountsPatchCall struct {
47222 s *Service
47223 profileId int64
47224 subaccount *Subaccount
47225 urlParams_ gensupport.URLParams
47226 ctx_ context.Context
47227 header_ http.Header
47228 }
47229
47230
47231
47232 func (r *SubaccountsService) Patch(profileId int64, id int64, subaccount *Subaccount) *SubaccountsPatchCall {
47233 c := &SubaccountsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
47234 c.profileId = profileId
47235 c.urlParams_.Set("id", fmt.Sprint(id))
47236 c.subaccount = subaccount
47237 return c
47238 }
47239
47240
47241
47242
47243 func (c *SubaccountsPatchCall) Fields(s ...googleapi.Field) *SubaccountsPatchCall {
47244 c.urlParams_.Set("fields", googleapi.CombineFields(s))
47245 return c
47246 }
47247
47248
47249
47250
47251 func (c *SubaccountsPatchCall) Context(ctx context.Context) *SubaccountsPatchCall {
47252 c.ctx_ = ctx
47253 return c
47254 }
47255
47256
47257
47258 func (c *SubaccountsPatchCall) Header() http.Header {
47259 if c.header_ == nil {
47260 c.header_ = make(http.Header)
47261 }
47262 return c.header_
47263 }
47264
47265 func (c *SubaccountsPatchCall) doRequest(alt string) (*http.Response, error) {
47266 reqHeaders := make(http.Header)
47267 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
47268 for k, v := range c.header_ {
47269 reqHeaders[k] = v
47270 }
47271 reqHeaders.Set("User-Agent", c.s.userAgent())
47272 var body io.Reader = nil
47273 body, err := googleapi.WithoutDataWrapper.JSONReader(c.subaccount)
47274 if err != nil {
47275 return nil, err
47276 }
47277 reqHeaders.Set("Content-Type", "application/json")
47278 c.urlParams_.Set("alt", alt)
47279 c.urlParams_.Set("prettyPrint", "false")
47280 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/subaccounts")
47281 urls += "?" + c.urlParams_.Encode()
47282 req, err := http.NewRequest("PATCH", urls, body)
47283 if err != nil {
47284 return nil, err
47285 }
47286 req.Header = reqHeaders
47287 googleapi.Expand(req.URL, map[string]string{
47288 "profileId": strconv.FormatInt(c.profileId, 10),
47289 })
47290 return gensupport.SendRequest(c.ctx_, c.s.client, req)
47291 }
47292
47293
47294
47295
47296
47297
47298
47299
47300 func (c *SubaccountsPatchCall) Do(opts ...googleapi.CallOption) (*Subaccount, error) {
47301 gensupport.SetOptions(c.urlParams_, opts...)
47302 res, err := c.doRequest("json")
47303 if res != nil && res.StatusCode == http.StatusNotModified {
47304 if res.Body != nil {
47305 res.Body.Close()
47306 }
47307 return nil, &googleapi.Error{
47308 Code: res.StatusCode,
47309 Header: res.Header,
47310 }
47311 }
47312 if err != nil {
47313 return nil, err
47314 }
47315 defer googleapi.CloseBody(res)
47316 if err := googleapi.CheckResponse(res); err != nil {
47317 return nil, err
47318 }
47319 ret := &Subaccount{
47320 ServerResponse: googleapi.ServerResponse{
47321 Header: res.Header,
47322 HTTPStatusCode: res.StatusCode,
47323 },
47324 }
47325 target := &ret
47326 if err := gensupport.DecodeResponse(target, res); err != nil {
47327 return nil, err
47328 }
47329 return ret, nil
47330
47331
47332
47333
47334
47335
47336
47337
47338
47339
47340
47341
47342
47343
47344
47345
47346
47347
47348
47349
47350
47351
47352
47353
47354
47355
47356
47357
47358
47359
47360
47361
47362
47363
47364
47365
47366 }
47367
47368
47369
47370 type SubaccountsUpdateCall struct {
47371 s *Service
47372 profileId int64
47373 subaccount *Subaccount
47374 urlParams_ gensupport.URLParams
47375 ctx_ context.Context
47376 header_ http.Header
47377 }
47378
47379
47380 func (r *SubaccountsService) Update(profileId int64, subaccount *Subaccount) *SubaccountsUpdateCall {
47381 c := &SubaccountsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
47382 c.profileId = profileId
47383 c.subaccount = subaccount
47384 return c
47385 }
47386
47387
47388
47389
47390 func (c *SubaccountsUpdateCall) Fields(s ...googleapi.Field) *SubaccountsUpdateCall {
47391 c.urlParams_.Set("fields", googleapi.CombineFields(s))
47392 return c
47393 }
47394
47395
47396
47397
47398 func (c *SubaccountsUpdateCall) Context(ctx context.Context) *SubaccountsUpdateCall {
47399 c.ctx_ = ctx
47400 return c
47401 }
47402
47403
47404
47405 func (c *SubaccountsUpdateCall) Header() http.Header {
47406 if c.header_ == nil {
47407 c.header_ = make(http.Header)
47408 }
47409 return c.header_
47410 }
47411
47412 func (c *SubaccountsUpdateCall) doRequest(alt string) (*http.Response, error) {
47413 reqHeaders := make(http.Header)
47414 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
47415 for k, v := range c.header_ {
47416 reqHeaders[k] = v
47417 }
47418 reqHeaders.Set("User-Agent", c.s.userAgent())
47419 var body io.Reader = nil
47420 body, err := googleapi.WithoutDataWrapper.JSONReader(c.subaccount)
47421 if err != nil {
47422 return nil, err
47423 }
47424 reqHeaders.Set("Content-Type", "application/json")
47425 c.urlParams_.Set("alt", alt)
47426 c.urlParams_.Set("prettyPrint", "false")
47427 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/subaccounts")
47428 urls += "?" + c.urlParams_.Encode()
47429 req, err := http.NewRequest("PUT", urls, body)
47430 if err != nil {
47431 return nil, err
47432 }
47433 req.Header = reqHeaders
47434 googleapi.Expand(req.URL, map[string]string{
47435 "profileId": strconv.FormatInt(c.profileId, 10),
47436 })
47437 return gensupport.SendRequest(c.ctx_, c.s.client, req)
47438 }
47439
47440
47441
47442
47443
47444
47445
47446
47447 func (c *SubaccountsUpdateCall) Do(opts ...googleapi.CallOption) (*Subaccount, error) {
47448 gensupport.SetOptions(c.urlParams_, opts...)
47449 res, err := c.doRequest("json")
47450 if res != nil && res.StatusCode == http.StatusNotModified {
47451 if res.Body != nil {
47452 res.Body.Close()
47453 }
47454 return nil, &googleapi.Error{
47455 Code: res.StatusCode,
47456 Header: res.Header,
47457 }
47458 }
47459 if err != nil {
47460 return nil, err
47461 }
47462 defer googleapi.CloseBody(res)
47463 if err := googleapi.CheckResponse(res); err != nil {
47464 return nil, err
47465 }
47466 ret := &Subaccount{
47467 ServerResponse: googleapi.ServerResponse{
47468 Header: res.Header,
47469 HTTPStatusCode: res.StatusCode,
47470 },
47471 }
47472 target := &ret
47473 if err := gensupport.DecodeResponse(target, res); err != nil {
47474 return nil, err
47475 }
47476 return ret, nil
47477
47478
47479
47480
47481
47482
47483
47484
47485
47486
47487
47488
47489
47490
47491
47492
47493
47494
47495
47496
47497
47498
47499
47500
47501
47502
47503
47504
47505 }
47506
47507
47508
47509 type TargetableRemarketingListsGetCall struct {
47510 s *Service
47511 profileId int64
47512 id int64
47513 urlParams_ gensupport.URLParams
47514 ifNoneMatch_ string
47515 ctx_ context.Context
47516 header_ http.Header
47517 }
47518
47519
47520 func (r *TargetableRemarketingListsService) Get(profileId int64, id int64) *TargetableRemarketingListsGetCall {
47521 c := &TargetableRemarketingListsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
47522 c.profileId = profileId
47523 c.id = id
47524 return c
47525 }
47526
47527
47528
47529
47530 func (c *TargetableRemarketingListsGetCall) Fields(s ...googleapi.Field) *TargetableRemarketingListsGetCall {
47531 c.urlParams_.Set("fields", googleapi.CombineFields(s))
47532 return c
47533 }
47534
47535
47536
47537
47538
47539
47540 func (c *TargetableRemarketingListsGetCall) IfNoneMatch(entityTag string) *TargetableRemarketingListsGetCall {
47541 c.ifNoneMatch_ = entityTag
47542 return c
47543 }
47544
47545
47546
47547
47548 func (c *TargetableRemarketingListsGetCall) Context(ctx context.Context) *TargetableRemarketingListsGetCall {
47549 c.ctx_ = ctx
47550 return c
47551 }
47552
47553
47554
47555 func (c *TargetableRemarketingListsGetCall) Header() http.Header {
47556 if c.header_ == nil {
47557 c.header_ = make(http.Header)
47558 }
47559 return c.header_
47560 }
47561
47562 func (c *TargetableRemarketingListsGetCall) doRequest(alt string) (*http.Response, error) {
47563 reqHeaders := make(http.Header)
47564 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
47565 for k, v := range c.header_ {
47566 reqHeaders[k] = v
47567 }
47568 reqHeaders.Set("User-Agent", c.s.userAgent())
47569 if c.ifNoneMatch_ != "" {
47570 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
47571 }
47572 var body io.Reader = nil
47573 c.urlParams_.Set("alt", alt)
47574 c.urlParams_.Set("prettyPrint", "false")
47575 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/targetableRemarketingLists/{id}")
47576 urls += "?" + c.urlParams_.Encode()
47577 req, err := http.NewRequest("GET", urls, body)
47578 if err != nil {
47579 return nil, err
47580 }
47581 req.Header = reqHeaders
47582 googleapi.Expand(req.URL, map[string]string{
47583 "profileId": strconv.FormatInt(c.profileId, 10),
47584 "id": strconv.FormatInt(c.id, 10),
47585 })
47586 return gensupport.SendRequest(c.ctx_, c.s.client, req)
47587 }
47588
47589
47590
47591
47592
47593
47594
47595
47596 func (c *TargetableRemarketingListsGetCall) Do(opts ...googleapi.CallOption) (*TargetableRemarketingList, error) {
47597 gensupport.SetOptions(c.urlParams_, opts...)
47598 res, err := c.doRequest("json")
47599 if res != nil && res.StatusCode == http.StatusNotModified {
47600 if res.Body != nil {
47601 res.Body.Close()
47602 }
47603 return nil, &googleapi.Error{
47604 Code: res.StatusCode,
47605 Header: res.Header,
47606 }
47607 }
47608 if err != nil {
47609 return nil, err
47610 }
47611 defer googleapi.CloseBody(res)
47612 if err := googleapi.CheckResponse(res); err != nil {
47613 return nil, err
47614 }
47615 ret := &TargetableRemarketingList{
47616 ServerResponse: googleapi.ServerResponse{
47617 Header: res.Header,
47618 HTTPStatusCode: res.StatusCode,
47619 },
47620 }
47621 target := &ret
47622 if err := gensupport.DecodeResponse(target, res); err != nil {
47623 return nil, err
47624 }
47625 return ret, nil
47626
47627
47628
47629
47630
47631
47632
47633
47634
47635
47636
47637
47638
47639
47640
47641
47642
47643
47644
47645
47646
47647
47648
47649
47650
47651
47652
47653
47654
47655
47656
47657
47658
47659 }
47660
47661
47662
47663 type TargetableRemarketingListsListCall struct {
47664 s *Service
47665 profileId int64
47666 urlParams_ gensupport.URLParams
47667 ifNoneMatch_ string
47668 ctx_ context.Context
47669 header_ http.Header
47670 }
47671
47672
47673
47674 func (r *TargetableRemarketingListsService) List(profileId int64, advertiserId int64) *TargetableRemarketingListsListCall {
47675 c := &TargetableRemarketingListsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
47676 c.profileId = profileId
47677 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
47678 return c
47679 }
47680
47681
47682
47683 func (c *TargetableRemarketingListsListCall) Active(active bool) *TargetableRemarketingListsListCall {
47684 c.urlParams_.Set("active", fmt.Sprint(active))
47685 return c
47686 }
47687
47688
47689
47690 func (c *TargetableRemarketingListsListCall) MaxResults(maxResults int64) *TargetableRemarketingListsListCall {
47691 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
47692 return c
47693 }
47694
47695
47696
47697
47698
47699
47700
47701
47702
47703 func (c *TargetableRemarketingListsListCall) Name(name string) *TargetableRemarketingListsListCall {
47704 c.urlParams_.Set("name", name)
47705 return c
47706 }
47707
47708
47709
47710 func (c *TargetableRemarketingListsListCall) PageToken(pageToken string) *TargetableRemarketingListsListCall {
47711 c.urlParams_.Set("pageToken", pageToken)
47712 return c
47713 }
47714
47715
47716
47717
47718
47719
47720
47721
47722 func (c *TargetableRemarketingListsListCall) SortField(sortField string) *TargetableRemarketingListsListCall {
47723 c.urlParams_.Set("sortField", sortField)
47724 return c
47725 }
47726
47727
47728
47729
47730
47731
47732
47733
47734 func (c *TargetableRemarketingListsListCall) SortOrder(sortOrder string) *TargetableRemarketingListsListCall {
47735 c.urlParams_.Set("sortOrder", sortOrder)
47736 return c
47737 }
47738
47739
47740
47741
47742 func (c *TargetableRemarketingListsListCall) Fields(s ...googleapi.Field) *TargetableRemarketingListsListCall {
47743 c.urlParams_.Set("fields", googleapi.CombineFields(s))
47744 return c
47745 }
47746
47747
47748
47749
47750
47751
47752 func (c *TargetableRemarketingListsListCall) IfNoneMatch(entityTag string) *TargetableRemarketingListsListCall {
47753 c.ifNoneMatch_ = entityTag
47754 return c
47755 }
47756
47757
47758
47759
47760 func (c *TargetableRemarketingListsListCall) Context(ctx context.Context) *TargetableRemarketingListsListCall {
47761 c.ctx_ = ctx
47762 return c
47763 }
47764
47765
47766
47767 func (c *TargetableRemarketingListsListCall) Header() http.Header {
47768 if c.header_ == nil {
47769 c.header_ = make(http.Header)
47770 }
47771 return c.header_
47772 }
47773
47774 func (c *TargetableRemarketingListsListCall) doRequest(alt string) (*http.Response, error) {
47775 reqHeaders := make(http.Header)
47776 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
47777 for k, v := range c.header_ {
47778 reqHeaders[k] = v
47779 }
47780 reqHeaders.Set("User-Agent", c.s.userAgent())
47781 if c.ifNoneMatch_ != "" {
47782 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
47783 }
47784 var body io.Reader = nil
47785 c.urlParams_.Set("alt", alt)
47786 c.urlParams_.Set("prettyPrint", "false")
47787 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/targetableRemarketingLists")
47788 urls += "?" + c.urlParams_.Encode()
47789 req, err := http.NewRequest("GET", urls, body)
47790 if err != nil {
47791 return nil, err
47792 }
47793 req.Header = reqHeaders
47794 googleapi.Expand(req.URL, map[string]string{
47795 "profileId": strconv.FormatInt(c.profileId, 10),
47796 })
47797 return gensupport.SendRequest(c.ctx_, c.s.client, req)
47798 }
47799
47800
47801
47802
47803
47804
47805
47806
47807
47808 func (c *TargetableRemarketingListsListCall) Do(opts ...googleapi.CallOption) (*TargetableRemarketingListsListResponse, error) {
47809 gensupport.SetOptions(c.urlParams_, opts...)
47810 res, err := c.doRequest("json")
47811 if res != nil && res.StatusCode == http.StatusNotModified {
47812 if res.Body != nil {
47813 res.Body.Close()
47814 }
47815 return nil, &googleapi.Error{
47816 Code: res.StatusCode,
47817 Header: res.Header,
47818 }
47819 }
47820 if err != nil {
47821 return nil, err
47822 }
47823 defer googleapi.CloseBody(res)
47824 if err := googleapi.CheckResponse(res); err != nil {
47825 return nil, err
47826 }
47827 ret := &TargetableRemarketingListsListResponse{
47828 ServerResponse: googleapi.ServerResponse{
47829 Header: res.Header,
47830 HTTPStatusCode: res.StatusCode,
47831 },
47832 }
47833 target := &ret
47834 if err := gensupport.DecodeResponse(target, res); err != nil {
47835 return nil, err
47836 }
47837 return ret, nil
47838
47839
47840
47841
47842
47843
47844
47845
47846
47847
47848
47849
47850
47851
47852
47853
47854
47855
47856
47857
47858
47859
47860
47861
47862
47863
47864
47865
47866
47867
47868
47869
47870
47871
47872
47873
47874
47875
47876
47877
47878
47879
47880
47881
47882
47883
47884
47885
47886
47887
47888
47889
47890
47891
47892
47893
47894
47895
47896
47897
47898
47899
47900
47901
47902
47903
47904
47905
47906
47907
47908
47909
47910
47911
47912
47913
47914
47915
47916
47917
47918
47919
47920
47921
47922
47923 }
47924
47925
47926
47927
47928 func (c *TargetableRemarketingListsListCall) Pages(ctx context.Context, f func(*TargetableRemarketingListsListResponse) error) error {
47929 c.ctx_ = ctx
47930 defer c.PageToken(c.urlParams_.Get("pageToken"))
47931 for {
47932 x, err := c.Do()
47933 if err != nil {
47934 return err
47935 }
47936 if err := f(x); err != nil {
47937 return err
47938 }
47939 if x.NextPageToken == "" {
47940 return nil
47941 }
47942 c.PageToken(x.NextPageToken)
47943 }
47944 }
47945
47946
47947
47948 type TargetingTemplatesGetCall struct {
47949 s *Service
47950 profileId int64
47951 id int64
47952 urlParams_ gensupport.URLParams
47953 ifNoneMatch_ string
47954 ctx_ context.Context
47955 header_ http.Header
47956 }
47957
47958
47959 func (r *TargetingTemplatesService) Get(profileId int64, id int64) *TargetingTemplatesGetCall {
47960 c := &TargetingTemplatesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
47961 c.profileId = profileId
47962 c.id = id
47963 return c
47964 }
47965
47966
47967
47968
47969 func (c *TargetingTemplatesGetCall) Fields(s ...googleapi.Field) *TargetingTemplatesGetCall {
47970 c.urlParams_.Set("fields", googleapi.CombineFields(s))
47971 return c
47972 }
47973
47974
47975
47976
47977
47978
47979 func (c *TargetingTemplatesGetCall) IfNoneMatch(entityTag string) *TargetingTemplatesGetCall {
47980 c.ifNoneMatch_ = entityTag
47981 return c
47982 }
47983
47984
47985
47986
47987 func (c *TargetingTemplatesGetCall) Context(ctx context.Context) *TargetingTemplatesGetCall {
47988 c.ctx_ = ctx
47989 return c
47990 }
47991
47992
47993
47994 func (c *TargetingTemplatesGetCall) Header() http.Header {
47995 if c.header_ == nil {
47996 c.header_ = make(http.Header)
47997 }
47998 return c.header_
47999 }
48000
48001 func (c *TargetingTemplatesGetCall) doRequest(alt string) (*http.Response, error) {
48002 reqHeaders := make(http.Header)
48003 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
48004 for k, v := range c.header_ {
48005 reqHeaders[k] = v
48006 }
48007 reqHeaders.Set("User-Agent", c.s.userAgent())
48008 if c.ifNoneMatch_ != "" {
48009 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
48010 }
48011 var body io.Reader = nil
48012 c.urlParams_.Set("alt", alt)
48013 c.urlParams_.Set("prettyPrint", "false")
48014 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/targetingTemplates/{id}")
48015 urls += "?" + c.urlParams_.Encode()
48016 req, err := http.NewRequest("GET", urls, body)
48017 if err != nil {
48018 return nil, err
48019 }
48020 req.Header = reqHeaders
48021 googleapi.Expand(req.URL, map[string]string{
48022 "profileId": strconv.FormatInt(c.profileId, 10),
48023 "id": strconv.FormatInt(c.id, 10),
48024 })
48025 return gensupport.SendRequest(c.ctx_, c.s.client, req)
48026 }
48027
48028
48029
48030
48031
48032
48033
48034
48035 func (c *TargetingTemplatesGetCall) Do(opts ...googleapi.CallOption) (*TargetingTemplate, error) {
48036 gensupport.SetOptions(c.urlParams_, opts...)
48037 res, err := c.doRequest("json")
48038 if res != nil && res.StatusCode == http.StatusNotModified {
48039 if res.Body != nil {
48040 res.Body.Close()
48041 }
48042 return nil, &googleapi.Error{
48043 Code: res.StatusCode,
48044 Header: res.Header,
48045 }
48046 }
48047 if err != nil {
48048 return nil, err
48049 }
48050 defer googleapi.CloseBody(res)
48051 if err := googleapi.CheckResponse(res); err != nil {
48052 return nil, err
48053 }
48054 ret := &TargetingTemplate{
48055 ServerResponse: googleapi.ServerResponse{
48056 Header: res.Header,
48057 HTTPStatusCode: res.StatusCode,
48058 },
48059 }
48060 target := &ret
48061 if err := gensupport.DecodeResponse(target, res); err != nil {
48062 return nil, err
48063 }
48064 return ret, nil
48065
48066
48067
48068
48069
48070
48071
48072
48073
48074
48075
48076
48077
48078
48079
48080
48081
48082
48083
48084
48085
48086
48087
48088
48089
48090
48091
48092
48093
48094
48095
48096
48097
48098 }
48099
48100
48101
48102 type TargetingTemplatesInsertCall struct {
48103 s *Service
48104 profileId int64
48105 targetingtemplate *TargetingTemplate
48106 urlParams_ gensupport.URLParams
48107 ctx_ context.Context
48108 header_ http.Header
48109 }
48110
48111
48112 func (r *TargetingTemplatesService) Insert(profileId int64, targetingtemplate *TargetingTemplate) *TargetingTemplatesInsertCall {
48113 c := &TargetingTemplatesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
48114 c.profileId = profileId
48115 c.targetingtemplate = targetingtemplate
48116 return c
48117 }
48118
48119
48120
48121
48122 func (c *TargetingTemplatesInsertCall) Fields(s ...googleapi.Field) *TargetingTemplatesInsertCall {
48123 c.urlParams_.Set("fields", googleapi.CombineFields(s))
48124 return c
48125 }
48126
48127
48128
48129
48130 func (c *TargetingTemplatesInsertCall) Context(ctx context.Context) *TargetingTemplatesInsertCall {
48131 c.ctx_ = ctx
48132 return c
48133 }
48134
48135
48136
48137 func (c *TargetingTemplatesInsertCall) Header() http.Header {
48138 if c.header_ == nil {
48139 c.header_ = make(http.Header)
48140 }
48141 return c.header_
48142 }
48143
48144 func (c *TargetingTemplatesInsertCall) doRequest(alt string) (*http.Response, error) {
48145 reqHeaders := make(http.Header)
48146 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
48147 for k, v := range c.header_ {
48148 reqHeaders[k] = v
48149 }
48150 reqHeaders.Set("User-Agent", c.s.userAgent())
48151 var body io.Reader = nil
48152 body, err := googleapi.WithoutDataWrapper.JSONReader(c.targetingtemplate)
48153 if err != nil {
48154 return nil, err
48155 }
48156 reqHeaders.Set("Content-Type", "application/json")
48157 c.urlParams_.Set("alt", alt)
48158 c.urlParams_.Set("prettyPrint", "false")
48159 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/targetingTemplates")
48160 urls += "?" + c.urlParams_.Encode()
48161 req, err := http.NewRequest("POST", urls, body)
48162 if err != nil {
48163 return nil, err
48164 }
48165 req.Header = reqHeaders
48166 googleapi.Expand(req.URL, map[string]string{
48167 "profileId": strconv.FormatInt(c.profileId, 10),
48168 })
48169 return gensupport.SendRequest(c.ctx_, c.s.client, req)
48170 }
48171
48172
48173
48174
48175
48176
48177
48178
48179 func (c *TargetingTemplatesInsertCall) Do(opts ...googleapi.CallOption) (*TargetingTemplate, error) {
48180 gensupport.SetOptions(c.urlParams_, opts...)
48181 res, err := c.doRequest("json")
48182 if res != nil && res.StatusCode == http.StatusNotModified {
48183 if res.Body != nil {
48184 res.Body.Close()
48185 }
48186 return nil, &googleapi.Error{
48187 Code: res.StatusCode,
48188 Header: res.Header,
48189 }
48190 }
48191 if err != nil {
48192 return nil, err
48193 }
48194 defer googleapi.CloseBody(res)
48195 if err := googleapi.CheckResponse(res); err != nil {
48196 return nil, err
48197 }
48198 ret := &TargetingTemplate{
48199 ServerResponse: googleapi.ServerResponse{
48200 Header: res.Header,
48201 HTTPStatusCode: res.StatusCode,
48202 },
48203 }
48204 target := &ret
48205 if err := gensupport.DecodeResponse(target, res); err != nil {
48206 return nil, err
48207 }
48208 return ret, nil
48209
48210
48211
48212
48213
48214
48215
48216
48217
48218
48219
48220
48221
48222
48223
48224
48225
48226
48227
48228
48229
48230
48231
48232
48233
48234
48235
48236
48237 }
48238
48239
48240
48241 type TargetingTemplatesListCall struct {
48242 s *Service
48243 profileId int64
48244 urlParams_ gensupport.URLParams
48245 ifNoneMatch_ string
48246 ctx_ context.Context
48247 header_ http.Header
48248 }
48249
48250
48251
48252 func (r *TargetingTemplatesService) List(profileId int64) *TargetingTemplatesListCall {
48253 c := &TargetingTemplatesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
48254 c.profileId = profileId
48255 return c
48256 }
48257
48258
48259
48260 func (c *TargetingTemplatesListCall) AdvertiserId(advertiserId int64) *TargetingTemplatesListCall {
48261 c.urlParams_.Set("advertiserId", fmt.Sprint(advertiserId))
48262 return c
48263 }
48264
48265
48266
48267 func (c *TargetingTemplatesListCall) Ids(ids ...int64) *TargetingTemplatesListCall {
48268 var ids_ []string
48269 for _, v := range ids {
48270 ids_ = append(ids_, fmt.Sprint(v))
48271 }
48272 c.urlParams_.SetMulti("ids", ids_)
48273 return c
48274 }
48275
48276
48277
48278 func (c *TargetingTemplatesListCall) MaxResults(maxResults int64) *TargetingTemplatesListCall {
48279 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
48280 return c
48281 }
48282
48283
48284
48285 func (c *TargetingTemplatesListCall) PageToken(pageToken string) *TargetingTemplatesListCall {
48286 c.urlParams_.Set("pageToken", pageToken)
48287 return c
48288 }
48289
48290
48291
48292
48293
48294
48295
48296
48297
48298 func (c *TargetingTemplatesListCall) SearchString(searchString string) *TargetingTemplatesListCall {
48299 c.urlParams_.Set("searchString", searchString)
48300 return c
48301 }
48302
48303
48304
48305
48306
48307
48308
48309
48310 func (c *TargetingTemplatesListCall) SortField(sortField string) *TargetingTemplatesListCall {
48311 c.urlParams_.Set("sortField", sortField)
48312 return c
48313 }
48314
48315
48316
48317
48318
48319
48320
48321
48322 func (c *TargetingTemplatesListCall) SortOrder(sortOrder string) *TargetingTemplatesListCall {
48323 c.urlParams_.Set("sortOrder", sortOrder)
48324 return c
48325 }
48326
48327
48328
48329
48330 func (c *TargetingTemplatesListCall) Fields(s ...googleapi.Field) *TargetingTemplatesListCall {
48331 c.urlParams_.Set("fields", googleapi.CombineFields(s))
48332 return c
48333 }
48334
48335
48336
48337
48338
48339
48340 func (c *TargetingTemplatesListCall) IfNoneMatch(entityTag string) *TargetingTemplatesListCall {
48341 c.ifNoneMatch_ = entityTag
48342 return c
48343 }
48344
48345
48346
48347
48348 func (c *TargetingTemplatesListCall) Context(ctx context.Context) *TargetingTemplatesListCall {
48349 c.ctx_ = ctx
48350 return c
48351 }
48352
48353
48354
48355 func (c *TargetingTemplatesListCall) Header() http.Header {
48356 if c.header_ == nil {
48357 c.header_ = make(http.Header)
48358 }
48359 return c.header_
48360 }
48361
48362 func (c *TargetingTemplatesListCall) doRequest(alt string) (*http.Response, error) {
48363 reqHeaders := make(http.Header)
48364 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
48365 for k, v := range c.header_ {
48366 reqHeaders[k] = v
48367 }
48368 reqHeaders.Set("User-Agent", c.s.userAgent())
48369 if c.ifNoneMatch_ != "" {
48370 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
48371 }
48372 var body io.Reader = nil
48373 c.urlParams_.Set("alt", alt)
48374 c.urlParams_.Set("prettyPrint", "false")
48375 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/targetingTemplates")
48376 urls += "?" + c.urlParams_.Encode()
48377 req, err := http.NewRequest("GET", urls, body)
48378 if err != nil {
48379 return nil, err
48380 }
48381 req.Header = reqHeaders
48382 googleapi.Expand(req.URL, map[string]string{
48383 "profileId": strconv.FormatInt(c.profileId, 10),
48384 })
48385 return gensupport.SendRequest(c.ctx_, c.s.client, req)
48386 }
48387
48388
48389
48390
48391
48392
48393
48394
48395 func (c *TargetingTemplatesListCall) Do(opts ...googleapi.CallOption) (*TargetingTemplatesListResponse, error) {
48396 gensupport.SetOptions(c.urlParams_, opts...)
48397 res, err := c.doRequest("json")
48398 if res != nil && res.StatusCode == http.StatusNotModified {
48399 if res.Body != nil {
48400 res.Body.Close()
48401 }
48402 return nil, &googleapi.Error{
48403 Code: res.StatusCode,
48404 Header: res.Header,
48405 }
48406 }
48407 if err != nil {
48408 return nil, err
48409 }
48410 defer googleapi.CloseBody(res)
48411 if err := googleapi.CheckResponse(res); err != nil {
48412 return nil, err
48413 }
48414 ret := &TargetingTemplatesListResponse{
48415 ServerResponse: googleapi.ServerResponse{
48416 Header: res.Header,
48417 HTTPStatusCode: res.StatusCode,
48418 },
48419 }
48420 target := &ret
48421 if err := gensupport.DecodeResponse(target, res); err != nil {
48422 return nil, err
48423 }
48424 return ret, nil
48425
48426
48427
48428
48429
48430
48431
48432
48433
48434
48435
48436
48437
48438
48439
48440
48441
48442
48443
48444
48445
48446
48447
48448
48449
48450
48451
48452
48453
48454
48455
48456
48457
48458
48459
48460
48461
48462
48463
48464
48465
48466
48467
48468
48469
48470
48471
48472
48473
48474
48475
48476
48477
48478
48479
48480
48481
48482
48483
48484
48485
48486
48487
48488
48489
48490
48491
48492
48493
48494
48495
48496
48497
48498
48499
48500
48501
48502
48503
48504
48505
48506
48507
48508
48509
48510 }
48511
48512
48513
48514
48515 func (c *TargetingTemplatesListCall) Pages(ctx context.Context, f func(*TargetingTemplatesListResponse) error) error {
48516 c.ctx_ = ctx
48517 defer c.PageToken(c.urlParams_.Get("pageToken"))
48518 for {
48519 x, err := c.Do()
48520 if err != nil {
48521 return err
48522 }
48523 if err := f(x); err != nil {
48524 return err
48525 }
48526 if x.NextPageToken == "" {
48527 return nil
48528 }
48529 c.PageToken(x.NextPageToken)
48530 }
48531 }
48532
48533
48534
48535 type TargetingTemplatesPatchCall struct {
48536 s *Service
48537 profileId int64
48538 targetingtemplate *TargetingTemplate
48539 urlParams_ gensupport.URLParams
48540 ctx_ context.Context
48541 header_ http.Header
48542 }
48543
48544
48545
48546 func (r *TargetingTemplatesService) Patch(profileId int64, id int64, targetingtemplate *TargetingTemplate) *TargetingTemplatesPatchCall {
48547 c := &TargetingTemplatesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
48548 c.profileId = profileId
48549 c.urlParams_.Set("id", fmt.Sprint(id))
48550 c.targetingtemplate = targetingtemplate
48551 return c
48552 }
48553
48554
48555
48556
48557 func (c *TargetingTemplatesPatchCall) Fields(s ...googleapi.Field) *TargetingTemplatesPatchCall {
48558 c.urlParams_.Set("fields", googleapi.CombineFields(s))
48559 return c
48560 }
48561
48562
48563
48564
48565 func (c *TargetingTemplatesPatchCall) Context(ctx context.Context) *TargetingTemplatesPatchCall {
48566 c.ctx_ = ctx
48567 return c
48568 }
48569
48570
48571
48572 func (c *TargetingTemplatesPatchCall) Header() http.Header {
48573 if c.header_ == nil {
48574 c.header_ = make(http.Header)
48575 }
48576 return c.header_
48577 }
48578
48579 func (c *TargetingTemplatesPatchCall) doRequest(alt string) (*http.Response, error) {
48580 reqHeaders := make(http.Header)
48581 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
48582 for k, v := range c.header_ {
48583 reqHeaders[k] = v
48584 }
48585 reqHeaders.Set("User-Agent", c.s.userAgent())
48586 var body io.Reader = nil
48587 body, err := googleapi.WithoutDataWrapper.JSONReader(c.targetingtemplate)
48588 if err != nil {
48589 return nil, err
48590 }
48591 reqHeaders.Set("Content-Type", "application/json")
48592 c.urlParams_.Set("alt", alt)
48593 c.urlParams_.Set("prettyPrint", "false")
48594 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/targetingTemplates")
48595 urls += "?" + c.urlParams_.Encode()
48596 req, err := http.NewRequest("PATCH", urls, body)
48597 if err != nil {
48598 return nil, err
48599 }
48600 req.Header = reqHeaders
48601 googleapi.Expand(req.URL, map[string]string{
48602 "profileId": strconv.FormatInt(c.profileId, 10),
48603 })
48604 return gensupport.SendRequest(c.ctx_, c.s.client, req)
48605 }
48606
48607
48608
48609
48610
48611
48612
48613
48614 func (c *TargetingTemplatesPatchCall) Do(opts ...googleapi.CallOption) (*TargetingTemplate, error) {
48615 gensupport.SetOptions(c.urlParams_, opts...)
48616 res, err := c.doRequest("json")
48617 if res != nil && res.StatusCode == http.StatusNotModified {
48618 if res.Body != nil {
48619 res.Body.Close()
48620 }
48621 return nil, &googleapi.Error{
48622 Code: res.StatusCode,
48623 Header: res.Header,
48624 }
48625 }
48626 if err != nil {
48627 return nil, err
48628 }
48629 defer googleapi.CloseBody(res)
48630 if err := googleapi.CheckResponse(res); err != nil {
48631 return nil, err
48632 }
48633 ret := &TargetingTemplate{
48634 ServerResponse: googleapi.ServerResponse{
48635 Header: res.Header,
48636 HTTPStatusCode: res.StatusCode,
48637 },
48638 }
48639 target := &ret
48640 if err := gensupport.DecodeResponse(target, res); err != nil {
48641 return nil, err
48642 }
48643 return ret, nil
48644
48645
48646
48647
48648
48649
48650
48651
48652
48653
48654
48655
48656
48657
48658
48659
48660
48661
48662
48663
48664
48665
48666
48667
48668
48669
48670
48671
48672
48673
48674
48675
48676
48677
48678
48679
48680 }
48681
48682
48683
48684 type TargetingTemplatesUpdateCall struct {
48685 s *Service
48686 profileId int64
48687 targetingtemplate *TargetingTemplate
48688 urlParams_ gensupport.URLParams
48689 ctx_ context.Context
48690 header_ http.Header
48691 }
48692
48693
48694 func (r *TargetingTemplatesService) Update(profileId int64, targetingtemplate *TargetingTemplate) *TargetingTemplatesUpdateCall {
48695 c := &TargetingTemplatesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
48696 c.profileId = profileId
48697 c.targetingtemplate = targetingtemplate
48698 return c
48699 }
48700
48701
48702
48703
48704 func (c *TargetingTemplatesUpdateCall) Fields(s ...googleapi.Field) *TargetingTemplatesUpdateCall {
48705 c.urlParams_.Set("fields", googleapi.CombineFields(s))
48706 return c
48707 }
48708
48709
48710
48711
48712 func (c *TargetingTemplatesUpdateCall) Context(ctx context.Context) *TargetingTemplatesUpdateCall {
48713 c.ctx_ = ctx
48714 return c
48715 }
48716
48717
48718
48719 func (c *TargetingTemplatesUpdateCall) Header() http.Header {
48720 if c.header_ == nil {
48721 c.header_ = make(http.Header)
48722 }
48723 return c.header_
48724 }
48725
48726 func (c *TargetingTemplatesUpdateCall) doRequest(alt string) (*http.Response, error) {
48727 reqHeaders := make(http.Header)
48728 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
48729 for k, v := range c.header_ {
48730 reqHeaders[k] = v
48731 }
48732 reqHeaders.Set("User-Agent", c.s.userAgent())
48733 var body io.Reader = nil
48734 body, err := googleapi.WithoutDataWrapper.JSONReader(c.targetingtemplate)
48735 if err != nil {
48736 return nil, err
48737 }
48738 reqHeaders.Set("Content-Type", "application/json")
48739 c.urlParams_.Set("alt", alt)
48740 c.urlParams_.Set("prettyPrint", "false")
48741 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/targetingTemplates")
48742 urls += "?" + c.urlParams_.Encode()
48743 req, err := http.NewRequest("PUT", urls, body)
48744 if err != nil {
48745 return nil, err
48746 }
48747 req.Header = reqHeaders
48748 googleapi.Expand(req.URL, map[string]string{
48749 "profileId": strconv.FormatInt(c.profileId, 10),
48750 })
48751 return gensupport.SendRequest(c.ctx_, c.s.client, req)
48752 }
48753
48754
48755
48756
48757
48758
48759
48760
48761 func (c *TargetingTemplatesUpdateCall) Do(opts ...googleapi.CallOption) (*TargetingTemplate, error) {
48762 gensupport.SetOptions(c.urlParams_, opts...)
48763 res, err := c.doRequest("json")
48764 if res != nil && res.StatusCode == http.StatusNotModified {
48765 if res.Body != nil {
48766 res.Body.Close()
48767 }
48768 return nil, &googleapi.Error{
48769 Code: res.StatusCode,
48770 Header: res.Header,
48771 }
48772 }
48773 if err != nil {
48774 return nil, err
48775 }
48776 defer googleapi.CloseBody(res)
48777 if err := googleapi.CheckResponse(res); err != nil {
48778 return nil, err
48779 }
48780 ret := &TargetingTemplate{
48781 ServerResponse: googleapi.ServerResponse{
48782 Header: res.Header,
48783 HTTPStatusCode: res.StatusCode,
48784 },
48785 }
48786 target := &ret
48787 if err := gensupport.DecodeResponse(target, res); err != nil {
48788 return nil, err
48789 }
48790 return ret, nil
48791
48792
48793
48794
48795
48796
48797
48798
48799
48800
48801
48802
48803
48804
48805
48806
48807
48808
48809
48810
48811
48812
48813
48814
48815
48816
48817
48818
48819 }
48820
48821
48822
48823 type UserProfilesGetCall struct {
48824 s *Service
48825 profileId int64
48826 urlParams_ gensupport.URLParams
48827 ifNoneMatch_ string
48828 ctx_ context.Context
48829 header_ http.Header
48830 }
48831
48832
48833 func (r *UserProfilesService) Get(profileId int64) *UserProfilesGetCall {
48834 c := &UserProfilesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
48835 c.profileId = profileId
48836 return c
48837 }
48838
48839
48840
48841
48842 func (c *UserProfilesGetCall) Fields(s ...googleapi.Field) *UserProfilesGetCall {
48843 c.urlParams_.Set("fields", googleapi.CombineFields(s))
48844 return c
48845 }
48846
48847
48848
48849
48850
48851
48852 func (c *UserProfilesGetCall) IfNoneMatch(entityTag string) *UserProfilesGetCall {
48853 c.ifNoneMatch_ = entityTag
48854 return c
48855 }
48856
48857
48858
48859
48860 func (c *UserProfilesGetCall) Context(ctx context.Context) *UserProfilesGetCall {
48861 c.ctx_ = ctx
48862 return c
48863 }
48864
48865
48866
48867 func (c *UserProfilesGetCall) Header() http.Header {
48868 if c.header_ == nil {
48869 c.header_ = make(http.Header)
48870 }
48871 return c.header_
48872 }
48873
48874 func (c *UserProfilesGetCall) doRequest(alt string) (*http.Response, error) {
48875 reqHeaders := make(http.Header)
48876 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
48877 for k, v := range c.header_ {
48878 reqHeaders[k] = v
48879 }
48880 reqHeaders.Set("User-Agent", c.s.userAgent())
48881 if c.ifNoneMatch_ != "" {
48882 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
48883 }
48884 var body io.Reader = nil
48885 c.urlParams_.Set("alt", alt)
48886 c.urlParams_.Set("prettyPrint", "false")
48887 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}")
48888 urls += "?" + c.urlParams_.Encode()
48889 req, err := http.NewRequest("GET", urls, body)
48890 if err != nil {
48891 return nil, err
48892 }
48893 req.Header = reqHeaders
48894 googleapi.Expand(req.URL, map[string]string{
48895 "profileId": strconv.FormatInt(c.profileId, 10),
48896 })
48897 return gensupport.SendRequest(c.ctx_, c.s.client, req)
48898 }
48899
48900
48901
48902
48903
48904
48905
48906
48907 func (c *UserProfilesGetCall) Do(opts ...googleapi.CallOption) (*UserProfile, error) {
48908 gensupport.SetOptions(c.urlParams_, opts...)
48909 res, err := c.doRequest("json")
48910 if res != nil && res.StatusCode == http.StatusNotModified {
48911 if res.Body != nil {
48912 res.Body.Close()
48913 }
48914 return nil, &googleapi.Error{
48915 Code: res.StatusCode,
48916 Header: res.Header,
48917 }
48918 }
48919 if err != nil {
48920 return nil, err
48921 }
48922 defer googleapi.CloseBody(res)
48923 if err := googleapi.CheckResponse(res); err != nil {
48924 return nil, err
48925 }
48926 ret := &UserProfile{
48927 ServerResponse: googleapi.ServerResponse{
48928 Header: res.Header,
48929 HTTPStatusCode: res.StatusCode,
48930 },
48931 }
48932 target := &ret
48933 if err := gensupport.DecodeResponse(target, res); err != nil {
48934 return nil, err
48935 }
48936 return ret, nil
48937
48938
48939
48940
48941
48942
48943
48944
48945
48946
48947
48948
48949
48950
48951
48952
48953
48954
48955
48956
48957
48958
48959
48960
48961
48962
48963 }
48964
48965
48966
48967 type UserProfilesListCall struct {
48968 s *Service
48969 urlParams_ gensupport.URLParams
48970 ifNoneMatch_ string
48971 ctx_ context.Context
48972 header_ http.Header
48973 }
48974
48975
48976 func (r *UserProfilesService) List() *UserProfilesListCall {
48977 c := &UserProfilesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
48978 return c
48979 }
48980
48981
48982
48983
48984 func (c *UserProfilesListCall) Fields(s ...googleapi.Field) *UserProfilesListCall {
48985 c.urlParams_.Set("fields", googleapi.CombineFields(s))
48986 return c
48987 }
48988
48989
48990
48991
48992
48993
48994 func (c *UserProfilesListCall) IfNoneMatch(entityTag string) *UserProfilesListCall {
48995 c.ifNoneMatch_ = entityTag
48996 return c
48997 }
48998
48999
49000
49001
49002 func (c *UserProfilesListCall) Context(ctx context.Context) *UserProfilesListCall {
49003 c.ctx_ = ctx
49004 return c
49005 }
49006
49007
49008
49009 func (c *UserProfilesListCall) Header() http.Header {
49010 if c.header_ == nil {
49011 c.header_ = make(http.Header)
49012 }
49013 return c.header_
49014 }
49015
49016 func (c *UserProfilesListCall) doRequest(alt string) (*http.Response, error) {
49017 reqHeaders := make(http.Header)
49018 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
49019 for k, v := range c.header_ {
49020 reqHeaders[k] = v
49021 }
49022 reqHeaders.Set("User-Agent", c.s.userAgent())
49023 if c.ifNoneMatch_ != "" {
49024 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
49025 }
49026 var body io.Reader = nil
49027 c.urlParams_.Set("alt", alt)
49028 c.urlParams_.Set("prettyPrint", "false")
49029 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles")
49030 urls += "?" + c.urlParams_.Encode()
49031 req, err := http.NewRequest("GET", urls, body)
49032 if err != nil {
49033 return nil, err
49034 }
49035 req.Header = reqHeaders
49036 return gensupport.SendRequest(c.ctx_, c.s.client, req)
49037 }
49038
49039
49040
49041
49042
49043
49044
49045
49046 func (c *UserProfilesListCall) Do(opts ...googleapi.CallOption) (*UserProfileList, error) {
49047 gensupport.SetOptions(c.urlParams_, opts...)
49048 res, err := c.doRequest("json")
49049 if res != nil && res.StatusCode == http.StatusNotModified {
49050 if res.Body != nil {
49051 res.Body.Close()
49052 }
49053 return nil, &googleapi.Error{
49054 Code: res.StatusCode,
49055 Header: res.Header,
49056 }
49057 }
49058 if err != nil {
49059 return nil, err
49060 }
49061 defer googleapi.CloseBody(res)
49062 if err := googleapi.CheckResponse(res); err != nil {
49063 return nil, err
49064 }
49065 ret := &UserProfileList{
49066 ServerResponse: googleapi.ServerResponse{
49067 Header: res.Header,
49068 HTTPStatusCode: res.StatusCode,
49069 },
49070 }
49071 target := &ret
49072 if err := gensupport.DecodeResponse(target, res); err != nil {
49073 return nil, err
49074 }
49075 return ret, nil
49076
49077
49078
49079
49080
49081
49082
49083
49084
49085
49086
49087
49088
49089
49090 }
49091
49092
49093
49094 type UserRolePermissionGroupsGetCall struct {
49095 s *Service
49096 profileId int64
49097 id int64
49098 urlParams_ gensupport.URLParams
49099 ifNoneMatch_ string
49100 ctx_ context.Context
49101 header_ http.Header
49102 }
49103
49104
49105 func (r *UserRolePermissionGroupsService) Get(profileId int64, id int64) *UserRolePermissionGroupsGetCall {
49106 c := &UserRolePermissionGroupsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
49107 c.profileId = profileId
49108 c.id = id
49109 return c
49110 }
49111
49112
49113
49114
49115 func (c *UserRolePermissionGroupsGetCall) Fields(s ...googleapi.Field) *UserRolePermissionGroupsGetCall {
49116 c.urlParams_.Set("fields", googleapi.CombineFields(s))
49117 return c
49118 }
49119
49120
49121
49122
49123
49124
49125 func (c *UserRolePermissionGroupsGetCall) IfNoneMatch(entityTag string) *UserRolePermissionGroupsGetCall {
49126 c.ifNoneMatch_ = entityTag
49127 return c
49128 }
49129
49130
49131
49132
49133 func (c *UserRolePermissionGroupsGetCall) Context(ctx context.Context) *UserRolePermissionGroupsGetCall {
49134 c.ctx_ = ctx
49135 return c
49136 }
49137
49138
49139
49140 func (c *UserRolePermissionGroupsGetCall) Header() http.Header {
49141 if c.header_ == nil {
49142 c.header_ = make(http.Header)
49143 }
49144 return c.header_
49145 }
49146
49147 func (c *UserRolePermissionGroupsGetCall) doRequest(alt string) (*http.Response, error) {
49148 reqHeaders := make(http.Header)
49149 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
49150 for k, v := range c.header_ {
49151 reqHeaders[k] = v
49152 }
49153 reqHeaders.Set("User-Agent", c.s.userAgent())
49154 if c.ifNoneMatch_ != "" {
49155 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
49156 }
49157 var body io.Reader = nil
49158 c.urlParams_.Set("alt", alt)
49159 c.urlParams_.Set("prettyPrint", "false")
49160 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRolePermissionGroups/{id}")
49161 urls += "?" + c.urlParams_.Encode()
49162 req, err := http.NewRequest("GET", urls, body)
49163 if err != nil {
49164 return nil, err
49165 }
49166 req.Header = reqHeaders
49167 googleapi.Expand(req.URL, map[string]string{
49168 "profileId": strconv.FormatInt(c.profileId, 10),
49169 "id": strconv.FormatInt(c.id, 10),
49170 })
49171 return gensupport.SendRequest(c.ctx_, c.s.client, req)
49172 }
49173
49174
49175
49176
49177
49178
49179
49180
49181 func (c *UserRolePermissionGroupsGetCall) Do(opts ...googleapi.CallOption) (*UserRolePermissionGroup, error) {
49182 gensupport.SetOptions(c.urlParams_, opts...)
49183 res, err := c.doRequest("json")
49184 if res != nil && res.StatusCode == http.StatusNotModified {
49185 if res.Body != nil {
49186 res.Body.Close()
49187 }
49188 return nil, &googleapi.Error{
49189 Code: res.StatusCode,
49190 Header: res.Header,
49191 }
49192 }
49193 if err != nil {
49194 return nil, err
49195 }
49196 defer googleapi.CloseBody(res)
49197 if err := googleapi.CheckResponse(res); err != nil {
49198 return nil, err
49199 }
49200 ret := &UserRolePermissionGroup{
49201 ServerResponse: googleapi.ServerResponse{
49202 Header: res.Header,
49203 HTTPStatusCode: res.StatusCode,
49204 },
49205 }
49206 target := &ret
49207 if err := gensupport.DecodeResponse(target, res); err != nil {
49208 return nil, err
49209 }
49210 return ret, nil
49211
49212
49213
49214
49215
49216
49217
49218
49219
49220
49221
49222
49223
49224
49225
49226
49227
49228
49229
49230
49231
49232
49233
49234
49235
49236
49237
49238
49239
49240
49241
49242
49243
49244 }
49245
49246
49247
49248 type UserRolePermissionGroupsListCall struct {
49249 s *Service
49250 profileId int64
49251 urlParams_ gensupport.URLParams
49252 ifNoneMatch_ string
49253 ctx_ context.Context
49254 header_ http.Header
49255 }
49256
49257
49258 func (r *UserRolePermissionGroupsService) List(profileId int64) *UserRolePermissionGroupsListCall {
49259 c := &UserRolePermissionGroupsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
49260 c.profileId = profileId
49261 return c
49262 }
49263
49264
49265
49266
49267 func (c *UserRolePermissionGroupsListCall) Fields(s ...googleapi.Field) *UserRolePermissionGroupsListCall {
49268 c.urlParams_.Set("fields", googleapi.CombineFields(s))
49269 return c
49270 }
49271
49272
49273
49274
49275
49276
49277 func (c *UserRolePermissionGroupsListCall) IfNoneMatch(entityTag string) *UserRolePermissionGroupsListCall {
49278 c.ifNoneMatch_ = entityTag
49279 return c
49280 }
49281
49282
49283
49284
49285 func (c *UserRolePermissionGroupsListCall) Context(ctx context.Context) *UserRolePermissionGroupsListCall {
49286 c.ctx_ = ctx
49287 return c
49288 }
49289
49290
49291
49292 func (c *UserRolePermissionGroupsListCall) Header() http.Header {
49293 if c.header_ == nil {
49294 c.header_ = make(http.Header)
49295 }
49296 return c.header_
49297 }
49298
49299 func (c *UserRolePermissionGroupsListCall) doRequest(alt string) (*http.Response, error) {
49300 reqHeaders := make(http.Header)
49301 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
49302 for k, v := range c.header_ {
49303 reqHeaders[k] = v
49304 }
49305 reqHeaders.Set("User-Agent", c.s.userAgent())
49306 if c.ifNoneMatch_ != "" {
49307 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
49308 }
49309 var body io.Reader = nil
49310 c.urlParams_.Set("alt", alt)
49311 c.urlParams_.Set("prettyPrint", "false")
49312 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRolePermissionGroups")
49313 urls += "?" + c.urlParams_.Encode()
49314 req, err := http.NewRequest("GET", urls, body)
49315 if err != nil {
49316 return nil, err
49317 }
49318 req.Header = reqHeaders
49319 googleapi.Expand(req.URL, map[string]string{
49320 "profileId": strconv.FormatInt(c.profileId, 10),
49321 })
49322 return gensupport.SendRequest(c.ctx_, c.s.client, req)
49323 }
49324
49325
49326
49327
49328
49329
49330
49331
49332
49333 func (c *UserRolePermissionGroupsListCall) Do(opts ...googleapi.CallOption) (*UserRolePermissionGroupsListResponse, error) {
49334 gensupport.SetOptions(c.urlParams_, opts...)
49335 res, err := c.doRequest("json")
49336 if res != nil && res.StatusCode == http.StatusNotModified {
49337 if res.Body != nil {
49338 res.Body.Close()
49339 }
49340 return nil, &googleapi.Error{
49341 Code: res.StatusCode,
49342 Header: res.Header,
49343 }
49344 }
49345 if err != nil {
49346 return nil, err
49347 }
49348 defer googleapi.CloseBody(res)
49349 if err := googleapi.CheckResponse(res); err != nil {
49350 return nil, err
49351 }
49352 ret := &UserRolePermissionGroupsListResponse{
49353 ServerResponse: googleapi.ServerResponse{
49354 Header: res.Header,
49355 HTTPStatusCode: res.StatusCode,
49356 },
49357 }
49358 target := &ret
49359 if err := gensupport.DecodeResponse(target, res); err != nil {
49360 return nil, err
49361 }
49362 return ret, nil
49363
49364
49365
49366
49367
49368
49369
49370
49371
49372
49373
49374
49375
49376
49377
49378
49379
49380
49381
49382
49383
49384
49385
49386
49387
49388 }
49389
49390
49391
49392 type UserRolePermissionsGetCall struct {
49393 s *Service
49394 profileId int64
49395 id int64
49396 urlParams_ gensupport.URLParams
49397 ifNoneMatch_ string
49398 ctx_ context.Context
49399 header_ http.Header
49400 }
49401
49402
49403 func (r *UserRolePermissionsService) Get(profileId int64, id int64) *UserRolePermissionsGetCall {
49404 c := &UserRolePermissionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
49405 c.profileId = profileId
49406 c.id = id
49407 return c
49408 }
49409
49410
49411
49412
49413 func (c *UserRolePermissionsGetCall) Fields(s ...googleapi.Field) *UserRolePermissionsGetCall {
49414 c.urlParams_.Set("fields", googleapi.CombineFields(s))
49415 return c
49416 }
49417
49418
49419
49420
49421
49422
49423 func (c *UserRolePermissionsGetCall) IfNoneMatch(entityTag string) *UserRolePermissionsGetCall {
49424 c.ifNoneMatch_ = entityTag
49425 return c
49426 }
49427
49428
49429
49430
49431 func (c *UserRolePermissionsGetCall) Context(ctx context.Context) *UserRolePermissionsGetCall {
49432 c.ctx_ = ctx
49433 return c
49434 }
49435
49436
49437
49438 func (c *UserRolePermissionsGetCall) Header() http.Header {
49439 if c.header_ == nil {
49440 c.header_ = make(http.Header)
49441 }
49442 return c.header_
49443 }
49444
49445 func (c *UserRolePermissionsGetCall) doRequest(alt string) (*http.Response, error) {
49446 reqHeaders := make(http.Header)
49447 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
49448 for k, v := range c.header_ {
49449 reqHeaders[k] = v
49450 }
49451 reqHeaders.Set("User-Agent", c.s.userAgent())
49452 if c.ifNoneMatch_ != "" {
49453 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
49454 }
49455 var body io.Reader = nil
49456 c.urlParams_.Set("alt", alt)
49457 c.urlParams_.Set("prettyPrint", "false")
49458 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRolePermissions/{id}")
49459 urls += "?" + c.urlParams_.Encode()
49460 req, err := http.NewRequest("GET", urls, body)
49461 if err != nil {
49462 return nil, err
49463 }
49464 req.Header = reqHeaders
49465 googleapi.Expand(req.URL, map[string]string{
49466 "profileId": strconv.FormatInt(c.profileId, 10),
49467 "id": strconv.FormatInt(c.id, 10),
49468 })
49469 return gensupport.SendRequest(c.ctx_, c.s.client, req)
49470 }
49471
49472
49473
49474
49475
49476
49477
49478
49479 func (c *UserRolePermissionsGetCall) Do(opts ...googleapi.CallOption) (*UserRolePermission, error) {
49480 gensupport.SetOptions(c.urlParams_, opts...)
49481 res, err := c.doRequest("json")
49482 if res != nil && res.StatusCode == http.StatusNotModified {
49483 if res.Body != nil {
49484 res.Body.Close()
49485 }
49486 return nil, &googleapi.Error{
49487 Code: res.StatusCode,
49488 Header: res.Header,
49489 }
49490 }
49491 if err != nil {
49492 return nil, err
49493 }
49494 defer googleapi.CloseBody(res)
49495 if err := googleapi.CheckResponse(res); err != nil {
49496 return nil, err
49497 }
49498 ret := &UserRolePermission{
49499 ServerResponse: googleapi.ServerResponse{
49500 Header: res.Header,
49501 HTTPStatusCode: res.StatusCode,
49502 },
49503 }
49504 target := &ret
49505 if err := gensupport.DecodeResponse(target, res); err != nil {
49506 return nil, err
49507 }
49508 return ret, nil
49509
49510
49511
49512
49513
49514
49515
49516
49517
49518
49519
49520
49521
49522
49523
49524
49525
49526
49527
49528
49529
49530
49531
49532
49533
49534
49535
49536
49537
49538
49539
49540
49541
49542 }
49543
49544
49545
49546 type UserRolePermissionsListCall struct {
49547 s *Service
49548 profileId int64
49549 urlParams_ gensupport.URLParams
49550 ifNoneMatch_ string
49551 ctx_ context.Context
49552 header_ http.Header
49553 }
49554
49555
49556 func (r *UserRolePermissionsService) List(profileId int64) *UserRolePermissionsListCall {
49557 c := &UserRolePermissionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
49558 c.profileId = profileId
49559 return c
49560 }
49561
49562
49563
49564 func (c *UserRolePermissionsListCall) Ids(ids ...int64) *UserRolePermissionsListCall {
49565 var ids_ []string
49566 for _, v := range ids {
49567 ids_ = append(ids_, fmt.Sprint(v))
49568 }
49569 c.urlParams_.SetMulti("ids", ids_)
49570 return c
49571 }
49572
49573
49574
49575
49576 func (c *UserRolePermissionsListCall) Fields(s ...googleapi.Field) *UserRolePermissionsListCall {
49577 c.urlParams_.Set("fields", googleapi.CombineFields(s))
49578 return c
49579 }
49580
49581
49582
49583
49584
49585
49586 func (c *UserRolePermissionsListCall) IfNoneMatch(entityTag string) *UserRolePermissionsListCall {
49587 c.ifNoneMatch_ = entityTag
49588 return c
49589 }
49590
49591
49592
49593
49594 func (c *UserRolePermissionsListCall) Context(ctx context.Context) *UserRolePermissionsListCall {
49595 c.ctx_ = ctx
49596 return c
49597 }
49598
49599
49600
49601 func (c *UserRolePermissionsListCall) Header() http.Header {
49602 if c.header_ == nil {
49603 c.header_ = make(http.Header)
49604 }
49605 return c.header_
49606 }
49607
49608 func (c *UserRolePermissionsListCall) doRequest(alt string) (*http.Response, error) {
49609 reqHeaders := make(http.Header)
49610 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
49611 for k, v := range c.header_ {
49612 reqHeaders[k] = v
49613 }
49614 reqHeaders.Set("User-Agent", c.s.userAgent())
49615 if c.ifNoneMatch_ != "" {
49616 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
49617 }
49618 var body io.Reader = nil
49619 c.urlParams_.Set("alt", alt)
49620 c.urlParams_.Set("prettyPrint", "false")
49621 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRolePermissions")
49622 urls += "?" + c.urlParams_.Encode()
49623 req, err := http.NewRequest("GET", urls, body)
49624 if err != nil {
49625 return nil, err
49626 }
49627 req.Header = reqHeaders
49628 googleapi.Expand(req.URL, map[string]string{
49629 "profileId": strconv.FormatInt(c.profileId, 10),
49630 })
49631 return gensupport.SendRequest(c.ctx_, c.s.client, req)
49632 }
49633
49634
49635
49636
49637
49638
49639
49640
49641 func (c *UserRolePermissionsListCall) Do(opts ...googleapi.CallOption) (*UserRolePermissionsListResponse, error) {
49642 gensupport.SetOptions(c.urlParams_, opts...)
49643 res, err := c.doRequest("json")
49644 if res != nil && res.StatusCode == http.StatusNotModified {
49645 if res.Body != nil {
49646 res.Body.Close()
49647 }
49648 return nil, &googleapi.Error{
49649 Code: res.StatusCode,
49650 Header: res.Header,
49651 }
49652 }
49653 if err != nil {
49654 return nil, err
49655 }
49656 defer googleapi.CloseBody(res)
49657 if err := googleapi.CheckResponse(res); err != nil {
49658 return nil, err
49659 }
49660 ret := &UserRolePermissionsListResponse{
49661 ServerResponse: googleapi.ServerResponse{
49662 Header: res.Header,
49663 HTTPStatusCode: res.StatusCode,
49664 },
49665 }
49666 target := &ret
49667 if err := gensupport.DecodeResponse(target, res); err != nil {
49668 return nil, err
49669 }
49670 return ret, nil
49671
49672
49673
49674
49675
49676
49677
49678
49679
49680
49681
49682
49683
49684
49685
49686
49687
49688
49689
49690
49691
49692
49693
49694
49695
49696
49697
49698
49699
49700
49701
49702
49703 }
49704
49705
49706
49707 type UserRolesDeleteCall struct {
49708 s *Service
49709 profileId int64
49710 id int64
49711 urlParams_ gensupport.URLParams
49712 ctx_ context.Context
49713 header_ http.Header
49714 }
49715
49716
49717 func (r *UserRolesService) Delete(profileId int64, id int64) *UserRolesDeleteCall {
49718 c := &UserRolesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
49719 c.profileId = profileId
49720 c.id = id
49721 return c
49722 }
49723
49724
49725
49726
49727 func (c *UserRolesDeleteCall) Fields(s ...googleapi.Field) *UserRolesDeleteCall {
49728 c.urlParams_.Set("fields", googleapi.CombineFields(s))
49729 return c
49730 }
49731
49732
49733
49734
49735 func (c *UserRolesDeleteCall) Context(ctx context.Context) *UserRolesDeleteCall {
49736 c.ctx_ = ctx
49737 return c
49738 }
49739
49740
49741
49742 func (c *UserRolesDeleteCall) Header() http.Header {
49743 if c.header_ == nil {
49744 c.header_ = make(http.Header)
49745 }
49746 return c.header_
49747 }
49748
49749 func (c *UserRolesDeleteCall) doRequest(alt string) (*http.Response, error) {
49750 reqHeaders := make(http.Header)
49751 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
49752 for k, v := range c.header_ {
49753 reqHeaders[k] = v
49754 }
49755 reqHeaders.Set("User-Agent", c.s.userAgent())
49756 var body io.Reader = nil
49757 c.urlParams_.Set("alt", alt)
49758 c.urlParams_.Set("prettyPrint", "false")
49759 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRoles/{id}")
49760 urls += "?" + c.urlParams_.Encode()
49761 req, err := http.NewRequest("DELETE", urls, body)
49762 if err != nil {
49763 return nil, err
49764 }
49765 req.Header = reqHeaders
49766 googleapi.Expand(req.URL, map[string]string{
49767 "profileId": strconv.FormatInt(c.profileId, 10),
49768 "id": strconv.FormatInt(c.id, 10),
49769 })
49770 return gensupport.SendRequest(c.ctx_, c.s.client, req)
49771 }
49772
49773
49774 func (c *UserRolesDeleteCall) Do(opts ...googleapi.CallOption) error {
49775 gensupport.SetOptions(c.urlParams_, opts...)
49776 res, err := c.doRequest("json")
49777 if err != nil {
49778 return err
49779 }
49780 defer googleapi.CloseBody(res)
49781 if err := googleapi.CheckResponse(res); err != nil {
49782 return err
49783 }
49784 return nil
49785
49786
49787
49788
49789
49790
49791
49792
49793
49794
49795
49796
49797
49798
49799
49800
49801
49802
49803
49804
49805
49806
49807
49808
49809
49810
49811
49812
49813
49814
49815 }
49816
49817
49818
49819 type UserRolesGetCall struct {
49820 s *Service
49821 profileId int64
49822 id int64
49823 urlParams_ gensupport.URLParams
49824 ifNoneMatch_ string
49825 ctx_ context.Context
49826 header_ http.Header
49827 }
49828
49829
49830 func (r *UserRolesService) Get(profileId int64, id int64) *UserRolesGetCall {
49831 c := &UserRolesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
49832 c.profileId = profileId
49833 c.id = id
49834 return c
49835 }
49836
49837
49838
49839
49840 func (c *UserRolesGetCall) Fields(s ...googleapi.Field) *UserRolesGetCall {
49841 c.urlParams_.Set("fields", googleapi.CombineFields(s))
49842 return c
49843 }
49844
49845
49846
49847
49848
49849
49850 func (c *UserRolesGetCall) IfNoneMatch(entityTag string) *UserRolesGetCall {
49851 c.ifNoneMatch_ = entityTag
49852 return c
49853 }
49854
49855
49856
49857
49858 func (c *UserRolesGetCall) Context(ctx context.Context) *UserRolesGetCall {
49859 c.ctx_ = ctx
49860 return c
49861 }
49862
49863
49864
49865 func (c *UserRolesGetCall) Header() http.Header {
49866 if c.header_ == nil {
49867 c.header_ = make(http.Header)
49868 }
49869 return c.header_
49870 }
49871
49872 func (c *UserRolesGetCall) doRequest(alt string) (*http.Response, error) {
49873 reqHeaders := make(http.Header)
49874 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
49875 for k, v := range c.header_ {
49876 reqHeaders[k] = v
49877 }
49878 reqHeaders.Set("User-Agent", c.s.userAgent())
49879 if c.ifNoneMatch_ != "" {
49880 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
49881 }
49882 var body io.Reader = nil
49883 c.urlParams_.Set("alt", alt)
49884 c.urlParams_.Set("prettyPrint", "false")
49885 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRoles/{id}")
49886 urls += "?" + c.urlParams_.Encode()
49887 req, err := http.NewRequest("GET", urls, body)
49888 if err != nil {
49889 return nil, err
49890 }
49891 req.Header = reqHeaders
49892 googleapi.Expand(req.URL, map[string]string{
49893 "profileId": strconv.FormatInt(c.profileId, 10),
49894 "id": strconv.FormatInt(c.id, 10),
49895 })
49896 return gensupport.SendRequest(c.ctx_, c.s.client, req)
49897 }
49898
49899
49900
49901
49902
49903
49904
49905
49906 func (c *UserRolesGetCall) Do(opts ...googleapi.CallOption) (*UserRole, error) {
49907 gensupport.SetOptions(c.urlParams_, opts...)
49908 res, err := c.doRequest("json")
49909 if res != nil && res.StatusCode == http.StatusNotModified {
49910 if res.Body != nil {
49911 res.Body.Close()
49912 }
49913 return nil, &googleapi.Error{
49914 Code: res.StatusCode,
49915 Header: res.Header,
49916 }
49917 }
49918 if err != nil {
49919 return nil, err
49920 }
49921 defer googleapi.CloseBody(res)
49922 if err := googleapi.CheckResponse(res); err != nil {
49923 return nil, err
49924 }
49925 ret := &UserRole{
49926 ServerResponse: googleapi.ServerResponse{
49927 Header: res.Header,
49928 HTTPStatusCode: res.StatusCode,
49929 },
49930 }
49931 target := &ret
49932 if err := gensupport.DecodeResponse(target, res); err != nil {
49933 return nil, err
49934 }
49935 return ret, nil
49936
49937
49938
49939
49940
49941
49942
49943
49944
49945
49946
49947
49948
49949
49950
49951
49952
49953
49954
49955
49956
49957
49958
49959
49960
49961
49962
49963
49964
49965
49966
49967
49968
49969 }
49970
49971
49972
49973 type UserRolesInsertCall struct {
49974 s *Service
49975 profileId int64
49976 userrole *UserRole
49977 urlParams_ gensupport.URLParams
49978 ctx_ context.Context
49979 header_ http.Header
49980 }
49981
49982
49983 func (r *UserRolesService) Insert(profileId int64, userrole *UserRole) *UserRolesInsertCall {
49984 c := &UserRolesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
49985 c.profileId = profileId
49986 c.userrole = userrole
49987 return c
49988 }
49989
49990
49991
49992
49993 func (c *UserRolesInsertCall) Fields(s ...googleapi.Field) *UserRolesInsertCall {
49994 c.urlParams_.Set("fields", googleapi.CombineFields(s))
49995 return c
49996 }
49997
49998
49999
50000
50001 func (c *UserRolesInsertCall) Context(ctx context.Context) *UserRolesInsertCall {
50002 c.ctx_ = ctx
50003 return c
50004 }
50005
50006
50007
50008 func (c *UserRolesInsertCall) Header() http.Header {
50009 if c.header_ == nil {
50010 c.header_ = make(http.Header)
50011 }
50012 return c.header_
50013 }
50014
50015 func (c *UserRolesInsertCall) doRequest(alt string) (*http.Response, error) {
50016 reqHeaders := make(http.Header)
50017 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
50018 for k, v := range c.header_ {
50019 reqHeaders[k] = v
50020 }
50021 reqHeaders.Set("User-Agent", c.s.userAgent())
50022 var body io.Reader = nil
50023 body, err := googleapi.WithoutDataWrapper.JSONReader(c.userrole)
50024 if err != nil {
50025 return nil, err
50026 }
50027 reqHeaders.Set("Content-Type", "application/json")
50028 c.urlParams_.Set("alt", alt)
50029 c.urlParams_.Set("prettyPrint", "false")
50030 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRoles")
50031 urls += "?" + c.urlParams_.Encode()
50032 req, err := http.NewRequest("POST", urls, body)
50033 if err != nil {
50034 return nil, err
50035 }
50036 req.Header = reqHeaders
50037 googleapi.Expand(req.URL, map[string]string{
50038 "profileId": strconv.FormatInt(c.profileId, 10),
50039 })
50040 return gensupport.SendRequest(c.ctx_, c.s.client, req)
50041 }
50042
50043
50044
50045
50046
50047
50048
50049
50050 func (c *UserRolesInsertCall) Do(opts ...googleapi.CallOption) (*UserRole, error) {
50051 gensupport.SetOptions(c.urlParams_, opts...)
50052 res, err := c.doRequest("json")
50053 if res != nil && res.StatusCode == http.StatusNotModified {
50054 if res.Body != nil {
50055 res.Body.Close()
50056 }
50057 return nil, &googleapi.Error{
50058 Code: res.StatusCode,
50059 Header: res.Header,
50060 }
50061 }
50062 if err != nil {
50063 return nil, err
50064 }
50065 defer googleapi.CloseBody(res)
50066 if err := googleapi.CheckResponse(res); err != nil {
50067 return nil, err
50068 }
50069 ret := &UserRole{
50070 ServerResponse: googleapi.ServerResponse{
50071 Header: res.Header,
50072 HTTPStatusCode: res.StatusCode,
50073 },
50074 }
50075 target := &ret
50076 if err := gensupport.DecodeResponse(target, res); err != nil {
50077 return nil, err
50078 }
50079 return ret, nil
50080
50081
50082
50083
50084
50085
50086
50087
50088
50089
50090
50091
50092
50093
50094
50095
50096
50097
50098
50099
50100
50101
50102
50103
50104
50105
50106
50107
50108 }
50109
50110
50111
50112 type UserRolesListCall struct {
50113 s *Service
50114 profileId int64
50115 urlParams_ gensupport.URLParams
50116 ifNoneMatch_ string
50117 ctx_ context.Context
50118 header_ http.Header
50119 }
50120
50121
50122
50123 func (r *UserRolesService) List(profileId int64) *UserRolesListCall {
50124 c := &UserRolesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
50125 c.profileId = profileId
50126 return c
50127 }
50128
50129
50130
50131
50132 func (c *UserRolesListCall) AccountUserRoleOnly(accountUserRoleOnly bool) *UserRolesListCall {
50133 c.urlParams_.Set("accountUserRoleOnly", fmt.Sprint(accountUserRoleOnly))
50134 return c
50135 }
50136
50137
50138
50139 func (c *UserRolesListCall) Ids(ids ...int64) *UserRolesListCall {
50140 var ids_ []string
50141 for _, v := range ids {
50142 ids_ = append(ids_, fmt.Sprint(v))
50143 }
50144 c.urlParams_.SetMulti("ids", ids_)
50145 return c
50146 }
50147
50148
50149
50150 func (c *UserRolesListCall) MaxResults(maxResults int64) *UserRolesListCall {
50151 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
50152 return c
50153 }
50154
50155
50156
50157 func (c *UserRolesListCall) PageToken(pageToken string) *UserRolesListCall {
50158 c.urlParams_.Set("pageToken", pageToken)
50159 return c
50160 }
50161
50162
50163
50164
50165
50166
50167
50168
50169
50170 func (c *UserRolesListCall) SearchString(searchString string) *UserRolesListCall {
50171 c.urlParams_.Set("searchString", searchString)
50172 return c
50173 }
50174
50175
50176
50177
50178
50179
50180
50181
50182 func (c *UserRolesListCall) SortField(sortField string) *UserRolesListCall {
50183 c.urlParams_.Set("sortField", sortField)
50184 return c
50185 }
50186
50187
50188
50189
50190
50191
50192
50193
50194 func (c *UserRolesListCall) SortOrder(sortOrder string) *UserRolesListCall {
50195 c.urlParams_.Set("sortOrder", sortOrder)
50196 return c
50197 }
50198
50199
50200
50201 func (c *UserRolesListCall) SubaccountId(subaccountId int64) *UserRolesListCall {
50202 c.urlParams_.Set("subaccountId", fmt.Sprint(subaccountId))
50203 return c
50204 }
50205
50206
50207
50208
50209 func (c *UserRolesListCall) Fields(s ...googleapi.Field) *UserRolesListCall {
50210 c.urlParams_.Set("fields", googleapi.CombineFields(s))
50211 return c
50212 }
50213
50214
50215
50216
50217
50218
50219 func (c *UserRolesListCall) IfNoneMatch(entityTag string) *UserRolesListCall {
50220 c.ifNoneMatch_ = entityTag
50221 return c
50222 }
50223
50224
50225
50226
50227 func (c *UserRolesListCall) Context(ctx context.Context) *UserRolesListCall {
50228 c.ctx_ = ctx
50229 return c
50230 }
50231
50232
50233
50234 func (c *UserRolesListCall) Header() http.Header {
50235 if c.header_ == nil {
50236 c.header_ = make(http.Header)
50237 }
50238 return c.header_
50239 }
50240
50241 func (c *UserRolesListCall) doRequest(alt string) (*http.Response, error) {
50242 reqHeaders := make(http.Header)
50243 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
50244 for k, v := range c.header_ {
50245 reqHeaders[k] = v
50246 }
50247 reqHeaders.Set("User-Agent", c.s.userAgent())
50248 if c.ifNoneMatch_ != "" {
50249 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
50250 }
50251 var body io.Reader = nil
50252 c.urlParams_.Set("alt", alt)
50253 c.urlParams_.Set("prettyPrint", "false")
50254 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRoles")
50255 urls += "?" + c.urlParams_.Encode()
50256 req, err := http.NewRequest("GET", urls, body)
50257 if err != nil {
50258 return nil, err
50259 }
50260 req.Header = reqHeaders
50261 googleapi.Expand(req.URL, map[string]string{
50262 "profileId": strconv.FormatInt(c.profileId, 10),
50263 })
50264 return gensupport.SendRequest(c.ctx_, c.s.client, req)
50265 }
50266
50267
50268
50269
50270
50271
50272
50273
50274 func (c *UserRolesListCall) Do(opts ...googleapi.CallOption) (*UserRolesListResponse, error) {
50275 gensupport.SetOptions(c.urlParams_, opts...)
50276 res, err := c.doRequest("json")
50277 if res != nil && res.StatusCode == http.StatusNotModified {
50278 if res.Body != nil {
50279 res.Body.Close()
50280 }
50281 return nil, &googleapi.Error{
50282 Code: res.StatusCode,
50283 Header: res.Header,
50284 }
50285 }
50286 if err != nil {
50287 return nil, err
50288 }
50289 defer googleapi.CloseBody(res)
50290 if err := googleapi.CheckResponse(res); err != nil {
50291 return nil, err
50292 }
50293 ret := &UserRolesListResponse{
50294 ServerResponse: googleapi.ServerResponse{
50295 Header: res.Header,
50296 HTTPStatusCode: res.StatusCode,
50297 },
50298 }
50299 target := &ret
50300 if err := gensupport.DecodeResponse(target, res); err != nil {
50301 return nil, err
50302 }
50303 return ret, nil
50304
50305
50306
50307
50308
50309
50310
50311
50312
50313
50314
50315
50316
50317
50318
50319
50320
50321
50322
50323
50324
50325
50326
50327
50328
50329
50330
50331
50332
50333
50334
50335
50336
50337
50338
50339
50340
50341
50342
50343
50344
50345
50346
50347
50348
50349
50350
50351
50352
50353
50354
50355
50356
50357
50358
50359
50360
50361
50362
50363
50364
50365
50366
50367
50368
50369
50370
50371
50372
50373
50374
50375
50376
50377
50378
50379
50380
50381
50382
50383
50384
50385
50386
50387
50388
50389
50390
50391
50392
50393
50394 }
50395
50396
50397
50398
50399 func (c *UserRolesListCall) Pages(ctx context.Context, f func(*UserRolesListResponse) error) error {
50400 c.ctx_ = ctx
50401 defer c.PageToken(c.urlParams_.Get("pageToken"))
50402 for {
50403 x, err := c.Do()
50404 if err != nil {
50405 return err
50406 }
50407 if err := f(x); err != nil {
50408 return err
50409 }
50410 if x.NextPageToken == "" {
50411 return nil
50412 }
50413 c.PageToken(x.NextPageToken)
50414 }
50415 }
50416
50417
50418
50419 type UserRolesPatchCall struct {
50420 s *Service
50421 profileId int64
50422 userrole *UserRole
50423 urlParams_ gensupport.URLParams
50424 ctx_ context.Context
50425 header_ http.Header
50426 }
50427
50428
50429
50430 func (r *UserRolesService) Patch(profileId int64, id int64, userrole *UserRole) *UserRolesPatchCall {
50431 c := &UserRolesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
50432 c.profileId = profileId
50433 c.urlParams_.Set("id", fmt.Sprint(id))
50434 c.userrole = userrole
50435 return c
50436 }
50437
50438
50439
50440
50441 func (c *UserRolesPatchCall) Fields(s ...googleapi.Field) *UserRolesPatchCall {
50442 c.urlParams_.Set("fields", googleapi.CombineFields(s))
50443 return c
50444 }
50445
50446
50447
50448
50449 func (c *UserRolesPatchCall) Context(ctx context.Context) *UserRolesPatchCall {
50450 c.ctx_ = ctx
50451 return c
50452 }
50453
50454
50455
50456 func (c *UserRolesPatchCall) Header() http.Header {
50457 if c.header_ == nil {
50458 c.header_ = make(http.Header)
50459 }
50460 return c.header_
50461 }
50462
50463 func (c *UserRolesPatchCall) doRequest(alt string) (*http.Response, error) {
50464 reqHeaders := make(http.Header)
50465 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
50466 for k, v := range c.header_ {
50467 reqHeaders[k] = v
50468 }
50469 reqHeaders.Set("User-Agent", c.s.userAgent())
50470 var body io.Reader = nil
50471 body, err := googleapi.WithoutDataWrapper.JSONReader(c.userrole)
50472 if err != nil {
50473 return nil, err
50474 }
50475 reqHeaders.Set("Content-Type", "application/json")
50476 c.urlParams_.Set("alt", alt)
50477 c.urlParams_.Set("prettyPrint", "false")
50478 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRoles")
50479 urls += "?" + c.urlParams_.Encode()
50480 req, err := http.NewRequest("PATCH", urls, body)
50481 if err != nil {
50482 return nil, err
50483 }
50484 req.Header = reqHeaders
50485 googleapi.Expand(req.URL, map[string]string{
50486 "profileId": strconv.FormatInt(c.profileId, 10),
50487 })
50488 return gensupport.SendRequest(c.ctx_, c.s.client, req)
50489 }
50490
50491
50492
50493
50494
50495
50496
50497
50498 func (c *UserRolesPatchCall) Do(opts ...googleapi.CallOption) (*UserRole, error) {
50499 gensupport.SetOptions(c.urlParams_, opts...)
50500 res, err := c.doRequest("json")
50501 if res != nil && res.StatusCode == http.StatusNotModified {
50502 if res.Body != nil {
50503 res.Body.Close()
50504 }
50505 return nil, &googleapi.Error{
50506 Code: res.StatusCode,
50507 Header: res.Header,
50508 }
50509 }
50510 if err != nil {
50511 return nil, err
50512 }
50513 defer googleapi.CloseBody(res)
50514 if err := googleapi.CheckResponse(res); err != nil {
50515 return nil, err
50516 }
50517 ret := &UserRole{
50518 ServerResponse: googleapi.ServerResponse{
50519 Header: res.Header,
50520 HTTPStatusCode: res.StatusCode,
50521 },
50522 }
50523 target := &ret
50524 if err := gensupport.DecodeResponse(target, res); err != nil {
50525 return nil, err
50526 }
50527 return ret, nil
50528
50529
50530
50531
50532
50533
50534
50535
50536
50537
50538
50539
50540
50541
50542
50543
50544
50545
50546
50547
50548
50549
50550
50551
50552
50553
50554
50555
50556
50557
50558
50559
50560
50561
50562
50563
50564 }
50565
50566
50567
50568 type UserRolesUpdateCall struct {
50569 s *Service
50570 profileId int64
50571 userrole *UserRole
50572 urlParams_ gensupport.URLParams
50573 ctx_ context.Context
50574 header_ http.Header
50575 }
50576
50577
50578 func (r *UserRolesService) Update(profileId int64, userrole *UserRole) *UserRolesUpdateCall {
50579 c := &UserRolesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
50580 c.profileId = profileId
50581 c.userrole = userrole
50582 return c
50583 }
50584
50585
50586
50587
50588 func (c *UserRolesUpdateCall) Fields(s ...googleapi.Field) *UserRolesUpdateCall {
50589 c.urlParams_.Set("fields", googleapi.CombineFields(s))
50590 return c
50591 }
50592
50593
50594
50595
50596 func (c *UserRolesUpdateCall) Context(ctx context.Context) *UserRolesUpdateCall {
50597 c.ctx_ = ctx
50598 return c
50599 }
50600
50601
50602
50603 func (c *UserRolesUpdateCall) Header() http.Header {
50604 if c.header_ == nil {
50605 c.header_ = make(http.Header)
50606 }
50607 return c.header_
50608 }
50609
50610 func (c *UserRolesUpdateCall) doRequest(alt string) (*http.Response, error) {
50611 reqHeaders := make(http.Header)
50612 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
50613 for k, v := range c.header_ {
50614 reqHeaders[k] = v
50615 }
50616 reqHeaders.Set("User-Agent", c.s.userAgent())
50617 var body io.Reader = nil
50618 body, err := googleapi.WithoutDataWrapper.JSONReader(c.userrole)
50619 if err != nil {
50620 return nil, err
50621 }
50622 reqHeaders.Set("Content-Type", "application/json")
50623 c.urlParams_.Set("alt", alt)
50624 c.urlParams_.Set("prettyPrint", "false")
50625 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/userRoles")
50626 urls += "?" + c.urlParams_.Encode()
50627 req, err := http.NewRequest("PUT", urls, body)
50628 if err != nil {
50629 return nil, err
50630 }
50631 req.Header = reqHeaders
50632 googleapi.Expand(req.URL, map[string]string{
50633 "profileId": strconv.FormatInt(c.profileId, 10),
50634 })
50635 return gensupport.SendRequest(c.ctx_, c.s.client, req)
50636 }
50637
50638
50639
50640
50641
50642
50643
50644
50645 func (c *UserRolesUpdateCall) Do(opts ...googleapi.CallOption) (*UserRole, error) {
50646 gensupport.SetOptions(c.urlParams_, opts...)
50647 res, err := c.doRequest("json")
50648 if res != nil && res.StatusCode == http.StatusNotModified {
50649 if res.Body != nil {
50650 res.Body.Close()
50651 }
50652 return nil, &googleapi.Error{
50653 Code: res.StatusCode,
50654 Header: res.Header,
50655 }
50656 }
50657 if err != nil {
50658 return nil, err
50659 }
50660 defer googleapi.CloseBody(res)
50661 if err := googleapi.CheckResponse(res); err != nil {
50662 return nil, err
50663 }
50664 ret := &UserRole{
50665 ServerResponse: googleapi.ServerResponse{
50666 Header: res.Header,
50667 HTTPStatusCode: res.StatusCode,
50668 },
50669 }
50670 target := &ret
50671 if err := gensupport.DecodeResponse(target, res); err != nil {
50672 return nil, err
50673 }
50674 return ret, nil
50675
50676
50677
50678
50679
50680
50681
50682
50683
50684
50685
50686
50687
50688
50689
50690
50691
50692
50693
50694
50695
50696
50697
50698
50699
50700
50701
50702
50703 }
50704
50705
50706
50707 type VideoFormatsGetCall struct {
50708 s *Service
50709 profileId int64
50710 id int64
50711 urlParams_ gensupport.URLParams
50712 ifNoneMatch_ string
50713 ctx_ context.Context
50714 header_ http.Header
50715 }
50716
50717
50718 func (r *VideoFormatsService) Get(profileId int64, id int64) *VideoFormatsGetCall {
50719 c := &VideoFormatsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
50720 c.profileId = profileId
50721 c.id = id
50722 return c
50723 }
50724
50725
50726
50727
50728 func (c *VideoFormatsGetCall) Fields(s ...googleapi.Field) *VideoFormatsGetCall {
50729 c.urlParams_.Set("fields", googleapi.CombineFields(s))
50730 return c
50731 }
50732
50733
50734
50735
50736
50737
50738 func (c *VideoFormatsGetCall) IfNoneMatch(entityTag string) *VideoFormatsGetCall {
50739 c.ifNoneMatch_ = entityTag
50740 return c
50741 }
50742
50743
50744
50745
50746 func (c *VideoFormatsGetCall) Context(ctx context.Context) *VideoFormatsGetCall {
50747 c.ctx_ = ctx
50748 return c
50749 }
50750
50751
50752
50753 func (c *VideoFormatsGetCall) Header() http.Header {
50754 if c.header_ == nil {
50755 c.header_ = make(http.Header)
50756 }
50757 return c.header_
50758 }
50759
50760 func (c *VideoFormatsGetCall) doRequest(alt string) (*http.Response, error) {
50761 reqHeaders := make(http.Header)
50762 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
50763 for k, v := range c.header_ {
50764 reqHeaders[k] = v
50765 }
50766 reqHeaders.Set("User-Agent", c.s.userAgent())
50767 if c.ifNoneMatch_ != "" {
50768 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
50769 }
50770 var body io.Reader = nil
50771 c.urlParams_.Set("alt", alt)
50772 c.urlParams_.Set("prettyPrint", "false")
50773 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/videoFormats/{id}")
50774 urls += "?" + c.urlParams_.Encode()
50775 req, err := http.NewRequest("GET", urls, body)
50776 if err != nil {
50777 return nil, err
50778 }
50779 req.Header = reqHeaders
50780 googleapi.Expand(req.URL, map[string]string{
50781 "profileId": strconv.FormatInt(c.profileId, 10),
50782 "id": strconv.FormatInt(c.id, 10),
50783 })
50784 return gensupport.SendRequest(c.ctx_, c.s.client, req)
50785 }
50786
50787
50788
50789
50790
50791
50792
50793
50794 func (c *VideoFormatsGetCall) Do(opts ...googleapi.CallOption) (*VideoFormat, error) {
50795 gensupport.SetOptions(c.urlParams_, opts...)
50796 res, err := c.doRequest("json")
50797 if res != nil && res.StatusCode == http.StatusNotModified {
50798 if res.Body != nil {
50799 res.Body.Close()
50800 }
50801 return nil, &googleapi.Error{
50802 Code: res.StatusCode,
50803 Header: res.Header,
50804 }
50805 }
50806 if err != nil {
50807 return nil, err
50808 }
50809 defer googleapi.CloseBody(res)
50810 if err := googleapi.CheckResponse(res); err != nil {
50811 return nil, err
50812 }
50813 ret := &VideoFormat{
50814 ServerResponse: googleapi.ServerResponse{
50815 Header: res.Header,
50816 HTTPStatusCode: res.StatusCode,
50817 },
50818 }
50819 target := &ret
50820 if err := gensupport.DecodeResponse(target, res); err != nil {
50821 return nil, err
50822 }
50823 return ret, nil
50824
50825
50826
50827
50828
50829
50830
50831
50832
50833
50834
50835
50836
50837
50838
50839
50840
50841
50842
50843
50844
50845
50846
50847
50848
50849
50850
50851
50852
50853
50854
50855
50856
50857 }
50858
50859
50860
50861 type VideoFormatsListCall struct {
50862 s *Service
50863 profileId int64
50864 urlParams_ gensupport.URLParams
50865 ifNoneMatch_ string
50866 ctx_ context.Context
50867 header_ http.Header
50868 }
50869
50870
50871 func (r *VideoFormatsService) List(profileId int64) *VideoFormatsListCall {
50872 c := &VideoFormatsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
50873 c.profileId = profileId
50874 return c
50875 }
50876
50877
50878
50879
50880 func (c *VideoFormatsListCall) Fields(s ...googleapi.Field) *VideoFormatsListCall {
50881 c.urlParams_.Set("fields", googleapi.CombineFields(s))
50882 return c
50883 }
50884
50885
50886
50887
50888
50889
50890 func (c *VideoFormatsListCall) IfNoneMatch(entityTag string) *VideoFormatsListCall {
50891 c.ifNoneMatch_ = entityTag
50892 return c
50893 }
50894
50895
50896
50897
50898 func (c *VideoFormatsListCall) Context(ctx context.Context) *VideoFormatsListCall {
50899 c.ctx_ = ctx
50900 return c
50901 }
50902
50903
50904
50905 func (c *VideoFormatsListCall) Header() http.Header {
50906 if c.header_ == nil {
50907 c.header_ = make(http.Header)
50908 }
50909 return c.header_
50910 }
50911
50912 func (c *VideoFormatsListCall) doRequest(alt string) (*http.Response, error) {
50913 reqHeaders := make(http.Header)
50914 reqHeaders.Set("x-goog-api-client", "gl-go/1.13.7 gdcl/20200203")
50915 for k, v := range c.header_ {
50916 reqHeaders[k] = v
50917 }
50918 reqHeaders.Set("User-Agent", c.s.userAgent())
50919 if c.ifNoneMatch_ != "" {
50920 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
50921 }
50922 var body io.Reader = nil
50923 c.urlParams_.Set("alt", alt)
50924 c.urlParams_.Set("prettyPrint", "false")
50925 urls := googleapi.ResolveRelative(c.s.BasePath, "userprofiles/{profileId}/videoFormats")
50926 urls += "?" + c.urlParams_.Encode()
50927 req, err := http.NewRequest("GET", urls, body)
50928 if err != nil {
50929 return nil, err
50930 }
50931 req.Header = reqHeaders
50932 googleapi.Expand(req.URL, map[string]string{
50933 "profileId": strconv.FormatInt(c.profileId, 10),
50934 })
50935 return gensupport.SendRequest(c.ctx_, c.s.client, req)
50936 }
50937
50938
50939
50940
50941
50942
50943
50944
50945 func (c *VideoFormatsListCall) Do(opts ...googleapi.CallOption) (*VideoFormatsListResponse, error) {
50946 gensupport.SetOptions(c.urlParams_, opts...)
50947 res, err := c.doRequest("json")
50948 if res != nil && res.StatusCode == http.StatusNotModified {
50949 if res.Body != nil {
50950 res.Body.Close()
50951 }
50952 return nil, &googleapi.Error{
50953 Code: res.StatusCode,
50954 Header: res.Header,
50955 }
50956 }
50957 if err != nil {
50958 return nil, err
50959 }
50960 defer googleapi.CloseBody(res)
50961 if err := googleapi.CheckResponse(res); err != nil {
50962 return nil, err
50963 }
50964 ret := &VideoFormatsListResponse{
50965 ServerResponse: googleapi.ServerResponse{
50966 Header: res.Header,
50967 HTTPStatusCode: res.StatusCode,
50968 },
50969 }
50970 target := &ret
50971 if err := gensupport.DecodeResponse(target, res); err != nil {
50972 return nil, err
50973 }
50974 return ret, nil
50975
50976
50977
50978
50979
50980
50981
50982
50983
50984
50985
50986
50987
50988
50989
50990
50991
50992
50993
50994
50995
50996
50997
50998
50999
51000 }
51001
View as plain text