1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51 package walletobjects
52
53 import (
54 "bytes"
55 "context"
56 "encoding/json"
57 "errors"
58 "fmt"
59 "io"
60 "net/http"
61 "net/url"
62 "strconv"
63 "strings"
64
65 googleapi "google.golang.org/api/googleapi"
66 internal "google.golang.org/api/internal"
67 gensupport "google.golang.org/api/internal/gensupport"
68 option "google.golang.org/api/option"
69 internaloption "google.golang.org/api/option/internaloption"
70 htransport "google.golang.org/api/transport/http"
71 )
72
73
74
75 var _ = bytes.NewBuffer
76 var _ = strconv.Itoa
77 var _ = fmt.Sprintf
78 var _ = json.NewDecoder
79 var _ = io.Copy
80 var _ = url.Parse
81 var _ = gensupport.MarshalJSON
82 var _ = googleapi.Version
83 var _ = errors.New
84 var _ = strings.Replace
85 var _ = context.Canceled
86 var _ = internaloption.WithDefaultEndpoint
87 var _ = internal.Version
88
89 const apiId = "walletobjects:v1"
90 const apiName = "walletobjects"
91 const apiVersion = "v1"
92 const basePath = "https://walletobjects.googleapis.com/"
93 const basePathTemplate = "https://walletobjects.UNIVERSE_DOMAIN/"
94 const mtlsBasePath = "https://walletobjects.mtls.googleapis.com/"
95
96
97 const (
98
99 WalletObjectIssuerScope = "https://www.googleapis.com/auth/wallet_object.issuer"
100 )
101
102
103 func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
104 scopesOption := internaloption.WithDefaultScopes(
105 "https://www.googleapis.com/auth/wallet_object.issuer",
106 )
107
108 opts = append([]option.ClientOption{scopesOption}, opts...)
109 opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
110 opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate))
111 opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
112 opts = append(opts, internaloption.EnableNewAuthLibrary())
113 client, endpoint, err := htransport.NewClient(ctx, opts...)
114 if err != nil {
115 return nil, err
116 }
117 s, err := New(client)
118 if err != nil {
119 return nil, err
120 }
121 if endpoint != "" {
122 s.BasePath = endpoint
123 }
124 return s, nil
125 }
126
127
128
129
130
131
132 func New(client *http.Client) (*Service, error) {
133 if client == nil {
134 return nil, errors.New("client is nil")
135 }
136 s := &Service{client: client, BasePath: basePath}
137 s.Eventticketclass = NewEventticketclassService(s)
138 s.Eventticketobject = NewEventticketobjectService(s)
139 s.Flightclass = NewFlightclassService(s)
140 s.Flightobject = NewFlightobjectService(s)
141 s.Genericclass = NewGenericclassService(s)
142 s.Genericobject = NewGenericobjectService(s)
143 s.Giftcardclass = NewGiftcardclassService(s)
144 s.Giftcardobject = NewGiftcardobjectService(s)
145 s.Issuer = NewIssuerService(s)
146 s.Jwt = NewJwtService(s)
147 s.Loyaltyclass = NewLoyaltyclassService(s)
148 s.Loyaltyobject = NewLoyaltyobjectService(s)
149 s.Media = NewMediaService(s)
150 s.Offerclass = NewOfferclassService(s)
151 s.Offerobject = NewOfferobjectService(s)
152 s.Permissions = NewPermissionsService(s)
153 s.Smarttap = NewSmarttapService(s)
154 s.Transitclass = NewTransitclassService(s)
155 s.Transitobject = NewTransitobjectService(s)
156 return s, nil
157 }
158
159 type Service struct {
160 client *http.Client
161 BasePath string
162 UserAgent string
163
164 Eventticketclass *EventticketclassService
165
166 Eventticketobject *EventticketobjectService
167
168 Flightclass *FlightclassService
169
170 Flightobject *FlightobjectService
171
172 Genericclass *GenericclassService
173
174 Genericobject *GenericobjectService
175
176 Giftcardclass *GiftcardclassService
177
178 Giftcardobject *GiftcardobjectService
179
180 Issuer *IssuerService
181
182 Jwt *JwtService
183
184 Loyaltyclass *LoyaltyclassService
185
186 Loyaltyobject *LoyaltyobjectService
187
188 Media *MediaService
189
190 Offerclass *OfferclassService
191
192 Offerobject *OfferobjectService
193
194 Permissions *PermissionsService
195
196 Smarttap *SmarttapService
197
198 Transitclass *TransitclassService
199
200 Transitobject *TransitobjectService
201 }
202
203 func (s *Service) userAgent() string {
204 if s.UserAgent == "" {
205 return googleapi.UserAgent
206 }
207 return googleapi.UserAgent + " " + s.UserAgent
208 }
209
210 func NewEventticketclassService(s *Service) *EventticketclassService {
211 rs := &EventticketclassService{s: s}
212 return rs
213 }
214
215 type EventticketclassService struct {
216 s *Service
217 }
218
219 func NewEventticketobjectService(s *Service) *EventticketobjectService {
220 rs := &EventticketobjectService{s: s}
221 return rs
222 }
223
224 type EventticketobjectService struct {
225 s *Service
226 }
227
228 func NewFlightclassService(s *Service) *FlightclassService {
229 rs := &FlightclassService{s: s}
230 return rs
231 }
232
233 type FlightclassService struct {
234 s *Service
235 }
236
237 func NewFlightobjectService(s *Service) *FlightobjectService {
238 rs := &FlightobjectService{s: s}
239 return rs
240 }
241
242 type FlightobjectService struct {
243 s *Service
244 }
245
246 func NewGenericclassService(s *Service) *GenericclassService {
247 rs := &GenericclassService{s: s}
248 return rs
249 }
250
251 type GenericclassService struct {
252 s *Service
253 }
254
255 func NewGenericobjectService(s *Service) *GenericobjectService {
256 rs := &GenericobjectService{s: s}
257 return rs
258 }
259
260 type GenericobjectService struct {
261 s *Service
262 }
263
264 func NewGiftcardclassService(s *Service) *GiftcardclassService {
265 rs := &GiftcardclassService{s: s}
266 return rs
267 }
268
269 type GiftcardclassService struct {
270 s *Service
271 }
272
273 func NewGiftcardobjectService(s *Service) *GiftcardobjectService {
274 rs := &GiftcardobjectService{s: s}
275 return rs
276 }
277
278 type GiftcardobjectService struct {
279 s *Service
280 }
281
282 func NewIssuerService(s *Service) *IssuerService {
283 rs := &IssuerService{s: s}
284 return rs
285 }
286
287 type IssuerService struct {
288 s *Service
289 }
290
291 func NewJwtService(s *Service) *JwtService {
292 rs := &JwtService{s: s}
293 return rs
294 }
295
296 type JwtService struct {
297 s *Service
298 }
299
300 func NewLoyaltyclassService(s *Service) *LoyaltyclassService {
301 rs := &LoyaltyclassService{s: s}
302 return rs
303 }
304
305 type LoyaltyclassService struct {
306 s *Service
307 }
308
309 func NewLoyaltyobjectService(s *Service) *LoyaltyobjectService {
310 rs := &LoyaltyobjectService{s: s}
311 return rs
312 }
313
314 type LoyaltyobjectService struct {
315 s *Service
316 }
317
318 func NewMediaService(s *Service) *MediaService {
319 rs := &MediaService{s: s}
320 return rs
321 }
322
323 type MediaService struct {
324 s *Service
325 }
326
327 func NewOfferclassService(s *Service) *OfferclassService {
328 rs := &OfferclassService{s: s}
329 return rs
330 }
331
332 type OfferclassService struct {
333 s *Service
334 }
335
336 func NewOfferobjectService(s *Service) *OfferobjectService {
337 rs := &OfferobjectService{s: s}
338 return rs
339 }
340
341 type OfferobjectService struct {
342 s *Service
343 }
344
345 func NewPermissionsService(s *Service) *PermissionsService {
346 rs := &PermissionsService{s: s}
347 return rs
348 }
349
350 type PermissionsService struct {
351 s *Service
352 }
353
354 func NewSmarttapService(s *Service) *SmarttapService {
355 rs := &SmarttapService{s: s}
356 return rs
357 }
358
359 type SmarttapService struct {
360 s *Service
361 }
362
363 func NewTransitclassService(s *Service) *TransitclassService {
364 rs := &TransitclassService{s: s}
365 return rs
366 }
367
368 type TransitclassService struct {
369 s *Service
370 }
371
372 func NewTransitobjectService(s *Service) *TransitobjectService {
373 rs := &TransitobjectService{s: s}
374 return rs
375 }
376
377 type TransitobjectService struct {
378 s *Service
379 }
380
381
382 type ActivationOptions struct {
383
384
385
386 ActivationUrl string `json:"activationUrl,omitempty"`
387
388
389
390
391 AllowReactivation bool `json:"allowReactivation,omitempty"`
392
393
394
395
396
397 ForceSendFields []string `json:"-"`
398
399
400
401
402 NullFields []string `json:"-"`
403 }
404
405 func (s *ActivationOptions) MarshalJSON() ([]byte, error) {
406 type NoMethod ActivationOptions
407 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
408 }
409
410
411
412 type ActivationStatus struct {
413
414
415
416
417
418
419 State string `json:"state,omitempty"`
420
421
422
423
424
425 ForceSendFields []string `json:"-"`
426
427
428
429
430 NullFields []string `json:"-"`
431 }
432
433 func (s *ActivationStatus) MarshalJSON() ([]byte, error) {
434 type NoMethod ActivationStatus
435 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
436 }
437
438
439 type AddMessageRequest struct {
440 Message *Message `json:"message,omitempty"`
441
442
443
444
445
446 ForceSendFields []string `json:"-"`
447
448
449
450
451 NullFields []string `json:"-"`
452 }
453
454 func (s *AddMessageRequest) MarshalJSON() ([]byte, error) {
455 type NoMethod AddMessageRequest
456 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
457 }
458
459 type AirportInfo struct {
460
461
462 AirportIataCode string `json:"airportIataCode,omitempty"`
463
464
465
466
467
468
469
470
471 AirportNameOverride *LocalizedString `json:"airportNameOverride,omitempty"`
472
473 Gate string `json:"gate,omitempty"`
474
475
476 Kind string `json:"kind,omitempty"`
477
478 Terminal string `json:"terminal,omitempty"`
479
480
481
482
483
484 ForceSendFields []string `json:"-"`
485
486
487
488
489 NullFields []string `json:"-"`
490 }
491
492 func (s *AirportInfo) MarshalJSON() ([]byte, error) {
493 type NoMethod AirportInfo
494 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
495 }
496
497 type AppLinkData struct {
498
499
500
501 AndroidAppLinkInfo *AppLinkDataAppLinkInfo `json:"androidAppLinkInfo,omitempty"`
502
503 IosAppLinkInfo *AppLinkDataAppLinkInfo `json:"iosAppLinkInfo,omitempty"`
504
505
506
507 WebAppLinkInfo *AppLinkDataAppLinkInfo `json:"webAppLinkInfo,omitempty"`
508
509
510
511
512
513 ForceSendFields []string `json:"-"`
514
515
516
517
518 NullFields []string `json:"-"`
519 }
520
521 func (s *AppLinkData) MarshalJSON() ([]byte, error) {
522 type NoMethod AppLinkData
523 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
524 }
525
526 type AppLinkDataAppLinkInfo struct {
527
528 AppLogoImage *Image `json:"appLogoImage,omitempty"`
529
530
531 AppTarget *AppLinkDataAppLinkInfoAppTarget `json:"appTarget,omitempty"`
532
533
534 Description *LocalizedString `json:"description,omitempty"`
535
536 Title *LocalizedString `json:"title,omitempty"`
537
538
539
540
541
542 ForceSendFields []string `json:"-"`
543
544
545
546
547 NullFields []string `json:"-"`
548 }
549
550 func (s *AppLinkDataAppLinkInfo) MarshalJSON() ([]byte, error) {
551 type NoMethod AppLinkDataAppLinkInfo
552 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
553 }
554
555 type AppLinkDataAppLinkInfoAppTarget struct {
556
557 PackageName string `json:"packageName,omitempty"`
558
559
560
561 TargetUri *Uri `json:"targetUri,omitempty"`
562
563
564
565
566
567 ForceSendFields []string `json:"-"`
568
569
570
571
572 NullFields []string `json:"-"`
573 }
574
575 func (s *AppLinkDataAppLinkInfoAppTarget) MarshalJSON() ([]byte, error) {
576 type NoMethod AppLinkDataAppLinkInfoAppTarget
577 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
578 }
579
580 type AuthenticationKey struct {
581
582
583 Id int64 `json:"id,omitempty"`
584
585
586 PublicKeyPem string `json:"publicKeyPem,omitempty"`
587
588
589
590
591
592 ForceSendFields []string `json:"-"`
593
594
595
596
597 NullFields []string `json:"-"`
598 }
599
600 func (s *AuthenticationKey) MarshalJSON() ([]byte, error) {
601 type NoMethod AuthenticationKey
602 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
603 }
604
605 type Barcode struct {
606
607
608
609 AlternateText string `json:"alternateText,omitempty"`
610
611
612 Kind string `json:"kind,omitempty"`
613
614
615
616
617
618
619
620
621 RenderEncoding string `json:"renderEncoding,omitempty"`
622
623
624
625 ShowCodeText *LocalizedString `json:"showCodeText,omitempty"`
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672 Type string `json:"type,omitempty"`
673
674 Value string `json:"value,omitempty"`
675
676
677
678
679
680 ForceSendFields []string `json:"-"`
681
682
683
684
685 NullFields []string `json:"-"`
686 }
687
688 func (s *Barcode) MarshalJSON() ([]byte, error) {
689 type NoMethod Barcode
690 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
691 }
692
693 type BarcodeSectionDetail struct {
694
695
696 FieldSelector *FieldSelector `json:"fieldSelector,omitempty"`
697
698
699
700
701
702 ForceSendFields []string `json:"-"`
703
704
705
706
707 NullFields []string `json:"-"`
708 }
709
710 func (s *BarcodeSectionDetail) MarshalJSON() ([]byte, error) {
711 type NoMethod BarcodeSectionDetail
712 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
713 }
714
715
716 type Blobstore2Info struct {
717
718 BlobGeneration int64 `json:"blobGeneration,omitempty,string"`
719
720 BlobId string `json:"blobId,omitempty"`
721
722
723
724
725 DownloadReadHandle string `json:"downloadReadHandle,omitempty"`
726
727
728 ReadToken string `json:"readToken,omitempty"`
729
730
731
732
733 UploadMetadataContainer string `json:"uploadMetadataContainer,omitempty"`
734
735
736
737
738
739 ForceSendFields []string `json:"-"`
740
741
742
743
744 NullFields []string `json:"-"`
745 }
746
747 func (s *Blobstore2Info) MarshalJSON() ([]byte, error) {
748 type NoMethod Blobstore2Info
749 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
750 }
751
752 type BoardingAndSeatingInfo struct {
753
754
755
756
757
758
759
760
761
762
763
764
765 BoardingDoor string `json:"boardingDoor,omitempty"`
766
767
768
769 BoardingGroup string `json:"boardingGroup,omitempty"`
770
771 BoardingPosition string `json:"boardingPosition,omitempty"`
772
773
774
775
776 BoardingPrivilegeImage *Image `json:"boardingPrivilegeImage,omitempty"`
777
778
779 Kind string `json:"kind,omitempty"`
780
781
782 SeatAssignment *LocalizedString `json:"seatAssignment,omitempty"`
783
784 SeatClass string `json:"seatClass,omitempty"`
785
786
787 SeatNumber string `json:"seatNumber,omitempty"`
788
789
790
791 SequenceNumber string `json:"sequenceNumber,omitempty"`
792
793
794
795
796
797 ForceSendFields []string `json:"-"`
798
799
800
801
802 NullFields []string `json:"-"`
803 }
804
805 func (s *BoardingAndSeatingInfo) MarshalJSON() ([]byte, error) {
806 type NoMethod BoardingAndSeatingInfo
807 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
808 }
809
810 type BoardingAndSeatingPolicy struct {
811
812
813
814
815
816
817
818
819
820
821
822
823 BoardingPolicy string `json:"boardingPolicy,omitempty"`
824
825
826 Kind string `json:"kind,omitempty"`
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841 SeatClassPolicy string `json:"seatClassPolicy,omitempty"`
842
843
844
845
846
847 ForceSendFields []string `json:"-"`
848
849
850
851
852 NullFields []string `json:"-"`
853 }
854
855 func (s *BoardingAndSeatingPolicy) MarshalJSON() ([]byte, error) {
856 type NoMethod BoardingAndSeatingPolicy
857 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
858 }
859
860 type CallbackOptions struct {
861
862
863
864 UpdateRequestUrl string `json:"updateRequestUrl,omitempty"`
865
866
867
868 Url string `json:"url,omitempty"`
869
870
871
872
873
874 ForceSendFields []string `json:"-"`
875
876
877
878
879 NullFields []string `json:"-"`
880 }
881
882 func (s *CallbackOptions) MarshalJSON() ([]byte, error) {
883 type NoMethod CallbackOptions
884 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
885 }
886
887 type CardBarcodeSectionDetails struct {
888
889 FirstBottomDetail *BarcodeSectionDetail `json:"firstBottomDetail,omitempty"`
890
891
892
893 FirstTopDetail *BarcodeSectionDetail `json:"firstTopDetail,omitempty"`
894
895
896
897 SecondTopDetail *BarcodeSectionDetail `json:"secondTopDetail,omitempty"`
898
899
900
901
902
903 ForceSendFields []string `json:"-"`
904
905
906
907
908 NullFields []string `json:"-"`
909 }
910
911 func (s *CardBarcodeSectionDetails) MarshalJSON() ([]byte, error) {
912 type NoMethod CardBarcodeSectionDetails
913 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
914 }
915
916 type CardRowOneItem struct {
917
918
919 Item *TemplateItem `json:"item,omitempty"`
920
921
922
923
924
925 ForceSendFields []string `json:"-"`
926
927
928
929
930 NullFields []string `json:"-"`
931 }
932
933 func (s *CardRowOneItem) MarshalJSON() ([]byte, error) {
934 type NoMethod CardRowOneItem
935 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
936 }
937
938 type CardRowTemplateInfo struct {
939
940
941 OneItem *CardRowOneItem `json:"oneItem,omitempty"`
942
943
944 ThreeItems *CardRowThreeItems `json:"threeItems,omitempty"`
945
946
947 TwoItems *CardRowTwoItems `json:"twoItems,omitempty"`
948
949
950
951
952
953 ForceSendFields []string `json:"-"`
954
955
956
957
958 NullFields []string `json:"-"`
959 }
960
961 func (s *CardRowTemplateInfo) MarshalJSON() ([]byte, error) {
962 type NoMethod CardRowTemplateInfo
963 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
964 }
965
966 type CardRowThreeItems struct {
967
968
969 EndItem *TemplateItem `json:"endItem,omitempty"`
970
971
972 MiddleItem *TemplateItem `json:"middleItem,omitempty"`
973
974
975 StartItem *TemplateItem `json:"startItem,omitempty"`
976
977
978
979
980
981 ForceSendFields []string `json:"-"`
982
983
984
985
986 NullFields []string `json:"-"`
987 }
988
989 func (s *CardRowThreeItems) MarshalJSON() ([]byte, error) {
990 type NoMethod CardRowThreeItems
991 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
992 }
993
994 type CardRowTwoItems struct {
995
996
997 EndItem *TemplateItem `json:"endItem,omitempty"`
998
999
1000 StartItem *TemplateItem `json:"startItem,omitempty"`
1001
1002
1003
1004
1005
1006 ForceSendFields []string `json:"-"`
1007
1008
1009
1010
1011 NullFields []string `json:"-"`
1012 }
1013
1014 func (s *CardRowTwoItems) MarshalJSON() ([]byte, error) {
1015 type NoMethod CardRowTwoItems
1016 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1017 }
1018
1019 type CardTemplateOverride struct {
1020
1021
1022 CardRowTemplateInfos []*CardRowTemplateInfo `json:"cardRowTemplateInfos,omitempty"`
1023
1024
1025
1026
1027
1028 ForceSendFields []string `json:"-"`
1029
1030
1031
1032
1033 NullFields []string `json:"-"`
1034 }
1035
1036 func (s *CardTemplateOverride) MarshalJSON() ([]byte, error) {
1037 type NoMethod CardTemplateOverride
1038 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1039 }
1040
1041 type ClassTemplateInfo struct {
1042
1043
1044 CardBarcodeSectionDetails *CardBarcodeSectionDetails `json:"cardBarcodeSectionDetails,omitempty"`
1045
1046 CardTemplateOverride *CardTemplateOverride `json:"cardTemplateOverride,omitempty"`
1047
1048
1049 DetailsTemplateOverride *DetailsTemplateOverride `json:"detailsTemplateOverride,omitempty"`
1050
1051 ListTemplateOverride *ListTemplateOverride `json:"listTemplateOverride,omitempty"`
1052
1053
1054
1055
1056
1057 ForceSendFields []string `json:"-"`
1058
1059
1060
1061
1062 NullFields []string `json:"-"`
1063 }
1064
1065 func (s *ClassTemplateInfo) MarshalJSON() ([]byte, error) {
1066 type NoMethod ClassTemplateInfo
1067 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1068 }
1069
1070
1071
1072
1073 type CompositeMedia struct {
1074
1075
1076
1077
1078 BlobRef string `json:"blobRef,omitempty"`
1079
1080
1081 Blobstore2Info *Blobstore2Info `json:"blobstore2Info,omitempty"`
1082
1083
1084
1085
1086
1087
1088 CosmoBinaryReference string `json:"cosmoBinaryReference,omitempty"`
1089
1090 Crc32cHash int64 `json:"crc32cHash,omitempty"`
1091
1092 Inline string `json:"inline,omitempty"`
1093
1094 Length int64 `json:"length,omitempty,string"`
1095
1096 Md5Hash string `json:"md5Hash,omitempty"`
1097
1098 ObjectId *ObjectId `json:"objectId,omitempty"`
1099
1100 Path string `json:"path,omitempty"`
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112 ReferenceType string `json:"referenceType,omitempty"`
1113
1114 Sha1Hash string `json:"sha1Hash,omitempty"`
1115
1116
1117
1118
1119
1120 ForceSendFields []string `json:"-"`
1121
1122
1123
1124
1125 NullFields []string `json:"-"`
1126 }
1127
1128 func (s *CompositeMedia) MarshalJSON() ([]byte, error) {
1129 type NoMethod CompositeMedia
1130 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1131 }
1132
1133
1134
1135
1136
1137
1138 type ContentTypeInfo struct {
1139
1140 BestGuess string `json:"bestGuess,omitempty"`
1141
1142
1143 FromBytes string `json:"fromBytes,omitempty"`
1144
1145
1146 FromFileName string `json:"fromFileName,omitempty"`
1147
1148
1149 FromHeader string `json:"fromHeader,omitempty"`
1150
1151
1152
1153 FromUrlPath string `json:"fromUrlPath,omitempty"`
1154
1155
1156
1157
1158
1159 ForceSendFields []string `json:"-"`
1160
1161
1162
1163
1164 NullFields []string `json:"-"`
1165 }
1166
1167 func (s *ContentTypeInfo) MarshalJSON() ([]byte, error) {
1168 type NoMethod ContentTypeInfo
1169 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1170 }
1171
1172 type DateTime struct {
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195 Date string `json:"date,omitempty"`
1196
1197
1198
1199
1200
1201 ForceSendFields []string `json:"-"`
1202
1203
1204
1205
1206 NullFields []string `json:"-"`
1207 }
1208
1209 func (s *DateTime) MarshalJSON() ([]byte, error) {
1210 type NoMethod DateTime
1211 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1212 }
1213
1214 type DetailsItemInfo struct {
1215
1216 Item *TemplateItem `json:"item,omitempty"`
1217
1218
1219
1220
1221
1222 ForceSendFields []string `json:"-"`
1223
1224
1225
1226
1227 NullFields []string `json:"-"`
1228 }
1229
1230 func (s *DetailsItemInfo) MarshalJSON() ([]byte, error) {
1231 type NoMethod DetailsItemInfo
1232 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1233 }
1234
1235 type DetailsTemplateOverride struct {
1236
1237
1238 DetailsItemInfos []*DetailsItemInfo `json:"detailsItemInfos,omitempty"`
1239
1240
1241
1242
1243
1244 ForceSendFields []string `json:"-"`
1245
1246
1247
1248
1249 NullFields []string `json:"-"`
1250 }
1251
1252 func (s *DetailsTemplateOverride) MarshalJSON() ([]byte, error) {
1253 type NoMethod DetailsTemplateOverride
1254 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1255 }
1256
1257
1258 type DeviceContext struct {
1259
1260
1261
1262
1263
1264
1265 DeviceToken string `json:"deviceToken,omitempty"`
1266
1267
1268
1269
1270
1271 ForceSendFields []string `json:"-"`
1272
1273
1274
1275
1276 NullFields []string `json:"-"`
1277 }
1278
1279 func (s *DeviceContext) MarshalJSON() ([]byte, error) {
1280 type NoMethod DeviceContext
1281 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1282 }
1283
1284
1285
1286
1287 type DiffChecksumsResponse struct {
1288
1289
1290
1291
1292
1293
1294 ChecksumsLocation *CompositeMedia `json:"checksumsLocation,omitempty"`
1295
1296 ChunkSizeBytes int64 `json:"chunkSizeBytes,omitempty,string"`
1297
1298
1299 ObjectLocation *CompositeMedia `json:"objectLocation,omitempty"`
1300
1301 ObjectSizeBytes int64 `json:"objectSizeBytes,omitempty,string"`
1302
1303
1304 ObjectVersion string `json:"objectVersion,omitempty"`
1305
1306
1307
1308
1309
1310 ForceSendFields []string `json:"-"`
1311
1312
1313
1314
1315 NullFields []string `json:"-"`
1316 }
1317
1318 func (s *DiffChecksumsResponse) MarshalJSON() ([]byte, error) {
1319 type NoMethod DiffChecksumsResponse
1320 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1321 }
1322
1323
1324
1325 type DiffDownloadResponse struct {
1326
1327 ObjectLocation *CompositeMedia `json:"objectLocation,omitempty"`
1328
1329
1330
1331
1332
1333 ForceSendFields []string `json:"-"`
1334
1335
1336
1337
1338 NullFields []string `json:"-"`
1339 }
1340
1341 func (s *DiffDownloadResponse) MarshalJSON() ([]byte, error) {
1342 type NoMethod DiffDownloadResponse
1343 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1344 }
1345
1346
1347
1348 type DiffUploadRequest struct {
1349
1350
1351
1352
1353 ChecksumsInfo *CompositeMedia `json:"checksumsInfo,omitempty"`
1354
1355
1356
1357 ObjectInfo *CompositeMedia `json:"objectInfo,omitempty"`
1358
1359
1360
1361 ObjectVersion string `json:"objectVersion,omitempty"`
1362
1363
1364
1365
1366
1367 ForceSendFields []string `json:"-"`
1368
1369
1370
1371
1372 NullFields []string `json:"-"`
1373 }
1374
1375 func (s *DiffUploadRequest) MarshalJSON() ([]byte, error) {
1376 type NoMethod DiffUploadRequest
1377 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1378 }
1379
1380
1381
1382 type DiffUploadResponse struct {
1383
1384
1385
1386
1387 ObjectVersion string `json:"objectVersion,omitempty"`
1388
1389
1390 OriginalObject *CompositeMedia `json:"originalObject,omitempty"`
1391
1392
1393
1394
1395
1396 ForceSendFields []string `json:"-"`
1397
1398
1399
1400
1401 NullFields []string `json:"-"`
1402 }
1403
1404 func (s *DiffUploadResponse) MarshalJSON() ([]byte, error) {
1405 type NoMethod DiffUploadResponse
1406 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1407 }
1408
1409
1410
1411 type DiffVersionResponse struct {
1412
1413 ObjectSizeBytes int64 `json:"objectSizeBytes,omitempty,string"`
1414
1415 ObjectVersion string `json:"objectVersion,omitempty"`
1416
1417
1418
1419
1420
1421 ForceSendFields []string `json:"-"`
1422
1423
1424
1425
1426 NullFields []string `json:"-"`
1427 }
1428
1429 func (s *DiffVersionResponse) MarshalJSON() ([]byte, error) {
1430 type NoMethod DiffVersionResponse
1431 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1432 }
1433
1434
1435
1436
1437 type DiscoverableProgram struct {
1438
1439
1440
1441 MerchantSigninInfo *DiscoverableProgramMerchantSigninInfo `json:"merchantSigninInfo,omitempty"`
1442
1443
1444
1445 MerchantSignupInfo *DiscoverableProgramMerchantSignupInfo `json:"merchantSignupInfo,omitempty"`
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457 State string `json:"state,omitempty"`
1458
1459
1460
1461
1462
1463 ForceSendFields []string `json:"-"`
1464
1465
1466
1467
1468 NullFields []string `json:"-"`
1469 }
1470
1471 func (s *DiscoverableProgram) MarshalJSON() ([]byte, error) {
1472 type NoMethod DiscoverableProgram
1473 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1474 }
1475
1476
1477
1478 type DiscoverableProgramMerchantSigninInfo struct {
1479
1480 SigninWebsite *Uri `json:"signinWebsite,omitempty"`
1481
1482
1483
1484
1485
1486 ForceSendFields []string `json:"-"`
1487
1488
1489
1490
1491 NullFields []string `json:"-"`
1492 }
1493
1494 func (s *DiscoverableProgramMerchantSigninInfo) MarshalJSON() ([]byte, error) {
1495 type NoMethod DiscoverableProgramMerchantSigninInfo
1496 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1497 }
1498
1499
1500
1501 type DiscoverableProgramMerchantSignupInfo struct {
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521 SignupSharedDatas []string `json:"signupSharedDatas,omitempty"`
1522
1523 SignupWebsite *Uri `json:"signupWebsite,omitempty"`
1524
1525
1526
1527
1528
1529 ForceSendFields []string `json:"-"`
1530
1531
1532
1533
1534 NullFields []string `json:"-"`
1535 }
1536
1537 func (s *DiscoverableProgramMerchantSignupInfo) MarshalJSON() ([]byte, error) {
1538 type NoMethod DiscoverableProgramMerchantSignupInfo
1539 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1540 }
1541
1542
1543 type DownloadParameters struct {
1544
1545
1546
1547
1548 AllowGzipCompression bool `json:"allowGzipCompression,omitempty"`
1549
1550
1551 IgnoreRange bool `json:"ignoreRange,omitempty"`
1552
1553
1554
1555
1556
1557 ForceSendFields []string `json:"-"`
1558
1559
1560
1561
1562 NullFields []string `json:"-"`
1563 }
1564
1565 func (s *DownloadParameters) MarshalJSON() ([]byte, error) {
1566 type NoMethod DownloadParameters
1567 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1568 }
1569
1570 type EventDateTime struct {
1571
1572
1573
1574
1575
1576
1577 CustomDoorsOpenLabel *LocalizedString `json:"customDoorsOpenLabel,omitempty"`
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597 DoorsOpen string `json:"doorsOpen,omitempty"`
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611 DoorsOpenLabel string `json:"doorsOpenLabel,omitempty"`
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632 End string `json:"end,omitempty"`
1633
1634
1635 Kind string `json:"kind,omitempty"`
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656 Start string `json:"start,omitempty"`
1657
1658
1659
1660
1661
1662 ForceSendFields []string `json:"-"`
1663
1664
1665
1666
1667 NullFields []string `json:"-"`
1668 }
1669
1670 func (s *EventDateTime) MarshalJSON() ([]byte, error) {
1671 type NoMethod EventDateTime
1672 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1673 }
1674
1675 type EventReservationInfo struct {
1676
1677
1678
1679 ConfirmationCode string `json:"confirmationCode,omitempty"`
1680
1681
1682 Kind string `json:"kind,omitempty"`
1683
1684
1685
1686
1687
1688 ForceSendFields []string `json:"-"`
1689
1690
1691
1692
1693 NullFields []string `json:"-"`
1694 }
1695
1696 func (s *EventReservationInfo) MarshalJSON() ([]byte, error) {
1697 type NoMethod EventReservationInfo
1698 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1699 }
1700
1701 type EventSeat struct {
1702
1703
1704
1705 Gate *LocalizedString `json:"gate,omitempty"`
1706
1707
1708 Kind string `json:"kind,omitempty"`
1709
1710
1711
1712 Row *LocalizedString `json:"row,omitempty"`
1713
1714
1715
1716 Seat *LocalizedString `json:"seat,omitempty"`
1717
1718
1719
1720 Section *LocalizedString `json:"section,omitempty"`
1721
1722
1723
1724
1725
1726 ForceSendFields []string `json:"-"`
1727
1728
1729
1730
1731 NullFields []string `json:"-"`
1732 }
1733
1734 func (s *EventSeat) MarshalJSON() ([]byte, error) {
1735 type NoMethod EventSeat
1736 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1737 }
1738
1739 type EventTicketClass struct {
1740
1741
1742 AllowMultipleUsersPerObject bool `json:"allowMultipleUsersPerObject,omitempty"`
1743
1744
1745
1746 CallbackOptions *CallbackOptions `json:"callbackOptions,omitempty"`
1747
1748
1749
1750 ClassTemplateInfo *ClassTemplateInfo `json:"classTemplateInfo,omitempty"`
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769 ConfirmationCodeLabel string `json:"confirmationCodeLabel,omitempty"`
1770
1771
1772
1773 CountryCode string `json:"countryCode,omitempty"`
1774
1775
1776
1777
1778
1779
1780
1781 CustomConfirmationCodeLabel *LocalizedString `json:"customConfirmationCodeLabel,omitempty"`
1782
1783
1784
1785
1786
1787
1788 CustomGateLabel *LocalizedString `json:"customGateLabel,omitempty"`
1789
1790
1791
1792
1793
1794
1795 CustomRowLabel *LocalizedString `json:"customRowLabel,omitempty"`
1796
1797
1798
1799
1800
1801
1802 CustomSeatLabel *LocalizedString `json:"customSeatLabel,omitempty"`
1803
1804
1805
1806
1807
1808
1809 CustomSectionLabel *LocalizedString `json:"customSectionLabel,omitempty"`
1810
1811 DateTime *EventDateTime `json:"dateTime,omitempty"`
1812
1813
1814
1815 EnableSmartTap bool `json:"enableSmartTap,omitempty"`
1816
1817
1818
1819
1820
1821
1822
1823
1824 EventId string `json:"eventId,omitempty"`
1825
1826
1827 EventName *LocalizedString `json:"eventName,omitempty"`
1828
1829 FinePrint *LocalizedString `json:"finePrint,omitempty"`
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845 GateLabel string `json:"gateLabel,omitempty"`
1846
1847
1848 HeroImage *Image `json:"heroImage,omitempty"`
1849
1850
1851
1852
1853
1854 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
1855
1856
1857
1858
1859
1860 HomepageUri *Uri `json:"homepageUri,omitempty"`
1861
1862
1863
1864
1865
1866 Id string `json:"id,omitempty"`
1867
1868
1869 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
1870
1871 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
1872
1873
1874 IssuerName string `json:"issuerName,omitempty"`
1875
1876
1877 Kind string `json:"kind,omitempty"`
1878
1879
1880 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
1881
1882
1883
1884 LocalizedIssuerName *LocalizedString `json:"localizedIssuerName,omitempty"`
1885
1886
1887 Locations []*LatLongPoint `json:"locations,omitempty"`
1888
1889
1890 Logo *Image `json:"logo,omitempty"`
1891
1892
1893
1894 Messages []*Message `json:"messages,omitempty"`
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915 MultipleDevicesAndHoldersAllowedStatus string `json:"multipleDevicesAndHoldersAllowedStatus,omitempty"`
1916
1917
1918
1919
1920
1921 RedemptionIssuers googleapi.Int64s `json:"redemptionIssuers,omitempty"`
1922
1923
1924 Review *Review `json:"review,omitempty"`
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945 ReviewStatus string `json:"reviewStatus,omitempty"`
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957 RowLabel string `json:"rowLabel,omitempty"`
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969 SeatLabel string `json:"seatLabel,omitempty"`
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984 SectionLabel string `json:"sectionLabel,omitempty"`
1985
1986
1987 SecurityAnimation *SecurityAnimation `json:"securityAnimation,omitempty"`
1988
1989
1990
1991 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
1992
1993 Venue *EventVenue `json:"venue,omitempty"`
1994
1995 Version int64 `json:"version,omitempty,string"`
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007 ViewUnlockRequirement string `json:"viewUnlockRequirement,omitempty"`
2008
2009
2010 WideLogo *Image `json:"wideLogo,omitempty"`
2011
2012 WordMark *Image `json:"wordMark,omitempty"`
2013
2014
2015 googleapi.ServerResponse `json:"-"`
2016
2017
2018
2019
2020
2021 ForceSendFields []string `json:"-"`
2022
2023
2024
2025
2026 NullFields []string `json:"-"`
2027 }
2028
2029 func (s *EventTicketClass) MarshalJSON() ([]byte, error) {
2030 type NoMethod EventTicketClass
2031 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2032 }
2033
2034 type EventTicketClassAddMessageResponse struct {
2035
2036 Resource *EventTicketClass `json:"resource,omitempty"`
2037
2038
2039 googleapi.ServerResponse `json:"-"`
2040
2041
2042
2043
2044
2045 ForceSendFields []string `json:"-"`
2046
2047
2048
2049
2050 NullFields []string `json:"-"`
2051 }
2052
2053 func (s *EventTicketClassAddMessageResponse) MarshalJSON() ([]byte, error) {
2054 type NoMethod EventTicketClassAddMessageResponse
2055 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2056 }
2057
2058 type EventTicketClassListResponse struct {
2059
2060 Pagination *Pagination `json:"pagination,omitempty"`
2061
2062 Resources []*EventTicketClass `json:"resources,omitempty"`
2063
2064
2065 googleapi.ServerResponse `json:"-"`
2066
2067
2068
2069
2070
2071 ForceSendFields []string `json:"-"`
2072
2073
2074
2075
2076 NullFields []string `json:"-"`
2077 }
2078
2079 func (s *EventTicketClassListResponse) MarshalJSON() ([]byte, error) {
2080 type NoMethod EventTicketClassListResponse
2081 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2082 }
2083
2084 type EventTicketObject struct {
2085
2086 AppLinkData *AppLinkData `json:"appLinkData,omitempty"`
2087
2088 Barcode *Barcode `json:"barcode,omitempty"`
2089
2090
2091
2092
2093 ClassId string `json:"classId,omitempty"`
2094
2095
2096 ClassReference *EventTicketClass `json:"classReference,omitempty"`
2097
2098
2099
2100
2101 DisableExpirationNotification bool `json:"disableExpirationNotification,omitempty"`
2102
2103
2104 FaceValue *Money `json:"faceValue,omitempty"`
2105
2106 GroupingInfo *GroupingInfo `json:"groupingInfo,omitempty"`
2107
2108
2109
2110
2111 HasLinkedDevice bool `json:"hasLinkedDevice,omitempty"`
2112
2113
2114 HasUsers bool `json:"hasUsers,omitempty"`
2115
2116
2117
2118 HeroImage *Image `json:"heroImage,omitempty"`
2119
2120
2121
2122
2123
2124 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
2125
2126
2127
2128
2129
2130 Id string `json:"id,omitempty"`
2131
2132
2133 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
2134
2135 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
2136
2137
2138 Kind string `json:"kind,omitempty"`
2139
2140
2141
2142
2143 LinkedOfferIds []string `json:"linkedOfferIds,omitempty"`
2144
2145
2146 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
2147
2148
2149 Locations []*LatLongPoint `json:"locations,omitempty"`
2150
2151
2152
2153 Messages []*Message `json:"messages,omitempty"`
2154
2155
2156 PassConstraints *PassConstraints `json:"passConstraints,omitempty"`
2157
2158
2159 ReservationInfo *EventReservationInfo `json:"reservationInfo,omitempty"`
2160
2161 RotatingBarcode *RotatingBarcode `json:"rotatingBarcode,omitempty"`
2162
2163 SeatInfo *EventSeat `json:"seatInfo,omitempty"`
2164
2165
2166
2167
2168
2169 SmartTapRedemptionValue string `json:"smartTapRedemptionValue,omitempty"`
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184 State string `json:"state,omitempty"`
2185
2186
2187
2188 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
2189
2190
2191 TicketHolderName string `json:"ticketHolderName,omitempty"`
2192
2193
2194
2195 TicketNumber string `json:"ticketNumber,omitempty"`
2196
2197
2198 TicketType *LocalizedString `json:"ticketType,omitempty"`
2199
2200
2201
2202 ValidTimeInterval *TimeInterval `json:"validTimeInterval,omitempty"`
2203
2204 Version int64 `json:"version,omitempty,string"`
2205
2206
2207 googleapi.ServerResponse `json:"-"`
2208
2209
2210
2211
2212
2213 ForceSendFields []string `json:"-"`
2214
2215
2216
2217
2218 NullFields []string `json:"-"`
2219 }
2220
2221 func (s *EventTicketObject) MarshalJSON() ([]byte, error) {
2222 type NoMethod EventTicketObject
2223 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2224 }
2225
2226 type EventTicketObjectAddMessageResponse struct {
2227
2228 Resource *EventTicketObject `json:"resource,omitempty"`
2229
2230
2231 googleapi.ServerResponse `json:"-"`
2232
2233
2234
2235
2236
2237 ForceSendFields []string `json:"-"`
2238
2239
2240
2241
2242 NullFields []string `json:"-"`
2243 }
2244
2245 func (s *EventTicketObjectAddMessageResponse) MarshalJSON() ([]byte, error) {
2246 type NoMethod EventTicketObjectAddMessageResponse
2247 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2248 }
2249
2250 type EventTicketObjectListResponse struct {
2251
2252 Pagination *Pagination `json:"pagination,omitempty"`
2253
2254 Resources []*EventTicketObject `json:"resources,omitempty"`
2255
2256
2257 googleapi.ServerResponse `json:"-"`
2258
2259
2260
2261
2262
2263 ForceSendFields []string `json:"-"`
2264
2265
2266
2267
2268 NullFields []string `json:"-"`
2269 }
2270
2271 func (s *EventTicketObjectListResponse) MarshalJSON() ([]byte, error) {
2272 type NoMethod EventTicketObjectListResponse
2273 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2274 }
2275
2276 type EventVenue struct {
2277
2278
2279
2280 Address *LocalizedString `json:"address,omitempty"`
2281
2282
2283 Kind string `json:"kind,omitempty"`
2284
2285 Name *LocalizedString `json:"name,omitempty"`
2286
2287
2288
2289
2290
2291 ForceSendFields []string `json:"-"`
2292
2293
2294
2295
2296 NullFields []string `json:"-"`
2297 }
2298
2299 func (s *EventVenue) MarshalJSON() ([]byte, error) {
2300 type NoMethod EventVenue
2301 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2302 }
2303
2304
2305
2306 type ExpiryNotification struct {
2307
2308
2309 EnableNotification bool `json:"enableNotification,omitempty"`
2310
2311
2312
2313
2314
2315 ForceSendFields []string `json:"-"`
2316
2317
2318
2319
2320 NullFields []string `json:"-"`
2321 }
2322
2323 func (s *ExpiryNotification) MarshalJSON() ([]byte, error) {
2324 type NoMethod ExpiryNotification
2325 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2326 }
2327
2328
2329 type FieldReference struct {
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350 DateFormat string `json:"dateFormat,omitempty"`
2351
2352
2353
2354 FieldPath string `json:"fieldPath,omitempty"`
2355
2356
2357
2358
2359
2360 ForceSendFields []string `json:"-"`
2361
2362
2363
2364
2365 NullFields []string `json:"-"`
2366 }
2367
2368 func (s *FieldReference) MarshalJSON() ([]byte, error) {
2369 type NoMethod FieldReference
2370 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2371 }
2372
2373
2374 type FieldSelector struct {
2375
2376
2377 Fields []*FieldReference `json:"fields,omitempty"`
2378
2379
2380
2381
2382
2383 ForceSendFields []string `json:"-"`
2384
2385
2386
2387
2388 NullFields []string `json:"-"`
2389 }
2390
2391 func (s *FieldSelector) MarshalJSON() ([]byte, error) {
2392 type NoMethod FieldSelector
2393 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2394 }
2395
2396 type FirstRowOption struct {
2397
2398 FieldOption *FieldSelector `json:"fieldOption,omitempty"`
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409 TransitOption string `json:"transitOption,omitempty"`
2410
2411
2412
2413
2414
2415 ForceSendFields []string `json:"-"`
2416
2417
2418
2419
2420 NullFields []string `json:"-"`
2421 }
2422
2423 func (s *FirstRowOption) MarshalJSON() ([]byte, error) {
2424 type NoMethod FirstRowOption
2425 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2426 }
2427
2428 type FlightCarrier struct {
2429
2430
2431 AirlineAllianceLogo *Image `json:"airlineAllianceLogo,omitempty"`
2432
2433
2434
2435 AirlineLogo *Image `json:"airlineLogo,omitempty"`
2436
2437
2438
2439 AirlineName *LocalizedString `json:"airlineName,omitempty"`
2440
2441
2442
2443
2444 CarrierIataCode string `json:"carrierIataCode,omitempty"`
2445
2446
2447
2448
2449 CarrierIcaoCode string `json:"carrierIcaoCode,omitempty"`
2450
2451
2452 Kind string `json:"kind,omitempty"`
2453
2454
2455 WideAirlineLogo *Image `json:"wideAirlineLogo,omitempty"`
2456
2457
2458
2459
2460
2461 ForceSendFields []string `json:"-"`
2462
2463
2464
2465
2466 NullFields []string `json:"-"`
2467 }
2468
2469 func (s *FlightCarrier) MarshalJSON() ([]byte, error) {
2470 type NoMethod FlightCarrier
2471 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2472 }
2473
2474 type FlightClass struct {
2475
2476
2477 AllowMultipleUsersPerObject bool `json:"allowMultipleUsersPerObject,omitempty"`
2478
2479
2480 BoardingAndSeatingPolicy *BoardingAndSeatingPolicy `json:"boardingAndSeatingPolicy,omitempty"`
2481
2482
2483
2484 CallbackOptions *CallbackOptions `json:"callbackOptions,omitempty"`
2485
2486
2487
2488 ClassTemplateInfo *ClassTemplateInfo `json:"classTemplateInfo,omitempty"`
2489
2490
2491
2492 CountryCode string `json:"countryCode,omitempty"`
2493
2494 Destination *AirportInfo `json:"destination,omitempty"`
2495
2496
2497
2498 EnableSmartTap bool `json:"enableSmartTap,omitempty"`
2499
2500 FlightHeader *FlightHeader `json:"flightHeader,omitempty"`
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521 FlightStatus string `json:"flightStatus,omitempty"`
2522
2523
2524 HeroImage *Image `json:"heroImage,omitempty"`
2525
2526
2527
2528
2529
2530 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
2531
2532
2533
2534
2535
2536 HomepageUri *Uri `json:"homepageUri,omitempty"`
2537
2538
2539
2540
2541
2542 Id string `json:"id,omitempty"`
2543
2544
2545 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
2546
2547 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
2548
2549
2550 IssuerName string `json:"issuerName,omitempty"`
2551
2552
2553 Kind string `json:"kind,omitempty"`
2554
2555
2556
2557 LanguageOverride string `json:"languageOverride,omitempty"`
2558
2559
2560 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
2561
2562
2563
2564
2565
2566
2567
2568 LocalBoardingDateTime string `json:"localBoardingDateTime,omitempty"`
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581 LocalEstimatedOrActualArrivalDateTime string `json:"localEstimatedOrActualArrivalDateTime,omitempty"`
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594 LocalEstimatedOrActualDepartureDateTime string `json:"localEstimatedOrActualDepartureDateTime,omitempty"`
2595
2596
2597
2598
2599
2600
2601
2602 LocalGateClosingDateTime string `json:"localGateClosingDateTime,omitempty"`
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613 LocalScheduledArrivalDateTime string `json:"localScheduledArrivalDateTime,omitempty"`
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624 LocalScheduledDepartureDateTime string `json:"localScheduledDepartureDateTime,omitempty"`
2625
2626
2627
2628 LocalizedIssuerName *LocalizedString `json:"localizedIssuerName,omitempty"`
2629
2630
2631 Locations []*LatLongPoint `json:"locations,omitempty"`
2632
2633
2634
2635 Messages []*Message `json:"messages,omitempty"`
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656 MultipleDevicesAndHoldersAllowedStatus string `json:"multipleDevicesAndHoldersAllowedStatus,omitempty"`
2657
2658 Origin *AirportInfo `json:"origin,omitempty"`
2659
2660
2661
2662
2663
2664 RedemptionIssuers googleapi.Int64s `json:"redemptionIssuers,omitempty"`
2665
2666
2667 Review *Review `json:"review,omitempty"`
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688 ReviewStatus string `json:"reviewStatus,omitempty"`
2689
2690
2691 SecurityAnimation *SecurityAnimation `json:"securityAnimation,omitempty"`
2692
2693
2694
2695 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
2696
2697 Version int64 `json:"version,omitempty,string"`
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710 ViewUnlockRequirement string `json:"viewUnlockRequirement,omitempty"`
2711
2712 WordMark *Image `json:"wordMark,omitempty"`
2713
2714
2715 googleapi.ServerResponse `json:"-"`
2716
2717
2718
2719
2720
2721 ForceSendFields []string `json:"-"`
2722
2723
2724
2725
2726 NullFields []string `json:"-"`
2727 }
2728
2729 func (s *FlightClass) MarshalJSON() ([]byte, error) {
2730 type NoMethod FlightClass
2731 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2732 }
2733
2734 type FlightClassAddMessageResponse struct {
2735
2736 Resource *FlightClass `json:"resource,omitempty"`
2737
2738
2739 googleapi.ServerResponse `json:"-"`
2740
2741
2742
2743
2744
2745 ForceSendFields []string `json:"-"`
2746
2747
2748
2749
2750 NullFields []string `json:"-"`
2751 }
2752
2753 func (s *FlightClassAddMessageResponse) MarshalJSON() ([]byte, error) {
2754 type NoMethod FlightClassAddMessageResponse
2755 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2756 }
2757
2758 type FlightClassListResponse struct {
2759
2760 Pagination *Pagination `json:"pagination,omitempty"`
2761
2762 Resources []*FlightClass `json:"resources,omitempty"`
2763
2764
2765 googleapi.ServerResponse `json:"-"`
2766
2767
2768
2769
2770
2771 ForceSendFields []string `json:"-"`
2772
2773
2774
2775
2776 NullFields []string `json:"-"`
2777 }
2778
2779 func (s *FlightClassListResponse) MarshalJSON() ([]byte, error) {
2780 type NoMethod FlightClassListResponse
2781 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2782 }
2783
2784 type FlightHeader struct {
2785
2786
2787 Carrier *FlightCarrier `json:"carrier,omitempty"`
2788
2789
2790
2791 FlightNumber string `json:"flightNumber,omitempty"`
2792
2793
2794
2795
2796 FlightNumberDisplayOverride string `json:"flightNumberDisplayOverride,omitempty"`
2797
2798
2799 Kind string `json:"kind,omitempty"`
2800
2801 OperatingCarrier *FlightCarrier `json:"operatingCarrier,omitempty"`
2802
2803
2804 OperatingFlightNumber string `json:"operatingFlightNumber,omitempty"`
2805
2806
2807
2808
2809
2810 ForceSendFields []string `json:"-"`
2811
2812
2813
2814
2815 NullFields []string `json:"-"`
2816 }
2817
2818 func (s *FlightHeader) MarshalJSON() ([]byte, error) {
2819 type NoMethod FlightHeader
2820 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2821 }
2822
2823 type FlightObject struct {
2824
2825 AppLinkData *AppLinkData `json:"appLinkData,omitempty"`
2826
2827 Barcode *Barcode `json:"barcode,omitempty"`
2828
2829
2830 BoardingAndSeatingInfo *BoardingAndSeatingInfo `json:"boardingAndSeatingInfo,omitempty"`
2831
2832
2833
2834
2835 ClassId string `json:"classId,omitempty"`
2836
2837
2838 ClassReference *FlightClass `json:"classReference,omitempty"`
2839
2840
2841
2842
2843 DisableExpirationNotification bool `json:"disableExpirationNotification,omitempty"`
2844
2845 GroupingInfo *GroupingInfo `json:"groupingInfo,omitempty"`
2846
2847
2848
2849
2850 HasLinkedDevice bool `json:"hasLinkedDevice,omitempty"`
2851
2852
2853 HasUsers bool `json:"hasUsers,omitempty"`
2854
2855
2856
2857 HeroImage *Image `json:"heroImage,omitempty"`
2858
2859
2860
2861
2862
2863 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
2864
2865
2866
2867
2868
2869 Id string `json:"id,omitempty"`
2870
2871
2872 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
2873
2874 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
2875
2876
2877 Kind string `json:"kind,omitempty"`
2878
2879
2880 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
2881
2882
2883 Locations []*LatLongPoint `json:"locations,omitempty"`
2884
2885
2886
2887 Messages []*Message `json:"messages,omitempty"`
2888
2889
2890 PassConstraints *PassConstraints `json:"passConstraints,omitempty"`
2891
2892
2893 PassengerName string `json:"passengerName,omitempty"`
2894
2895 ReservationInfo *ReservationInfo `json:"reservationInfo,omitempty"`
2896
2897 RotatingBarcode *RotatingBarcode `json:"rotatingBarcode,omitempty"`
2898
2899
2900 SecurityProgramLogo *Image `json:"securityProgramLogo,omitempty"`
2901
2902
2903
2904
2905
2906 SmartTapRedemptionValue string `json:"smartTapRedemptionValue,omitempty"`
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921 State string `json:"state,omitempty"`
2922
2923
2924
2925 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
2926
2927
2928
2929 ValidTimeInterval *TimeInterval `json:"validTimeInterval,omitempty"`
2930
2931 Version int64 `json:"version,omitempty,string"`
2932
2933
2934 googleapi.ServerResponse `json:"-"`
2935
2936
2937
2938
2939
2940 ForceSendFields []string `json:"-"`
2941
2942
2943
2944
2945 NullFields []string `json:"-"`
2946 }
2947
2948 func (s *FlightObject) MarshalJSON() ([]byte, error) {
2949 type NoMethod FlightObject
2950 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2951 }
2952
2953 type FlightObjectAddMessageResponse struct {
2954
2955 Resource *FlightObject `json:"resource,omitempty"`
2956
2957
2958 googleapi.ServerResponse `json:"-"`
2959
2960
2961
2962
2963
2964 ForceSendFields []string `json:"-"`
2965
2966
2967
2968
2969 NullFields []string `json:"-"`
2970 }
2971
2972 func (s *FlightObjectAddMessageResponse) MarshalJSON() ([]byte, error) {
2973 type NoMethod FlightObjectAddMessageResponse
2974 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2975 }
2976
2977 type FlightObjectListResponse struct {
2978
2979 Pagination *Pagination `json:"pagination,omitempty"`
2980
2981 Resources []*FlightObject `json:"resources,omitempty"`
2982
2983
2984 googleapi.ServerResponse `json:"-"`
2985
2986
2987
2988
2989
2990 ForceSendFields []string `json:"-"`
2991
2992
2993
2994
2995 NullFields []string `json:"-"`
2996 }
2997
2998 func (s *FlightObjectListResponse) MarshalJSON() ([]byte, error) {
2999 type NoMethod FlightObjectListResponse
3000 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3001 }
3002
3003 type FrequentFlyerInfo struct {
3004
3005
3006 FrequentFlyerNumber string `json:"frequentFlyerNumber,omitempty"`
3007
3008
3009 FrequentFlyerProgramName *LocalizedString `json:"frequentFlyerProgramName,omitempty"`
3010
3011
3012 Kind string `json:"kind,omitempty"`
3013
3014
3015
3016
3017
3018 ForceSendFields []string `json:"-"`
3019
3020
3021
3022
3023 NullFields []string `json:"-"`
3024 }
3025
3026 func (s *FrequentFlyerInfo) MarshalJSON() ([]byte, error) {
3027 type NoMethod FrequentFlyerInfo
3028 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3029 }
3030
3031
3032 type GenericClass struct {
3033
3034
3035
3036 CallbackOptions *CallbackOptions `json:"callbackOptions,omitempty"`
3037
3038
3039
3040 ClassTemplateInfo *ClassTemplateInfo `json:"classTemplateInfo,omitempty"`
3041
3042
3043 EnableSmartTap bool `json:"enableSmartTap,omitempty"`
3044
3045
3046
3047
3048
3049 Id string `json:"id,omitempty"`
3050
3051
3052
3053 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
3054
3055
3056
3057 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
3058
3059
3060
3061 Messages []*Message `json:"messages,omitempty"`
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082 MultipleDevicesAndHoldersAllowedStatus string `json:"multipleDevicesAndHoldersAllowedStatus,omitempty"`
3083
3084
3085
3086
3087
3088 RedemptionIssuers googleapi.Int64s `json:"redemptionIssuers,omitempty"`
3089
3090
3091 SecurityAnimation *SecurityAnimation `json:"securityAnimation,omitempty"`
3092
3093
3094
3095 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107 ViewUnlockRequirement string `json:"viewUnlockRequirement,omitempty"`
3108
3109
3110 googleapi.ServerResponse `json:"-"`
3111
3112
3113
3114
3115
3116 ForceSendFields []string `json:"-"`
3117
3118
3119
3120
3121 NullFields []string `json:"-"`
3122 }
3123
3124 func (s *GenericClass) MarshalJSON() ([]byte, error) {
3125 type NoMethod GenericClass
3126 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3127 }
3128
3129
3130
3131 type GenericClassAddMessageResponse struct {
3132
3133 Resource *GenericClass `json:"resource,omitempty"`
3134
3135
3136 googleapi.ServerResponse `json:"-"`
3137
3138
3139
3140
3141
3142 ForceSendFields []string `json:"-"`
3143
3144
3145
3146
3147 NullFields []string `json:"-"`
3148 }
3149
3150 func (s *GenericClassAddMessageResponse) MarshalJSON() ([]byte, error) {
3151 type NoMethod GenericClassAddMessageResponse
3152 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3153 }
3154
3155
3156
3157 type GenericClassListResponse struct {
3158
3159 Pagination *Pagination `json:"pagination,omitempty"`
3160
3161 Resources []*GenericClass `json:"resources,omitempty"`
3162
3163
3164 googleapi.ServerResponse `json:"-"`
3165
3166
3167
3168
3169
3170 ForceSendFields []string `json:"-"`
3171
3172
3173
3174
3175 NullFields []string `json:"-"`
3176 }
3177
3178 func (s *GenericClassListResponse) MarshalJSON() ([]byte, error) {
3179 type NoMethod GenericClassListResponse
3180 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3181 }
3182
3183
3184 type GenericObject struct {
3185
3186
3187 AppLinkData *AppLinkData `json:"appLinkData,omitempty"`
3188
3189
3190 Barcode *Barcode `json:"barcode,omitempty"`
3191
3192
3193
3194 CardTitle *LocalizedString `json:"cardTitle,omitempty"`
3195
3196
3197
3198
3199 ClassId string `json:"classId,omitempty"`
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216 GenericType string `json:"genericType,omitempty"`
3217
3218 GroupingInfo *GroupingInfo `json:"groupingInfo,omitempty"`
3219
3220
3221 HasUsers bool `json:"hasUsers,omitempty"`
3222
3223
3224
3225 Header *LocalizedString `json:"header,omitempty"`
3226
3227
3228 HeroImage *Image `json:"heroImage,omitempty"`
3229
3230
3231
3232
3233 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
3234
3235
3236
3237
3238
3239 Id string `json:"id,omitempty"`
3240
3241
3242 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
3243
3244
3245
3246 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
3247
3248
3249
3250 Logo *Image `json:"logo,omitempty"`
3251
3252 Notifications *Notifications `json:"notifications,omitempty"`
3253
3254
3255 PassConstraints *PassConstraints `json:"passConstraints,omitempty"`
3256
3257 RotatingBarcode *RotatingBarcode `json:"rotatingBarcode,omitempty"`
3258
3259
3260
3261
3262
3263 SmartTapRedemptionValue string `json:"smartTapRedemptionValue,omitempty"`
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279 State string `json:"state,omitempty"`
3280
3281
3282
3283 Subheader *LocalizedString `json:"subheader,omitempty"`
3284
3285
3286
3287 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
3288
3289
3290
3291 ValidTimeInterval *TimeInterval `json:"validTimeInterval,omitempty"`
3292
3293
3294 WideLogo *Image `json:"wideLogo,omitempty"`
3295
3296
3297 googleapi.ServerResponse `json:"-"`
3298
3299
3300
3301
3302
3303 ForceSendFields []string `json:"-"`
3304
3305
3306
3307
3308 NullFields []string `json:"-"`
3309 }
3310
3311 func (s *GenericObject) MarshalJSON() ([]byte, error) {
3312 type NoMethod GenericObject
3313 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3314 }
3315
3316
3317
3318 type GenericObjectAddMessageResponse struct {
3319
3320 Resource *GenericObject `json:"resource,omitempty"`
3321
3322
3323 googleapi.ServerResponse `json:"-"`
3324
3325
3326
3327
3328
3329 ForceSendFields []string `json:"-"`
3330
3331
3332
3333
3334 NullFields []string `json:"-"`
3335 }
3336
3337 func (s *GenericObjectAddMessageResponse) MarshalJSON() ([]byte, error) {
3338 type NoMethod GenericObjectAddMessageResponse
3339 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3340 }
3341
3342
3343
3344 type GenericObjectListResponse struct {
3345
3346 Pagination *Pagination `json:"pagination,omitempty"`
3347
3348 Resources []*GenericObject `json:"resources,omitempty"`
3349
3350
3351 googleapi.ServerResponse `json:"-"`
3352
3353
3354
3355
3356
3357 ForceSendFields []string `json:"-"`
3358
3359
3360
3361
3362 NullFields []string `json:"-"`
3363 }
3364
3365 func (s *GenericObjectListResponse) MarshalJSON() ([]byte, error) {
3366 type NoMethod GenericObjectListResponse
3367 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3368 }
3369
3370 type GiftCardClass struct {
3371
3372
3373
3374 AllowBarcodeRedemption bool `json:"allowBarcodeRedemption,omitempty"`
3375
3376
3377 AllowMultipleUsersPerObject bool `json:"allowMultipleUsersPerObject,omitempty"`
3378
3379
3380
3381 CallbackOptions *CallbackOptions `json:"callbackOptions,omitempty"`
3382
3383
3384 CardNumberLabel string `json:"cardNumberLabel,omitempty"`
3385
3386
3387
3388 ClassTemplateInfo *ClassTemplateInfo `json:"classTemplateInfo,omitempty"`
3389
3390
3391
3392 CountryCode string `json:"countryCode,omitempty"`
3393
3394
3395
3396 EnableSmartTap bool `json:"enableSmartTap,omitempty"`
3397
3398
3399 EventNumberLabel string `json:"eventNumberLabel,omitempty"`
3400
3401
3402 HeroImage *Image `json:"heroImage,omitempty"`
3403
3404
3405
3406
3407
3408 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
3409
3410
3411
3412
3413
3414 HomepageUri *Uri `json:"homepageUri,omitempty"`
3415
3416
3417
3418
3419
3420 Id string `json:"id,omitempty"`
3421
3422
3423 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
3424
3425 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
3426
3427
3428 IssuerName string `json:"issuerName,omitempty"`
3429
3430
3431 Kind string `json:"kind,omitempty"`
3432
3433
3434 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
3435
3436 LocalizedCardNumberLabel *LocalizedString `json:"localizedCardNumberLabel,omitempty"`
3437
3438 LocalizedEventNumberLabel *LocalizedString `json:"localizedEventNumberLabel,omitempty"`
3439
3440
3441
3442 LocalizedIssuerName *LocalizedString `json:"localizedIssuerName,omitempty"`
3443
3444
3445
3446 LocalizedMerchantName *LocalizedString `json:"localizedMerchantName,omitempty"`
3447
3448 LocalizedPinLabel *LocalizedString `json:"localizedPinLabel,omitempty"`
3449
3450
3451 Locations []*LatLongPoint `json:"locations,omitempty"`
3452
3453
3454
3455 MerchantName string `json:"merchantName,omitempty"`
3456
3457
3458
3459 Messages []*Message `json:"messages,omitempty"`
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480 MultipleDevicesAndHoldersAllowedStatus string `json:"multipleDevicesAndHoldersAllowedStatus,omitempty"`
3481
3482 PinLabel string `json:"pinLabel,omitempty"`
3483
3484
3485 ProgramLogo *Image `json:"programLogo,omitempty"`
3486
3487
3488
3489
3490
3491 RedemptionIssuers googleapi.Int64s `json:"redemptionIssuers,omitempty"`
3492
3493
3494 Review *Review `json:"review,omitempty"`
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515 ReviewStatus string `json:"reviewStatus,omitempty"`
3516
3517
3518 SecurityAnimation *SecurityAnimation `json:"securityAnimation,omitempty"`
3519
3520
3521
3522 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
3523
3524 Version int64 `json:"version,omitempty,string"`
3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535
3536 ViewUnlockRequirement string `json:"viewUnlockRequirement,omitempty"`
3537
3538
3539
3540 WideProgramLogo *Image `json:"wideProgramLogo,omitempty"`
3541
3542 WordMark *Image `json:"wordMark,omitempty"`
3543
3544
3545 googleapi.ServerResponse `json:"-"`
3546
3547
3548
3549
3550
3551 ForceSendFields []string `json:"-"`
3552
3553
3554
3555
3556 NullFields []string `json:"-"`
3557 }
3558
3559 func (s *GiftCardClass) MarshalJSON() ([]byte, error) {
3560 type NoMethod GiftCardClass
3561 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3562 }
3563
3564 type GiftCardClassAddMessageResponse struct {
3565
3566 Resource *GiftCardClass `json:"resource,omitempty"`
3567
3568
3569 googleapi.ServerResponse `json:"-"`
3570
3571
3572
3573
3574
3575 ForceSendFields []string `json:"-"`
3576
3577
3578
3579
3580 NullFields []string `json:"-"`
3581 }
3582
3583 func (s *GiftCardClassAddMessageResponse) MarshalJSON() ([]byte, error) {
3584 type NoMethod GiftCardClassAddMessageResponse
3585 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3586 }
3587
3588 type GiftCardClassListResponse struct {
3589
3590 Pagination *Pagination `json:"pagination,omitempty"`
3591
3592 Resources []*GiftCardClass `json:"resources,omitempty"`
3593
3594
3595 googleapi.ServerResponse `json:"-"`
3596
3597
3598
3599
3600
3601 ForceSendFields []string `json:"-"`
3602
3603
3604
3605
3606 NullFields []string `json:"-"`
3607 }
3608
3609 func (s *GiftCardClassListResponse) MarshalJSON() ([]byte, error) {
3610 type NoMethod GiftCardClassListResponse
3611 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3612 }
3613
3614 type GiftCardObject struct {
3615
3616 AppLinkData *AppLinkData `json:"appLinkData,omitempty"`
3617
3618 Balance *Money `json:"balance,omitempty"`
3619
3620
3621
3622 BalanceUpdateTime *DateTime `json:"balanceUpdateTime,omitempty"`
3623
3624 Barcode *Barcode `json:"barcode,omitempty"`
3625
3626 CardNumber string `json:"cardNumber,omitempty"`
3627
3628
3629
3630
3631 ClassId string `json:"classId,omitempty"`
3632
3633
3634 ClassReference *GiftCardClass `json:"classReference,omitempty"`
3635
3636
3637
3638
3639 DisableExpirationNotification bool `json:"disableExpirationNotification,omitempty"`
3640
3641
3642 EventNumber string `json:"eventNumber,omitempty"`
3643
3644 GroupingInfo *GroupingInfo `json:"groupingInfo,omitempty"`
3645
3646
3647
3648
3649 HasLinkedDevice bool `json:"hasLinkedDevice,omitempty"`
3650
3651
3652 HasUsers bool `json:"hasUsers,omitempty"`
3653
3654
3655
3656 HeroImage *Image `json:"heroImage,omitempty"`
3657
3658
3659
3660
3661
3662 Id string `json:"id,omitempty"`
3663
3664
3665 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
3666
3667 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
3668
3669
3670 Kind string `json:"kind,omitempty"`
3671
3672
3673 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
3674
3675
3676 Locations []*LatLongPoint `json:"locations,omitempty"`
3677
3678
3679
3680 Messages []*Message `json:"messages,omitempty"`
3681
3682
3683 PassConstraints *PassConstraints `json:"passConstraints,omitempty"`
3684
3685 Pin string `json:"pin,omitempty"`
3686
3687 RotatingBarcode *RotatingBarcode `json:"rotatingBarcode,omitempty"`
3688
3689
3690
3691
3692
3693 SmartTapRedemptionValue string `json:"smartTapRedemptionValue,omitempty"`
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703
3704
3705
3706
3707
3708 State string `json:"state,omitempty"`
3709
3710
3711
3712 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
3713
3714
3715
3716 ValidTimeInterval *TimeInterval `json:"validTimeInterval,omitempty"`
3717
3718 Version int64 `json:"version,omitempty,string"`
3719
3720
3721 googleapi.ServerResponse `json:"-"`
3722
3723
3724
3725
3726
3727 ForceSendFields []string `json:"-"`
3728
3729
3730
3731
3732 NullFields []string `json:"-"`
3733 }
3734
3735 func (s *GiftCardObject) MarshalJSON() ([]byte, error) {
3736 type NoMethod GiftCardObject
3737 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3738 }
3739
3740 type GiftCardObjectAddMessageResponse struct {
3741
3742 Resource *GiftCardObject `json:"resource,omitempty"`
3743
3744
3745 googleapi.ServerResponse `json:"-"`
3746
3747
3748
3749
3750
3751 ForceSendFields []string `json:"-"`
3752
3753
3754
3755
3756 NullFields []string `json:"-"`
3757 }
3758
3759 func (s *GiftCardObjectAddMessageResponse) MarshalJSON() ([]byte, error) {
3760 type NoMethod GiftCardObjectAddMessageResponse
3761 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3762 }
3763
3764 type GiftCardObjectListResponse struct {
3765
3766 Pagination *Pagination `json:"pagination,omitempty"`
3767
3768 Resources []*GiftCardObject `json:"resources,omitempty"`
3769
3770
3771 googleapi.ServerResponse `json:"-"`
3772
3773
3774
3775
3776
3777 ForceSendFields []string `json:"-"`
3778
3779
3780
3781
3782 NullFields []string `json:"-"`
3783 }
3784
3785 func (s *GiftCardObjectListResponse) MarshalJSON() ([]byte, error) {
3786 type NoMethod GiftCardObjectListResponse
3787 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3788 }
3789
3790 type GroupingInfo struct {
3791
3792
3793 GroupingId string `json:"groupingId,omitempty"`
3794
3795
3796
3797
3798 SortIndex int64 `json:"sortIndex,omitempty"`
3799
3800
3801
3802
3803
3804 ForceSendFields []string `json:"-"`
3805
3806
3807
3808
3809 NullFields []string `json:"-"`
3810 }
3811
3812 func (s *GroupingInfo) MarshalJSON() ([]byte, error) {
3813 type NoMethod GroupingInfo
3814 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3815 }
3816
3817
3818 type Image struct {
3819
3820 ContentDescription *LocalizedString `json:"contentDescription,omitempty"`
3821
3822
3823 Kind string `json:"kind,omitempty"`
3824
3825 SourceUri *ImageUri `json:"sourceUri,omitempty"`
3826
3827
3828
3829
3830
3831 ForceSendFields []string `json:"-"`
3832
3833
3834
3835
3836 NullFields []string `json:"-"`
3837 }
3838
3839 func (s *Image) MarshalJSON() ([]byte, error) {
3840 type NoMethod Image
3841 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3842 }
3843
3844 type ImageModuleData struct {
3845
3846
3847 Id string `json:"id,omitempty"`
3848
3849 MainImage *Image `json:"mainImage,omitempty"`
3850
3851
3852
3853
3854
3855 ForceSendFields []string `json:"-"`
3856
3857
3858
3859
3860 NullFields []string `json:"-"`
3861 }
3862
3863 func (s *ImageModuleData) MarshalJSON() ([]byte, error) {
3864 type NoMethod ImageModuleData
3865 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3866 }
3867
3868 type ImageUri struct {
3869
3870
3871 Description string `json:"description,omitempty"`
3872
3873
3874 LocalizedDescription *LocalizedString `json:"localizedDescription,omitempty"`
3875
3876 Uri string `json:"uri,omitempty"`
3877
3878
3879
3880
3881
3882 ForceSendFields []string `json:"-"`
3883
3884
3885
3886
3887 NullFields []string `json:"-"`
3888 }
3889
3890 func (s *ImageUri) MarshalJSON() ([]byte, error) {
3891 type NoMethod ImageUri
3892 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3893 }
3894
3895 type InfoModuleData struct {
3896
3897
3898 LabelValueRows []*LabelValueRow `json:"labelValueRows,omitempty"`
3899 ShowLastUpdateTime bool `json:"showLastUpdateTime,omitempty"`
3900
3901
3902
3903
3904
3905 ForceSendFields []string `json:"-"`
3906
3907
3908
3909
3910 NullFields []string `json:"-"`
3911 }
3912
3913 func (s *InfoModuleData) MarshalJSON() ([]byte, error) {
3914 type NoMethod InfoModuleData
3915 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3916 }
3917
3918 type Issuer struct {
3919
3920 CallbackOptions *CallbackOptions `json:"callbackOptions,omitempty"`
3921
3922 ContactInfo *IssuerContactInfo `json:"contactInfo,omitempty"`
3923
3924 HomepageUrl string `json:"homepageUrl,omitempty"`
3925
3926
3927 IssuerId int64 `json:"issuerId,omitempty,string"`
3928
3929 Name string `json:"name,omitempty"`
3930
3931
3932 SmartTapMerchantData *SmartTapMerchantData `json:"smartTapMerchantData,omitempty"`
3933
3934
3935 googleapi.ServerResponse `json:"-"`
3936
3937
3938
3939
3940
3941 ForceSendFields []string `json:"-"`
3942
3943
3944
3945
3946 NullFields []string `json:"-"`
3947 }
3948
3949 func (s *Issuer) MarshalJSON() ([]byte, error) {
3950 type NoMethod Issuer
3951 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3952 }
3953
3954 type IssuerContactInfo struct {
3955
3956 AlertsEmails []string `json:"alertsEmails,omitempty"`
3957
3958 Email string `json:"email,omitempty"`
3959
3960 Name string `json:"name,omitempty"`
3961
3962 Phone string `json:"phone,omitempty"`
3963
3964
3965
3966
3967
3968 ForceSendFields []string `json:"-"`
3969
3970
3971
3972
3973 NullFields []string `json:"-"`
3974 }
3975
3976 func (s *IssuerContactInfo) MarshalJSON() ([]byte, error) {
3977 type NoMethod IssuerContactInfo
3978 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3979 }
3980
3981 type IssuerListResponse struct {
3982
3983 Resources []*Issuer `json:"resources,omitempty"`
3984
3985
3986 googleapi.ServerResponse `json:"-"`
3987
3988
3989
3990
3991
3992 ForceSendFields []string `json:"-"`
3993
3994
3995
3996
3997 NullFields []string `json:"-"`
3998 }
3999
4000 func (s *IssuerListResponse) MarshalJSON() ([]byte, error) {
4001 type NoMethod IssuerListResponse
4002 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4003 }
4004
4005 type IssuerToUserInfo struct {
4006
4007
4008
4009
4010
4011
4012 Action string `json:"action,omitempty"`
4013 SignUpInfo *SignUpInfo `json:"signUpInfo,omitempty"`
4014
4015 Url string `json:"url,omitempty"`
4016
4017 Value string `json:"value,omitempty"`
4018
4019
4020
4021
4022
4023 ForceSendFields []string `json:"-"`
4024
4025
4026
4027
4028 NullFields []string `json:"-"`
4029 }
4030
4031 func (s *IssuerToUserInfo) MarshalJSON() ([]byte, error) {
4032 type NoMethod IssuerToUserInfo
4033 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4034 }
4035
4036 type JwtInsertResponse struct {
4037
4038
4039
4040
4041 Resources *Resources `json:"resources,omitempty"`
4042
4043
4044 SaveUri string `json:"saveUri,omitempty"`
4045
4046
4047 googleapi.ServerResponse `json:"-"`
4048
4049
4050
4051
4052
4053 ForceSendFields []string `json:"-"`
4054
4055
4056
4057
4058 NullFields []string `json:"-"`
4059 }
4060
4061 func (s *JwtInsertResponse) MarshalJSON() ([]byte, error) {
4062 type NoMethod JwtInsertResponse
4063 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4064 }
4065
4066 type JwtResource struct {
4067
4068
4069 Jwt string `json:"jwt,omitempty"`
4070
4071
4072
4073
4074
4075 ForceSendFields []string `json:"-"`
4076
4077
4078
4079
4080 NullFields []string `json:"-"`
4081 }
4082
4083 func (s *JwtResource) MarshalJSON() ([]byte, error) {
4084 type NoMethod JwtResource
4085 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4086 }
4087
4088
4089
4090
4091 type LabelValue struct {
4092
4093
4094
4095 Label string `json:"label,omitempty"`
4096
4097
4098
4099 LocalizedLabel *LocalizedString `json:"localizedLabel,omitempty"`
4100
4101
4102
4103 LocalizedValue *LocalizedString `json:"localizedValue,omitempty"`
4104
4105
4106
4107 Value string `json:"value,omitempty"`
4108
4109
4110
4111
4112
4113 ForceSendFields []string `json:"-"`
4114
4115
4116
4117
4118 NullFields []string `json:"-"`
4119 }
4120
4121 func (s *LabelValue) MarshalJSON() ([]byte, error) {
4122 type NoMethod LabelValue
4123 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4124 }
4125
4126 type LabelValueRow struct {
4127
4128
4129
4130 Columns []*LabelValue `json:"columns,omitempty"`
4131
4132
4133
4134
4135
4136 ForceSendFields []string `json:"-"`
4137
4138
4139
4140
4141 NullFields []string `json:"-"`
4142 }
4143
4144 func (s *LabelValueRow) MarshalJSON() ([]byte, error) {
4145 type NoMethod LabelValueRow
4146 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4147 }
4148
4149 type LatLongPoint struct {
4150
4151
4152 Kind string `json:"kind,omitempty"`
4153
4154
4155 Latitude float64 `json:"latitude,omitempty"`
4156
4157
4158 Longitude float64 `json:"longitude,omitempty"`
4159
4160
4161
4162
4163
4164 ForceSendFields []string `json:"-"`
4165
4166
4167
4168
4169 NullFields []string `json:"-"`
4170 }
4171
4172 func (s *LatLongPoint) MarshalJSON() ([]byte, error) {
4173 type NoMethod LatLongPoint
4174 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4175 }
4176
4177 func (s *LatLongPoint) UnmarshalJSON(data []byte) error {
4178 type NoMethod LatLongPoint
4179 var s1 struct {
4180 Latitude gensupport.JSONFloat64 `json:"latitude"`
4181 Longitude gensupport.JSONFloat64 `json:"longitude"`
4182 *NoMethod
4183 }
4184 s1.NoMethod = (*NoMethod)(s)
4185 if err := json.Unmarshal(data, &s1); err != nil {
4186 return err
4187 }
4188 s.Latitude = float64(s1.Latitude)
4189 s.Longitude = float64(s1.Longitude)
4190 return nil
4191 }
4192
4193 type LinksModuleData struct {
4194
4195 Uris []*Uri `json:"uris,omitempty"`
4196
4197
4198
4199
4200
4201 ForceSendFields []string `json:"-"`
4202
4203
4204
4205
4206 NullFields []string `json:"-"`
4207 }
4208
4209 func (s *LinksModuleData) MarshalJSON() ([]byte, error) {
4210 type NoMethod LinksModuleData
4211 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4212 }
4213
4214 type ListTemplateOverride struct {
4215
4216
4217
4218
4219 FirstRowOption *FirstRowOption `json:"firstRowOption,omitempty"`
4220
4221
4222
4223
4224
4225 SecondRowOption *FieldSelector `json:"secondRowOption,omitempty"`
4226
4227
4228 ThirdRowOption *FieldSelector `json:"thirdRowOption,omitempty"`
4229
4230
4231
4232
4233
4234 ForceSendFields []string `json:"-"`
4235
4236
4237
4238
4239 NullFields []string `json:"-"`
4240 }
4241
4242 func (s *ListTemplateOverride) MarshalJSON() ([]byte, error) {
4243 type NoMethod ListTemplateOverride
4244 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4245 }
4246
4247 type LocalizedString struct {
4248
4249
4250 DefaultValue *TranslatedString `json:"defaultValue,omitempty"`
4251
4252
4253 Kind string `json:"kind,omitempty"`
4254
4255 TranslatedValues []*TranslatedString `json:"translatedValues,omitempty"`
4256
4257
4258
4259
4260
4261 ForceSendFields []string `json:"-"`
4262
4263
4264
4265
4266 NullFields []string `json:"-"`
4267 }
4268
4269 func (s *LocalizedString) MarshalJSON() ([]byte, error) {
4270 type NoMethod LocalizedString
4271 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4272 }
4273
4274 type LoyaltyClass struct {
4275
4276
4277
4278 AccountIdLabel string `json:"accountIdLabel,omitempty"`
4279
4280
4281
4282 AccountNameLabel string `json:"accountNameLabel,omitempty"`
4283
4284
4285 AllowMultipleUsersPerObject bool `json:"allowMultipleUsersPerObject,omitempty"`
4286
4287
4288
4289 CallbackOptions *CallbackOptions `json:"callbackOptions,omitempty"`
4290
4291
4292
4293 ClassTemplateInfo *ClassTemplateInfo `json:"classTemplateInfo,omitempty"`
4294
4295
4296
4297 CountryCode string `json:"countryCode,omitempty"`
4298
4299
4300 DiscoverableProgram *DiscoverableProgram `json:"discoverableProgram,omitempty"`
4301
4302
4303
4304
4305 EnableSmartTap bool `json:"enableSmartTap,omitempty"`
4306
4307
4308 HeroImage *Image `json:"heroImage,omitempty"`
4309
4310
4311
4312
4313
4314 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
4315
4316
4317
4318
4319
4320 HomepageUri *Uri `json:"homepageUri,omitempty"`
4321
4322
4323
4324
4325
4326 Id string `json:"id,omitempty"`
4327
4328
4329 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
4330
4331 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
4332
4333
4334 IssuerName string `json:"issuerName,omitempty"`
4335
4336
4337 Kind string `json:"kind,omitempty"`
4338
4339
4340 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
4341
4342
4343
4344 LocalizedAccountIdLabel *LocalizedString `json:"localizedAccountIdLabel,omitempty"`
4345
4346
4347
4348 LocalizedAccountNameLabel *LocalizedString `json:"localizedAccountNameLabel,omitempty"`
4349
4350
4351
4352 LocalizedIssuerName *LocalizedString `json:"localizedIssuerName,omitempty"`
4353
4354
4355
4356 LocalizedProgramName *LocalizedString `json:"localizedProgramName,omitempty"`
4357
4358
4359
4360 LocalizedRewardsTier *LocalizedString `json:"localizedRewardsTier,omitempty"`
4361
4362
4363
4364 LocalizedRewardsTierLabel *LocalizedString `json:"localizedRewardsTierLabel,omitempty"`
4365
4366
4367 LocalizedSecondaryRewardsTier *LocalizedString `json:"localizedSecondaryRewardsTier,omitempty"`
4368
4369
4370 LocalizedSecondaryRewardsTierLabel *LocalizedString `json:"localizedSecondaryRewardsTierLabel,omitempty"`
4371
4372
4373 Locations []*LatLongPoint `json:"locations,omitempty"`
4374
4375
4376
4377 Messages []*Message `json:"messages,omitempty"`
4378
4379
4380
4381
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398 MultipleDevicesAndHoldersAllowedStatus string `json:"multipleDevicesAndHoldersAllowedStatus,omitempty"`
4399
4400
4401 ProgramLogo *Image `json:"programLogo,omitempty"`
4402
4403
4404
4405 ProgramName string `json:"programName,omitempty"`
4406
4407
4408
4409
4410
4411
4412 RedemptionIssuers googleapi.Int64s `json:"redemptionIssuers,omitempty"`
4413
4414
4415 Review *Review `json:"review,omitempty"`
4416
4417
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430
4431
4432
4433
4434
4435
4436 ReviewStatus string `json:"reviewStatus,omitempty"`
4437
4438
4439
4440 RewardsTier string `json:"rewardsTier,omitempty"`
4441
4442
4443
4444 RewardsTierLabel string `json:"rewardsTierLabel,omitempty"`
4445
4446
4447 SecondaryRewardsTier string `json:"secondaryRewardsTier,omitempty"`
4448
4449
4450 SecondaryRewardsTierLabel string `json:"secondaryRewardsTierLabel,omitempty"`
4451
4452
4453 SecurityAnimation *SecurityAnimation `json:"securityAnimation,omitempty"`
4454
4455
4456
4457 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
4458
4459 Version int64 `json:"version,omitempty,string"`
4460
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470
4471 ViewUnlockRequirement string `json:"viewUnlockRequirement,omitempty"`
4472
4473
4474
4475 WideProgramLogo *Image `json:"wideProgramLogo,omitempty"`
4476
4477 WordMark *Image `json:"wordMark,omitempty"`
4478
4479
4480 googleapi.ServerResponse `json:"-"`
4481
4482
4483
4484
4485
4486 ForceSendFields []string `json:"-"`
4487
4488
4489
4490
4491 NullFields []string `json:"-"`
4492 }
4493
4494 func (s *LoyaltyClass) MarshalJSON() ([]byte, error) {
4495 type NoMethod LoyaltyClass
4496 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4497 }
4498
4499 type LoyaltyClassAddMessageResponse struct {
4500
4501 Resource *LoyaltyClass `json:"resource,omitempty"`
4502
4503
4504 googleapi.ServerResponse `json:"-"`
4505
4506
4507
4508
4509
4510 ForceSendFields []string `json:"-"`
4511
4512
4513
4514
4515 NullFields []string `json:"-"`
4516 }
4517
4518 func (s *LoyaltyClassAddMessageResponse) MarshalJSON() ([]byte, error) {
4519 type NoMethod LoyaltyClassAddMessageResponse
4520 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4521 }
4522
4523 type LoyaltyClassListResponse struct {
4524
4525 Pagination *Pagination `json:"pagination,omitempty"`
4526
4527 Resources []*LoyaltyClass `json:"resources,omitempty"`
4528
4529
4530 googleapi.ServerResponse `json:"-"`
4531
4532
4533
4534
4535
4536 ForceSendFields []string `json:"-"`
4537
4538
4539
4540
4541 NullFields []string `json:"-"`
4542 }
4543
4544 func (s *LoyaltyClassListResponse) MarshalJSON() ([]byte, error) {
4545 type NoMethod LoyaltyClassListResponse
4546 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4547 }
4548
4549 type LoyaltyObject struct {
4550
4551
4552 AccountId string `json:"accountId,omitempty"`
4553
4554
4555
4556 AccountName string `json:"accountName,omitempty"`
4557
4558 AppLinkData *AppLinkData `json:"appLinkData,omitempty"`
4559
4560 Barcode *Barcode `json:"barcode,omitempty"`
4561
4562
4563
4564
4565 ClassId string `json:"classId,omitempty"`
4566
4567
4568 ClassReference *LoyaltyClass `json:"classReference,omitempty"`
4569
4570
4571
4572
4573 DisableExpirationNotification bool `json:"disableExpirationNotification,omitempty"`
4574
4575 GroupingInfo *GroupingInfo `json:"groupingInfo,omitempty"`
4576
4577
4578
4579
4580 HasLinkedDevice bool `json:"hasLinkedDevice,omitempty"`
4581
4582
4583 HasUsers bool `json:"hasUsers,omitempty"`
4584
4585
4586
4587 HeroImage *Image `json:"heroImage,omitempty"`
4588
4589
4590
4591
4592
4593 Id string `json:"id,omitempty"`
4594
4595
4596 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
4597
4598 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
4599
4600
4601 Kind string `json:"kind,omitempty"`
4602
4603
4604
4605
4606 LinkedOfferIds []string `json:"linkedOfferIds,omitempty"`
4607
4608
4609 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
4610
4611
4612 Locations []*LatLongPoint `json:"locations,omitempty"`
4613
4614 LoyaltyPoints *LoyaltyPoints `json:"loyaltyPoints,omitempty"`
4615
4616
4617
4618 Messages []*Message `json:"messages,omitempty"`
4619
4620
4621 PassConstraints *PassConstraints `json:"passConstraints,omitempty"`
4622
4623 RotatingBarcode *RotatingBarcode `json:"rotatingBarcode,omitempty"`
4624
4625
4626 SecondaryLoyaltyPoints *LoyaltyPoints `json:"secondaryLoyaltyPoints,omitempty"`
4627
4628
4629
4630
4631
4632
4633
4634 SmartTapRedemptionValue string `json:"smartTapRedemptionValue,omitempty"`
4635
4636
4637
4638
4639
4640
4641
4642
4643
4644
4645
4646
4647
4648
4649 State string `json:"state,omitempty"`
4650
4651
4652
4653 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
4654
4655
4656
4657 ValidTimeInterval *TimeInterval `json:"validTimeInterval,omitempty"`
4658
4659 Version int64 `json:"version,omitempty,string"`
4660
4661
4662 googleapi.ServerResponse `json:"-"`
4663
4664
4665
4666
4667
4668 ForceSendFields []string `json:"-"`
4669
4670
4671
4672
4673 NullFields []string `json:"-"`
4674 }
4675
4676 func (s *LoyaltyObject) MarshalJSON() ([]byte, error) {
4677 type NoMethod LoyaltyObject
4678 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4679 }
4680
4681 type LoyaltyObjectAddMessageResponse struct {
4682
4683 Resource *LoyaltyObject `json:"resource,omitempty"`
4684
4685
4686 googleapi.ServerResponse `json:"-"`
4687
4688
4689
4690
4691
4692 ForceSendFields []string `json:"-"`
4693
4694
4695
4696
4697 NullFields []string `json:"-"`
4698 }
4699
4700 func (s *LoyaltyObjectAddMessageResponse) MarshalJSON() ([]byte, error) {
4701 type NoMethod LoyaltyObjectAddMessageResponse
4702 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4703 }
4704
4705 type LoyaltyObjectListResponse struct {
4706
4707 Pagination *Pagination `json:"pagination,omitempty"`
4708
4709 Resources []*LoyaltyObject `json:"resources,omitempty"`
4710
4711
4712 googleapi.ServerResponse `json:"-"`
4713
4714
4715
4716
4717
4718 ForceSendFields []string `json:"-"`
4719
4720
4721
4722
4723 NullFields []string `json:"-"`
4724 }
4725
4726 func (s *LoyaltyObjectListResponse) MarshalJSON() ([]byte, error) {
4727 type NoMethod LoyaltyObjectListResponse
4728 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4729 }
4730
4731 type LoyaltyPoints struct {
4732
4733
4734
4735 Balance *LoyaltyPointsBalance `json:"balance,omitempty"`
4736
4737
4738 Label string `json:"label,omitempty"`
4739
4740
4741 LocalizedLabel *LocalizedString `json:"localizedLabel,omitempty"`
4742
4743
4744
4745
4746
4747 ForceSendFields []string `json:"-"`
4748
4749
4750
4751
4752 NullFields []string `json:"-"`
4753 }
4754
4755 func (s *LoyaltyPoints) MarshalJSON() ([]byte, error) {
4756 type NoMethod LoyaltyPoints
4757 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4758 }
4759
4760 type LoyaltyPointsBalance struct {
4761
4762
4763 Double float64 `json:"double,omitempty"`
4764
4765
4766 Int int64 `json:"int,omitempty"`
4767
4768
4769 Money *Money `json:"money,omitempty"`
4770
4771
4772 String string `json:"string,omitempty"`
4773
4774
4775
4776
4777
4778 ForceSendFields []string `json:"-"`
4779
4780
4781
4782
4783 NullFields []string `json:"-"`
4784 }
4785
4786 func (s *LoyaltyPointsBalance) MarshalJSON() ([]byte, error) {
4787 type NoMethod LoyaltyPointsBalance
4788 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4789 }
4790
4791 func (s *LoyaltyPointsBalance) UnmarshalJSON(data []byte) error {
4792 type NoMethod LoyaltyPointsBalance
4793 var s1 struct {
4794 Double gensupport.JSONFloat64 `json:"double"`
4795 *NoMethod
4796 }
4797 s1.NoMethod = (*NoMethod)(s)
4798 if err := json.Unmarshal(data, &s1); err != nil {
4799 return err
4800 }
4801 s.Double = float64(s1.Double)
4802 return nil
4803 }
4804
4805
4806 type Media struct {
4807
4808
4809
4810 Algorithm string `json:"algorithm,omitempty"`
4811
4812 BigstoreObjectRef string `json:"bigstoreObjectRef,omitempty"`
4813
4814
4815
4816
4817 BlobRef string `json:"blobRef,omitempty"`
4818
4819
4820 Blobstore2Info *Blobstore2Info `json:"blobstore2Info,omitempty"`
4821
4822
4823
4824
4825 CompositeMedia []*CompositeMedia `json:"compositeMedia,omitempty"`
4826
4827 ContentType string `json:"contentType,omitempty"`
4828
4829
4830 ContentTypeInfo *ContentTypeInfo `json:"contentTypeInfo,omitempty"`
4831
4832
4833
4834
4835
4836
4837 CosmoBinaryReference string `json:"cosmoBinaryReference,omitempty"`
4838
4839
4840
4841
4842
4843 Crc32cHash int64 `json:"crc32cHash,omitempty"`
4844
4845 DiffChecksumsResponse *DiffChecksumsResponse `json:"diffChecksumsResponse,omitempty"`
4846
4847 DiffDownloadResponse *DiffDownloadResponse `json:"diffDownloadResponse,omitempty"`
4848
4849 DiffUploadRequest *DiffUploadRequest `json:"diffUploadRequest,omitempty"`
4850
4851 DiffUploadResponse *DiffUploadResponse `json:"diffUploadResponse,omitempty"`
4852
4853 DiffVersionResponse *DiffVersionResponse `json:"diffVersionResponse,omitempty"`
4854
4855 DownloadParameters *DownloadParameters `json:"downloadParameters,omitempty"`
4856
4857 Filename string `json:"filename,omitempty"`
4858
4859
4860
4861
4862
4863 Hash string `json:"hash,omitempty"`
4864
4865
4866
4867
4868
4869 HashVerified bool `json:"hashVerified,omitempty"`
4870
4871 Inline string `json:"inline,omitempty"`
4872
4873
4874
4875
4876
4877 IsPotentialRetry bool `json:"isPotentialRetry,omitempty"`
4878
4879 Length int64 `json:"length,omitempty,string"`
4880
4881 Md5Hash string `json:"md5Hash,omitempty"`
4882
4883
4884 MediaId string `json:"mediaId,omitempty"`
4885
4886 ObjectId *ObjectId `json:"objectId,omitempty"`
4887
4888 Path string `json:"path,omitempty"`
4889
4890
4891
4892
4893
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
4918
4919 ReferenceType string `json:"referenceType,omitempty"`
4920
4921 Sha1Hash string `json:"sha1Hash,omitempty"`
4922
4923 Sha256Hash string `json:"sha256Hash,omitempty"`
4924
4925
4926 Timestamp uint64 `json:"timestamp,omitempty,string"`
4927
4928 Token string `json:"token,omitempty"`
4929
4930
4931 googleapi.ServerResponse `json:"-"`
4932
4933
4934
4935
4936
4937 ForceSendFields []string `json:"-"`
4938
4939
4940
4941
4942 NullFields []string `json:"-"`
4943 }
4944
4945 func (s *Media) MarshalJSON() ([]byte, error) {
4946 type NoMethod Media
4947 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4948 }
4949
4950
4951
4952 type MediaRequestInfo struct {
4953
4954 CurrentBytes int64 `json:"currentBytes,omitempty,string"`
4955
4956
4957
4958 CustomData string `json:"customData,omitempty"`
4959
4960
4961
4962
4963
4964 DiffObjectVersion string `json:"diffObjectVersion,omitempty"`
4965
4966
4967
4968 FinalStatus int64 `json:"finalStatus,omitempty"`
4969
4970
4971
4972
4973
4974
4975
4976
4977
4978
4979
4980
4981
4982
4983
4984
4985
4986
4987
4988
4989
4990
4991
4992
4993
4994
4995
4996 NotificationType string `json:"notificationType,omitempty"`
4997
4998 RequestId string `json:"requestId,omitempty"`
4999
5000
5001
5002
5003
5004 RequestReceivedParamsServingInfo string `json:"requestReceivedParamsServingInfo,omitempty"`
5005
5006 TotalBytes int64 `json:"totalBytes,omitempty,string"`
5007
5008
5009 TotalBytesIsEstimated bool `json:"totalBytesIsEstimated,omitempty"`
5010
5011
5012
5013
5014
5015 ForceSendFields []string `json:"-"`
5016
5017
5018
5019
5020 NullFields []string `json:"-"`
5021 }
5022
5023 func (s *MediaRequestInfo) MarshalJSON() ([]byte, error) {
5024 type NoMethod MediaRequestInfo
5025 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5026 }
5027
5028
5029 type Message struct {
5030
5031 Body string `json:"body,omitempty"`
5032
5033
5034
5035
5036
5037 DisplayInterval *TimeInterval `json:"displayInterval,omitempty"`
5038
5039 Header string `json:"header,omitempty"`
5040
5041
5042
5043
5044 Id string `json:"id,omitempty"`
5045
5046
5047 Kind string `json:"kind,omitempty"`
5048
5049 LocalizedBody *LocalizedString `json:"localizedBody,omitempty"`
5050
5051 LocalizedHeader *LocalizedString `json:"localizedHeader,omitempty"`
5052
5053
5054
5055
5056
5057
5058
5059
5060
5061
5062
5063
5064 MessageType string `json:"messageType,omitempty"`
5065
5066
5067
5068
5069
5070 ForceSendFields []string `json:"-"`
5071
5072
5073
5074
5075 NullFields []string `json:"-"`
5076 }
5077
5078 func (s *Message) MarshalJSON() ([]byte, error) {
5079 type NoMethod Message
5080 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5081 }
5082
5083 type ModifyLinkedOfferObjects struct {
5084
5085 AddLinkedOfferObjectIds []string `json:"addLinkedOfferObjectIds,omitempty"`
5086
5087
5088 RemoveLinkedOfferObjectIds []string `json:"removeLinkedOfferObjectIds,omitempty"`
5089
5090
5091
5092
5093
5094 ForceSendFields []string `json:"-"`
5095
5096
5097
5098
5099 NullFields []string `json:"-"`
5100 }
5101
5102 func (s *ModifyLinkedOfferObjects) MarshalJSON() ([]byte, error) {
5103 type NoMethod ModifyLinkedOfferObjects
5104 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5105 }
5106
5107 type ModifyLinkedOfferObjectsRequest struct {
5108
5109
5110 LinkedOfferObjectIds *ModifyLinkedOfferObjects `json:"linkedOfferObjectIds,omitempty"`
5111
5112
5113
5114
5115
5116 ForceSendFields []string `json:"-"`
5117
5118
5119
5120
5121 NullFields []string `json:"-"`
5122 }
5123
5124 func (s *ModifyLinkedOfferObjectsRequest) MarshalJSON() ([]byte, error) {
5125 type NoMethod ModifyLinkedOfferObjectsRequest
5126 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5127 }
5128
5129 type Money struct {
5130
5131 CurrencyCode string `json:"currencyCode,omitempty"`
5132
5133
5134 Kind string `json:"kind,omitempty"`
5135
5136
5137 Micros int64 `json:"micros,omitempty,string"`
5138
5139
5140
5141
5142
5143 ForceSendFields []string `json:"-"`
5144
5145
5146
5147
5148 NullFields []string `json:"-"`
5149 }
5150
5151 func (s *Money) MarshalJSON() ([]byte, error) {
5152 type NoMethod Money
5153 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5154 }
5155
5156
5157
5158
5159
5160
5161 type Notifications struct {
5162
5163
5164 ExpiryNotification *ExpiryNotification `json:"expiryNotification,omitempty"`
5165
5166
5167 UpcomingNotification *UpcomingNotification `json:"upcomingNotification,omitempty"`
5168
5169
5170
5171
5172
5173 ForceSendFields []string `json:"-"`
5174
5175
5176
5177
5178 NullFields []string `json:"-"`
5179 }
5180
5181 func (s *Notifications) MarshalJSON() ([]byte, error) {
5182 type NoMethod Notifications
5183 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5184 }
5185
5186
5187
5188
5189 type ObjectId struct {
5190
5191 BucketName string `json:"bucketName,omitempty"`
5192
5193
5194
5195
5196 Generation int64 `json:"generation,omitempty,string"`
5197
5198 ObjectName string `json:"objectName,omitempty"`
5199
5200
5201
5202
5203
5204 ForceSendFields []string `json:"-"`
5205
5206
5207
5208
5209 NullFields []string `json:"-"`
5210 }
5211
5212 func (s *ObjectId) MarshalJSON() ([]byte, error) {
5213 type NoMethod ObjectId
5214 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5215 }
5216
5217 type OfferClass struct {
5218
5219
5220 AllowMultipleUsersPerObject bool `json:"allowMultipleUsersPerObject,omitempty"`
5221
5222
5223
5224 CallbackOptions *CallbackOptions `json:"callbackOptions,omitempty"`
5225
5226
5227
5228 ClassTemplateInfo *ClassTemplateInfo `json:"classTemplateInfo,omitempty"`
5229
5230
5231
5232 CountryCode string `json:"countryCode,omitempty"`
5233
5234 Details string `json:"details,omitempty"`
5235
5236
5237
5238 EnableSmartTap bool `json:"enableSmartTap,omitempty"`
5239
5240
5241 FinePrint string `json:"finePrint,omitempty"`
5242
5243
5244 HelpUri *Uri `json:"helpUri,omitempty"`
5245
5246
5247 HeroImage *Image `json:"heroImage,omitempty"`
5248
5249
5250
5251
5252
5253 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
5254
5255
5256
5257
5258
5259 HomepageUri *Uri `json:"homepageUri,omitempty"`
5260
5261
5262
5263
5264
5265 Id string `json:"id,omitempty"`
5266
5267
5268 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
5269
5270 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
5271
5272
5273 IssuerName string `json:"issuerName,omitempty"`
5274
5275
5276 Kind string `json:"kind,omitempty"`
5277
5278
5279 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
5280
5281 LocalizedDetails *LocalizedString `json:"localizedDetails,omitempty"`
5282
5283 LocalizedFinePrint *LocalizedString `json:"localizedFinePrint,omitempty"`
5284
5285
5286
5287 LocalizedIssuerName *LocalizedString `json:"localizedIssuerName,omitempty"`
5288
5289
5290
5291 LocalizedProvider *LocalizedString `json:"localizedProvider,omitempty"`
5292
5293
5294 LocalizedShortTitle *LocalizedString `json:"localizedShortTitle,omitempty"`
5295
5296
5297 LocalizedTitle *LocalizedString `json:"localizedTitle,omitempty"`
5298
5299
5300 Locations []*LatLongPoint `json:"locations,omitempty"`
5301
5302
5303
5304 Messages []*Message `json:"messages,omitempty"`
5305
5306
5307
5308
5309
5310
5311
5312
5313
5314
5315
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325 MultipleDevicesAndHoldersAllowedStatus string `json:"multipleDevicesAndHoldersAllowedStatus,omitempty"`
5326
5327
5328
5329 Provider string `json:"provider,omitempty"`
5330
5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342
5343
5344 RedemptionChannel string `json:"redemptionChannel,omitempty"`
5345
5346
5347
5348
5349
5350 RedemptionIssuers googleapi.Int64s `json:"redemptionIssuers,omitempty"`
5351
5352
5353 Review *Review `json:"review,omitempty"`
5354
5355
5356
5357
5358
5359
5360
5361
5362
5363
5364
5365
5366
5367
5368
5369
5370
5371
5372
5373
5374
5375 ReviewStatus string `json:"reviewStatus,omitempty"`
5376
5377
5378 SecurityAnimation *SecurityAnimation `json:"securityAnimation,omitempty"`
5379
5380
5381
5382 ShortTitle string `json:"shortTitle,omitempty"`
5383
5384
5385
5386 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
5387
5388
5389
5390 Title string `json:"title,omitempty"`
5391
5392
5393 TitleImage *Image `json:"titleImage,omitempty"`
5394
5395 Version int64 `json:"version,omitempty,string"`
5396
5397
5398
5399
5400
5401
5402
5403
5404
5405
5406
5407 ViewUnlockRequirement string `json:"viewUnlockRequirement,omitempty"`
5408
5409
5410 WideTitleImage *Image `json:"wideTitleImage,omitempty"`
5411
5412 WordMark *Image `json:"wordMark,omitempty"`
5413
5414
5415 googleapi.ServerResponse `json:"-"`
5416
5417
5418
5419
5420
5421 ForceSendFields []string `json:"-"`
5422
5423
5424
5425
5426 NullFields []string `json:"-"`
5427 }
5428
5429 func (s *OfferClass) MarshalJSON() ([]byte, error) {
5430 type NoMethod OfferClass
5431 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5432 }
5433
5434 type OfferClassAddMessageResponse struct {
5435
5436 Resource *OfferClass `json:"resource,omitempty"`
5437
5438
5439 googleapi.ServerResponse `json:"-"`
5440
5441
5442
5443
5444
5445 ForceSendFields []string `json:"-"`
5446
5447
5448
5449
5450 NullFields []string `json:"-"`
5451 }
5452
5453 func (s *OfferClassAddMessageResponse) MarshalJSON() ([]byte, error) {
5454 type NoMethod OfferClassAddMessageResponse
5455 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5456 }
5457
5458 type OfferClassListResponse struct {
5459
5460 Pagination *Pagination `json:"pagination,omitempty"`
5461
5462 Resources []*OfferClass `json:"resources,omitempty"`
5463
5464
5465 googleapi.ServerResponse `json:"-"`
5466
5467
5468
5469
5470
5471 ForceSendFields []string `json:"-"`
5472
5473
5474
5475
5476 NullFields []string `json:"-"`
5477 }
5478
5479 func (s *OfferClassListResponse) MarshalJSON() ([]byte, error) {
5480 type NoMethod OfferClassListResponse
5481 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5482 }
5483
5484 type OfferObject struct {
5485
5486 AppLinkData *AppLinkData `json:"appLinkData,omitempty"`
5487
5488 Barcode *Barcode `json:"barcode,omitempty"`
5489
5490
5491
5492
5493 ClassId string `json:"classId,omitempty"`
5494
5495
5496 ClassReference *OfferClass `json:"classReference,omitempty"`
5497
5498
5499
5500
5501 DisableExpirationNotification bool `json:"disableExpirationNotification,omitempty"`
5502
5503 GroupingInfo *GroupingInfo `json:"groupingInfo,omitempty"`
5504
5505
5506
5507
5508 HasLinkedDevice bool `json:"hasLinkedDevice,omitempty"`
5509
5510
5511 HasUsers bool `json:"hasUsers,omitempty"`
5512
5513
5514
5515 HeroImage *Image `json:"heroImage,omitempty"`
5516
5517
5518
5519
5520
5521 Id string `json:"id,omitempty"`
5522
5523
5524 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
5525
5526 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
5527
5528
5529 Kind string `json:"kind,omitempty"`
5530
5531
5532 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
5533
5534
5535 Locations []*LatLongPoint `json:"locations,omitempty"`
5536
5537
5538
5539 Messages []*Message `json:"messages,omitempty"`
5540
5541
5542 PassConstraints *PassConstraints `json:"passConstraints,omitempty"`
5543
5544 RotatingBarcode *RotatingBarcode `json:"rotatingBarcode,omitempty"`
5545
5546
5547
5548
5549
5550 SmartTapRedemptionValue string `json:"smartTapRedemptionValue,omitempty"`
5551
5552
5553
5554
5555
5556
5557
5558
5559
5560
5561
5562
5563
5564
5565 State string `json:"state,omitempty"`
5566
5567
5568
5569 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
5570
5571
5572
5573 ValidTimeInterval *TimeInterval `json:"validTimeInterval,omitempty"`
5574
5575 Version int64 `json:"version,omitempty,string"`
5576
5577
5578 googleapi.ServerResponse `json:"-"`
5579
5580
5581
5582
5583
5584 ForceSendFields []string `json:"-"`
5585
5586
5587
5588
5589 NullFields []string `json:"-"`
5590 }
5591
5592 func (s *OfferObject) MarshalJSON() ([]byte, error) {
5593 type NoMethod OfferObject
5594 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5595 }
5596
5597 type OfferObjectAddMessageResponse struct {
5598
5599 Resource *OfferObject `json:"resource,omitempty"`
5600
5601
5602 googleapi.ServerResponse `json:"-"`
5603
5604
5605
5606
5607
5608 ForceSendFields []string `json:"-"`
5609
5610
5611
5612
5613 NullFields []string `json:"-"`
5614 }
5615
5616 func (s *OfferObjectAddMessageResponse) MarshalJSON() ([]byte, error) {
5617 type NoMethod OfferObjectAddMessageResponse
5618 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5619 }
5620
5621 type OfferObjectListResponse struct {
5622
5623 Pagination *Pagination `json:"pagination,omitempty"`
5624
5625 Resources []*OfferObject `json:"resources,omitempty"`
5626
5627
5628 googleapi.ServerResponse `json:"-"`
5629
5630
5631
5632
5633
5634 ForceSendFields []string `json:"-"`
5635
5636
5637
5638
5639 NullFields []string `json:"-"`
5640 }
5641
5642 func (s *OfferObjectListResponse) MarshalJSON() ([]byte, error) {
5643 type NoMethod OfferObjectListResponse
5644 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5645 }
5646
5647 type Pagination struct {
5648
5649
5650 Kind string `json:"kind,omitempty"`
5651
5652 NextPageToken string `json:"nextPageToken,omitempty"`
5653
5654 ResultsPerPage int64 `json:"resultsPerPage,omitempty"`
5655
5656
5657
5658
5659
5660 ForceSendFields []string `json:"-"`
5661
5662
5663
5664
5665 NullFields []string `json:"-"`
5666 }
5667
5668 func (s *Pagination) MarshalJSON() ([]byte, error) {
5669 type NoMethod Pagination
5670 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5671 }
5672
5673
5674 type PassConstraints struct {
5675
5676
5677
5678
5679
5680
5681
5682
5683 NfcConstraint []string `json:"nfcConstraint,omitempty"`
5684
5685
5686
5687
5688
5689
5690
5691
5692
5693 ScreenshotEligibility string `json:"screenshotEligibility,omitempty"`
5694
5695
5696
5697
5698
5699 ForceSendFields []string `json:"-"`
5700
5701
5702
5703
5704 NullFields []string `json:"-"`
5705 }
5706
5707 func (s *PassConstraints) MarshalJSON() ([]byte, error) {
5708 type NoMethod PassConstraints
5709 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5710 }
5711
5712 type Permission struct {
5713
5714
5715 EmailAddress string `json:"emailAddress,omitempty"`
5716
5717
5718
5719
5720
5721
5722
5723
5724
5725
5726 Role string `json:"role,omitempty"`
5727
5728
5729
5730
5731
5732 ForceSendFields []string `json:"-"`
5733
5734
5735
5736
5737 NullFields []string `json:"-"`
5738 }
5739
5740 func (s *Permission) MarshalJSON() ([]byte, error) {
5741 type NoMethod Permission
5742 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5743 }
5744
5745 type Permissions struct {
5746
5747 IssuerId int64 `json:"issuerId,omitempty,string"`
5748
5749 Permissions []*Permission `json:"permissions,omitempty"`
5750
5751
5752 googleapi.ServerResponse `json:"-"`
5753
5754
5755
5756
5757
5758 ForceSendFields []string `json:"-"`
5759
5760
5761
5762
5763 NullFields []string `json:"-"`
5764 }
5765
5766 func (s *Permissions) MarshalJSON() ([]byte, error) {
5767 type NoMethod Permissions
5768 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5769 }
5770
5771 type PurchaseDetails struct {
5772
5773 AccountId string `json:"accountId,omitempty"`
5774
5775
5776 ConfirmationCode string `json:"confirmationCode,omitempty"`
5777
5778
5779
5780
5781
5782
5783
5784
5785
5786
5787
5788
5789
5790
5791 PurchaseDateTime string `json:"purchaseDateTime,omitempty"`
5792
5793
5794 PurchaseReceiptNumber string `json:"purchaseReceiptNumber,omitempty"`
5795
5796 TicketCost *TicketCost `json:"ticketCost,omitempty"`
5797
5798
5799
5800
5801
5802 ForceSendFields []string `json:"-"`
5803
5804
5805
5806
5807 NullFields []string `json:"-"`
5808 }
5809
5810 func (s *PurchaseDetails) MarshalJSON() ([]byte, error) {
5811 type NoMethod PurchaseDetails
5812 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5813 }
5814
5815 type ReservationInfo struct {
5816
5817
5818
5819 ConfirmationCode string `json:"confirmationCode,omitempty"`
5820
5821 EticketNumber string `json:"eticketNumber,omitempty"`
5822
5823 FrequentFlyerInfo *FrequentFlyerInfo `json:"frequentFlyerInfo,omitempty"`
5824
5825
5826 Kind string `json:"kind,omitempty"`
5827
5828
5829
5830
5831
5832 ForceSendFields []string `json:"-"`
5833
5834
5835
5836
5837 NullFields []string `json:"-"`
5838 }
5839
5840 func (s *ReservationInfo) MarshalJSON() ([]byte, error) {
5841 type NoMethod ReservationInfo
5842 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5843 }
5844
5845 type Resources struct {
5846 EventTicketClasses []*EventTicketClass `json:"eventTicketClasses,omitempty"`
5847 EventTicketObjects []*EventTicketObject `json:"eventTicketObjects,omitempty"`
5848 FlightClasses []*FlightClass `json:"flightClasses,omitempty"`
5849 FlightObjects []*FlightObject `json:"flightObjects,omitempty"`
5850 GiftCardClasses []*GiftCardClass `json:"giftCardClasses,omitempty"`
5851 GiftCardObjects []*GiftCardObject `json:"giftCardObjects,omitempty"`
5852 LoyaltyClasses []*LoyaltyClass `json:"loyaltyClasses,omitempty"`
5853 LoyaltyObjects []*LoyaltyObject `json:"loyaltyObjects,omitempty"`
5854 OfferClasses []*OfferClass `json:"offerClasses,omitempty"`
5855 OfferObjects []*OfferObject `json:"offerObjects,omitempty"`
5856 TransitClasses []*TransitClass `json:"transitClasses,omitempty"`
5857 TransitObjects []*TransitObject `json:"transitObjects,omitempty"`
5858
5859
5860
5861
5862
5863 ForceSendFields []string `json:"-"`
5864
5865
5866
5867
5868 NullFields []string `json:"-"`
5869 }
5870
5871 func (s *Resources) MarshalJSON() ([]byte, error) {
5872 type NoMethod Resources
5873 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5874 }
5875
5876 type Review struct {
5877 Comments string `json:"comments,omitempty"`
5878
5879
5880
5881
5882
5883 ForceSendFields []string `json:"-"`
5884
5885
5886
5887
5888 NullFields []string `json:"-"`
5889 }
5890
5891 func (s *Review) MarshalJSON() ([]byte, error) {
5892 type NoMethod Review
5893 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5894 }
5895
5896 type RotatingBarcode struct {
5897
5898
5899
5900 AlternateText string `json:"alternateText,omitempty"`
5901
5902
5903
5904
5905
5906 InitialRotatingBarcodeValues *RotatingBarcodeValues `json:"initialRotatingBarcodeValues,omitempty"`
5907
5908
5909
5910
5911
5912
5913
5914
5915 RenderEncoding string `json:"renderEncoding,omitempty"`
5916
5917
5918
5919 ShowCodeText *LocalizedString `json:"showCodeText,omitempty"`
5920
5921 TotpDetails *RotatingBarcodeTotpDetails `json:"totpDetails,omitempty"`
5922
5923
5924
5925
5926
5927
5928
5929
5930
5931
5932
5933
5934
5935
5936
5937
5938
5939
5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956
5957
5958
5959
5960
5961
5962
5963
5964
5965
5966
5967
5968 Type string `json:"type,omitempty"`
5969
5970
5971
5972
5973
5974
5975 ValuePattern string `json:"valuePattern,omitempty"`
5976
5977
5978
5979
5980
5981 ForceSendFields []string `json:"-"`
5982
5983
5984
5985
5986 NullFields []string `json:"-"`
5987 }
5988
5989 func (s *RotatingBarcode) MarshalJSON() ([]byte, error) {
5990 type NoMethod RotatingBarcode
5991 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5992 }
5993
5994
5995
5996 type RotatingBarcodeTotpDetails struct {
5997
5998
5999
6000
6001
6002 Algorithm string `json:"algorithm,omitempty"`
6003
6004
6005
6006 Parameters []*RotatingBarcodeTotpDetailsTotpParameters `json:"parameters,omitempty"`
6007
6008
6009 PeriodMillis int64 `json:"periodMillis,omitempty,string"`
6010
6011
6012
6013
6014
6015 ForceSendFields []string `json:"-"`
6016
6017
6018
6019
6020 NullFields []string `json:"-"`
6021 }
6022
6023 func (s *RotatingBarcodeTotpDetails) MarshalJSON() ([]byte, error) {
6024 type NoMethod RotatingBarcodeTotpDetails
6025 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6026 }
6027
6028
6029
6030 type RotatingBarcodeTotpDetailsTotpParameters struct {
6031
6032
6033 Key string `json:"key,omitempty"`
6034
6035 ValueLength int64 `json:"valueLength,omitempty"`
6036
6037
6038
6039
6040
6041 ForceSendFields []string `json:"-"`
6042
6043
6044
6045
6046 NullFields []string `json:"-"`
6047 }
6048
6049 func (s *RotatingBarcodeTotpDetailsTotpParameters) MarshalJSON() ([]byte, error) {
6050 type NoMethod RotatingBarcodeTotpDetailsTotpParameters
6051 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6052 }
6053
6054
6055
6056 type RotatingBarcodeValues struct {
6057
6058 PeriodMillis int64 `json:"periodMillis,omitempty,string"`
6059
6060
6061
6062
6063
6064
6065
6066
6067
6068
6069
6070
6071
6072 StartDateTime string `json:"startDateTime,omitempty"`
6073
6074
6075 Values []string `json:"values,omitempty"`
6076
6077
6078
6079
6080
6081 ForceSendFields []string `json:"-"`
6082
6083
6084
6085
6086 NullFields []string `json:"-"`
6087 }
6088
6089 func (s *RotatingBarcodeValues) MarshalJSON() ([]byte, error) {
6090 type NoMethod RotatingBarcodeValues
6091 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6092 }
6093
6094 type SecurityAnimation struct {
6095
6096
6097
6098
6099
6100
6101 AnimationType string `json:"animationType,omitempty"`
6102
6103
6104
6105
6106
6107 ForceSendFields []string `json:"-"`
6108
6109
6110
6111
6112 NullFields []string `json:"-"`
6113 }
6114
6115 func (s *SecurityAnimation) MarshalJSON() ([]byte, error) {
6116 type NoMethod SecurityAnimation
6117 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6118 }
6119
6120 type SignUpInfo struct {
6121
6122 ClassId string `json:"classId,omitempty"`
6123
6124
6125
6126
6127
6128 ForceSendFields []string `json:"-"`
6129
6130
6131
6132
6133 NullFields []string `json:"-"`
6134 }
6135
6136 func (s *SignUpInfo) MarshalJSON() ([]byte, error) {
6137 type NoMethod SignUpInfo
6138 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6139 }
6140
6141 type SmartTap struct {
6142
6143
6144
6145
6146 Id string `json:"id,omitempty"`
6147
6148 Infos []*IssuerToUserInfo `json:"infos,omitempty"`
6149
6150
6151 Kind string `json:"kind,omitempty"`
6152
6153
6154 MerchantId int64 `json:"merchantId,omitempty,string"`
6155
6156
6157 googleapi.ServerResponse `json:"-"`
6158
6159
6160
6161
6162
6163 ForceSendFields []string `json:"-"`
6164
6165
6166
6167
6168 NullFields []string `json:"-"`
6169 }
6170
6171 func (s *SmartTap) MarshalJSON() ([]byte, error) {
6172 type NoMethod SmartTap
6173 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6174 }
6175
6176 type SmartTapMerchantData struct {
6177
6178
6179 AuthenticationKeys []*AuthenticationKey `json:"authenticationKeys,omitempty"`
6180
6181
6182 SmartTapMerchantId int64 `json:"smartTapMerchantId,omitempty,string"`
6183
6184
6185
6186
6187
6188 ForceSendFields []string `json:"-"`
6189
6190
6191
6192
6193 NullFields []string `json:"-"`
6194 }
6195
6196 func (s *SmartTapMerchantData) MarshalJSON() ([]byte, error) {
6197 type NoMethod SmartTapMerchantData
6198 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6199 }
6200
6201 type TemplateItem struct {
6202
6203
6204
6205 FirstValue *FieldSelector `json:"firstValue,omitempty"`
6206
6207
6208
6209
6210
6211
6212
6213
6214
6215
6216
6217 PredefinedItem string `json:"predefinedItem,omitempty"`
6218
6219
6220 SecondValue *FieldSelector `json:"secondValue,omitempty"`
6221
6222
6223
6224
6225
6226 ForceSendFields []string `json:"-"`
6227
6228
6229
6230
6231 NullFields []string `json:"-"`
6232 }
6233
6234 func (s *TemplateItem) MarshalJSON() ([]byte, error) {
6235 type NoMethod TemplateItem
6236 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6237 }
6238
6239
6240
6241
6242 type TextModuleData struct {
6243
6244
6245
6246 Body string `json:"body,omitempty"`
6247
6248
6249 Header string `json:"header,omitempty"`
6250
6251
6252 Id string `json:"id,omitempty"`
6253
6254
6255 LocalizedBody *LocalizedString `json:"localizedBody,omitempty"`
6256
6257
6258
6259 LocalizedHeader *LocalizedString `json:"localizedHeader,omitempty"`
6260
6261
6262
6263
6264
6265 ForceSendFields []string `json:"-"`
6266
6267
6268
6269
6270 NullFields []string `json:"-"`
6271 }
6272
6273 func (s *TextModuleData) MarshalJSON() ([]byte, error) {
6274 type NoMethod TextModuleData
6275 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6276 }
6277
6278 type TicketCost struct {
6279
6280 DiscountMessage *LocalizedString `json:"discountMessage,omitempty"`
6281
6282 FaceValue *Money `json:"faceValue,omitempty"`
6283
6284
6285 PurchasePrice *Money `json:"purchasePrice,omitempty"`
6286
6287
6288
6289
6290
6291 ForceSendFields []string `json:"-"`
6292
6293
6294
6295
6296 NullFields []string `json:"-"`
6297 }
6298
6299 func (s *TicketCost) MarshalJSON() ([]byte, error) {
6300 type NoMethod TicketCost
6301 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6302 }
6303
6304 type TicketLeg struct {
6305
6306
6307
6308
6309
6310
6311
6312
6313
6314
6315
6316
6317
6318
6319
6320
6321
6322
6323
6324
6325 ArrivalDateTime string `json:"arrivalDateTime,omitempty"`
6326
6327 Carriage string `json:"carriage,omitempty"`
6328
6329
6330
6331
6332
6333
6334
6335
6336
6337
6338
6339
6340
6341
6342
6343
6344
6345
6346
6347
6348
6349 DepartureDateTime string `json:"departureDateTime,omitempty"`
6350
6351 DestinationName *LocalizedString `json:"destinationName,omitempty"`
6352
6353 DestinationStationCode string `json:"destinationStationCode,omitempty"`
6354
6355
6356 FareName *LocalizedString `json:"fareName,omitempty"`
6357
6358
6359 OriginName *LocalizedString `json:"originName,omitempty"`
6360
6361
6362 OriginStationCode string `json:"originStationCode,omitempty"`
6363
6364 Platform string `json:"platform,omitempty"`
6365
6366
6367
6368 TicketSeat *TicketSeat `json:"ticketSeat,omitempty"`
6369
6370
6371
6372 TicketSeats []*TicketSeat `json:"ticketSeats,omitempty"`
6373
6374
6375 TransitOperatorName *LocalizedString `json:"transitOperatorName,omitempty"`
6376
6377 TransitTerminusName *LocalizedString `json:"transitTerminusName,omitempty"`
6378
6379 Zone string `json:"zone,omitempty"`
6380
6381
6382
6383
6384
6385 ForceSendFields []string `json:"-"`
6386
6387
6388
6389
6390 NullFields []string `json:"-"`
6391 }
6392
6393 func (s *TicketLeg) MarshalJSON() ([]byte, error) {
6394 type NoMethod TicketLeg
6395 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6396 }
6397
6398 type TicketRestrictions struct {
6399
6400
6401 OtherRestrictions *LocalizedString `json:"otherRestrictions,omitempty"`
6402
6403
6404 RouteRestrictions *LocalizedString `json:"routeRestrictions,omitempty"`
6405
6406 RouteRestrictionsDetails *LocalizedString `json:"routeRestrictionsDetails,omitempty"`
6407
6408 TimeRestrictions *LocalizedString `json:"timeRestrictions,omitempty"`
6409
6410
6411
6412
6413
6414 ForceSendFields []string `json:"-"`
6415
6416
6417
6418
6419 NullFields []string `json:"-"`
6420 }
6421
6422 func (s *TicketRestrictions) MarshalJSON() ([]byte, error) {
6423 type NoMethod TicketRestrictions
6424 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6425 }
6426
6427 type TicketSeat struct {
6428
6429
6430 Coach string `json:"coach,omitempty"`
6431
6432
6433 CustomFareClass *LocalizedString `json:"customFareClass,omitempty"`
6434
6435
6436
6437
6438
6439
6440
6441
6442
6443
6444 FareClass string `json:"fareClass,omitempty"`
6445
6446
6447 Seat string `json:"seat,omitempty"`
6448
6449
6450 SeatAssignment *LocalizedString `json:"seatAssignment,omitempty"`
6451
6452
6453
6454
6455
6456 ForceSendFields []string `json:"-"`
6457
6458
6459
6460
6461 NullFields []string `json:"-"`
6462 }
6463
6464 func (s *TicketSeat) MarshalJSON() ([]byte, error) {
6465 type NoMethod TicketSeat
6466 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6467 }
6468
6469 type TimeInterval struct {
6470
6471
6472 End *DateTime `json:"end,omitempty"`
6473
6474
6475 Kind string `json:"kind,omitempty"`
6476
6477
6478 Start *DateTime `json:"start,omitempty"`
6479
6480
6481
6482
6483
6484 ForceSendFields []string `json:"-"`
6485
6486
6487
6488
6489 NullFields []string `json:"-"`
6490 }
6491
6492 func (s *TimeInterval) MarshalJSON() ([]byte, error) {
6493 type NoMethod TimeInterval
6494 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6495 }
6496
6497 type TransitClass struct {
6498
6499 ActivationOptions *ActivationOptions `json:"activationOptions,omitempty"`
6500
6501
6502 AllowMultipleUsersPerObject bool `json:"allowMultipleUsersPerObject,omitempty"`
6503
6504
6505
6506 CallbackOptions *CallbackOptions `json:"callbackOptions,omitempty"`
6507
6508
6509
6510 ClassTemplateInfo *ClassTemplateInfo `json:"classTemplateInfo,omitempty"`
6511
6512
6513
6514 CountryCode string `json:"countryCode,omitempty"`
6515
6516
6517 CustomCarriageLabel *LocalizedString `json:"customCarriageLabel,omitempty"`
6518
6519
6520 CustomCoachLabel *LocalizedString `json:"customCoachLabel,omitempty"`
6521
6522
6523 CustomConcessionCategoryLabel *LocalizedString `json:"customConcessionCategoryLabel,omitempty"`
6524
6525
6526 CustomConfirmationCodeLabel *LocalizedString `json:"customConfirmationCodeLabel,omitempty"`
6527
6528
6529 CustomDiscountMessageLabel *LocalizedString `json:"customDiscountMessageLabel,omitempty"`
6530
6531
6532 CustomFareClassLabel *LocalizedString `json:"customFareClassLabel,omitempty"`
6533
6534
6535 CustomFareNameLabel *LocalizedString `json:"customFareNameLabel,omitempty"`
6536
6537
6538 CustomOtherRestrictionsLabel *LocalizedString `json:"customOtherRestrictionsLabel,omitempty"`
6539
6540
6541 CustomPlatformLabel *LocalizedString `json:"customPlatformLabel,omitempty"`
6542
6543
6544 CustomPurchaseFaceValueLabel *LocalizedString `json:"customPurchaseFaceValueLabel,omitempty"`
6545
6546
6547 CustomPurchasePriceLabel *LocalizedString `json:"customPurchasePriceLabel,omitempty"`
6548
6549
6550
6551 CustomPurchaseReceiptNumberLabel *LocalizedString `json:"customPurchaseReceiptNumberLabel,omitempty"`
6552
6553
6554
6555 CustomRouteRestrictionsDetailsLabel *LocalizedString `json:"customRouteRestrictionsDetailsLabel,omitempty"`
6556
6557
6558 CustomRouteRestrictionsLabel *LocalizedString `json:"customRouteRestrictionsLabel,omitempty"`
6559
6560
6561 CustomSeatLabel *LocalizedString `json:"customSeatLabel,omitempty"`
6562
6563
6564 CustomTicketNumberLabel *LocalizedString `json:"customTicketNumberLabel,omitempty"`
6565
6566
6567 CustomTimeRestrictionsLabel *LocalizedString `json:"customTimeRestrictionsLabel,omitempty"`
6568
6569
6570 CustomTransitTerminusNameLabel *LocalizedString `json:"customTransitTerminusNameLabel,omitempty"`
6571
6572
6573 CustomZoneLabel *LocalizedString `json:"customZoneLabel,omitempty"`
6574
6575
6576
6577 EnableSingleLegItinerary bool `json:"enableSingleLegItinerary,omitempty"`
6578
6579
6580
6581 EnableSmartTap bool `json:"enableSmartTap,omitempty"`
6582
6583
6584 HeroImage *Image `json:"heroImage,omitempty"`
6585
6586
6587
6588
6589
6590 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
6591
6592
6593
6594
6595
6596 HomepageUri *Uri `json:"homepageUri,omitempty"`
6597
6598
6599
6600
6601
6602 Id string `json:"id,omitempty"`
6603
6604
6605 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
6606
6607 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
6608
6609
6610 IssuerName string `json:"issuerName,omitempty"`
6611
6612
6613
6614 LanguageOverride string `json:"languageOverride,omitempty"`
6615
6616
6617 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
6618
6619
6620
6621 LocalizedIssuerName *LocalizedString `json:"localizedIssuerName,omitempty"`
6622
6623
6624 Locations []*LatLongPoint `json:"locations,omitempty"`
6625
6626
6627 Logo *Image `json:"logo,omitempty"`
6628
6629
6630
6631 Messages []*Message `json:"messages,omitempty"`
6632
6633
6634
6635
6636
6637
6638
6639
6640
6641
6642
6643
6644
6645
6646
6647
6648
6649
6650
6651
6652 MultipleDevicesAndHoldersAllowedStatus string `json:"multipleDevicesAndHoldersAllowedStatus,omitempty"`
6653
6654
6655
6656
6657
6658 RedemptionIssuers googleapi.Int64s `json:"redemptionIssuers,omitempty"`
6659
6660
6661 Review *Review `json:"review,omitempty"`
6662
6663
6664
6665
6666
6667
6668
6669
6670
6671
6672
6673
6674
6675
6676
6677
6678
6679
6680
6681
6682 ReviewStatus string `json:"reviewStatus,omitempty"`
6683
6684
6685 SecurityAnimation *SecurityAnimation `json:"securityAnimation,omitempty"`
6686
6687
6688
6689 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
6690
6691 TransitOperatorName *LocalizedString `json:"transitOperatorName,omitempty"`
6692
6693
6694
6695
6696
6697
6698
6699
6700
6701
6702
6703
6704
6705
6706
6707 TransitType string `json:"transitType,omitempty"`
6708
6709 Version int64 `json:"version,omitempty,string"`
6710
6711
6712
6713
6714
6715
6716
6717
6718
6719
6720
6721
6722 ViewUnlockRequirement string `json:"viewUnlockRequirement,omitempty"`
6723
6724 Watermark *Image `json:"watermark,omitempty"`
6725
6726
6727 WideLogo *Image `json:"wideLogo,omitempty"`
6728
6729 WordMark *Image `json:"wordMark,omitempty"`
6730
6731
6732 googleapi.ServerResponse `json:"-"`
6733
6734
6735
6736
6737
6738 ForceSendFields []string `json:"-"`
6739
6740
6741
6742
6743 NullFields []string `json:"-"`
6744 }
6745
6746 func (s *TransitClass) MarshalJSON() ([]byte, error) {
6747 type NoMethod TransitClass
6748 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6749 }
6750
6751 type TransitClassAddMessageResponse struct {
6752
6753 Resource *TransitClass `json:"resource,omitempty"`
6754
6755
6756 googleapi.ServerResponse `json:"-"`
6757
6758
6759
6760
6761
6762 ForceSendFields []string `json:"-"`
6763
6764
6765
6766
6767 NullFields []string `json:"-"`
6768 }
6769
6770 func (s *TransitClassAddMessageResponse) MarshalJSON() ([]byte, error) {
6771 type NoMethod TransitClassAddMessageResponse
6772 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6773 }
6774
6775 type TransitClassListResponse struct {
6776
6777 Pagination *Pagination `json:"pagination,omitempty"`
6778
6779 Resources []*TransitClass `json:"resources,omitempty"`
6780
6781
6782 googleapi.ServerResponse `json:"-"`
6783
6784
6785
6786
6787
6788 ForceSendFields []string `json:"-"`
6789
6790
6791
6792
6793 NullFields []string `json:"-"`
6794 }
6795
6796 func (s *TransitClassListResponse) MarshalJSON() ([]byte, error) {
6797 type NoMethod TransitClassListResponse
6798 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6799 }
6800
6801 type TransitObject struct {
6802
6803
6804 ActivationStatus *ActivationStatus `json:"activationStatus,omitempty"`
6805
6806 AppLinkData *AppLinkData `json:"appLinkData,omitempty"`
6807
6808 Barcode *Barcode `json:"barcode,omitempty"`
6809
6810
6811
6812
6813 ClassId string `json:"classId,omitempty"`
6814
6815
6816 ClassReference *TransitClass `json:"classReference,omitempty"`
6817
6818
6819
6820
6821
6822
6823
6824
6825
6826
6827 ConcessionCategory string `json:"concessionCategory,omitempty"`
6828
6829
6830
6831 CustomConcessionCategory *LocalizedString `json:"customConcessionCategory,omitempty"`
6832
6833
6834
6835 CustomTicketStatus *LocalizedString `json:"customTicketStatus,omitempty"`
6836
6837 DeviceContext *DeviceContext `json:"deviceContext,omitempty"`
6838
6839
6840
6841
6842 DisableExpirationNotification bool `json:"disableExpirationNotification,omitempty"`
6843
6844 GroupingInfo *GroupingInfo `json:"groupingInfo,omitempty"`
6845
6846
6847
6848
6849 HasLinkedDevice bool `json:"hasLinkedDevice,omitempty"`
6850
6851
6852 HasUsers bool `json:"hasUsers,omitempty"`
6853
6854
6855
6856 HeroImage *Image `json:"heroImage,omitempty"`
6857
6858
6859
6860
6861
6862 HexBackgroundColor string `json:"hexBackgroundColor,omitempty"`
6863
6864
6865
6866
6867
6868 Id string `json:"id,omitempty"`
6869
6870
6871 ImageModulesData []*ImageModuleData `json:"imageModulesData,omitempty"`
6872
6873 InfoModuleData *InfoModuleData `json:"infoModuleData,omitempty"`
6874
6875
6876 LinksModuleData *LinksModuleData `json:"linksModuleData,omitempty"`
6877
6878
6879 Locations []*LatLongPoint `json:"locations,omitempty"`
6880
6881
6882
6883 Messages []*Message `json:"messages,omitempty"`
6884
6885
6886 PassConstraints *PassConstraints `json:"passConstraints,omitempty"`
6887
6888
6889 PassengerNames string `json:"passengerNames,omitempty"`
6890
6891
6892
6893
6894
6895
6896
6897
6898 PassengerType string `json:"passengerType,omitempty"`
6899
6900 PurchaseDetails *PurchaseDetails `json:"purchaseDetails,omitempty"`
6901
6902 RotatingBarcode *RotatingBarcode `json:"rotatingBarcode,omitempty"`
6903
6904
6905
6906
6907
6908 SmartTapRedemptionValue string `json:"smartTapRedemptionValue,omitempty"`
6909
6910
6911
6912
6913
6914
6915
6916
6917
6918
6919
6920
6921
6922
6923 State string `json:"state,omitempty"`
6924
6925
6926
6927 TextModulesData []*TextModuleData `json:"textModulesData,omitempty"`
6928
6929
6930
6931
6932 TicketLeg *TicketLeg `json:"ticketLeg,omitempty"`
6933
6934
6935
6936
6937 TicketLegs []*TicketLeg `json:"ticketLegs,omitempty"`
6938
6939
6940 TicketNumber string `json:"ticketNumber,omitempty"`
6941
6942
6943
6944 TicketRestrictions *TicketRestrictions `json:"ticketRestrictions,omitempty"`
6945
6946
6947
6948
6949
6950
6951
6952
6953
6954
6955
6956 TicketStatus string `json:"ticketStatus,omitempty"`
6957
6958
6959 TripId string `json:"tripId,omitempty"`
6960
6961
6962
6963
6964
6965
6966
6967
6968
6969
6970 TripType string `json:"tripType,omitempty"`
6971
6972
6973
6974 ValidTimeInterval *TimeInterval `json:"validTimeInterval,omitempty"`
6975
6976 Version int64 `json:"version,omitempty,string"`
6977
6978
6979 googleapi.ServerResponse `json:"-"`
6980
6981
6982
6983
6984
6985 ForceSendFields []string `json:"-"`
6986
6987
6988
6989
6990 NullFields []string `json:"-"`
6991 }
6992
6993 func (s *TransitObject) MarshalJSON() ([]byte, error) {
6994 type NoMethod TransitObject
6995 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
6996 }
6997
6998 type TransitObjectAddMessageResponse struct {
6999
7000 Resource *TransitObject `json:"resource,omitempty"`
7001
7002
7003 googleapi.ServerResponse `json:"-"`
7004
7005
7006
7007
7008
7009 ForceSendFields []string `json:"-"`
7010
7011
7012
7013
7014 NullFields []string `json:"-"`
7015 }
7016
7017 func (s *TransitObjectAddMessageResponse) MarshalJSON() ([]byte, error) {
7018 type NoMethod TransitObjectAddMessageResponse
7019 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
7020 }
7021
7022 type TransitObjectListResponse struct {
7023
7024 Pagination *Pagination `json:"pagination,omitempty"`
7025
7026 Resources []*TransitObject `json:"resources,omitempty"`
7027
7028
7029 googleapi.ServerResponse `json:"-"`
7030
7031
7032
7033
7034
7035 ForceSendFields []string `json:"-"`
7036
7037
7038
7039
7040 NullFields []string `json:"-"`
7041 }
7042
7043 func (s *TransitObjectListResponse) MarshalJSON() ([]byte, error) {
7044 type NoMethod TransitObjectListResponse
7045 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
7046 }
7047
7048
7049
7050 type TransitObjectUploadRotatingBarcodeValuesRequest struct {
7051
7052 Blob *Media `json:"blob,omitempty"`
7053
7054 MediaRequestInfo *MediaRequestInfo `json:"mediaRequestInfo,omitempty"`
7055
7056
7057
7058
7059
7060 ForceSendFields []string `json:"-"`
7061
7062
7063
7064
7065 NullFields []string `json:"-"`
7066 }
7067
7068 func (s *TransitObjectUploadRotatingBarcodeValuesRequest) MarshalJSON() ([]byte, error) {
7069 type NoMethod TransitObjectUploadRotatingBarcodeValuesRequest
7070 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
7071 }
7072
7073
7074
7075 type TransitObjectUploadRotatingBarcodeValuesResponse struct {
7076
7077 googleapi.ServerResponse `json:"-"`
7078 }
7079
7080 type TranslatedString struct {
7081
7082
7083 Kind string `json:"kind,omitempty"`
7084
7085
7086 Language string `json:"language,omitempty"`
7087
7088 Value string `json:"value,omitempty"`
7089
7090
7091
7092
7093
7094 ForceSendFields []string `json:"-"`
7095
7096
7097
7098
7099 NullFields []string `json:"-"`
7100 }
7101
7102 func (s *TranslatedString) MarshalJSON() ([]byte, error) {
7103 type NoMethod TranslatedString
7104 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
7105 }
7106
7107
7108
7109
7110 type UpcomingNotification struct {
7111
7112
7113 EnableNotification bool `json:"enableNotification,omitempty"`
7114
7115
7116
7117
7118
7119 ForceSendFields []string `json:"-"`
7120
7121
7122
7123
7124 NullFields []string `json:"-"`
7125 }
7126
7127 func (s *UpcomingNotification) MarshalJSON() ([]byte, error) {
7128 type NoMethod UpcomingNotification
7129 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
7130 }
7131
7132 type Uri struct {
7133
7134
7135
7136
7137 Description string `json:"description,omitempty"`
7138
7139
7140 Id string `json:"id,omitempty"`
7141
7142
7143 Kind string `json:"kind,omitempty"`
7144
7145
7146
7147 LocalizedDescription *LocalizedString `json:"localizedDescription,omitempty"`
7148
7149
7150
7151
7152 Uri string `json:"uri,omitempty"`
7153
7154
7155
7156
7157
7158 ForceSendFields []string `json:"-"`
7159
7160
7161
7162
7163 NullFields []string `json:"-"`
7164 }
7165
7166 func (s *Uri) MarshalJSON() ([]byte, error) {
7167 type NoMethod Uri
7168 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
7169 }
7170
7171 type EventticketclassAddmessageCall struct {
7172 s *Service
7173 resourceId string
7174 addmessagerequest *AddMessageRequest
7175 urlParams_ gensupport.URLParams
7176 ctx_ context.Context
7177 header_ http.Header
7178 }
7179
7180
7181
7182
7183
7184
7185
7186
7187
7188 func (r *EventticketclassService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *EventticketclassAddmessageCall {
7189 c := &EventticketclassAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7190 c.resourceId = resourceId
7191 c.addmessagerequest = addmessagerequest
7192 return c
7193 }
7194
7195
7196
7197
7198 func (c *EventticketclassAddmessageCall) Fields(s ...googleapi.Field) *EventticketclassAddmessageCall {
7199 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7200 return c
7201 }
7202
7203
7204 func (c *EventticketclassAddmessageCall) Context(ctx context.Context) *EventticketclassAddmessageCall {
7205 c.ctx_ = ctx
7206 return c
7207 }
7208
7209
7210
7211 func (c *EventticketclassAddmessageCall) Header() http.Header {
7212 if c.header_ == nil {
7213 c.header_ = make(http.Header)
7214 }
7215 return c.header_
7216 }
7217
7218 func (c *EventticketclassAddmessageCall) doRequest(alt string) (*http.Response, error) {
7219 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7220 var body io.Reader = nil
7221 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
7222 if err != nil {
7223 return nil, err
7224 }
7225 c.urlParams_.Set("alt", alt)
7226 c.urlParams_.Set("prettyPrint", "false")
7227 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketClass/{resourceId}/addMessage")
7228 urls += "?" + c.urlParams_.Encode()
7229 req, err := http.NewRequest("POST", urls, body)
7230 if err != nil {
7231 return nil, err
7232 }
7233 req.Header = reqHeaders
7234 googleapi.Expand(req.URL, map[string]string{
7235 "resourceId": c.resourceId,
7236 })
7237 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7238 }
7239
7240
7241
7242
7243
7244
7245
7246 func (c *EventticketclassAddmessageCall) Do(opts ...googleapi.CallOption) (*EventTicketClassAddMessageResponse, error) {
7247 gensupport.SetOptions(c.urlParams_, opts...)
7248 res, err := c.doRequest("json")
7249 if res != nil && res.StatusCode == http.StatusNotModified {
7250 if res.Body != nil {
7251 res.Body.Close()
7252 }
7253 return nil, gensupport.WrapError(&googleapi.Error{
7254 Code: res.StatusCode,
7255 Header: res.Header,
7256 })
7257 }
7258 if err != nil {
7259 return nil, err
7260 }
7261 defer googleapi.CloseBody(res)
7262 if err := googleapi.CheckResponse(res); err != nil {
7263 return nil, gensupport.WrapError(err)
7264 }
7265 ret := &EventTicketClassAddMessageResponse{
7266 ServerResponse: googleapi.ServerResponse{
7267 Header: res.Header,
7268 HTTPStatusCode: res.StatusCode,
7269 },
7270 }
7271 target := &ret
7272 if err := gensupport.DecodeResponse(target, res); err != nil {
7273 return nil, err
7274 }
7275 return ret, nil
7276 }
7277
7278 type EventticketclassGetCall struct {
7279 s *Service
7280 resourceId string
7281 urlParams_ gensupport.URLParams
7282 ifNoneMatch_ string
7283 ctx_ context.Context
7284 header_ http.Header
7285 }
7286
7287
7288
7289
7290
7291
7292
7293
7294 func (r *EventticketclassService) Get(resourceId string) *EventticketclassGetCall {
7295 c := &EventticketclassGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7296 c.resourceId = resourceId
7297 return c
7298 }
7299
7300
7301
7302
7303 func (c *EventticketclassGetCall) Fields(s ...googleapi.Field) *EventticketclassGetCall {
7304 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7305 return c
7306 }
7307
7308
7309
7310
7311 func (c *EventticketclassGetCall) IfNoneMatch(entityTag string) *EventticketclassGetCall {
7312 c.ifNoneMatch_ = entityTag
7313 return c
7314 }
7315
7316
7317 func (c *EventticketclassGetCall) Context(ctx context.Context) *EventticketclassGetCall {
7318 c.ctx_ = ctx
7319 return c
7320 }
7321
7322
7323
7324 func (c *EventticketclassGetCall) Header() http.Header {
7325 if c.header_ == nil {
7326 c.header_ = make(http.Header)
7327 }
7328 return c.header_
7329 }
7330
7331 func (c *EventticketclassGetCall) doRequest(alt string) (*http.Response, error) {
7332 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7333 if c.ifNoneMatch_ != "" {
7334 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7335 }
7336 var body io.Reader = nil
7337 c.urlParams_.Set("alt", alt)
7338 c.urlParams_.Set("prettyPrint", "false")
7339 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketClass/{resourceId}")
7340 urls += "?" + c.urlParams_.Encode()
7341 req, err := http.NewRequest("GET", urls, body)
7342 if err != nil {
7343 return nil, err
7344 }
7345 req.Header = reqHeaders
7346 googleapi.Expand(req.URL, map[string]string{
7347 "resourceId": c.resourceId,
7348 })
7349 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7350 }
7351
7352
7353
7354
7355
7356
7357
7358 func (c *EventticketclassGetCall) Do(opts ...googleapi.CallOption) (*EventTicketClass, error) {
7359 gensupport.SetOptions(c.urlParams_, opts...)
7360 res, err := c.doRequest("json")
7361 if res != nil && res.StatusCode == http.StatusNotModified {
7362 if res.Body != nil {
7363 res.Body.Close()
7364 }
7365 return nil, gensupport.WrapError(&googleapi.Error{
7366 Code: res.StatusCode,
7367 Header: res.Header,
7368 })
7369 }
7370 if err != nil {
7371 return nil, err
7372 }
7373 defer googleapi.CloseBody(res)
7374 if err := googleapi.CheckResponse(res); err != nil {
7375 return nil, gensupport.WrapError(err)
7376 }
7377 ret := &EventTicketClass{
7378 ServerResponse: googleapi.ServerResponse{
7379 Header: res.Header,
7380 HTTPStatusCode: res.StatusCode,
7381 },
7382 }
7383 target := &ret
7384 if err := gensupport.DecodeResponse(target, res); err != nil {
7385 return nil, err
7386 }
7387 return ret, nil
7388 }
7389
7390 type EventticketclassInsertCall struct {
7391 s *Service
7392 eventticketclass *EventTicketClass
7393 urlParams_ gensupport.URLParams
7394 ctx_ context.Context
7395 header_ http.Header
7396 }
7397
7398
7399 func (r *EventticketclassService) Insert(eventticketclass *EventTicketClass) *EventticketclassInsertCall {
7400 c := &EventticketclassInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7401 c.eventticketclass = eventticketclass
7402 return c
7403 }
7404
7405
7406
7407
7408 func (c *EventticketclassInsertCall) Fields(s ...googleapi.Field) *EventticketclassInsertCall {
7409 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7410 return c
7411 }
7412
7413
7414 func (c *EventticketclassInsertCall) Context(ctx context.Context) *EventticketclassInsertCall {
7415 c.ctx_ = ctx
7416 return c
7417 }
7418
7419
7420
7421 func (c *EventticketclassInsertCall) Header() http.Header {
7422 if c.header_ == nil {
7423 c.header_ = make(http.Header)
7424 }
7425 return c.header_
7426 }
7427
7428 func (c *EventticketclassInsertCall) doRequest(alt string) (*http.Response, error) {
7429 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7430 var body io.Reader = nil
7431 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventticketclass)
7432 if err != nil {
7433 return nil, err
7434 }
7435 c.urlParams_.Set("alt", alt)
7436 c.urlParams_.Set("prettyPrint", "false")
7437 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketClass")
7438 urls += "?" + c.urlParams_.Encode()
7439 req, err := http.NewRequest("POST", urls, body)
7440 if err != nil {
7441 return nil, err
7442 }
7443 req.Header = reqHeaders
7444 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7445 }
7446
7447
7448
7449
7450
7451
7452
7453 func (c *EventticketclassInsertCall) Do(opts ...googleapi.CallOption) (*EventTicketClass, error) {
7454 gensupport.SetOptions(c.urlParams_, opts...)
7455 res, err := c.doRequest("json")
7456 if res != nil && res.StatusCode == http.StatusNotModified {
7457 if res.Body != nil {
7458 res.Body.Close()
7459 }
7460 return nil, gensupport.WrapError(&googleapi.Error{
7461 Code: res.StatusCode,
7462 Header: res.Header,
7463 })
7464 }
7465 if err != nil {
7466 return nil, err
7467 }
7468 defer googleapi.CloseBody(res)
7469 if err := googleapi.CheckResponse(res); err != nil {
7470 return nil, gensupport.WrapError(err)
7471 }
7472 ret := &EventTicketClass{
7473 ServerResponse: googleapi.ServerResponse{
7474 Header: res.Header,
7475 HTTPStatusCode: res.StatusCode,
7476 },
7477 }
7478 target := &ret
7479 if err := gensupport.DecodeResponse(target, res); err != nil {
7480 return nil, err
7481 }
7482 return ret, nil
7483 }
7484
7485 type EventticketclassListCall struct {
7486 s *Service
7487 urlParams_ gensupport.URLParams
7488 ifNoneMatch_ string
7489 ctx_ context.Context
7490 header_ http.Header
7491 }
7492
7493
7494 func (r *EventticketclassService) List() *EventticketclassListCall {
7495 c := &EventticketclassListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7496 return c
7497 }
7498
7499
7500
7501 func (c *EventticketclassListCall) IssuerId(issuerId int64) *EventticketclassListCall {
7502 c.urlParams_.Set("issuerId", fmt.Sprint(issuerId))
7503 return c
7504 }
7505
7506
7507
7508
7509 func (c *EventticketclassListCall) MaxResults(maxResults int64) *EventticketclassListCall {
7510 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
7511 return c
7512 }
7513
7514
7515
7516
7517
7518
7519
7520 func (c *EventticketclassListCall) Token(token string) *EventticketclassListCall {
7521 c.urlParams_.Set("token", token)
7522 return c
7523 }
7524
7525
7526
7527
7528 func (c *EventticketclassListCall) Fields(s ...googleapi.Field) *EventticketclassListCall {
7529 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7530 return c
7531 }
7532
7533
7534
7535
7536 func (c *EventticketclassListCall) IfNoneMatch(entityTag string) *EventticketclassListCall {
7537 c.ifNoneMatch_ = entityTag
7538 return c
7539 }
7540
7541
7542 func (c *EventticketclassListCall) Context(ctx context.Context) *EventticketclassListCall {
7543 c.ctx_ = ctx
7544 return c
7545 }
7546
7547
7548
7549 func (c *EventticketclassListCall) Header() http.Header {
7550 if c.header_ == nil {
7551 c.header_ = make(http.Header)
7552 }
7553 return c.header_
7554 }
7555
7556 func (c *EventticketclassListCall) doRequest(alt string) (*http.Response, error) {
7557 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7558 if c.ifNoneMatch_ != "" {
7559 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7560 }
7561 var body io.Reader = nil
7562 c.urlParams_.Set("alt", alt)
7563 c.urlParams_.Set("prettyPrint", "false")
7564 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketClass")
7565 urls += "?" + c.urlParams_.Encode()
7566 req, err := http.NewRequest("GET", urls, body)
7567 if err != nil {
7568 return nil, err
7569 }
7570 req.Header = reqHeaders
7571 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7572 }
7573
7574
7575
7576
7577
7578
7579
7580 func (c *EventticketclassListCall) Do(opts ...googleapi.CallOption) (*EventTicketClassListResponse, error) {
7581 gensupport.SetOptions(c.urlParams_, opts...)
7582 res, err := c.doRequest("json")
7583 if res != nil && res.StatusCode == http.StatusNotModified {
7584 if res.Body != nil {
7585 res.Body.Close()
7586 }
7587 return nil, gensupport.WrapError(&googleapi.Error{
7588 Code: res.StatusCode,
7589 Header: res.Header,
7590 })
7591 }
7592 if err != nil {
7593 return nil, err
7594 }
7595 defer googleapi.CloseBody(res)
7596 if err := googleapi.CheckResponse(res); err != nil {
7597 return nil, gensupport.WrapError(err)
7598 }
7599 ret := &EventTicketClassListResponse{
7600 ServerResponse: googleapi.ServerResponse{
7601 Header: res.Header,
7602 HTTPStatusCode: res.StatusCode,
7603 },
7604 }
7605 target := &ret
7606 if err := gensupport.DecodeResponse(target, res); err != nil {
7607 return nil, err
7608 }
7609 return ret, nil
7610 }
7611
7612 type EventticketclassPatchCall struct {
7613 s *Service
7614 resourceId string
7615 eventticketclass *EventTicketClass
7616 urlParams_ gensupport.URLParams
7617 ctx_ context.Context
7618 header_ http.Header
7619 }
7620
7621
7622
7623
7624
7625
7626
7627
7628
7629 func (r *EventticketclassService) Patch(resourceId string, eventticketclass *EventTicketClass) *EventticketclassPatchCall {
7630 c := &EventticketclassPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7631 c.resourceId = resourceId
7632 c.eventticketclass = eventticketclass
7633 return c
7634 }
7635
7636
7637
7638
7639 func (c *EventticketclassPatchCall) Fields(s ...googleapi.Field) *EventticketclassPatchCall {
7640 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7641 return c
7642 }
7643
7644
7645 func (c *EventticketclassPatchCall) Context(ctx context.Context) *EventticketclassPatchCall {
7646 c.ctx_ = ctx
7647 return c
7648 }
7649
7650
7651
7652 func (c *EventticketclassPatchCall) Header() http.Header {
7653 if c.header_ == nil {
7654 c.header_ = make(http.Header)
7655 }
7656 return c.header_
7657 }
7658
7659 func (c *EventticketclassPatchCall) doRequest(alt string) (*http.Response, error) {
7660 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7661 var body io.Reader = nil
7662 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventticketclass)
7663 if err != nil {
7664 return nil, err
7665 }
7666 c.urlParams_.Set("alt", alt)
7667 c.urlParams_.Set("prettyPrint", "false")
7668 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketClass/{resourceId}")
7669 urls += "?" + c.urlParams_.Encode()
7670 req, err := http.NewRequest("PATCH", urls, body)
7671 if err != nil {
7672 return nil, err
7673 }
7674 req.Header = reqHeaders
7675 googleapi.Expand(req.URL, map[string]string{
7676 "resourceId": c.resourceId,
7677 })
7678 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7679 }
7680
7681
7682
7683
7684
7685
7686
7687 func (c *EventticketclassPatchCall) Do(opts ...googleapi.CallOption) (*EventTicketClass, error) {
7688 gensupport.SetOptions(c.urlParams_, opts...)
7689 res, err := c.doRequest("json")
7690 if res != nil && res.StatusCode == http.StatusNotModified {
7691 if res.Body != nil {
7692 res.Body.Close()
7693 }
7694 return nil, gensupport.WrapError(&googleapi.Error{
7695 Code: res.StatusCode,
7696 Header: res.Header,
7697 })
7698 }
7699 if err != nil {
7700 return nil, err
7701 }
7702 defer googleapi.CloseBody(res)
7703 if err := googleapi.CheckResponse(res); err != nil {
7704 return nil, gensupport.WrapError(err)
7705 }
7706 ret := &EventTicketClass{
7707 ServerResponse: googleapi.ServerResponse{
7708 Header: res.Header,
7709 HTTPStatusCode: res.StatusCode,
7710 },
7711 }
7712 target := &ret
7713 if err := gensupport.DecodeResponse(target, res); err != nil {
7714 return nil, err
7715 }
7716 return ret, nil
7717 }
7718
7719 type EventticketclassUpdateCall struct {
7720 s *Service
7721 resourceId string
7722 eventticketclass *EventTicketClass
7723 urlParams_ gensupport.URLParams
7724 ctx_ context.Context
7725 header_ http.Header
7726 }
7727
7728
7729
7730
7731
7732
7733
7734
7735 func (r *EventticketclassService) Update(resourceId string, eventticketclass *EventTicketClass) *EventticketclassUpdateCall {
7736 c := &EventticketclassUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7737 c.resourceId = resourceId
7738 c.eventticketclass = eventticketclass
7739 return c
7740 }
7741
7742
7743
7744
7745 func (c *EventticketclassUpdateCall) Fields(s ...googleapi.Field) *EventticketclassUpdateCall {
7746 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7747 return c
7748 }
7749
7750
7751 func (c *EventticketclassUpdateCall) Context(ctx context.Context) *EventticketclassUpdateCall {
7752 c.ctx_ = ctx
7753 return c
7754 }
7755
7756
7757
7758 func (c *EventticketclassUpdateCall) Header() http.Header {
7759 if c.header_ == nil {
7760 c.header_ = make(http.Header)
7761 }
7762 return c.header_
7763 }
7764
7765 func (c *EventticketclassUpdateCall) doRequest(alt string) (*http.Response, error) {
7766 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7767 var body io.Reader = nil
7768 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventticketclass)
7769 if err != nil {
7770 return nil, err
7771 }
7772 c.urlParams_.Set("alt", alt)
7773 c.urlParams_.Set("prettyPrint", "false")
7774 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketClass/{resourceId}")
7775 urls += "?" + c.urlParams_.Encode()
7776 req, err := http.NewRequest("PUT", urls, body)
7777 if err != nil {
7778 return nil, err
7779 }
7780 req.Header = reqHeaders
7781 googleapi.Expand(req.URL, map[string]string{
7782 "resourceId": c.resourceId,
7783 })
7784 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7785 }
7786
7787
7788
7789
7790
7791
7792
7793 func (c *EventticketclassUpdateCall) Do(opts ...googleapi.CallOption) (*EventTicketClass, error) {
7794 gensupport.SetOptions(c.urlParams_, opts...)
7795 res, err := c.doRequest("json")
7796 if res != nil && res.StatusCode == http.StatusNotModified {
7797 if res.Body != nil {
7798 res.Body.Close()
7799 }
7800 return nil, gensupport.WrapError(&googleapi.Error{
7801 Code: res.StatusCode,
7802 Header: res.Header,
7803 })
7804 }
7805 if err != nil {
7806 return nil, err
7807 }
7808 defer googleapi.CloseBody(res)
7809 if err := googleapi.CheckResponse(res); err != nil {
7810 return nil, gensupport.WrapError(err)
7811 }
7812 ret := &EventTicketClass{
7813 ServerResponse: googleapi.ServerResponse{
7814 Header: res.Header,
7815 HTTPStatusCode: res.StatusCode,
7816 },
7817 }
7818 target := &ret
7819 if err := gensupport.DecodeResponse(target, res); err != nil {
7820 return nil, err
7821 }
7822 return ret, nil
7823 }
7824
7825 type EventticketobjectAddmessageCall struct {
7826 s *Service
7827 resourceId string
7828 addmessagerequest *AddMessageRequest
7829 urlParams_ gensupport.URLParams
7830 ctx_ context.Context
7831 header_ http.Header
7832 }
7833
7834
7835
7836
7837
7838
7839
7840
7841
7842 func (r *EventticketobjectService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *EventticketobjectAddmessageCall {
7843 c := &EventticketobjectAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7844 c.resourceId = resourceId
7845 c.addmessagerequest = addmessagerequest
7846 return c
7847 }
7848
7849
7850
7851
7852 func (c *EventticketobjectAddmessageCall) Fields(s ...googleapi.Field) *EventticketobjectAddmessageCall {
7853 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7854 return c
7855 }
7856
7857
7858 func (c *EventticketobjectAddmessageCall) Context(ctx context.Context) *EventticketobjectAddmessageCall {
7859 c.ctx_ = ctx
7860 return c
7861 }
7862
7863
7864
7865 func (c *EventticketobjectAddmessageCall) Header() http.Header {
7866 if c.header_ == nil {
7867 c.header_ = make(http.Header)
7868 }
7869 return c.header_
7870 }
7871
7872 func (c *EventticketobjectAddmessageCall) doRequest(alt string) (*http.Response, error) {
7873 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7874 var body io.Reader = nil
7875 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
7876 if err != nil {
7877 return nil, err
7878 }
7879 c.urlParams_.Set("alt", alt)
7880 c.urlParams_.Set("prettyPrint", "false")
7881 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketObject/{resourceId}/addMessage")
7882 urls += "?" + c.urlParams_.Encode()
7883 req, err := http.NewRequest("POST", urls, body)
7884 if err != nil {
7885 return nil, err
7886 }
7887 req.Header = reqHeaders
7888 googleapi.Expand(req.URL, map[string]string{
7889 "resourceId": c.resourceId,
7890 })
7891 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7892 }
7893
7894
7895
7896
7897
7898
7899
7900 func (c *EventticketobjectAddmessageCall) Do(opts ...googleapi.CallOption) (*EventTicketObjectAddMessageResponse, error) {
7901 gensupport.SetOptions(c.urlParams_, opts...)
7902 res, err := c.doRequest("json")
7903 if res != nil && res.StatusCode == http.StatusNotModified {
7904 if res.Body != nil {
7905 res.Body.Close()
7906 }
7907 return nil, gensupport.WrapError(&googleapi.Error{
7908 Code: res.StatusCode,
7909 Header: res.Header,
7910 })
7911 }
7912 if err != nil {
7913 return nil, err
7914 }
7915 defer googleapi.CloseBody(res)
7916 if err := googleapi.CheckResponse(res); err != nil {
7917 return nil, gensupport.WrapError(err)
7918 }
7919 ret := &EventTicketObjectAddMessageResponse{
7920 ServerResponse: googleapi.ServerResponse{
7921 Header: res.Header,
7922 HTTPStatusCode: res.StatusCode,
7923 },
7924 }
7925 target := &ret
7926 if err := gensupport.DecodeResponse(target, res); err != nil {
7927 return nil, err
7928 }
7929 return ret, nil
7930 }
7931
7932 type EventticketobjectGetCall struct {
7933 s *Service
7934 resourceId string
7935 urlParams_ gensupport.URLParams
7936 ifNoneMatch_ string
7937 ctx_ context.Context
7938 header_ http.Header
7939 }
7940
7941
7942
7943
7944
7945
7946
7947
7948 func (r *EventticketobjectService) Get(resourceId string) *EventticketobjectGetCall {
7949 c := &EventticketobjectGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7950 c.resourceId = resourceId
7951 return c
7952 }
7953
7954
7955
7956
7957 func (c *EventticketobjectGetCall) Fields(s ...googleapi.Field) *EventticketobjectGetCall {
7958 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7959 return c
7960 }
7961
7962
7963
7964
7965 func (c *EventticketobjectGetCall) IfNoneMatch(entityTag string) *EventticketobjectGetCall {
7966 c.ifNoneMatch_ = entityTag
7967 return c
7968 }
7969
7970
7971 func (c *EventticketobjectGetCall) Context(ctx context.Context) *EventticketobjectGetCall {
7972 c.ctx_ = ctx
7973 return c
7974 }
7975
7976
7977
7978 func (c *EventticketobjectGetCall) Header() http.Header {
7979 if c.header_ == nil {
7980 c.header_ = make(http.Header)
7981 }
7982 return c.header_
7983 }
7984
7985 func (c *EventticketobjectGetCall) doRequest(alt string) (*http.Response, error) {
7986 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7987 if c.ifNoneMatch_ != "" {
7988 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7989 }
7990 var body io.Reader = nil
7991 c.urlParams_.Set("alt", alt)
7992 c.urlParams_.Set("prettyPrint", "false")
7993 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketObject/{resourceId}")
7994 urls += "?" + c.urlParams_.Encode()
7995 req, err := http.NewRequest("GET", urls, body)
7996 if err != nil {
7997 return nil, err
7998 }
7999 req.Header = reqHeaders
8000 googleapi.Expand(req.URL, map[string]string{
8001 "resourceId": c.resourceId,
8002 })
8003 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8004 }
8005
8006
8007
8008
8009
8010
8011
8012 func (c *EventticketobjectGetCall) Do(opts ...googleapi.CallOption) (*EventTicketObject, error) {
8013 gensupport.SetOptions(c.urlParams_, opts...)
8014 res, err := c.doRequest("json")
8015 if res != nil && res.StatusCode == http.StatusNotModified {
8016 if res.Body != nil {
8017 res.Body.Close()
8018 }
8019 return nil, gensupport.WrapError(&googleapi.Error{
8020 Code: res.StatusCode,
8021 Header: res.Header,
8022 })
8023 }
8024 if err != nil {
8025 return nil, err
8026 }
8027 defer googleapi.CloseBody(res)
8028 if err := googleapi.CheckResponse(res); err != nil {
8029 return nil, gensupport.WrapError(err)
8030 }
8031 ret := &EventTicketObject{
8032 ServerResponse: googleapi.ServerResponse{
8033 Header: res.Header,
8034 HTTPStatusCode: res.StatusCode,
8035 },
8036 }
8037 target := &ret
8038 if err := gensupport.DecodeResponse(target, res); err != nil {
8039 return nil, err
8040 }
8041 return ret, nil
8042 }
8043
8044 type EventticketobjectInsertCall struct {
8045 s *Service
8046 eventticketobject *EventTicketObject
8047 urlParams_ gensupport.URLParams
8048 ctx_ context.Context
8049 header_ http.Header
8050 }
8051
8052
8053 func (r *EventticketobjectService) Insert(eventticketobject *EventTicketObject) *EventticketobjectInsertCall {
8054 c := &EventticketobjectInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8055 c.eventticketobject = eventticketobject
8056 return c
8057 }
8058
8059
8060
8061
8062 func (c *EventticketobjectInsertCall) Fields(s ...googleapi.Field) *EventticketobjectInsertCall {
8063 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8064 return c
8065 }
8066
8067
8068 func (c *EventticketobjectInsertCall) Context(ctx context.Context) *EventticketobjectInsertCall {
8069 c.ctx_ = ctx
8070 return c
8071 }
8072
8073
8074
8075 func (c *EventticketobjectInsertCall) Header() http.Header {
8076 if c.header_ == nil {
8077 c.header_ = make(http.Header)
8078 }
8079 return c.header_
8080 }
8081
8082 func (c *EventticketobjectInsertCall) doRequest(alt string) (*http.Response, error) {
8083 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8084 var body io.Reader = nil
8085 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventticketobject)
8086 if err != nil {
8087 return nil, err
8088 }
8089 c.urlParams_.Set("alt", alt)
8090 c.urlParams_.Set("prettyPrint", "false")
8091 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketObject")
8092 urls += "?" + c.urlParams_.Encode()
8093 req, err := http.NewRequest("POST", urls, body)
8094 if err != nil {
8095 return nil, err
8096 }
8097 req.Header = reqHeaders
8098 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8099 }
8100
8101
8102
8103
8104
8105
8106
8107 func (c *EventticketobjectInsertCall) Do(opts ...googleapi.CallOption) (*EventTicketObject, error) {
8108 gensupport.SetOptions(c.urlParams_, opts...)
8109 res, err := c.doRequest("json")
8110 if res != nil && res.StatusCode == http.StatusNotModified {
8111 if res.Body != nil {
8112 res.Body.Close()
8113 }
8114 return nil, gensupport.WrapError(&googleapi.Error{
8115 Code: res.StatusCode,
8116 Header: res.Header,
8117 })
8118 }
8119 if err != nil {
8120 return nil, err
8121 }
8122 defer googleapi.CloseBody(res)
8123 if err := googleapi.CheckResponse(res); err != nil {
8124 return nil, gensupport.WrapError(err)
8125 }
8126 ret := &EventTicketObject{
8127 ServerResponse: googleapi.ServerResponse{
8128 Header: res.Header,
8129 HTTPStatusCode: res.StatusCode,
8130 },
8131 }
8132 target := &ret
8133 if err := gensupport.DecodeResponse(target, res); err != nil {
8134 return nil, err
8135 }
8136 return ret, nil
8137 }
8138
8139 type EventticketobjectListCall struct {
8140 s *Service
8141 urlParams_ gensupport.URLParams
8142 ifNoneMatch_ string
8143 ctx_ context.Context
8144 header_ http.Header
8145 }
8146
8147
8148 func (r *EventticketobjectService) List() *EventticketobjectListCall {
8149 c := &EventticketobjectListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8150 return c
8151 }
8152
8153
8154
8155 func (c *EventticketobjectListCall) ClassId(classId string) *EventticketobjectListCall {
8156 c.urlParams_.Set("classId", classId)
8157 return c
8158 }
8159
8160
8161
8162
8163 func (c *EventticketobjectListCall) MaxResults(maxResults int64) *EventticketobjectListCall {
8164 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
8165 return c
8166 }
8167
8168
8169
8170
8171
8172
8173
8174 func (c *EventticketobjectListCall) Token(token string) *EventticketobjectListCall {
8175 c.urlParams_.Set("token", token)
8176 return c
8177 }
8178
8179
8180
8181
8182 func (c *EventticketobjectListCall) Fields(s ...googleapi.Field) *EventticketobjectListCall {
8183 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8184 return c
8185 }
8186
8187
8188
8189
8190 func (c *EventticketobjectListCall) IfNoneMatch(entityTag string) *EventticketobjectListCall {
8191 c.ifNoneMatch_ = entityTag
8192 return c
8193 }
8194
8195
8196 func (c *EventticketobjectListCall) Context(ctx context.Context) *EventticketobjectListCall {
8197 c.ctx_ = ctx
8198 return c
8199 }
8200
8201
8202
8203 func (c *EventticketobjectListCall) Header() http.Header {
8204 if c.header_ == nil {
8205 c.header_ = make(http.Header)
8206 }
8207 return c.header_
8208 }
8209
8210 func (c *EventticketobjectListCall) doRequest(alt string) (*http.Response, error) {
8211 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8212 if c.ifNoneMatch_ != "" {
8213 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8214 }
8215 var body io.Reader = nil
8216 c.urlParams_.Set("alt", alt)
8217 c.urlParams_.Set("prettyPrint", "false")
8218 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketObject")
8219 urls += "?" + c.urlParams_.Encode()
8220 req, err := http.NewRequest("GET", urls, body)
8221 if err != nil {
8222 return nil, err
8223 }
8224 req.Header = reqHeaders
8225 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8226 }
8227
8228
8229
8230
8231
8232
8233
8234 func (c *EventticketobjectListCall) Do(opts ...googleapi.CallOption) (*EventTicketObjectListResponse, error) {
8235 gensupport.SetOptions(c.urlParams_, opts...)
8236 res, err := c.doRequest("json")
8237 if res != nil && res.StatusCode == http.StatusNotModified {
8238 if res.Body != nil {
8239 res.Body.Close()
8240 }
8241 return nil, gensupport.WrapError(&googleapi.Error{
8242 Code: res.StatusCode,
8243 Header: res.Header,
8244 })
8245 }
8246 if err != nil {
8247 return nil, err
8248 }
8249 defer googleapi.CloseBody(res)
8250 if err := googleapi.CheckResponse(res); err != nil {
8251 return nil, gensupport.WrapError(err)
8252 }
8253 ret := &EventTicketObjectListResponse{
8254 ServerResponse: googleapi.ServerResponse{
8255 Header: res.Header,
8256 HTTPStatusCode: res.StatusCode,
8257 },
8258 }
8259 target := &ret
8260 if err := gensupport.DecodeResponse(target, res); err != nil {
8261 return nil, err
8262 }
8263 return ret, nil
8264 }
8265
8266 type EventticketobjectModifylinkedofferobjectsCall struct {
8267 s *Service
8268 resourceId string
8269 modifylinkedofferobjectsrequest *ModifyLinkedOfferObjectsRequest
8270 urlParams_ gensupport.URLParams
8271 ctx_ context.Context
8272 header_ http.Header
8273 }
8274
8275
8276
8277
8278
8279
8280
8281
8282
8283 func (r *EventticketobjectService) Modifylinkedofferobjects(resourceId string, modifylinkedofferobjectsrequest *ModifyLinkedOfferObjectsRequest) *EventticketobjectModifylinkedofferobjectsCall {
8284 c := &EventticketobjectModifylinkedofferobjectsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8285 c.resourceId = resourceId
8286 c.modifylinkedofferobjectsrequest = modifylinkedofferobjectsrequest
8287 return c
8288 }
8289
8290
8291
8292
8293 func (c *EventticketobjectModifylinkedofferobjectsCall) Fields(s ...googleapi.Field) *EventticketobjectModifylinkedofferobjectsCall {
8294 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8295 return c
8296 }
8297
8298
8299 func (c *EventticketobjectModifylinkedofferobjectsCall) Context(ctx context.Context) *EventticketobjectModifylinkedofferobjectsCall {
8300 c.ctx_ = ctx
8301 return c
8302 }
8303
8304
8305
8306 func (c *EventticketobjectModifylinkedofferobjectsCall) Header() http.Header {
8307 if c.header_ == nil {
8308 c.header_ = make(http.Header)
8309 }
8310 return c.header_
8311 }
8312
8313 func (c *EventticketobjectModifylinkedofferobjectsCall) doRequest(alt string) (*http.Response, error) {
8314 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8315 var body io.Reader = nil
8316 body, err := googleapi.WithoutDataWrapper.JSONReader(c.modifylinkedofferobjectsrequest)
8317 if err != nil {
8318 return nil, err
8319 }
8320 c.urlParams_.Set("alt", alt)
8321 c.urlParams_.Set("prettyPrint", "false")
8322 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketObject/{resourceId}/modifyLinkedOfferObjects")
8323 urls += "?" + c.urlParams_.Encode()
8324 req, err := http.NewRequest("POST", urls, body)
8325 if err != nil {
8326 return nil, err
8327 }
8328 req.Header = reqHeaders
8329 googleapi.Expand(req.URL, map[string]string{
8330 "resourceId": c.resourceId,
8331 })
8332 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8333 }
8334
8335
8336
8337
8338
8339
8340
8341 func (c *EventticketobjectModifylinkedofferobjectsCall) Do(opts ...googleapi.CallOption) (*EventTicketObject, error) {
8342 gensupport.SetOptions(c.urlParams_, opts...)
8343 res, err := c.doRequest("json")
8344 if res != nil && res.StatusCode == http.StatusNotModified {
8345 if res.Body != nil {
8346 res.Body.Close()
8347 }
8348 return nil, gensupport.WrapError(&googleapi.Error{
8349 Code: res.StatusCode,
8350 Header: res.Header,
8351 })
8352 }
8353 if err != nil {
8354 return nil, err
8355 }
8356 defer googleapi.CloseBody(res)
8357 if err := googleapi.CheckResponse(res); err != nil {
8358 return nil, gensupport.WrapError(err)
8359 }
8360 ret := &EventTicketObject{
8361 ServerResponse: googleapi.ServerResponse{
8362 Header: res.Header,
8363 HTTPStatusCode: res.StatusCode,
8364 },
8365 }
8366 target := &ret
8367 if err := gensupport.DecodeResponse(target, res); err != nil {
8368 return nil, err
8369 }
8370 return ret, nil
8371 }
8372
8373 type EventticketobjectPatchCall struct {
8374 s *Service
8375 resourceId string
8376 eventticketobject *EventTicketObject
8377 urlParams_ gensupport.URLParams
8378 ctx_ context.Context
8379 header_ http.Header
8380 }
8381
8382
8383
8384
8385
8386
8387
8388
8389
8390 func (r *EventticketobjectService) Patch(resourceId string, eventticketobject *EventTicketObject) *EventticketobjectPatchCall {
8391 c := &EventticketobjectPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8392 c.resourceId = resourceId
8393 c.eventticketobject = eventticketobject
8394 return c
8395 }
8396
8397
8398
8399
8400 func (c *EventticketobjectPatchCall) Fields(s ...googleapi.Field) *EventticketobjectPatchCall {
8401 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8402 return c
8403 }
8404
8405
8406 func (c *EventticketobjectPatchCall) Context(ctx context.Context) *EventticketobjectPatchCall {
8407 c.ctx_ = ctx
8408 return c
8409 }
8410
8411
8412
8413 func (c *EventticketobjectPatchCall) Header() http.Header {
8414 if c.header_ == nil {
8415 c.header_ = make(http.Header)
8416 }
8417 return c.header_
8418 }
8419
8420 func (c *EventticketobjectPatchCall) doRequest(alt string) (*http.Response, error) {
8421 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8422 var body io.Reader = nil
8423 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventticketobject)
8424 if err != nil {
8425 return nil, err
8426 }
8427 c.urlParams_.Set("alt", alt)
8428 c.urlParams_.Set("prettyPrint", "false")
8429 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketObject/{resourceId}")
8430 urls += "?" + c.urlParams_.Encode()
8431 req, err := http.NewRequest("PATCH", urls, body)
8432 if err != nil {
8433 return nil, err
8434 }
8435 req.Header = reqHeaders
8436 googleapi.Expand(req.URL, map[string]string{
8437 "resourceId": c.resourceId,
8438 })
8439 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8440 }
8441
8442
8443
8444
8445
8446
8447
8448 func (c *EventticketobjectPatchCall) Do(opts ...googleapi.CallOption) (*EventTicketObject, error) {
8449 gensupport.SetOptions(c.urlParams_, opts...)
8450 res, err := c.doRequest("json")
8451 if res != nil && res.StatusCode == http.StatusNotModified {
8452 if res.Body != nil {
8453 res.Body.Close()
8454 }
8455 return nil, gensupport.WrapError(&googleapi.Error{
8456 Code: res.StatusCode,
8457 Header: res.Header,
8458 })
8459 }
8460 if err != nil {
8461 return nil, err
8462 }
8463 defer googleapi.CloseBody(res)
8464 if err := googleapi.CheckResponse(res); err != nil {
8465 return nil, gensupport.WrapError(err)
8466 }
8467 ret := &EventTicketObject{
8468 ServerResponse: googleapi.ServerResponse{
8469 Header: res.Header,
8470 HTTPStatusCode: res.StatusCode,
8471 },
8472 }
8473 target := &ret
8474 if err := gensupport.DecodeResponse(target, res); err != nil {
8475 return nil, err
8476 }
8477 return ret, nil
8478 }
8479
8480 type EventticketobjectUpdateCall struct {
8481 s *Service
8482 resourceId string
8483 eventticketobject *EventTicketObject
8484 urlParams_ gensupport.URLParams
8485 ctx_ context.Context
8486 header_ http.Header
8487 }
8488
8489
8490
8491
8492
8493
8494
8495
8496 func (r *EventticketobjectService) Update(resourceId string, eventticketobject *EventTicketObject) *EventticketobjectUpdateCall {
8497 c := &EventticketobjectUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8498 c.resourceId = resourceId
8499 c.eventticketobject = eventticketobject
8500 return c
8501 }
8502
8503
8504
8505
8506 func (c *EventticketobjectUpdateCall) Fields(s ...googleapi.Field) *EventticketobjectUpdateCall {
8507 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8508 return c
8509 }
8510
8511
8512 func (c *EventticketobjectUpdateCall) Context(ctx context.Context) *EventticketobjectUpdateCall {
8513 c.ctx_ = ctx
8514 return c
8515 }
8516
8517
8518
8519 func (c *EventticketobjectUpdateCall) Header() http.Header {
8520 if c.header_ == nil {
8521 c.header_ = make(http.Header)
8522 }
8523 return c.header_
8524 }
8525
8526 func (c *EventticketobjectUpdateCall) doRequest(alt string) (*http.Response, error) {
8527 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8528 var body io.Reader = nil
8529 body, err := googleapi.WithoutDataWrapper.JSONReader(c.eventticketobject)
8530 if err != nil {
8531 return nil, err
8532 }
8533 c.urlParams_.Set("alt", alt)
8534 c.urlParams_.Set("prettyPrint", "false")
8535 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/eventTicketObject/{resourceId}")
8536 urls += "?" + c.urlParams_.Encode()
8537 req, err := http.NewRequest("PUT", urls, body)
8538 if err != nil {
8539 return nil, err
8540 }
8541 req.Header = reqHeaders
8542 googleapi.Expand(req.URL, map[string]string{
8543 "resourceId": c.resourceId,
8544 })
8545 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8546 }
8547
8548
8549
8550
8551
8552
8553
8554 func (c *EventticketobjectUpdateCall) Do(opts ...googleapi.CallOption) (*EventTicketObject, error) {
8555 gensupport.SetOptions(c.urlParams_, opts...)
8556 res, err := c.doRequest("json")
8557 if res != nil && res.StatusCode == http.StatusNotModified {
8558 if res.Body != nil {
8559 res.Body.Close()
8560 }
8561 return nil, gensupport.WrapError(&googleapi.Error{
8562 Code: res.StatusCode,
8563 Header: res.Header,
8564 })
8565 }
8566 if err != nil {
8567 return nil, err
8568 }
8569 defer googleapi.CloseBody(res)
8570 if err := googleapi.CheckResponse(res); err != nil {
8571 return nil, gensupport.WrapError(err)
8572 }
8573 ret := &EventTicketObject{
8574 ServerResponse: googleapi.ServerResponse{
8575 Header: res.Header,
8576 HTTPStatusCode: res.StatusCode,
8577 },
8578 }
8579 target := &ret
8580 if err := gensupport.DecodeResponse(target, res); err != nil {
8581 return nil, err
8582 }
8583 return ret, nil
8584 }
8585
8586 type FlightclassAddmessageCall struct {
8587 s *Service
8588 resourceId string
8589 addmessagerequest *AddMessageRequest
8590 urlParams_ gensupport.URLParams
8591 ctx_ context.Context
8592 header_ http.Header
8593 }
8594
8595
8596
8597
8598
8599
8600
8601
8602
8603 func (r *FlightclassService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *FlightclassAddmessageCall {
8604 c := &FlightclassAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8605 c.resourceId = resourceId
8606 c.addmessagerequest = addmessagerequest
8607 return c
8608 }
8609
8610
8611
8612
8613 func (c *FlightclassAddmessageCall) Fields(s ...googleapi.Field) *FlightclassAddmessageCall {
8614 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8615 return c
8616 }
8617
8618
8619 func (c *FlightclassAddmessageCall) Context(ctx context.Context) *FlightclassAddmessageCall {
8620 c.ctx_ = ctx
8621 return c
8622 }
8623
8624
8625
8626 func (c *FlightclassAddmessageCall) Header() http.Header {
8627 if c.header_ == nil {
8628 c.header_ = make(http.Header)
8629 }
8630 return c.header_
8631 }
8632
8633 func (c *FlightclassAddmessageCall) doRequest(alt string) (*http.Response, error) {
8634 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8635 var body io.Reader = nil
8636 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
8637 if err != nil {
8638 return nil, err
8639 }
8640 c.urlParams_.Set("alt", alt)
8641 c.urlParams_.Set("prettyPrint", "false")
8642 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightClass/{resourceId}/addMessage")
8643 urls += "?" + c.urlParams_.Encode()
8644 req, err := http.NewRequest("POST", urls, body)
8645 if err != nil {
8646 return nil, err
8647 }
8648 req.Header = reqHeaders
8649 googleapi.Expand(req.URL, map[string]string{
8650 "resourceId": c.resourceId,
8651 })
8652 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8653 }
8654
8655
8656
8657
8658
8659
8660
8661 func (c *FlightclassAddmessageCall) Do(opts ...googleapi.CallOption) (*FlightClassAddMessageResponse, error) {
8662 gensupport.SetOptions(c.urlParams_, opts...)
8663 res, err := c.doRequest("json")
8664 if res != nil && res.StatusCode == http.StatusNotModified {
8665 if res.Body != nil {
8666 res.Body.Close()
8667 }
8668 return nil, gensupport.WrapError(&googleapi.Error{
8669 Code: res.StatusCode,
8670 Header: res.Header,
8671 })
8672 }
8673 if err != nil {
8674 return nil, err
8675 }
8676 defer googleapi.CloseBody(res)
8677 if err := googleapi.CheckResponse(res); err != nil {
8678 return nil, gensupport.WrapError(err)
8679 }
8680 ret := &FlightClassAddMessageResponse{
8681 ServerResponse: googleapi.ServerResponse{
8682 Header: res.Header,
8683 HTTPStatusCode: res.StatusCode,
8684 },
8685 }
8686 target := &ret
8687 if err := gensupport.DecodeResponse(target, res); err != nil {
8688 return nil, err
8689 }
8690 return ret, nil
8691 }
8692
8693 type FlightclassGetCall struct {
8694 s *Service
8695 resourceId string
8696 urlParams_ gensupport.URLParams
8697 ifNoneMatch_ string
8698 ctx_ context.Context
8699 header_ http.Header
8700 }
8701
8702
8703
8704
8705
8706
8707
8708
8709 func (r *FlightclassService) Get(resourceId string) *FlightclassGetCall {
8710 c := &FlightclassGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8711 c.resourceId = resourceId
8712 return c
8713 }
8714
8715
8716
8717
8718 func (c *FlightclassGetCall) Fields(s ...googleapi.Field) *FlightclassGetCall {
8719 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8720 return c
8721 }
8722
8723
8724
8725
8726 func (c *FlightclassGetCall) IfNoneMatch(entityTag string) *FlightclassGetCall {
8727 c.ifNoneMatch_ = entityTag
8728 return c
8729 }
8730
8731
8732 func (c *FlightclassGetCall) Context(ctx context.Context) *FlightclassGetCall {
8733 c.ctx_ = ctx
8734 return c
8735 }
8736
8737
8738
8739 func (c *FlightclassGetCall) Header() http.Header {
8740 if c.header_ == nil {
8741 c.header_ = make(http.Header)
8742 }
8743 return c.header_
8744 }
8745
8746 func (c *FlightclassGetCall) doRequest(alt string) (*http.Response, error) {
8747 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8748 if c.ifNoneMatch_ != "" {
8749 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8750 }
8751 var body io.Reader = nil
8752 c.urlParams_.Set("alt", alt)
8753 c.urlParams_.Set("prettyPrint", "false")
8754 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightClass/{resourceId}")
8755 urls += "?" + c.urlParams_.Encode()
8756 req, err := http.NewRequest("GET", urls, body)
8757 if err != nil {
8758 return nil, err
8759 }
8760 req.Header = reqHeaders
8761 googleapi.Expand(req.URL, map[string]string{
8762 "resourceId": c.resourceId,
8763 })
8764 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8765 }
8766
8767
8768
8769
8770
8771
8772 func (c *FlightclassGetCall) Do(opts ...googleapi.CallOption) (*FlightClass, error) {
8773 gensupport.SetOptions(c.urlParams_, opts...)
8774 res, err := c.doRequest("json")
8775 if res != nil && res.StatusCode == http.StatusNotModified {
8776 if res.Body != nil {
8777 res.Body.Close()
8778 }
8779 return nil, gensupport.WrapError(&googleapi.Error{
8780 Code: res.StatusCode,
8781 Header: res.Header,
8782 })
8783 }
8784 if err != nil {
8785 return nil, err
8786 }
8787 defer googleapi.CloseBody(res)
8788 if err := googleapi.CheckResponse(res); err != nil {
8789 return nil, gensupport.WrapError(err)
8790 }
8791 ret := &FlightClass{
8792 ServerResponse: googleapi.ServerResponse{
8793 Header: res.Header,
8794 HTTPStatusCode: res.StatusCode,
8795 },
8796 }
8797 target := &ret
8798 if err := gensupport.DecodeResponse(target, res); err != nil {
8799 return nil, err
8800 }
8801 return ret, nil
8802 }
8803
8804 type FlightclassInsertCall struct {
8805 s *Service
8806 flightclass *FlightClass
8807 urlParams_ gensupport.URLParams
8808 ctx_ context.Context
8809 header_ http.Header
8810 }
8811
8812
8813 func (r *FlightclassService) Insert(flightclass *FlightClass) *FlightclassInsertCall {
8814 c := &FlightclassInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8815 c.flightclass = flightclass
8816 return c
8817 }
8818
8819
8820
8821
8822 func (c *FlightclassInsertCall) Fields(s ...googleapi.Field) *FlightclassInsertCall {
8823 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8824 return c
8825 }
8826
8827
8828 func (c *FlightclassInsertCall) Context(ctx context.Context) *FlightclassInsertCall {
8829 c.ctx_ = ctx
8830 return c
8831 }
8832
8833
8834
8835 func (c *FlightclassInsertCall) Header() http.Header {
8836 if c.header_ == nil {
8837 c.header_ = make(http.Header)
8838 }
8839 return c.header_
8840 }
8841
8842 func (c *FlightclassInsertCall) doRequest(alt string) (*http.Response, error) {
8843 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8844 var body io.Reader = nil
8845 body, err := googleapi.WithoutDataWrapper.JSONReader(c.flightclass)
8846 if err != nil {
8847 return nil, err
8848 }
8849 c.urlParams_.Set("alt", alt)
8850 c.urlParams_.Set("prettyPrint", "false")
8851 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightClass")
8852 urls += "?" + c.urlParams_.Encode()
8853 req, err := http.NewRequest("POST", urls, body)
8854 if err != nil {
8855 return nil, err
8856 }
8857 req.Header = reqHeaders
8858 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8859 }
8860
8861
8862
8863
8864
8865
8866 func (c *FlightclassInsertCall) Do(opts ...googleapi.CallOption) (*FlightClass, error) {
8867 gensupport.SetOptions(c.urlParams_, opts...)
8868 res, err := c.doRequest("json")
8869 if res != nil && res.StatusCode == http.StatusNotModified {
8870 if res.Body != nil {
8871 res.Body.Close()
8872 }
8873 return nil, gensupport.WrapError(&googleapi.Error{
8874 Code: res.StatusCode,
8875 Header: res.Header,
8876 })
8877 }
8878 if err != nil {
8879 return nil, err
8880 }
8881 defer googleapi.CloseBody(res)
8882 if err := googleapi.CheckResponse(res); err != nil {
8883 return nil, gensupport.WrapError(err)
8884 }
8885 ret := &FlightClass{
8886 ServerResponse: googleapi.ServerResponse{
8887 Header: res.Header,
8888 HTTPStatusCode: res.StatusCode,
8889 },
8890 }
8891 target := &ret
8892 if err := gensupport.DecodeResponse(target, res); err != nil {
8893 return nil, err
8894 }
8895 return ret, nil
8896 }
8897
8898 type FlightclassListCall struct {
8899 s *Service
8900 urlParams_ gensupport.URLParams
8901 ifNoneMatch_ string
8902 ctx_ context.Context
8903 header_ http.Header
8904 }
8905
8906
8907 func (r *FlightclassService) List() *FlightclassListCall {
8908 c := &FlightclassListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8909 return c
8910 }
8911
8912
8913
8914 func (c *FlightclassListCall) IssuerId(issuerId int64) *FlightclassListCall {
8915 c.urlParams_.Set("issuerId", fmt.Sprint(issuerId))
8916 return c
8917 }
8918
8919
8920
8921
8922 func (c *FlightclassListCall) MaxResults(maxResults int64) *FlightclassListCall {
8923 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
8924 return c
8925 }
8926
8927
8928
8929
8930
8931
8932
8933 func (c *FlightclassListCall) Token(token string) *FlightclassListCall {
8934 c.urlParams_.Set("token", token)
8935 return c
8936 }
8937
8938
8939
8940
8941 func (c *FlightclassListCall) Fields(s ...googleapi.Field) *FlightclassListCall {
8942 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8943 return c
8944 }
8945
8946
8947
8948
8949 func (c *FlightclassListCall) IfNoneMatch(entityTag string) *FlightclassListCall {
8950 c.ifNoneMatch_ = entityTag
8951 return c
8952 }
8953
8954
8955 func (c *FlightclassListCall) Context(ctx context.Context) *FlightclassListCall {
8956 c.ctx_ = ctx
8957 return c
8958 }
8959
8960
8961
8962 func (c *FlightclassListCall) Header() http.Header {
8963 if c.header_ == nil {
8964 c.header_ = make(http.Header)
8965 }
8966 return c.header_
8967 }
8968
8969 func (c *FlightclassListCall) doRequest(alt string) (*http.Response, error) {
8970 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8971 if c.ifNoneMatch_ != "" {
8972 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8973 }
8974 var body io.Reader = nil
8975 c.urlParams_.Set("alt", alt)
8976 c.urlParams_.Set("prettyPrint", "false")
8977 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightClass")
8978 urls += "?" + c.urlParams_.Encode()
8979 req, err := http.NewRequest("GET", urls, body)
8980 if err != nil {
8981 return nil, err
8982 }
8983 req.Header = reqHeaders
8984 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8985 }
8986
8987
8988
8989
8990
8991
8992
8993 func (c *FlightclassListCall) Do(opts ...googleapi.CallOption) (*FlightClassListResponse, error) {
8994 gensupport.SetOptions(c.urlParams_, opts...)
8995 res, err := c.doRequest("json")
8996 if res != nil && res.StatusCode == http.StatusNotModified {
8997 if res.Body != nil {
8998 res.Body.Close()
8999 }
9000 return nil, gensupport.WrapError(&googleapi.Error{
9001 Code: res.StatusCode,
9002 Header: res.Header,
9003 })
9004 }
9005 if err != nil {
9006 return nil, err
9007 }
9008 defer googleapi.CloseBody(res)
9009 if err := googleapi.CheckResponse(res); err != nil {
9010 return nil, gensupport.WrapError(err)
9011 }
9012 ret := &FlightClassListResponse{
9013 ServerResponse: googleapi.ServerResponse{
9014 Header: res.Header,
9015 HTTPStatusCode: res.StatusCode,
9016 },
9017 }
9018 target := &ret
9019 if err := gensupport.DecodeResponse(target, res); err != nil {
9020 return nil, err
9021 }
9022 return ret, nil
9023 }
9024
9025 type FlightclassPatchCall struct {
9026 s *Service
9027 resourceId string
9028 flightclass *FlightClass
9029 urlParams_ gensupport.URLParams
9030 ctx_ context.Context
9031 header_ http.Header
9032 }
9033
9034
9035
9036
9037
9038
9039
9040
9041
9042 func (r *FlightclassService) Patch(resourceId string, flightclass *FlightClass) *FlightclassPatchCall {
9043 c := &FlightclassPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9044 c.resourceId = resourceId
9045 c.flightclass = flightclass
9046 return c
9047 }
9048
9049
9050
9051
9052 func (c *FlightclassPatchCall) Fields(s ...googleapi.Field) *FlightclassPatchCall {
9053 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9054 return c
9055 }
9056
9057
9058 func (c *FlightclassPatchCall) Context(ctx context.Context) *FlightclassPatchCall {
9059 c.ctx_ = ctx
9060 return c
9061 }
9062
9063
9064
9065 func (c *FlightclassPatchCall) Header() http.Header {
9066 if c.header_ == nil {
9067 c.header_ = make(http.Header)
9068 }
9069 return c.header_
9070 }
9071
9072 func (c *FlightclassPatchCall) doRequest(alt string) (*http.Response, error) {
9073 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9074 var body io.Reader = nil
9075 body, err := googleapi.WithoutDataWrapper.JSONReader(c.flightclass)
9076 if err != nil {
9077 return nil, err
9078 }
9079 c.urlParams_.Set("alt", alt)
9080 c.urlParams_.Set("prettyPrint", "false")
9081 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightClass/{resourceId}")
9082 urls += "?" + c.urlParams_.Encode()
9083 req, err := http.NewRequest("PATCH", urls, body)
9084 if err != nil {
9085 return nil, err
9086 }
9087 req.Header = reqHeaders
9088 googleapi.Expand(req.URL, map[string]string{
9089 "resourceId": c.resourceId,
9090 })
9091 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9092 }
9093
9094
9095
9096
9097
9098
9099 func (c *FlightclassPatchCall) Do(opts ...googleapi.CallOption) (*FlightClass, error) {
9100 gensupport.SetOptions(c.urlParams_, opts...)
9101 res, err := c.doRequest("json")
9102 if res != nil && res.StatusCode == http.StatusNotModified {
9103 if res.Body != nil {
9104 res.Body.Close()
9105 }
9106 return nil, gensupport.WrapError(&googleapi.Error{
9107 Code: res.StatusCode,
9108 Header: res.Header,
9109 })
9110 }
9111 if err != nil {
9112 return nil, err
9113 }
9114 defer googleapi.CloseBody(res)
9115 if err := googleapi.CheckResponse(res); err != nil {
9116 return nil, gensupport.WrapError(err)
9117 }
9118 ret := &FlightClass{
9119 ServerResponse: googleapi.ServerResponse{
9120 Header: res.Header,
9121 HTTPStatusCode: res.StatusCode,
9122 },
9123 }
9124 target := &ret
9125 if err := gensupport.DecodeResponse(target, res); err != nil {
9126 return nil, err
9127 }
9128 return ret, nil
9129 }
9130
9131 type FlightclassUpdateCall struct {
9132 s *Service
9133 resourceId string
9134 flightclass *FlightClass
9135 urlParams_ gensupport.URLParams
9136 ctx_ context.Context
9137 header_ http.Header
9138 }
9139
9140
9141
9142
9143
9144
9145
9146
9147 func (r *FlightclassService) Update(resourceId string, flightclass *FlightClass) *FlightclassUpdateCall {
9148 c := &FlightclassUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9149 c.resourceId = resourceId
9150 c.flightclass = flightclass
9151 return c
9152 }
9153
9154
9155
9156
9157 func (c *FlightclassUpdateCall) Fields(s ...googleapi.Field) *FlightclassUpdateCall {
9158 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9159 return c
9160 }
9161
9162
9163 func (c *FlightclassUpdateCall) Context(ctx context.Context) *FlightclassUpdateCall {
9164 c.ctx_ = ctx
9165 return c
9166 }
9167
9168
9169
9170 func (c *FlightclassUpdateCall) Header() http.Header {
9171 if c.header_ == nil {
9172 c.header_ = make(http.Header)
9173 }
9174 return c.header_
9175 }
9176
9177 func (c *FlightclassUpdateCall) doRequest(alt string) (*http.Response, error) {
9178 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9179 var body io.Reader = nil
9180 body, err := googleapi.WithoutDataWrapper.JSONReader(c.flightclass)
9181 if err != nil {
9182 return nil, err
9183 }
9184 c.urlParams_.Set("alt", alt)
9185 c.urlParams_.Set("prettyPrint", "false")
9186 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightClass/{resourceId}")
9187 urls += "?" + c.urlParams_.Encode()
9188 req, err := http.NewRequest("PUT", urls, body)
9189 if err != nil {
9190 return nil, err
9191 }
9192 req.Header = reqHeaders
9193 googleapi.Expand(req.URL, map[string]string{
9194 "resourceId": c.resourceId,
9195 })
9196 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9197 }
9198
9199
9200
9201
9202
9203
9204 func (c *FlightclassUpdateCall) Do(opts ...googleapi.CallOption) (*FlightClass, error) {
9205 gensupport.SetOptions(c.urlParams_, opts...)
9206 res, err := c.doRequest("json")
9207 if res != nil && res.StatusCode == http.StatusNotModified {
9208 if res.Body != nil {
9209 res.Body.Close()
9210 }
9211 return nil, gensupport.WrapError(&googleapi.Error{
9212 Code: res.StatusCode,
9213 Header: res.Header,
9214 })
9215 }
9216 if err != nil {
9217 return nil, err
9218 }
9219 defer googleapi.CloseBody(res)
9220 if err := googleapi.CheckResponse(res); err != nil {
9221 return nil, gensupport.WrapError(err)
9222 }
9223 ret := &FlightClass{
9224 ServerResponse: googleapi.ServerResponse{
9225 Header: res.Header,
9226 HTTPStatusCode: res.StatusCode,
9227 },
9228 }
9229 target := &ret
9230 if err := gensupport.DecodeResponse(target, res); err != nil {
9231 return nil, err
9232 }
9233 return ret, nil
9234 }
9235
9236 type FlightobjectAddmessageCall struct {
9237 s *Service
9238 resourceId string
9239 addmessagerequest *AddMessageRequest
9240 urlParams_ gensupport.URLParams
9241 ctx_ context.Context
9242 header_ http.Header
9243 }
9244
9245
9246
9247
9248
9249
9250
9251
9252
9253 func (r *FlightobjectService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *FlightobjectAddmessageCall {
9254 c := &FlightobjectAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9255 c.resourceId = resourceId
9256 c.addmessagerequest = addmessagerequest
9257 return c
9258 }
9259
9260
9261
9262
9263 func (c *FlightobjectAddmessageCall) Fields(s ...googleapi.Field) *FlightobjectAddmessageCall {
9264 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9265 return c
9266 }
9267
9268
9269 func (c *FlightobjectAddmessageCall) Context(ctx context.Context) *FlightobjectAddmessageCall {
9270 c.ctx_ = ctx
9271 return c
9272 }
9273
9274
9275
9276 func (c *FlightobjectAddmessageCall) Header() http.Header {
9277 if c.header_ == nil {
9278 c.header_ = make(http.Header)
9279 }
9280 return c.header_
9281 }
9282
9283 func (c *FlightobjectAddmessageCall) doRequest(alt string) (*http.Response, error) {
9284 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9285 var body io.Reader = nil
9286 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
9287 if err != nil {
9288 return nil, err
9289 }
9290 c.urlParams_.Set("alt", alt)
9291 c.urlParams_.Set("prettyPrint", "false")
9292 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightObject/{resourceId}/addMessage")
9293 urls += "?" + c.urlParams_.Encode()
9294 req, err := http.NewRequest("POST", urls, body)
9295 if err != nil {
9296 return nil, err
9297 }
9298 req.Header = reqHeaders
9299 googleapi.Expand(req.URL, map[string]string{
9300 "resourceId": c.resourceId,
9301 })
9302 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9303 }
9304
9305
9306
9307
9308
9309
9310
9311 func (c *FlightobjectAddmessageCall) Do(opts ...googleapi.CallOption) (*FlightObjectAddMessageResponse, error) {
9312 gensupport.SetOptions(c.urlParams_, opts...)
9313 res, err := c.doRequest("json")
9314 if res != nil && res.StatusCode == http.StatusNotModified {
9315 if res.Body != nil {
9316 res.Body.Close()
9317 }
9318 return nil, gensupport.WrapError(&googleapi.Error{
9319 Code: res.StatusCode,
9320 Header: res.Header,
9321 })
9322 }
9323 if err != nil {
9324 return nil, err
9325 }
9326 defer googleapi.CloseBody(res)
9327 if err := googleapi.CheckResponse(res); err != nil {
9328 return nil, gensupport.WrapError(err)
9329 }
9330 ret := &FlightObjectAddMessageResponse{
9331 ServerResponse: googleapi.ServerResponse{
9332 Header: res.Header,
9333 HTTPStatusCode: res.StatusCode,
9334 },
9335 }
9336 target := &ret
9337 if err := gensupport.DecodeResponse(target, res); err != nil {
9338 return nil, err
9339 }
9340 return ret, nil
9341 }
9342
9343 type FlightobjectGetCall struct {
9344 s *Service
9345 resourceId string
9346 urlParams_ gensupport.URLParams
9347 ifNoneMatch_ string
9348 ctx_ context.Context
9349 header_ http.Header
9350 }
9351
9352
9353
9354
9355
9356
9357
9358
9359 func (r *FlightobjectService) Get(resourceId string) *FlightobjectGetCall {
9360 c := &FlightobjectGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9361 c.resourceId = resourceId
9362 return c
9363 }
9364
9365
9366
9367
9368 func (c *FlightobjectGetCall) Fields(s ...googleapi.Field) *FlightobjectGetCall {
9369 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9370 return c
9371 }
9372
9373
9374
9375
9376 func (c *FlightobjectGetCall) IfNoneMatch(entityTag string) *FlightobjectGetCall {
9377 c.ifNoneMatch_ = entityTag
9378 return c
9379 }
9380
9381
9382 func (c *FlightobjectGetCall) Context(ctx context.Context) *FlightobjectGetCall {
9383 c.ctx_ = ctx
9384 return c
9385 }
9386
9387
9388
9389 func (c *FlightobjectGetCall) Header() http.Header {
9390 if c.header_ == nil {
9391 c.header_ = make(http.Header)
9392 }
9393 return c.header_
9394 }
9395
9396 func (c *FlightobjectGetCall) doRequest(alt string) (*http.Response, error) {
9397 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9398 if c.ifNoneMatch_ != "" {
9399 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9400 }
9401 var body io.Reader = nil
9402 c.urlParams_.Set("alt", alt)
9403 c.urlParams_.Set("prettyPrint", "false")
9404 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightObject/{resourceId}")
9405 urls += "?" + c.urlParams_.Encode()
9406 req, err := http.NewRequest("GET", urls, body)
9407 if err != nil {
9408 return nil, err
9409 }
9410 req.Header = reqHeaders
9411 googleapi.Expand(req.URL, map[string]string{
9412 "resourceId": c.resourceId,
9413 })
9414 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9415 }
9416
9417
9418
9419
9420
9421
9422 func (c *FlightobjectGetCall) Do(opts ...googleapi.CallOption) (*FlightObject, error) {
9423 gensupport.SetOptions(c.urlParams_, opts...)
9424 res, err := c.doRequest("json")
9425 if res != nil && res.StatusCode == http.StatusNotModified {
9426 if res.Body != nil {
9427 res.Body.Close()
9428 }
9429 return nil, gensupport.WrapError(&googleapi.Error{
9430 Code: res.StatusCode,
9431 Header: res.Header,
9432 })
9433 }
9434 if err != nil {
9435 return nil, err
9436 }
9437 defer googleapi.CloseBody(res)
9438 if err := googleapi.CheckResponse(res); err != nil {
9439 return nil, gensupport.WrapError(err)
9440 }
9441 ret := &FlightObject{
9442 ServerResponse: googleapi.ServerResponse{
9443 Header: res.Header,
9444 HTTPStatusCode: res.StatusCode,
9445 },
9446 }
9447 target := &ret
9448 if err := gensupport.DecodeResponse(target, res); err != nil {
9449 return nil, err
9450 }
9451 return ret, nil
9452 }
9453
9454 type FlightobjectInsertCall struct {
9455 s *Service
9456 flightobject *FlightObject
9457 urlParams_ gensupport.URLParams
9458 ctx_ context.Context
9459 header_ http.Header
9460 }
9461
9462
9463 func (r *FlightobjectService) Insert(flightobject *FlightObject) *FlightobjectInsertCall {
9464 c := &FlightobjectInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9465 c.flightobject = flightobject
9466 return c
9467 }
9468
9469
9470
9471
9472 func (c *FlightobjectInsertCall) Fields(s ...googleapi.Field) *FlightobjectInsertCall {
9473 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9474 return c
9475 }
9476
9477
9478 func (c *FlightobjectInsertCall) Context(ctx context.Context) *FlightobjectInsertCall {
9479 c.ctx_ = ctx
9480 return c
9481 }
9482
9483
9484
9485 func (c *FlightobjectInsertCall) Header() http.Header {
9486 if c.header_ == nil {
9487 c.header_ = make(http.Header)
9488 }
9489 return c.header_
9490 }
9491
9492 func (c *FlightobjectInsertCall) doRequest(alt string) (*http.Response, error) {
9493 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9494 var body io.Reader = nil
9495 body, err := googleapi.WithoutDataWrapper.JSONReader(c.flightobject)
9496 if err != nil {
9497 return nil, err
9498 }
9499 c.urlParams_.Set("alt", alt)
9500 c.urlParams_.Set("prettyPrint", "false")
9501 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightObject")
9502 urls += "?" + c.urlParams_.Encode()
9503 req, err := http.NewRequest("POST", urls, body)
9504 if err != nil {
9505 return nil, err
9506 }
9507 req.Header = reqHeaders
9508 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9509 }
9510
9511
9512
9513
9514
9515
9516 func (c *FlightobjectInsertCall) Do(opts ...googleapi.CallOption) (*FlightObject, error) {
9517 gensupport.SetOptions(c.urlParams_, opts...)
9518 res, err := c.doRequest("json")
9519 if res != nil && res.StatusCode == http.StatusNotModified {
9520 if res.Body != nil {
9521 res.Body.Close()
9522 }
9523 return nil, gensupport.WrapError(&googleapi.Error{
9524 Code: res.StatusCode,
9525 Header: res.Header,
9526 })
9527 }
9528 if err != nil {
9529 return nil, err
9530 }
9531 defer googleapi.CloseBody(res)
9532 if err := googleapi.CheckResponse(res); err != nil {
9533 return nil, gensupport.WrapError(err)
9534 }
9535 ret := &FlightObject{
9536 ServerResponse: googleapi.ServerResponse{
9537 Header: res.Header,
9538 HTTPStatusCode: res.StatusCode,
9539 },
9540 }
9541 target := &ret
9542 if err := gensupport.DecodeResponse(target, res); err != nil {
9543 return nil, err
9544 }
9545 return ret, nil
9546 }
9547
9548 type FlightobjectListCall struct {
9549 s *Service
9550 urlParams_ gensupport.URLParams
9551 ifNoneMatch_ string
9552 ctx_ context.Context
9553 header_ http.Header
9554 }
9555
9556
9557 func (r *FlightobjectService) List() *FlightobjectListCall {
9558 c := &FlightobjectListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9559 return c
9560 }
9561
9562
9563
9564 func (c *FlightobjectListCall) ClassId(classId string) *FlightobjectListCall {
9565 c.urlParams_.Set("classId", classId)
9566 return c
9567 }
9568
9569
9570
9571
9572 func (c *FlightobjectListCall) MaxResults(maxResults int64) *FlightobjectListCall {
9573 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
9574 return c
9575 }
9576
9577
9578
9579
9580
9581
9582
9583 func (c *FlightobjectListCall) Token(token string) *FlightobjectListCall {
9584 c.urlParams_.Set("token", token)
9585 return c
9586 }
9587
9588
9589
9590
9591 func (c *FlightobjectListCall) Fields(s ...googleapi.Field) *FlightobjectListCall {
9592 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9593 return c
9594 }
9595
9596
9597
9598
9599 func (c *FlightobjectListCall) IfNoneMatch(entityTag string) *FlightobjectListCall {
9600 c.ifNoneMatch_ = entityTag
9601 return c
9602 }
9603
9604
9605 func (c *FlightobjectListCall) Context(ctx context.Context) *FlightobjectListCall {
9606 c.ctx_ = ctx
9607 return c
9608 }
9609
9610
9611
9612 func (c *FlightobjectListCall) Header() http.Header {
9613 if c.header_ == nil {
9614 c.header_ = make(http.Header)
9615 }
9616 return c.header_
9617 }
9618
9619 func (c *FlightobjectListCall) doRequest(alt string) (*http.Response, error) {
9620 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9621 if c.ifNoneMatch_ != "" {
9622 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9623 }
9624 var body io.Reader = nil
9625 c.urlParams_.Set("alt", alt)
9626 c.urlParams_.Set("prettyPrint", "false")
9627 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightObject")
9628 urls += "?" + c.urlParams_.Encode()
9629 req, err := http.NewRequest("GET", urls, body)
9630 if err != nil {
9631 return nil, err
9632 }
9633 req.Header = reqHeaders
9634 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9635 }
9636
9637
9638
9639
9640
9641
9642
9643 func (c *FlightobjectListCall) Do(opts ...googleapi.CallOption) (*FlightObjectListResponse, error) {
9644 gensupport.SetOptions(c.urlParams_, opts...)
9645 res, err := c.doRequest("json")
9646 if res != nil && res.StatusCode == http.StatusNotModified {
9647 if res.Body != nil {
9648 res.Body.Close()
9649 }
9650 return nil, gensupport.WrapError(&googleapi.Error{
9651 Code: res.StatusCode,
9652 Header: res.Header,
9653 })
9654 }
9655 if err != nil {
9656 return nil, err
9657 }
9658 defer googleapi.CloseBody(res)
9659 if err := googleapi.CheckResponse(res); err != nil {
9660 return nil, gensupport.WrapError(err)
9661 }
9662 ret := &FlightObjectListResponse{
9663 ServerResponse: googleapi.ServerResponse{
9664 Header: res.Header,
9665 HTTPStatusCode: res.StatusCode,
9666 },
9667 }
9668 target := &ret
9669 if err := gensupport.DecodeResponse(target, res); err != nil {
9670 return nil, err
9671 }
9672 return ret, nil
9673 }
9674
9675 type FlightobjectPatchCall struct {
9676 s *Service
9677 resourceId string
9678 flightobject *FlightObject
9679 urlParams_ gensupport.URLParams
9680 ctx_ context.Context
9681 header_ http.Header
9682 }
9683
9684
9685
9686
9687
9688
9689
9690
9691
9692 func (r *FlightobjectService) Patch(resourceId string, flightobject *FlightObject) *FlightobjectPatchCall {
9693 c := &FlightobjectPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9694 c.resourceId = resourceId
9695 c.flightobject = flightobject
9696 return c
9697 }
9698
9699
9700
9701
9702 func (c *FlightobjectPatchCall) Fields(s ...googleapi.Field) *FlightobjectPatchCall {
9703 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9704 return c
9705 }
9706
9707
9708 func (c *FlightobjectPatchCall) Context(ctx context.Context) *FlightobjectPatchCall {
9709 c.ctx_ = ctx
9710 return c
9711 }
9712
9713
9714
9715 func (c *FlightobjectPatchCall) Header() http.Header {
9716 if c.header_ == nil {
9717 c.header_ = make(http.Header)
9718 }
9719 return c.header_
9720 }
9721
9722 func (c *FlightobjectPatchCall) doRequest(alt string) (*http.Response, error) {
9723 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9724 var body io.Reader = nil
9725 body, err := googleapi.WithoutDataWrapper.JSONReader(c.flightobject)
9726 if err != nil {
9727 return nil, err
9728 }
9729 c.urlParams_.Set("alt", alt)
9730 c.urlParams_.Set("prettyPrint", "false")
9731 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightObject/{resourceId}")
9732 urls += "?" + c.urlParams_.Encode()
9733 req, err := http.NewRequest("PATCH", urls, body)
9734 if err != nil {
9735 return nil, err
9736 }
9737 req.Header = reqHeaders
9738 googleapi.Expand(req.URL, map[string]string{
9739 "resourceId": c.resourceId,
9740 })
9741 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9742 }
9743
9744
9745
9746
9747
9748
9749 func (c *FlightobjectPatchCall) Do(opts ...googleapi.CallOption) (*FlightObject, error) {
9750 gensupport.SetOptions(c.urlParams_, opts...)
9751 res, err := c.doRequest("json")
9752 if res != nil && res.StatusCode == http.StatusNotModified {
9753 if res.Body != nil {
9754 res.Body.Close()
9755 }
9756 return nil, gensupport.WrapError(&googleapi.Error{
9757 Code: res.StatusCode,
9758 Header: res.Header,
9759 })
9760 }
9761 if err != nil {
9762 return nil, err
9763 }
9764 defer googleapi.CloseBody(res)
9765 if err := googleapi.CheckResponse(res); err != nil {
9766 return nil, gensupport.WrapError(err)
9767 }
9768 ret := &FlightObject{
9769 ServerResponse: googleapi.ServerResponse{
9770 Header: res.Header,
9771 HTTPStatusCode: res.StatusCode,
9772 },
9773 }
9774 target := &ret
9775 if err := gensupport.DecodeResponse(target, res); err != nil {
9776 return nil, err
9777 }
9778 return ret, nil
9779 }
9780
9781 type FlightobjectUpdateCall struct {
9782 s *Service
9783 resourceId string
9784 flightobject *FlightObject
9785 urlParams_ gensupport.URLParams
9786 ctx_ context.Context
9787 header_ http.Header
9788 }
9789
9790
9791
9792
9793
9794
9795
9796
9797 func (r *FlightobjectService) Update(resourceId string, flightobject *FlightObject) *FlightobjectUpdateCall {
9798 c := &FlightobjectUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9799 c.resourceId = resourceId
9800 c.flightobject = flightobject
9801 return c
9802 }
9803
9804
9805
9806
9807 func (c *FlightobjectUpdateCall) Fields(s ...googleapi.Field) *FlightobjectUpdateCall {
9808 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9809 return c
9810 }
9811
9812
9813 func (c *FlightobjectUpdateCall) Context(ctx context.Context) *FlightobjectUpdateCall {
9814 c.ctx_ = ctx
9815 return c
9816 }
9817
9818
9819
9820 func (c *FlightobjectUpdateCall) Header() http.Header {
9821 if c.header_ == nil {
9822 c.header_ = make(http.Header)
9823 }
9824 return c.header_
9825 }
9826
9827 func (c *FlightobjectUpdateCall) doRequest(alt string) (*http.Response, error) {
9828 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9829 var body io.Reader = nil
9830 body, err := googleapi.WithoutDataWrapper.JSONReader(c.flightobject)
9831 if err != nil {
9832 return nil, err
9833 }
9834 c.urlParams_.Set("alt", alt)
9835 c.urlParams_.Set("prettyPrint", "false")
9836 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/flightObject/{resourceId}")
9837 urls += "?" + c.urlParams_.Encode()
9838 req, err := http.NewRequest("PUT", urls, body)
9839 if err != nil {
9840 return nil, err
9841 }
9842 req.Header = reqHeaders
9843 googleapi.Expand(req.URL, map[string]string{
9844 "resourceId": c.resourceId,
9845 })
9846 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9847 }
9848
9849
9850
9851
9852
9853
9854 func (c *FlightobjectUpdateCall) Do(opts ...googleapi.CallOption) (*FlightObject, error) {
9855 gensupport.SetOptions(c.urlParams_, opts...)
9856 res, err := c.doRequest("json")
9857 if res != nil && res.StatusCode == http.StatusNotModified {
9858 if res.Body != nil {
9859 res.Body.Close()
9860 }
9861 return nil, gensupport.WrapError(&googleapi.Error{
9862 Code: res.StatusCode,
9863 Header: res.Header,
9864 })
9865 }
9866 if err != nil {
9867 return nil, err
9868 }
9869 defer googleapi.CloseBody(res)
9870 if err := googleapi.CheckResponse(res); err != nil {
9871 return nil, gensupport.WrapError(err)
9872 }
9873 ret := &FlightObject{
9874 ServerResponse: googleapi.ServerResponse{
9875 Header: res.Header,
9876 HTTPStatusCode: res.StatusCode,
9877 },
9878 }
9879 target := &ret
9880 if err := gensupport.DecodeResponse(target, res); err != nil {
9881 return nil, err
9882 }
9883 return ret, nil
9884 }
9885
9886 type GenericclassAddmessageCall struct {
9887 s *Service
9888 resourceId string
9889 addmessagerequest *AddMessageRequest
9890 urlParams_ gensupport.URLParams
9891 ctx_ context.Context
9892 header_ http.Header
9893 }
9894
9895
9896
9897
9898
9899
9900
9901
9902
9903 func (r *GenericclassService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *GenericclassAddmessageCall {
9904 c := &GenericclassAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9905 c.resourceId = resourceId
9906 c.addmessagerequest = addmessagerequest
9907 return c
9908 }
9909
9910
9911
9912
9913 func (c *GenericclassAddmessageCall) Fields(s ...googleapi.Field) *GenericclassAddmessageCall {
9914 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9915 return c
9916 }
9917
9918
9919 func (c *GenericclassAddmessageCall) Context(ctx context.Context) *GenericclassAddmessageCall {
9920 c.ctx_ = ctx
9921 return c
9922 }
9923
9924
9925
9926 func (c *GenericclassAddmessageCall) Header() http.Header {
9927 if c.header_ == nil {
9928 c.header_ = make(http.Header)
9929 }
9930 return c.header_
9931 }
9932
9933 func (c *GenericclassAddmessageCall) doRequest(alt string) (*http.Response, error) {
9934 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9935 var body io.Reader = nil
9936 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
9937 if err != nil {
9938 return nil, err
9939 }
9940 c.urlParams_.Set("alt", alt)
9941 c.urlParams_.Set("prettyPrint", "false")
9942 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericClass/{resourceId}/addMessage")
9943 urls += "?" + c.urlParams_.Encode()
9944 req, err := http.NewRequest("POST", urls, body)
9945 if err != nil {
9946 return nil, err
9947 }
9948 req.Header = reqHeaders
9949 googleapi.Expand(req.URL, map[string]string{
9950 "resourceId": c.resourceId,
9951 })
9952 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9953 }
9954
9955
9956
9957
9958
9959
9960
9961 func (c *GenericclassAddmessageCall) Do(opts ...googleapi.CallOption) (*GenericClassAddMessageResponse, error) {
9962 gensupport.SetOptions(c.urlParams_, opts...)
9963 res, err := c.doRequest("json")
9964 if res != nil && res.StatusCode == http.StatusNotModified {
9965 if res.Body != nil {
9966 res.Body.Close()
9967 }
9968 return nil, gensupport.WrapError(&googleapi.Error{
9969 Code: res.StatusCode,
9970 Header: res.Header,
9971 })
9972 }
9973 if err != nil {
9974 return nil, err
9975 }
9976 defer googleapi.CloseBody(res)
9977 if err := googleapi.CheckResponse(res); err != nil {
9978 return nil, gensupport.WrapError(err)
9979 }
9980 ret := &GenericClassAddMessageResponse{
9981 ServerResponse: googleapi.ServerResponse{
9982 Header: res.Header,
9983 HTTPStatusCode: res.StatusCode,
9984 },
9985 }
9986 target := &ret
9987 if err := gensupport.DecodeResponse(target, res); err != nil {
9988 return nil, err
9989 }
9990 return ret, nil
9991 }
9992
9993 type GenericclassGetCall struct {
9994 s *Service
9995 resourceId string
9996 urlParams_ gensupport.URLParams
9997 ifNoneMatch_ string
9998 ctx_ context.Context
9999 header_ http.Header
10000 }
10001
10002
10003
10004
10005
10006
10007
10008
10009 func (r *GenericclassService) Get(resourceId string) *GenericclassGetCall {
10010 c := &GenericclassGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10011 c.resourceId = resourceId
10012 return c
10013 }
10014
10015
10016
10017
10018 func (c *GenericclassGetCall) Fields(s ...googleapi.Field) *GenericclassGetCall {
10019 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10020 return c
10021 }
10022
10023
10024
10025
10026 func (c *GenericclassGetCall) IfNoneMatch(entityTag string) *GenericclassGetCall {
10027 c.ifNoneMatch_ = entityTag
10028 return c
10029 }
10030
10031
10032 func (c *GenericclassGetCall) Context(ctx context.Context) *GenericclassGetCall {
10033 c.ctx_ = ctx
10034 return c
10035 }
10036
10037
10038
10039 func (c *GenericclassGetCall) Header() http.Header {
10040 if c.header_ == nil {
10041 c.header_ = make(http.Header)
10042 }
10043 return c.header_
10044 }
10045
10046 func (c *GenericclassGetCall) doRequest(alt string) (*http.Response, error) {
10047 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10048 if c.ifNoneMatch_ != "" {
10049 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10050 }
10051 var body io.Reader = nil
10052 c.urlParams_.Set("alt", alt)
10053 c.urlParams_.Set("prettyPrint", "false")
10054 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericClass/{resourceId}")
10055 urls += "?" + c.urlParams_.Encode()
10056 req, err := http.NewRequest("GET", urls, body)
10057 if err != nil {
10058 return nil, err
10059 }
10060 req.Header = reqHeaders
10061 googleapi.Expand(req.URL, map[string]string{
10062 "resourceId": c.resourceId,
10063 })
10064 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10065 }
10066
10067
10068
10069
10070
10071
10072 func (c *GenericclassGetCall) Do(opts ...googleapi.CallOption) (*GenericClass, error) {
10073 gensupport.SetOptions(c.urlParams_, opts...)
10074 res, err := c.doRequest("json")
10075 if res != nil && res.StatusCode == http.StatusNotModified {
10076 if res.Body != nil {
10077 res.Body.Close()
10078 }
10079 return nil, gensupport.WrapError(&googleapi.Error{
10080 Code: res.StatusCode,
10081 Header: res.Header,
10082 })
10083 }
10084 if err != nil {
10085 return nil, err
10086 }
10087 defer googleapi.CloseBody(res)
10088 if err := googleapi.CheckResponse(res); err != nil {
10089 return nil, gensupport.WrapError(err)
10090 }
10091 ret := &GenericClass{
10092 ServerResponse: googleapi.ServerResponse{
10093 Header: res.Header,
10094 HTTPStatusCode: res.StatusCode,
10095 },
10096 }
10097 target := &ret
10098 if err := gensupport.DecodeResponse(target, res); err != nil {
10099 return nil, err
10100 }
10101 return ret, nil
10102 }
10103
10104 type GenericclassInsertCall struct {
10105 s *Service
10106 genericclass *GenericClass
10107 urlParams_ gensupport.URLParams
10108 ctx_ context.Context
10109 header_ http.Header
10110 }
10111
10112
10113 func (r *GenericclassService) Insert(genericclass *GenericClass) *GenericclassInsertCall {
10114 c := &GenericclassInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10115 c.genericclass = genericclass
10116 return c
10117 }
10118
10119
10120
10121
10122 func (c *GenericclassInsertCall) Fields(s ...googleapi.Field) *GenericclassInsertCall {
10123 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10124 return c
10125 }
10126
10127
10128 func (c *GenericclassInsertCall) Context(ctx context.Context) *GenericclassInsertCall {
10129 c.ctx_ = ctx
10130 return c
10131 }
10132
10133
10134
10135 func (c *GenericclassInsertCall) Header() http.Header {
10136 if c.header_ == nil {
10137 c.header_ = make(http.Header)
10138 }
10139 return c.header_
10140 }
10141
10142 func (c *GenericclassInsertCall) doRequest(alt string) (*http.Response, error) {
10143 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10144 var body io.Reader = nil
10145 body, err := googleapi.WithoutDataWrapper.JSONReader(c.genericclass)
10146 if err != nil {
10147 return nil, err
10148 }
10149 c.urlParams_.Set("alt", alt)
10150 c.urlParams_.Set("prettyPrint", "false")
10151 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericClass")
10152 urls += "?" + c.urlParams_.Encode()
10153 req, err := http.NewRequest("POST", urls, body)
10154 if err != nil {
10155 return nil, err
10156 }
10157 req.Header = reqHeaders
10158 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10159 }
10160
10161
10162
10163
10164
10165
10166 func (c *GenericclassInsertCall) Do(opts ...googleapi.CallOption) (*GenericClass, error) {
10167 gensupport.SetOptions(c.urlParams_, opts...)
10168 res, err := c.doRequest("json")
10169 if res != nil && res.StatusCode == http.StatusNotModified {
10170 if res.Body != nil {
10171 res.Body.Close()
10172 }
10173 return nil, gensupport.WrapError(&googleapi.Error{
10174 Code: res.StatusCode,
10175 Header: res.Header,
10176 })
10177 }
10178 if err != nil {
10179 return nil, err
10180 }
10181 defer googleapi.CloseBody(res)
10182 if err := googleapi.CheckResponse(res); err != nil {
10183 return nil, gensupport.WrapError(err)
10184 }
10185 ret := &GenericClass{
10186 ServerResponse: googleapi.ServerResponse{
10187 Header: res.Header,
10188 HTTPStatusCode: res.StatusCode,
10189 },
10190 }
10191 target := &ret
10192 if err := gensupport.DecodeResponse(target, res); err != nil {
10193 return nil, err
10194 }
10195 return ret, nil
10196 }
10197
10198 type GenericclassListCall struct {
10199 s *Service
10200 urlParams_ gensupport.URLParams
10201 ifNoneMatch_ string
10202 ctx_ context.Context
10203 header_ http.Header
10204 }
10205
10206
10207 func (r *GenericclassService) List() *GenericclassListCall {
10208 c := &GenericclassListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10209 return c
10210 }
10211
10212
10213
10214 func (c *GenericclassListCall) IssuerId(issuerId int64) *GenericclassListCall {
10215 c.urlParams_.Set("issuerId", fmt.Sprint(issuerId))
10216 return c
10217 }
10218
10219
10220
10221
10222 func (c *GenericclassListCall) MaxResults(maxResults int64) *GenericclassListCall {
10223 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
10224 return c
10225 }
10226
10227
10228
10229
10230
10231
10232
10233 func (c *GenericclassListCall) Token(token string) *GenericclassListCall {
10234 c.urlParams_.Set("token", token)
10235 return c
10236 }
10237
10238
10239
10240
10241 func (c *GenericclassListCall) Fields(s ...googleapi.Field) *GenericclassListCall {
10242 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10243 return c
10244 }
10245
10246
10247
10248
10249 func (c *GenericclassListCall) IfNoneMatch(entityTag string) *GenericclassListCall {
10250 c.ifNoneMatch_ = entityTag
10251 return c
10252 }
10253
10254
10255 func (c *GenericclassListCall) Context(ctx context.Context) *GenericclassListCall {
10256 c.ctx_ = ctx
10257 return c
10258 }
10259
10260
10261
10262 func (c *GenericclassListCall) Header() http.Header {
10263 if c.header_ == nil {
10264 c.header_ = make(http.Header)
10265 }
10266 return c.header_
10267 }
10268
10269 func (c *GenericclassListCall) doRequest(alt string) (*http.Response, error) {
10270 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10271 if c.ifNoneMatch_ != "" {
10272 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10273 }
10274 var body io.Reader = nil
10275 c.urlParams_.Set("alt", alt)
10276 c.urlParams_.Set("prettyPrint", "false")
10277 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericClass")
10278 urls += "?" + c.urlParams_.Encode()
10279 req, err := http.NewRequest("GET", urls, body)
10280 if err != nil {
10281 return nil, err
10282 }
10283 req.Header = reqHeaders
10284 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10285 }
10286
10287
10288
10289
10290
10291
10292
10293 func (c *GenericclassListCall) Do(opts ...googleapi.CallOption) (*GenericClassListResponse, error) {
10294 gensupport.SetOptions(c.urlParams_, opts...)
10295 res, err := c.doRequest("json")
10296 if res != nil && res.StatusCode == http.StatusNotModified {
10297 if res.Body != nil {
10298 res.Body.Close()
10299 }
10300 return nil, gensupport.WrapError(&googleapi.Error{
10301 Code: res.StatusCode,
10302 Header: res.Header,
10303 })
10304 }
10305 if err != nil {
10306 return nil, err
10307 }
10308 defer googleapi.CloseBody(res)
10309 if err := googleapi.CheckResponse(res); err != nil {
10310 return nil, gensupport.WrapError(err)
10311 }
10312 ret := &GenericClassListResponse{
10313 ServerResponse: googleapi.ServerResponse{
10314 Header: res.Header,
10315 HTTPStatusCode: res.StatusCode,
10316 },
10317 }
10318 target := &ret
10319 if err := gensupport.DecodeResponse(target, res); err != nil {
10320 return nil, err
10321 }
10322 return ret, nil
10323 }
10324
10325 type GenericclassPatchCall struct {
10326 s *Service
10327 resourceId string
10328 genericclass *GenericClass
10329 urlParams_ gensupport.URLParams
10330 ctx_ context.Context
10331 header_ http.Header
10332 }
10333
10334
10335
10336
10337
10338
10339
10340
10341
10342 func (r *GenericclassService) Patch(resourceId string, genericclass *GenericClass) *GenericclassPatchCall {
10343 c := &GenericclassPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10344 c.resourceId = resourceId
10345 c.genericclass = genericclass
10346 return c
10347 }
10348
10349
10350
10351
10352 func (c *GenericclassPatchCall) Fields(s ...googleapi.Field) *GenericclassPatchCall {
10353 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10354 return c
10355 }
10356
10357
10358 func (c *GenericclassPatchCall) Context(ctx context.Context) *GenericclassPatchCall {
10359 c.ctx_ = ctx
10360 return c
10361 }
10362
10363
10364
10365 func (c *GenericclassPatchCall) Header() http.Header {
10366 if c.header_ == nil {
10367 c.header_ = make(http.Header)
10368 }
10369 return c.header_
10370 }
10371
10372 func (c *GenericclassPatchCall) doRequest(alt string) (*http.Response, error) {
10373 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10374 var body io.Reader = nil
10375 body, err := googleapi.WithoutDataWrapper.JSONReader(c.genericclass)
10376 if err != nil {
10377 return nil, err
10378 }
10379 c.urlParams_.Set("alt", alt)
10380 c.urlParams_.Set("prettyPrint", "false")
10381 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericClass/{resourceId}")
10382 urls += "?" + c.urlParams_.Encode()
10383 req, err := http.NewRequest("PATCH", urls, body)
10384 if err != nil {
10385 return nil, err
10386 }
10387 req.Header = reqHeaders
10388 googleapi.Expand(req.URL, map[string]string{
10389 "resourceId": c.resourceId,
10390 })
10391 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10392 }
10393
10394
10395
10396
10397
10398
10399 func (c *GenericclassPatchCall) Do(opts ...googleapi.CallOption) (*GenericClass, error) {
10400 gensupport.SetOptions(c.urlParams_, opts...)
10401 res, err := c.doRequest("json")
10402 if res != nil && res.StatusCode == http.StatusNotModified {
10403 if res.Body != nil {
10404 res.Body.Close()
10405 }
10406 return nil, gensupport.WrapError(&googleapi.Error{
10407 Code: res.StatusCode,
10408 Header: res.Header,
10409 })
10410 }
10411 if err != nil {
10412 return nil, err
10413 }
10414 defer googleapi.CloseBody(res)
10415 if err := googleapi.CheckResponse(res); err != nil {
10416 return nil, gensupport.WrapError(err)
10417 }
10418 ret := &GenericClass{
10419 ServerResponse: googleapi.ServerResponse{
10420 Header: res.Header,
10421 HTTPStatusCode: res.StatusCode,
10422 },
10423 }
10424 target := &ret
10425 if err := gensupport.DecodeResponse(target, res); err != nil {
10426 return nil, err
10427 }
10428 return ret, nil
10429 }
10430
10431 type GenericclassUpdateCall struct {
10432 s *Service
10433 resourceId string
10434 genericclass *GenericClass
10435 urlParams_ gensupport.URLParams
10436 ctx_ context.Context
10437 header_ http.Header
10438 }
10439
10440
10441
10442
10443
10444
10445
10446
10447 func (r *GenericclassService) Update(resourceId string, genericclass *GenericClass) *GenericclassUpdateCall {
10448 c := &GenericclassUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10449 c.resourceId = resourceId
10450 c.genericclass = genericclass
10451 return c
10452 }
10453
10454
10455
10456
10457 func (c *GenericclassUpdateCall) Fields(s ...googleapi.Field) *GenericclassUpdateCall {
10458 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10459 return c
10460 }
10461
10462
10463 func (c *GenericclassUpdateCall) Context(ctx context.Context) *GenericclassUpdateCall {
10464 c.ctx_ = ctx
10465 return c
10466 }
10467
10468
10469
10470 func (c *GenericclassUpdateCall) Header() http.Header {
10471 if c.header_ == nil {
10472 c.header_ = make(http.Header)
10473 }
10474 return c.header_
10475 }
10476
10477 func (c *GenericclassUpdateCall) doRequest(alt string) (*http.Response, error) {
10478 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10479 var body io.Reader = nil
10480 body, err := googleapi.WithoutDataWrapper.JSONReader(c.genericclass)
10481 if err != nil {
10482 return nil, err
10483 }
10484 c.urlParams_.Set("alt", alt)
10485 c.urlParams_.Set("prettyPrint", "false")
10486 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericClass/{resourceId}")
10487 urls += "?" + c.urlParams_.Encode()
10488 req, err := http.NewRequest("PUT", urls, body)
10489 if err != nil {
10490 return nil, err
10491 }
10492 req.Header = reqHeaders
10493 googleapi.Expand(req.URL, map[string]string{
10494 "resourceId": c.resourceId,
10495 })
10496 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10497 }
10498
10499
10500
10501
10502
10503
10504 func (c *GenericclassUpdateCall) Do(opts ...googleapi.CallOption) (*GenericClass, error) {
10505 gensupport.SetOptions(c.urlParams_, opts...)
10506 res, err := c.doRequest("json")
10507 if res != nil && res.StatusCode == http.StatusNotModified {
10508 if res.Body != nil {
10509 res.Body.Close()
10510 }
10511 return nil, gensupport.WrapError(&googleapi.Error{
10512 Code: res.StatusCode,
10513 Header: res.Header,
10514 })
10515 }
10516 if err != nil {
10517 return nil, err
10518 }
10519 defer googleapi.CloseBody(res)
10520 if err := googleapi.CheckResponse(res); err != nil {
10521 return nil, gensupport.WrapError(err)
10522 }
10523 ret := &GenericClass{
10524 ServerResponse: googleapi.ServerResponse{
10525 Header: res.Header,
10526 HTTPStatusCode: res.StatusCode,
10527 },
10528 }
10529 target := &ret
10530 if err := gensupport.DecodeResponse(target, res); err != nil {
10531 return nil, err
10532 }
10533 return ret, nil
10534 }
10535
10536 type GenericobjectAddmessageCall struct {
10537 s *Service
10538 resourceId string
10539 addmessagerequest *AddMessageRequest
10540 urlParams_ gensupport.URLParams
10541 ctx_ context.Context
10542 header_ http.Header
10543 }
10544
10545
10546
10547
10548
10549
10550
10551
10552
10553 func (r *GenericobjectService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *GenericobjectAddmessageCall {
10554 c := &GenericobjectAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10555 c.resourceId = resourceId
10556 c.addmessagerequest = addmessagerequest
10557 return c
10558 }
10559
10560
10561
10562
10563 func (c *GenericobjectAddmessageCall) Fields(s ...googleapi.Field) *GenericobjectAddmessageCall {
10564 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10565 return c
10566 }
10567
10568
10569 func (c *GenericobjectAddmessageCall) Context(ctx context.Context) *GenericobjectAddmessageCall {
10570 c.ctx_ = ctx
10571 return c
10572 }
10573
10574
10575
10576 func (c *GenericobjectAddmessageCall) Header() http.Header {
10577 if c.header_ == nil {
10578 c.header_ = make(http.Header)
10579 }
10580 return c.header_
10581 }
10582
10583 func (c *GenericobjectAddmessageCall) doRequest(alt string) (*http.Response, error) {
10584 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10585 var body io.Reader = nil
10586 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
10587 if err != nil {
10588 return nil, err
10589 }
10590 c.urlParams_.Set("alt", alt)
10591 c.urlParams_.Set("prettyPrint", "false")
10592 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericObject/{resourceId}/addMessage")
10593 urls += "?" + c.urlParams_.Encode()
10594 req, err := http.NewRequest("POST", urls, body)
10595 if err != nil {
10596 return nil, err
10597 }
10598 req.Header = reqHeaders
10599 googleapi.Expand(req.URL, map[string]string{
10600 "resourceId": c.resourceId,
10601 })
10602 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10603 }
10604
10605
10606
10607
10608
10609
10610
10611 func (c *GenericobjectAddmessageCall) Do(opts ...googleapi.CallOption) (*GenericObjectAddMessageResponse, error) {
10612 gensupport.SetOptions(c.urlParams_, opts...)
10613 res, err := c.doRequest("json")
10614 if res != nil && res.StatusCode == http.StatusNotModified {
10615 if res.Body != nil {
10616 res.Body.Close()
10617 }
10618 return nil, gensupport.WrapError(&googleapi.Error{
10619 Code: res.StatusCode,
10620 Header: res.Header,
10621 })
10622 }
10623 if err != nil {
10624 return nil, err
10625 }
10626 defer googleapi.CloseBody(res)
10627 if err := googleapi.CheckResponse(res); err != nil {
10628 return nil, gensupport.WrapError(err)
10629 }
10630 ret := &GenericObjectAddMessageResponse{
10631 ServerResponse: googleapi.ServerResponse{
10632 Header: res.Header,
10633 HTTPStatusCode: res.StatusCode,
10634 },
10635 }
10636 target := &ret
10637 if err := gensupport.DecodeResponse(target, res); err != nil {
10638 return nil, err
10639 }
10640 return ret, nil
10641 }
10642
10643 type GenericobjectGetCall struct {
10644 s *Service
10645 resourceId string
10646 urlParams_ gensupport.URLParams
10647 ifNoneMatch_ string
10648 ctx_ context.Context
10649 header_ http.Header
10650 }
10651
10652
10653
10654
10655
10656
10657
10658
10659 func (r *GenericobjectService) Get(resourceId string) *GenericobjectGetCall {
10660 c := &GenericobjectGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10661 c.resourceId = resourceId
10662 return c
10663 }
10664
10665
10666
10667
10668 func (c *GenericobjectGetCall) Fields(s ...googleapi.Field) *GenericobjectGetCall {
10669 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10670 return c
10671 }
10672
10673
10674
10675
10676 func (c *GenericobjectGetCall) IfNoneMatch(entityTag string) *GenericobjectGetCall {
10677 c.ifNoneMatch_ = entityTag
10678 return c
10679 }
10680
10681
10682 func (c *GenericobjectGetCall) Context(ctx context.Context) *GenericobjectGetCall {
10683 c.ctx_ = ctx
10684 return c
10685 }
10686
10687
10688
10689 func (c *GenericobjectGetCall) Header() http.Header {
10690 if c.header_ == nil {
10691 c.header_ = make(http.Header)
10692 }
10693 return c.header_
10694 }
10695
10696 func (c *GenericobjectGetCall) doRequest(alt string) (*http.Response, error) {
10697 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10698 if c.ifNoneMatch_ != "" {
10699 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10700 }
10701 var body io.Reader = nil
10702 c.urlParams_.Set("alt", alt)
10703 c.urlParams_.Set("prettyPrint", "false")
10704 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericObject/{resourceId}")
10705 urls += "?" + c.urlParams_.Encode()
10706 req, err := http.NewRequest("GET", urls, body)
10707 if err != nil {
10708 return nil, err
10709 }
10710 req.Header = reqHeaders
10711 googleapi.Expand(req.URL, map[string]string{
10712 "resourceId": c.resourceId,
10713 })
10714 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10715 }
10716
10717
10718
10719
10720
10721
10722 func (c *GenericobjectGetCall) Do(opts ...googleapi.CallOption) (*GenericObject, error) {
10723 gensupport.SetOptions(c.urlParams_, opts...)
10724 res, err := c.doRequest("json")
10725 if res != nil && res.StatusCode == http.StatusNotModified {
10726 if res.Body != nil {
10727 res.Body.Close()
10728 }
10729 return nil, gensupport.WrapError(&googleapi.Error{
10730 Code: res.StatusCode,
10731 Header: res.Header,
10732 })
10733 }
10734 if err != nil {
10735 return nil, err
10736 }
10737 defer googleapi.CloseBody(res)
10738 if err := googleapi.CheckResponse(res); err != nil {
10739 return nil, gensupport.WrapError(err)
10740 }
10741 ret := &GenericObject{
10742 ServerResponse: googleapi.ServerResponse{
10743 Header: res.Header,
10744 HTTPStatusCode: res.StatusCode,
10745 },
10746 }
10747 target := &ret
10748 if err := gensupport.DecodeResponse(target, res); err != nil {
10749 return nil, err
10750 }
10751 return ret, nil
10752 }
10753
10754 type GenericobjectInsertCall struct {
10755 s *Service
10756 genericobject *GenericObject
10757 urlParams_ gensupport.URLParams
10758 ctx_ context.Context
10759 header_ http.Header
10760 }
10761
10762
10763 func (r *GenericobjectService) Insert(genericobject *GenericObject) *GenericobjectInsertCall {
10764 c := &GenericobjectInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10765 c.genericobject = genericobject
10766 return c
10767 }
10768
10769
10770
10771
10772 func (c *GenericobjectInsertCall) Fields(s ...googleapi.Field) *GenericobjectInsertCall {
10773 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10774 return c
10775 }
10776
10777
10778 func (c *GenericobjectInsertCall) Context(ctx context.Context) *GenericobjectInsertCall {
10779 c.ctx_ = ctx
10780 return c
10781 }
10782
10783
10784
10785 func (c *GenericobjectInsertCall) Header() http.Header {
10786 if c.header_ == nil {
10787 c.header_ = make(http.Header)
10788 }
10789 return c.header_
10790 }
10791
10792 func (c *GenericobjectInsertCall) doRequest(alt string) (*http.Response, error) {
10793 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10794 var body io.Reader = nil
10795 body, err := googleapi.WithoutDataWrapper.JSONReader(c.genericobject)
10796 if err != nil {
10797 return nil, err
10798 }
10799 c.urlParams_.Set("alt", alt)
10800 c.urlParams_.Set("prettyPrint", "false")
10801 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericObject")
10802 urls += "?" + c.urlParams_.Encode()
10803 req, err := http.NewRequest("POST", urls, body)
10804 if err != nil {
10805 return nil, err
10806 }
10807 req.Header = reqHeaders
10808 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10809 }
10810
10811
10812
10813
10814
10815
10816 func (c *GenericobjectInsertCall) Do(opts ...googleapi.CallOption) (*GenericObject, error) {
10817 gensupport.SetOptions(c.urlParams_, opts...)
10818 res, err := c.doRequest("json")
10819 if res != nil && res.StatusCode == http.StatusNotModified {
10820 if res.Body != nil {
10821 res.Body.Close()
10822 }
10823 return nil, gensupport.WrapError(&googleapi.Error{
10824 Code: res.StatusCode,
10825 Header: res.Header,
10826 })
10827 }
10828 if err != nil {
10829 return nil, err
10830 }
10831 defer googleapi.CloseBody(res)
10832 if err := googleapi.CheckResponse(res); err != nil {
10833 return nil, gensupport.WrapError(err)
10834 }
10835 ret := &GenericObject{
10836 ServerResponse: googleapi.ServerResponse{
10837 Header: res.Header,
10838 HTTPStatusCode: res.StatusCode,
10839 },
10840 }
10841 target := &ret
10842 if err := gensupport.DecodeResponse(target, res); err != nil {
10843 return nil, err
10844 }
10845 return ret, nil
10846 }
10847
10848 type GenericobjectListCall struct {
10849 s *Service
10850 urlParams_ gensupport.URLParams
10851 ifNoneMatch_ string
10852 ctx_ context.Context
10853 header_ http.Header
10854 }
10855
10856
10857 func (r *GenericobjectService) List() *GenericobjectListCall {
10858 c := &GenericobjectListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10859 return c
10860 }
10861
10862
10863
10864 func (c *GenericobjectListCall) ClassId(classId string) *GenericobjectListCall {
10865 c.urlParams_.Set("classId", classId)
10866 return c
10867 }
10868
10869
10870
10871
10872 func (c *GenericobjectListCall) MaxResults(maxResults int64) *GenericobjectListCall {
10873 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
10874 return c
10875 }
10876
10877
10878
10879
10880
10881
10882
10883 func (c *GenericobjectListCall) Token(token string) *GenericobjectListCall {
10884 c.urlParams_.Set("token", token)
10885 return c
10886 }
10887
10888
10889
10890
10891 func (c *GenericobjectListCall) Fields(s ...googleapi.Field) *GenericobjectListCall {
10892 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10893 return c
10894 }
10895
10896
10897
10898
10899 func (c *GenericobjectListCall) IfNoneMatch(entityTag string) *GenericobjectListCall {
10900 c.ifNoneMatch_ = entityTag
10901 return c
10902 }
10903
10904
10905 func (c *GenericobjectListCall) Context(ctx context.Context) *GenericobjectListCall {
10906 c.ctx_ = ctx
10907 return c
10908 }
10909
10910
10911
10912 func (c *GenericobjectListCall) Header() http.Header {
10913 if c.header_ == nil {
10914 c.header_ = make(http.Header)
10915 }
10916 return c.header_
10917 }
10918
10919 func (c *GenericobjectListCall) doRequest(alt string) (*http.Response, error) {
10920 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10921 if c.ifNoneMatch_ != "" {
10922 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10923 }
10924 var body io.Reader = nil
10925 c.urlParams_.Set("alt", alt)
10926 c.urlParams_.Set("prettyPrint", "false")
10927 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericObject")
10928 urls += "?" + c.urlParams_.Encode()
10929 req, err := http.NewRequest("GET", urls, body)
10930 if err != nil {
10931 return nil, err
10932 }
10933 req.Header = reqHeaders
10934 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10935 }
10936
10937
10938
10939
10940
10941
10942
10943 func (c *GenericobjectListCall) Do(opts ...googleapi.CallOption) (*GenericObjectListResponse, error) {
10944 gensupport.SetOptions(c.urlParams_, opts...)
10945 res, err := c.doRequest("json")
10946 if res != nil && res.StatusCode == http.StatusNotModified {
10947 if res.Body != nil {
10948 res.Body.Close()
10949 }
10950 return nil, gensupport.WrapError(&googleapi.Error{
10951 Code: res.StatusCode,
10952 Header: res.Header,
10953 })
10954 }
10955 if err != nil {
10956 return nil, err
10957 }
10958 defer googleapi.CloseBody(res)
10959 if err := googleapi.CheckResponse(res); err != nil {
10960 return nil, gensupport.WrapError(err)
10961 }
10962 ret := &GenericObjectListResponse{
10963 ServerResponse: googleapi.ServerResponse{
10964 Header: res.Header,
10965 HTTPStatusCode: res.StatusCode,
10966 },
10967 }
10968 target := &ret
10969 if err := gensupport.DecodeResponse(target, res); err != nil {
10970 return nil, err
10971 }
10972 return ret, nil
10973 }
10974
10975 type GenericobjectPatchCall struct {
10976 s *Service
10977 resourceId string
10978 genericobject *GenericObject
10979 urlParams_ gensupport.URLParams
10980 ctx_ context.Context
10981 header_ http.Header
10982 }
10983
10984
10985
10986
10987
10988
10989
10990
10991
10992 func (r *GenericobjectService) Patch(resourceId string, genericobject *GenericObject) *GenericobjectPatchCall {
10993 c := &GenericobjectPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10994 c.resourceId = resourceId
10995 c.genericobject = genericobject
10996 return c
10997 }
10998
10999
11000
11001
11002 func (c *GenericobjectPatchCall) Fields(s ...googleapi.Field) *GenericobjectPatchCall {
11003 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11004 return c
11005 }
11006
11007
11008 func (c *GenericobjectPatchCall) Context(ctx context.Context) *GenericobjectPatchCall {
11009 c.ctx_ = ctx
11010 return c
11011 }
11012
11013
11014
11015 func (c *GenericobjectPatchCall) Header() http.Header {
11016 if c.header_ == nil {
11017 c.header_ = make(http.Header)
11018 }
11019 return c.header_
11020 }
11021
11022 func (c *GenericobjectPatchCall) doRequest(alt string) (*http.Response, error) {
11023 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11024 var body io.Reader = nil
11025 body, err := googleapi.WithoutDataWrapper.JSONReader(c.genericobject)
11026 if err != nil {
11027 return nil, err
11028 }
11029 c.urlParams_.Set("alt", alt)
11030 c.urlParams_.Set("prettyPrint", "false")
11031 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericObject/{resourceId}")
11032 urls += "?" + c.urlParams_.Encode()
11033 req, err := http.NewRequest("PATCH", urls, body)
11034 if err != nil {
11035 return nil, err
11036 }
11037 req.Header = reqHeaders
11038 googleapi.Expand(req.URL, map[string]string{
11039 "resourceId": c.resourceId,
11040 })
11041 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11042 }
11043
11044
11045
11046
11047
11048
11049 func (c *GenericobjectPatchCall) Do(opts ...googleapi.CallOption) (*GenericObject, error) {
11050 gensupport.SetOptions(c.urlParams_, opts...)
11051 res, err := c.doRequest("json")
11052 if res != nil && res.StatusCode == http.StatusNotModified {
11053 if res.Body != nil {
11054 res.Body.Close()
11055 }
11056 return nil, gensupport.WrapError(&googleapi.Error{
11057 Code: res.StatusCode,
11058 Header: res.Header,
11059 })
11060 }
11061 if err != nil {
11062 return nil, err
11063 }
11064 defer googleapi.CloseBody(res)
11065 if err := googleapi.CheckResponse(res); err != nil {
11066 return nil, gensupport.WrapError(err)
11067 }
11068 ret := &GenericObject{
11069 ServerResponse: googleapi.ServerResponse{
11070 Header: res.Header,
11071 HTTPStatusCode: res.StatusCode,
11072 },
11073 }
11074 target := &ret
11075 if err := gensupport.DecodeResponse(target, res); err != nil {
11076 return nil, err
11077 }
11078 return ret, nil
11079 }
11080
11081 type GenericobjectUpdateCall struct {
11082 s *Service
11083 resourceId string
11084 genericobject *GenericObject
11085 urlParams_ gensupport.URLParams
11086 ctx_ context.Context
11087 header_ http.Header
11088 }
11089
11090
11091
11092
11093
11094
11095
11096
11097 func (r *GenericobjectService) Update(resourceId string, genericobject *GenericObject) *GenericobjectUpdateCall {
11098 c := &GenericobjectUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11099 c.resourceId = resourceId
11100 c.genericobject = genericobject
11101 return c
11102 }
11103
11104
11105
11106
11107 func (c *GenericobjectUpdateCall) Fields(s ...googleapi.Field) *GenericobjectUpdateCall {
11108 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11109 return c
11110 }
11111
11112
11113 func (c *GenericobjectUpdateCall) Context(ctx context.Context) *GenericobjectUpdateCall {
11114 c.ctx_ = ctx
11115 return c
11116 }
11117
11118
11119
11120 func (c *GenericobjectUpdateCall) Header() http.Header {
11121 if c.header_ == nil {
11122 c.header_ = make(http.Header)
11123 }
11124 return c.header_
11125 }
11126
11127 func (c *GenericobjectUpdateCall) doRequest(alt string) (*http.Response, error) {
11128 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11129 var body io.Reader = nil
11130 body, err := googleapi.WithoutDataWrapper.JSONReader(c.genericobject)
11131 if err != nil {
11132 return nil, err
11133 }
11134 c.urlParams_.Set("alt", alt)
11135 c.urlParams_.Set("prettyPrint", "false")
11136 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/genericObject/{resourceId}")
11137 urls += "?" + c.urlParams_.Encode()
11138 req, err := http.NewRequest("PUT", urls, body)
11139 if err != nil {
11140 return nil, err
11141 }
11142 req.Header = reqHeaders
11143 googleapi.Expand(req.URL, map[string]string{
11144 "resourceId": c.resourceId,
11145 })
11146 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11147 }
11148
11149
11150
11151
11152
11153
11154 func (c *GenericobjectUpdateCall) Do(opts ...googleapi.CallOption) (*GenericObject, error) {
11155 gensupport.SetOptions(c.urlParams_, opts...)
11156 res, err := c.doRequest("json")
11157 if res != nil && res.StatusCode == http.StatusNotModified {
11158 if res.Body != nil {
11159 res.Body.Close()
11160 }
11161 return nil, gensupport.WrapError(&googleapi.Error{
11162 Code: res.StatusCode,
11163 Header: res.Header,
11164 })
11165 }
11166 if err != nil {
11167 return nil, err
11168 }
11169 defer googleapi.CloseBody(res)
11170 if err := googleapi.CheckResponse(res); err != nil {
11171 return nil, gensupport.WrapError(err)
11172 }
11173 ret := &GenericObject{
11174 ServerResponse: googleapi.ServerResponse{
11175 Header: res.Header,
11176 HTTPStatusCode: res.StatusCode,
11177 },
11178 }
11179 target := &ret
11180 if err := gensupport.DecodeResponse(target, res); err != nil {
11181 return nil, err
11182 }
11183 return ret, nil
11184 }
11185
11186 type GiftcardclassAddmessageCall struct {
11187 s *Service
11188 resourceId string
11189 addmessagerequest *AddMessageRequest
11190 urlParams_ gensupport.URLParams
11191 ctx_ context.Context
11192 header_ http.Header
11193 }
11194
11195
11196
11197
11198
11199
11200
11201
11202
11203 func (r *GiftcardclassService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *GiftcardclassAddmessageCall {
11204 c := &GiftcardclassAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11205 c.resourceId = resourceId
11206 c.addmessagerequest = addmessagerequest
11207 return c
11208 }
11209
11210
11211
11212
11213 func (c *GiftcardclassAddmessageCall) Fields(s ...googleapi.Field) *GiftcardclassAddmessageCall {
11214 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11215 return c
11216 }
11217
11218
11219 func (c *GiftcardclassAddmessageCall) Context(ctx context.Context) *GiftcardclassAddmessageCall {
11220 c.ctx_ = ctx
11221 return c
11222 }
11223
11224
11225
11226 func (c *GiftcardclassAddmessageCall) Header() http.Header {
11227 if c.header_ == nil {
11228 c.header_ = make(http.Header)
11229 }
11230 return c.header_
11231 }
11232
11233 func (c *GiftcardclassAddmessageCall) doRequest(alt string) (*http.Response, error) {
11234 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11235 var body io.Reader = nil
11236 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
11237 if err != nil {
11238 return nil, err
11239 }
11240 c.urlParams_.Set("alt", alt)
11241 c.urlParams_.Set("prettyPrint", "false")
11242 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardClass/{resourceId}/addMessage")
11243 urls += "?" + c.urlParams_.Encode()
11244 req, err := http.NewRequest("POST", urls, body)
11245 if err != nil {
11246 return nil, err
11247 }
11248 req.Header = reqHeaders
11249 googleapi.Expand(req.URL, map[string]string{
11250 "resourceId": c.resourceId,
11251 })
11252 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11253 }
11254
11255
11256
11257
11258
11259
11260
11261 func (c *GiftcardclassAddmessageCall) Do(opts ...googleapi.CallOption) (*GiftCardClassAddMessageResponse, error) {
11262 gensupport.SetOptions(c.urlParams_, opts...)
11263 res, err := c.doRequest("json")
11264 if res != nil && res.StatusCode == http.StatusNotModified {
11265 if res.Body != nil {
11266 res.Body.Close()
11267 }
11268 return nil, gensupport.WrapError(&googleapi.Error{
11269 Code: res.StatusCode,
11270 Header: res.Header,
11271 })
11272 }
11273 if err != nil {
11274 return nil, err
11275 }
11276 defer googleapi.CloseBody(res)
11277 if err := googleapi.CheckResponse(res); err != nil {
11278 return nil, gensupport.WrapError(err)
11279 }
11280 ret := &GiftCardClassAddMessageResponse{
11281 ServerResponse: googleapi.ServerResponse{
11282 Header: res.Header,
11283 HTTPStatusCode: res.StatusCode,
11284 },
11285 }
11286 target := &ret
11287 if err := gensupport.DecodeResponse(target, res); err != nil {
11288 return nil, err
11289 }
11290 return ret, nil
11291 }
11292
11293 type GiftcardclassGetCall struct {
11294 s *Service
11295 resourceId string
11296 urlParams_ gensupport.URLParams
11297 ifNoneMatch_ string
11298 ctx_ context.Context
11299 header_ http.Header
11300 }
11301
11302
11303
11304
11305
11306
11307
11308
11309 func (r *GiftcardclassService) Get(resourceId string) *GiftcardclassGetCall {
11310 c := &GiftcardclassGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11311 c.resourceId = resourceId
11312 return c
11313 }
11314
11315
11316
11317
11318 func (c *GiftcardclassGetCall) Fields(s ...googleapi.Field) *GiftcardclassGetCall {
11319 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11320 return c
11321 }
11322
11323
11324
11325
11326 func (c *GiftcardclassGetCall) IfNoneMatch(entityTag string) *GiftcardclassGetCall {
11327 c.ifNoneMatch_ = entityTag
11328 return c
11329 }
11330
11331
11332 func (c *GiftcardclassGetCall) Context(ctx context.Context) *GiftcardclassGetCall {
11333 c.ctx_ = ctx
11334 return c
11335 }
11336
11337
11338
11339 func (c *GiftcardclassGetCall) Header() http.Header {
11340 if c.header_ == nil {
11341 c.header_ = make(http.Header)
11342 }
11343 return c.header_
11344 }
11345
11346 func (c *GiftcardclassGetCall) doRequest(alt string) (*http.Response, error) {
11347 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11348 if c.ifNoneMatch_ != "" {
11349 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11350 }
11351 var body io.Reader = nil
11352 c.urlParams_.Set("alt", alt)
11353 c.urlParams_.Set("prettyPrint", "false")
11354 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardClass/{resourceId}")
11355 urls += "?" + c.urlParams_.Encode()
11356 req, err := http.NewRequest("GET", urls, body)
11357 if err != nil {
11358 return nil, err
11359 }
11360 req.Header = reqHeaders
11361 googleapi.Expand(req.URL, map[string]string{
11362 "resourceId": c.resourceId,
11363 })
11364 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11365 }
11366
11367
11368
11369
11370
11371
11372 func (c *GiftcardclassGetCall) Do(opts ...googleapi.CallOption) (*GiftCardClass, error) {
11373 gensupport.SetOptions(c.urlParams_, opts...)
11374 res, err := c.doRequest("json")
11375 if res != nil && res.StatusCode == http.StatusNotModified {
11376 if res.Body != nil {
11377 res.Body.Close()
11378 }
11379 return nil, gensupport.WrapError(&googleapi.Error{
11380 Code: res.StatusCode,
11381 Header: res.Header,
11382 })
11383 }
11384 if err != nil {
11385 return nil, err
11386 }
11387 defer googleapi.CloseBody(res)
11388 if err := googleapi.CheckResponse(res); err != nil {
11389 return nil, gensupport.WrapError(err)
11390 }
11391 ret := &GiftCardClass{
11392 ServerResponse: googleapi.ServerResponse{
11393 Header: res.Header,
11394 HTTPStatusCode: res.StatusCode,
11395 },
11396 }
11397 target := &ret
11398 if err := gensupport.DecodeResponse(target, res); err != nil {
11399 return nil, err
11400 }
11401 return ret, nil
11402 }
11403
11404 type GiftcardclassInsertCall struct {
11405 s *Service
11406 giftcardclass *GiftCardClass
11407 urlParams_ gensupport.URLParams
11408 ctx_ context.Context
11409 header_ http.Header
11410 }
11411
11412
11413 func (r *GiftcardclassService) Insert(giftcardclass *GiftCardClass) *GiftcardclassInsertCall {
11414 c := &GiftcardclassInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11415 c.giftcardclass = giftcardclass
11416 return c
11417 }
11418
11419
11420
11421
11422 func (c *GiftcardclassInsertCall) Fields(s ...googleapi.Field) *GiftcardclassInsertCall {
11423 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11424 return c
11425 }
11426
11427
11428 func (c *GiftcardclassInsertCall) Context(ctx context.Context) *GiftcardclassInsertCall {
11429 c.ctx_ = ctx
11430 return c
11431 }
11432
11433
11434
11435 func (c *GiftcardclassInsertCall) Header() http.Header {
11436 if c.header_ == nil {
11437 c.header_ = make(http.Header)
11438 }
11439 return c.header_
11440 }
11441
11442 func (c *GiftcardclassInsertCall) doRequest(alt string) (*http.Response, error) {
11443 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11444 var body io.Reader = nil
11445 body, err := googleapi.WithoutDataWrapper.JSONReader(c.giftcardclass)
11446 if err != nil {
11447 return nil, err
11448 }
11449 c.urlParams_.Set("alt", alt)
11450 c.urlParams_.Set("prettyPrint", "false")
11451 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardClass")
11452 urls += "?" + c.urlParams_.Encode()
11453 req, err := http.NewRequest("POST", urls, body)
11454 if err != nil {
11455 return nil, err
11456 }
11457 req.Header = reqHeaders
11458 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11459 }
11460
11461
11462
11463
11464
11465
11466 func (c *GiftcardclassInsertCall) Do(opts ...googleapi.CallOption) (*GiftCardClass, error) {
11467 gensupport.SetOptions(c.urlParams_, opts...)
11468 res, err := c.doRequest("json")
11469 if res != nil && res.StatusCode == http.StatusNotModified {
11470 if res.Body != nil {
11471 res.Body.Close()
11472 }
11473 return nil, gensupport.WrapError(&googleapi.Error{
11474 Code: res.StatusCode,
11475 Header: res.Header,
11476 })
11477 }
11478 if err != nil {
11479 return nil, err
11480 }
11481 defer googleapi.CloseBody(res)
11482 if err := googleapi.CheckResponse(res); err != nil {
11483 return nil, gensupport.WrapError(err)
11484 }
11485 ret := &GiftCardClass{
11486 ServerResponse: googleapi.ServerResponse{
11487 Header: res.Header,
11488 HTTPStatusCode: res.StatusCode,
11489 },
11490 }
11491 target := &ret
11492 if err := gensupport.DecodeResponse(target, res); err != nil {
11493 return nil, err
11494 }
11495 return ret, nil
11496 }
11497
11498 type GiftcardclassListCall struct {
11499 s *Service
11500 urlParams_ gensupport.URLParams
11501 ifNoneMatch_ string
11502 ctx_ context.Context
11503 header_ http.Header
11504 }
11505
11506
11507 func (r *GiftcardclassService) List() *GiftcardclassListCall {
11508 c := &GiftcardclassListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11509 return c
11510 }
11511
11512
11513
11514 func (c *GiftcardclassListCall) IssuerId(issuerId int64) *GiftcardclassListCall {
11515 c.urlParams_.Set("issuerId", fmt.Sprint(issuerId))
11516 return c
11517 }
11518
11519
11520
11521
11522 func (c *GiftcardclassListCall) MaxResults(maxResults int64) *GiftcardclassListCall {
11523 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
11524 return c
11525 }
11526
11527
11528
11529
11530
11531
11532
11533 func (c *GiftcardclassListCall) Token(token string) *GiftcardclassListCall {
11534 c.urlParams_.Set("token", token)
11535 return c
11536 }
11537
11538
11539
11540
11541 func (c *GiftcardclassListCall) Fields(s ...googleapi.Field) *GiftcardclassListCall {
11542 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11543 return c
11544 }
11545
11546
11547
11548
11549 func (c *GiftcardclassListCall) IfNoneMatch(entityTag string) *GiftcardclassListCall {
11550 c.ifNoneMatch_ = entityTag
11551 return c
11552 }
11553
11554
11555 func (c *GiftcardclassListCall) Context(ctx context.Context) *GiftcardclassListCall {
11556 c.ctx_ = ctx
11557 return c
11558 }
11559
11560
11561
11562 func (c *GiftcardclassListCall) Header() http.Header {
11563 if c.header_ == nil {
11564 c.header_ = make(http.Header)
11565 }
11566 return c.header_
11567 }
11568
11569 func (c *GiftcardclassListCall) doRequest(alt string) (*http.Response, error) {
11570 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11571 if c.ifNoneMatch_ != "" {
11572 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11573 }
11574 var body io.Reader = nil
11575 c.urlParams_.Set("alt", alt)
11576 c.urlParams_.Set("prettyPrint", "false")
11577 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardClass")
11578 urls += "?" + c.urlParams_.Encode()
11579 req, err := http.NewRequest("GET", urls, body)
11580 if err != nil {
11581 return nil, err
11582 }
11583 req.Header = reqHeaders
11584 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11585 }
11586
11587
11588
11589
11590
11591
11592
11593 func (c *GiftcardclassListCall) Do(opts ...googleapi.CallOption) (*GiftCardClassListResponse, error) {
11594 gensupport.SetOptions(c.urlParams_, opts...)
11595 res, err := c.doRequest("json")
11596 if res != nil && res.StatusCode == http.StatusNotModified {
11597 if res.Body != nil {
11598 res.Body.Close()
11599 }
11600 return nil, gensupport.WrapError(&googleapi.Error{
11601 Code: res.StatusCode,
11602 Header: res.Header,
11603 })
11604 }
11605 if err != nil {
11606 return nil, err
11607 }
11608 defer googleapi.CloseBody(res)
11609 if err := googleapi.CheckResponse(res); err != nil {
11610 return nil, gensupport.WrapError(err)
11611 }
11612 ret := &GiftCardClassListResponse{
11613 ServerResponse: googleapi.ServerResponse{
11614 Header: res.Header,
11615 HTTPStatusCode: res.StatusCode,
11616 },
11617 }
11618 target := &ret
11619 if err := gensupport.DecodeResponse(target, res); err != nil {
11620 return nil, err
11621 }
11622 return ret, nil
11623 }
11624
11625 type GiftcardclassPatchCall struct {
11626 s *Service
11627 resourceId string
11628 giftcardclass *GiftCardClass
11629 urlParams_ gensupport.URLParams
11630 ctx_ context.Context
11631 header_ http.Header
11632 }
11633
11634
11635
11636
11637
11638
11639
11640
11641
11642 func (r *GiftcardclassService) Patch(resourceId string, giftcardclass *GiftCardClass) *GiftcardclassPatchCall {
11643 c := &GiftcardclassPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11644 c.resourceId = resourceId
11645 c.giftcardclass = giftcardclass
11646 return c
11647 }
11648
11649
11650
11651
11652 func (c *GiftcardclassPatchCall) Fields(s ...googleapi.Field) *GiftcardclassPatchCall {
11653 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11654 return c
11655 }
11656
11657
11658 func (c *GiftcardclassPatchCall) Context(ctx context.Context) *GiftcardclassPatchCall {
11659 c.ctx_ = ctx
11660 return c
11661 }
11662
11663
11664
11665 func (c *GiftcardclassPatchCall) Header() http.Header {
11666 if c.header_ == nil {
11667 c.header_ = make(http.Header)
11668 }
11669 return c.header_
11670 }
11671
11672 func (c *GiftcardclassPatchCall) doRequest(alt string) (*http.Response, error) {
11673 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11674 var body io.Reader = nil
11675 body, err := googleapi.WithoutDataWrapper.JSONReader(c.giftcardclass)
11676 if err != nil {
11677 return nil, err
11678 }
11679 c.urlParams_.Set("alt", alt)
11680 c.urlParams_.Set("prettyPrint", "false")
11681 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardClass/{resourceId}")
11682 urls += "?" + c.urlParams_.Encode()
11683 req, err := http.NewRequest("PATCH", urls, body)
11684 if err != nil {
11685 return nil, err
11686 }
11687 req.Header = reqHeaders
11688 googleapi.Expand(req.URL, map[string]string{
11689 "resourceId": c.resourceId,
11690 })
11691 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11692 }
11693
11694
11695
11696
11697
11698
11699 func (c *GiftcardclassPatchCall) Do(opts ...googleapi.CallOption) (*GiftCardClass, error) {
11700 gensupport.SetOptions(c.urlParams_, opts...)
11701 res, err := c.doRequest("json")
11702 if res != nil && res.StatusCode == http.StatusNotModified {
11703 if res.Body != nil {
11704 res.Body.Close()
11705 }
11706 return nil, gensupport.WrapError(&googleapi.Error{
11707 Code: res.StatusCode,
11708 Header: res.Header,
11709 })
11710 }
11711 if err != nil {
11712 return nil, err
11713 }
11714 defer googleapi.CloseBody(res)
11715 if err := googleapi.CheckResponse(res); err != nil {
11716 return nil, gensupport.WrapError(err)
11717 }
11718 ret := &GiftCardClass{
11719 ServerResponse: googleapi.ServerResponse{
11720 Header: res.Header,
11721 HTTPStatusCode: res.StatusCode,
11722 },
11723 }
11724 target := &ret
11725 if err := gensupport.DecodeResponse(target, res); err != nil {
11726 return nil, err
11727 }
11728 return ret, nil
11729 }
11730
11731 type GiftcardclassUpdateCall struct {
11732 s *Service
11733 resourceId string
11734 giftcardclass *GiftCardClass
11735 urlParams_ gensupport.URLParams
11736 ctx_ context.Context
11737 header_ http.Header
11738 }
11739
11740
11741
11742
11743
11744
11745
11746
11747 func (r *GiftcardclassService) Update(resourceId string, giftcardclass *GiftCardClass) *GiftcardclassUpdateCall {
11748 c := &GiftcardclassUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11749 c.resourceId = resourceId
11750 c.giftcardclass = giftcardclass
11751 return c
11752 }
11753
11754
11755
11756
11757 func (c *GiftcardclassUpdateCall) Fields(s ...googleapi.Field) *GiftcardclassUpdateCall {
11758 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11759 return c
11760 }
11761
11762
11763 func (c *GiftcardclassUpdateCall) Context(ctx context.Context) *GiftcardclassUpdateCall {
11764 c.ctx_ = ctx
11765 return c
11766 }
11767
11768
11769
11770 func (c *GiftcardclassUpdateCall) Header() http.Header {
11771 if c.header_ == nil {
11772 c.header_ = make(http.Header)
11773 }
11774 return c.header_
11775 }
11776
11777 func (c *GiftcardclassUpdateCall) doRequest(alt string) (*http.Response, error) {
11778 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11779 var body io.Reader = nil
11780 body, err := googleapi.WithoutDataWrapper.JSONReader(c.giftcardclass)
11781 if err != nil {
11782 return nil, err
11783 }
11784 c.urlParams_.Set("alt", alt)
11785 c.urlParams_.Set("prettyPrint", "false")
11786 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardClass/{resourceId}")
11787 urls += "?" + c.urlParams_.Encode()
11788 req, err := http.NewRequest("PUT", urls, body)
11789 if err != nil {
11790 return nil, err
11791 }
11792 req.Header = reqHeaders
11793 googleapi.Expand(req.URL, map[string]string{
11794 "resourceId": c.resourceId,
11795 })
11796 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11797 }
11798
11799
11800
11801
11802
11803
11804 func (c *GiftcardclassUpdateCall) Do(opts ...googleapi.CallOption) (*GiftCardClass, error) {
11805 gensupport.SetOptions(c.urlParams_, opts...)
11806 res, err := c.doRequest("json")
11807 if res != nil && res.StatusCode == http.StatusNotModified {
11808 if res.Body != nil {
11809 res.Body.Close()
11810 }
11811 return nil, gensupport.WrapError(&googleapi.Error{
11812 Code: res.StatusCode,
11813 Header: res.Header,
11814 })
11815 }
11816 if err != nil {
11817 return nil, err
11818 }
11819 defer googleapi.CloseBody(res)
11820 if err := googleapi.CheckResponse(res); err != nil {
11821 return nil, gensupport.WrapError(err)
11822 }
11823 ret := &GiftCardClass{
11824 ServerResponse: googleapi.ServerResponse{
11825 Header: res.Header,
11826 HTTPStatusCode: res.StatusCode,
11827 },
11828 }
11829 target := &ret
11830 if err := gensupport.DecodeResponse(target, res); err != nil {
11831 return nil, err
11832 }
11833 return ret, nil
11834 }
11835
11836 type GiftcardobjectAddmessageCall struct {
11837 s *Service
11838 resourceId string
11839 addmessagerequest *AddMessageRequest
11840 urlParams_ gensupport.URLParams
11841 ctx_ context.Context
11842 header_ http.Header
11843 }
11844
11845
11846
11847
11848
11849
11850
11851
11852
11853 func (r *GiftcardobjectService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *GiftcardobjectAddmessageCall {
11854 c := &GiftcardobjectAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11855 c.resourceId = resourceId
11856 c.addmessagerequest = addmessagerequest
11857 return c
11858 }
11859
11860
11861
11862
11863 func (c *GiftcardobjectAddmessageCall) Fields(s ...googleapi.Field) *GiftcardobjectAddmessageCall {
11864 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11865 return c
11866 }
11867
11868
11869 func (c *GiftcardobjectAddmessageCall) Context(ctx context.Context) *GiftcardobjectAddmessageCall {
11870 c.ctx_ = ctx
11871 return c
11872 }
11873
11874
11875
11876 func (c *GiftcardobjectAddmessageCall) Header() http.Header {
11877 if c.header_ == nil {
11878 c.header_ = make(http.Header)
11879 }
11880 return c.header_
11881 }
11882
11883 func (c *GiftcardobjectAddmessageCall) doRequest(alt string) (*http.Response, error) {
11884 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11885 var body io.Reader = nil
11886 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
11887 if err != nil {
11888 return nil, err
11889 }
11890 c.urlParams_.Set("alt", alt)
11891 c.urlParams_.Set("prettyPrint", "false")
11892 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardObject/{resourceId}/addMessage")
11893 urls += "?" + c.urlParams_.Encode()
11894 req, err := http.NewRequest("POST", urls, body)
11895 if err != nil {
11896 return nil, err
11897 }
11898 req.Header = reqHeaders
11899 googleapi.Expand(req.URL, map[string]string{
11900 "resourceId": c.resourceId,
11901 })
11902 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11903 }
11904
11905
11906
11907
11908
11909
11910
11911 func (c *GiftcardobjectAddmessageCall) Do(opts ...googleapi.CallOption) (*GiftCardObjectAddMessageResponse, error) {
11912 gensupport.SetOptions(c.urlParams_, opts...)
11913 res, err := c.doRequest("json")
11914 if res != nil && res.StatusCode == http.StatusNotModified {
11915 if res.Body != nil {
11916 res.Body.Close()
11917 }
11918 return nil, gensupport.WrapError(&googleapi.Error{
11919 Code: res.StatusCode,
11920 Header: res.Header,
11921 })
11922 }
11923 if err != nil {
11924 return nil, err
11925 }
11926 defer googleapi.CloseBody(res)
11927 if err := googleapi.CheckResponse(res); err != nil {
11928 return nil, gensupport.WrapError(err)
11929 }
11930 ret := &GiftCardObjectAddMessageResponse{
11931 ServerResponse: googleapi.ServerResponse{
11932 Header: res.Header,
11933 HTTPStatusCode: res.StatusCode,
11934 },
11935 }
11936 target := &ret
11937 if err := gensupport.DecodeResponse(target, res); err != nil {
11938 return nil, err
11939 }
11940 return ret, nil
11941 }
11942
11943 type GiftcardobjectGetCall struct {
11944 s *Service
11945 resourceId string
11946 urlParams_ gensupport.URLParams
11947 ifNoneMatch_ string
11948 ctx_ context.Context
11949 header_ http.Header
11950 }
11951
11952
11953
11954
11955
11956
11957
11958
11959 func (r *GiftcardobjectService) Get(resourceId string) *GiftcardobjectGetCall {
11960 c := &GiftcardobjectGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11961 c.resourceId = resourceId
11962 return c
11963 }
11964
11965
11966
11967
11968 func (c *GiftcardobjectGetCall) Fields(s ...googleapi.Field) *GiftcardobjectGetCall {
11969 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11970 return c
11971 }
11972
11973
11974
11975
11976 func (c *GiftcardobjectGetCall) IfNoneMatch(entityTag string) *GiftcardobjectGetCall {
11977 c.ifNoneMatch_ = entityTag
11978 return c
11979 }
11980
11981
11982 func (c *GiftcardobjectGetCall) Context(ctx context.Context) *GiftcardobjectGetCall {
11983 c.ctx_ = ctx
11984 return c
11985 }
11986
11987
11988
11989 func (c *GiftcardobjectGetCall) Header() http.Header {
11990 if c.header_ == nil {
11991 c.header_ = make(http.Header)
11992 }
11993 return c.header_
11994 }
11995
11996 func (c *GiftcardobjectGetCall) doRequest(alt string) (*http.Response, error) {
11997 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11998 if c.ifNoneMatch_ != "" {
11999 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12000 }
12001 var body io.Reader = nil
12002 c.urlParams_.Set("alt", alt)
12003 c.urlParams_.Set("prettyPrint", "false")
12004 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardObject/{resourceId}")
12005 urls += "?" + c.urlParams_.Encode()
12006 req, err := http.NewRequest("GET", urls, body)
12007 if err != nil {
12008 return nil, err
12009 }
12010 req.Header = reqHeaders
12011 googleapi.Expand(req.URL, map[string]string{
12012 "resourceId": c.resourceId,
12013 })
12014 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12015 }
12016
12017
12018
12019
12020
12021
12022 func (c *GiftcardobjectGetCall) Do(opts ...googleapi.CallOption) (*GiftCardObject, error) {
12023 gensupport.SetOptions(c.urlParams_, opts...)
12024 res, err := c.doRequest("json")
12025 if res != nil && res.StatusCode == http.StatusNotModified {
12026 if res.Body != nil {
12027 res.Body.Close()
12028 }
12029 return nil, gensupport.WrapError(&googleapi.Error{
12030 Code: res.StatusCode,
12031 Header: res.Header,
12032 })
12033 }
12034 if err != nil {
12035 return nil, err
12036 }
12037 defer googleapi.CloseBody(res)
12038 if err := googleapi.CheckResponse(res); err != nil {
12039 return nil, gensupport.WrapError(err)
12040 }
12041 ret := &GiftCardObject{
12042 ServerResponse: googleapi.ServerResponse{
12043 Header: res.Header,
12044 HTTPStatusCode: res.StatusCode,
12045 },
12046 }
12047 target := &ret
12048 if err := gensupport.DecodeResponse(target, res); err != nil {
12049 return nil, err
12050 }
12051 return ret, nil
12052 }
12053
12054 type GiftcardobjectInsertCall struct {
12055 s *Service
12056 giftcardobject *GiftCardObject
12057 urlParams_ gensupport.URLParams
12058 ctx_ context.Context
12059 header_ http.Header
12060 }
12061
12062
12063 func (r *GiftcardobjectService) Insert(giftcardobject *GiftCardObject) *GiftcardobjectInsertCall {
12064 c := &GiftcardobjectInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12065 c.giftcardobject = giftcardobject
12066 return c
12067 }
12068
12069
12070
12071
12072 func (c *GiftcardobjectInsertCall) Fields(s ...googleapi.Field) *GiftcardobjectInsertCall {
12073 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12074 return c
12075 }
12076
12077
12078 func (c *GiftcardobjectInsertCall) Context(ctx context.Context) *GiftcardobjectInsertCall {
12079 c.ctx_ = ctx
12080 return c
12081 }
12082
12083
12084
12085 func (c *GiftcardobjectInsertCall) Header() http.Header {
12086 if c.header_ == nil {
12087 c.header_ = make(http.Header)
12088 }
12089 return c.header_
12090 }
12091
12092 func (c *GiftcardobjectInsertCall) doRequest(alt string) (*http.Response, error) {
12093 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12094 var body io.Reader = nil
12095 body, err := googleapi.WithoutDataWrapper.JSONReader(c.giftcardobject)
12096 if err != nil {
12097 return nil, err
12098 }
12099 c.urlParams_.Set("alt", alt)
12100 c.urlParams_.Set("prettyPrint", "false")
12101 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardObject")
12102 urls += "?" + c.urlParams_.Encode()
12103 req, err := http.NewRequest("POST", urls, body)
12104 if err != nil {
12105 return nil, err
12106 }
12107 req.Header = reqHeaders
12108 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12109 }
12110
12111
12112
12113
12114
12115
12116 func (c *GiftcardobjectInsertCall) Do(opts ...googleapi.CallOption) (*GiftCardObject, error) {
12117 gensupport.SetOptions(c.urlParams_, opts...)
12118 res, err := c.doRequest("json")
12119 if res != nil && res.StatusCode == http.StatusNotModified {
12120 if res.Body != nil {
12121 res.Body.Close()
12122 }
12123 return nil, gensupport.WrapError(&googleapi.Error{
12124 Code: res.StatusCode,
12125 Header: res.Header,
12126 })
12127 }
12128 if err != nil {
12129 return nil, err
12130 }
12131 defer googleapi.CloseBody(res)
12132 if err := googleapi.CheckResponse(res); err != nil {
12133 return nil, gensupport.WrapError(err)
12134 }
12135 ret := &GiftCardObject{
12136 ServerResponse: googleapi.ServerResponse{
12137 Header: res.Header,
12138 HTTPStatusCode: res.StatusCode,
12139 },
12140 }
12141 target := &ret
12142 if err := gensupport.DecodeResponse(target, res); err != nil {
12143 return nil, err
12144 }
12145 return ret, nil
12146 }
12147
12148 type GiftcardobjectListCall struct {
12149 s *Service
12150 urlParams_ gensupport.URLParams
12151 ifNoneMatch_ string
12152 ctx_ context.Context
12153 header_ http.Header
12154 }
12155
12156
12157 func (r *GiftcardobjectService) List() *GiftcardobjectListCall {
12158 c := &GiftcardobjectListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12159 return c
12160 }
12161
12162
12163
12164 func (c *GiftcardobjectListCall) ClassId(classId string) *GiftcardobjectListCall {
12165 c.urlParams_.Set("classId", classId)
12166 return c
12167 }
12168
12169
12170
12171
12172 func (c *GiftcardobjectListCall) MaxResults(maxResults int64) *GiftcardobjectListCall {
12173 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
12174 return c
12175 }
12176
12177
12178
12179
12180
12181
12182
12183 func (c *GiftcardobjectListCall) Token(token string) *GiftcardobjectListCall {
12184 c.urlParams_.Set("token", token)
12185 return c
12186 }
12187
12188
12189
12190
12191 func (c *GiftcardobjectListCall) Fields(s ...googleapi.Field) *GiftcardobjectListCall {
12192 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12193 return c
12194 }
12195
12196
12197
12198
12199 func (c *GiftcardobjectListCall) IfNoneMatch(entityTag string) *GiftcardobjectListCall {
12200 c.ifNoneMatch_ = entityTag
12201 return c
12202 }
12203
12204
12205 func (c *GiftcardobjectListCall) Context(ctx context.Context) *GiftcardobjectListCall {
12206 c.ctx_ = ctx
12207 return c
12208 }
12209
12210
12211
12212 func (c *GiftcardobjectListCall) Header() http.Header {
12213 if c.header_ == nil {
12214 c.header_ = make(http.Header)
12215 }
12216 return c.header_
12217 }
12218
12219 func (c *GiftcardobjectListCall) doRequest(alt string) (*http.Response, error) {
12220 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12221 if c.ifNoneMatch_ != "" {
12222 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12223 }
12224 var body io.Reader = nil
12225 c.urlParams_.Set("alt", alt)
12226 c.urlParams_.Set("prettyPrint", "false")
12227 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardObject")
12228 urls += "?" + c.urlParams_.Encode()
12229 req, err := http.NewRequest("GET", urls, body)
12230 if err != nil {
12231 return nil, err
12232 }
12233 req.Header = reqHeaders
12234 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12235 }
12236
12237
12238
12239
12240
12241
12242
12243 func (c *GiftcardobjectListCall) Do(opts ...googleapi.CallOption) (*GiftCardObjectListResponse, error) {
12244 gensupport.SetOptions(c.urlParams_, opts...)
12245 res, err := c.doRequest("json")
12246 if res != nil && res.StatusCode == http.StatusNotModified {
12247 if res.Body != nil {
12248 res.Body.Close()
12249 }
12250 return nil, gensupport.WrapError(&googleapi.Error{
12251 Code: res.StatusCode,
12252 Header: res.Header,
12253 })
12254 }
12255 if err != nil {
12256 return nil, err
12257 }
12258 defer googleapi.CloseBody(res)
12259 if err := googleapi.CheckResponse(res); err != nil {
12260 return nil, gensupport.WrapError(err)
12261 }
12262 ret := &GiftCardObjectListResponse{
12263 ServerResponse: googleapi.ServerResponse{
12264 Header: res.Header,
12265 HTTPStatusCode: res.StatusCode,
12266 },
12267 }
12268 target := &ret
12269 if err := gensupport.DecodeResponse(target, res); err != nil {
12270 return nil, err
12271 }
12272 return ret, nil
12273 }
12274
12275 type GiftcardobjectPatchCall struct {
12276 s *Service
12277 resourceId string
12278 giftcardobject *GiftCardObject
12279 urlParams_ gensupport.URLParams
12280 ctx_ context.Context
12281 header_ http.Header
12282 }
12283
12284
12285
12286
12287
12288
12289
12290
12291
12292 func (r *GiftcardobjectService) Patch(resourceId string, giftcardobject *GiftCardObject) *GiftcardobjectPatchCall {
12293 c := &GiftcardobjectPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12294 c.resourceId = resourceId
12295 c.giftcardobject = giftcardobject
12296 return c
12297 }
12298
12299
12300
12301
12302 func (c *GiftcardobjectPatchCall) Fields(s ...googleapi.Field) *GiftcardobjectPatchCall {
12303 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12304 return c
12305 }
12306
12307
12308 func (c *GiftcardobjectPatchCall) Context(ctx context.Context) *GiftcardobjectPatchCall {
12309 c.ctx_ = ctx
12310 return c
12311 }
12312
12313
12314
12315 func (c *GiftcardobjectPatchCall) Header() http.Header {
12316 if c.header_ == nil {
12317 c.header_ = make(http.Header)
12318 }
12319 return c.header_
12320 }
12321
12322 func (c *GiftcardobjectPatchCall) doRequest(alt string) (*http.Response, error) {
12323 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12324 var body io.Reader = nil
12325 body, err := googleapi.WithoutDataWrapper.JSONReader(c.giftcardobject)
12326 if err != nil {
12327 return nil, err
12328 }
12329 c.urlParams_.Set("alt", alt)
12330 c.urlParams_.Set("prettyPrint", "false")
12331 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardObject/{resourceId}")
12332 urls += "?" + c.urlParams_.Encode()
12333 req, err := http.NewRequest("PATCH", urls, body)
12334 if err != nil {
12335 return nil, err
12336 }
12337 req.Header = reqHeaders
12338 googleapi.Expand(req.URL, map[string]string{
12339 "resourceId": c.resourceId,
12340 })
12341 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12342 }
12343
12344
12345
12346
12347
12348
12349 func (c *GiftcardobjectPatchCall) Do(opts ...googleapi.CallOption) (*GiftCardObject, error) {
12350 gensupport.SetOptions(c.urlParams_, opts...)
12351 res, err := c.doRequest("json")
12352 if res != nil && res.StatusCode == http.StatusNotModified {
12353 if res.Body != nil {
12354 res.Body.Close()
12355 }
12356 return nil, gensupport.WrapError(&googleapi.Error{
12357 Code: res.StatusCode,
12358 Header: res.Header,
12359 })
12360 }
12361 if err != nil {
12362 return nil, err
12363 }
12364 defer googleapi.CloseBody(res)
12365 if err := googleapi.CheckResponse(res); err != nil {
12366 return nil, gensupport.WrapError(err)
12367 }
12368 ret := &GiftCardObject{
12369 ServerResponse: googleapi.ServerResponse{
12370 Header: res.Header,
12371 HTTPStatusCode: res.StatusCode,
12372 },
12373 }
12374 target := &ret
12375 if err := gensupport.DecodeResponse(target, res); err != nil {
12376 return nil, err
12377 }
12378 return ret, nil
12379 }
12380
12381 type GiftcardobjectUpdateCall struct {
12382 s *Service
12383 resourceId string
12384 giftcardobject *GiftCardObject
12385 urlParams_ gensupport.URLParams
12386 ctx_ context.Context
12387 header_ http.Header
12388 }
12389
12390
12391
12392
12393
12394
12395
12396
12397 func (r *GiftcardobjectService) Update(resourceId string, giftcardobject *GiftCardObject) *GiftcardobjectUpdateCall {
12398 c := &GiftcardobjectUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12399 c.resourceId = resourceId
12400 c.giftcardobject = giftcardobject
12401 return c
12402 }
12403
12404
12405
12406
12407 func (c *GiftcardobjectUpdateCall) Fields(s ...googleapi.Field) *GiftcardobjectUpdateCall {
12408 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12409 return c
12410 }
12411
12412
12413 func (c *GiftcardobjectUpdateCall) Context(ctx context.Context) *GiftcardobjectUpdateCall {
12414 c.ctx_ = ctx
12415 return c
12416 }
12417
12418
12419
12420 func (c *GiftcardobjectUpdateCall) Header() http.Header {
12421 if c.header_ == nil {
12422 c.header_ = make(http.Header)
12423 }
12424 return c.header_
12425 }
12426
12427 func (c *GiftcardobjectUpdateCall) doRequest(alt string) (*http.Response, error) {
12428 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12429 var body io.Reader = nil
12430 body, err := googleapi.WithoutDataWrapper.JSONReader(c.giftcardobject)
12431 if err != nil {
12432 return nil, err
12433 }
12434 c.urlParams_.Set("alt", alt)
12435 c.urlParams_.Set("prettyPrint", "false")
12436 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/giftCardObject/{resourceId}")
12437 urls += "?" + c.urlParams_.Encode()
12438 req, err := http.NewRequest("PUT", urls, body)
12439 if err != nil {
12440 return nil, err
12441 }
12442 req.Header = reqHeaders
12443 googleapi.Expand(req.URL, map[string]string{
12444 "resourceId": c.resourceId,
12445 })
12446 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12447 }
12448
12449
12450
12451
12452
12453
12454 func (c *GiftcardobjectUpdateCall) Do(opts ...googleapi.CallOption) (*GiftCardObject, error) {
12455 gensupport.SetOptions(c.urlParams_, opts...)
12456 res, err := c.doRequest("json")
12457 if res != nil && res.StatusCode == http.StatusNotModified {
12458 if res.Body != nil {
12459 res.Body.Close()
12460 }
12461 return nil, gensupport.WrapError(&googleapi.Error{
12462 Code: res.StatusCode,
12463 Header: res.Header,
12464 })
12465 }
12466 if err != nil {
12467 return nil, err
12468 }
12469 defer googleapi.CloseBody(res)
12470 if err := googleapi.CheckResponse(res); err != nil {
12471 return nil, gensupport.WrapError(err)
12472 }
12473 ret := &GiftCardObject{
12474 ServerResponse: googleapi.ServerResponse{
12475 Header: res.Header,
12476 HTTPStatusCode: res.StatusCode,
12477 },
12478 }
12479 target := &ret
12480 if err := gensupport.DecodeResponse(target, res); err != nil {
12481 return nil, err
12482 }
12483 return ret, nil
12484 }
12485
12486 type IssuerGetCall struct {
12487 s *Service
12488 resourceId int64
12489 urlParams_ gensupport.URLParams
12490 ifNoneMatch_ string
12491 ctx_ context.Context
12492 header_ http.Header
12493 }
12494
12495
12496
12497
12498 func (r *IssuerService) Get(resourceId int64) *IssuerGetCall {
12499 c := &IssuerGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12500 c.resourceId = resourceId
12501 return c
12502 }
12503
12504
12505
12506
12507 func (c *IssuerGetCall) Fields(s ...googleapi.Field) *IssuerGetCall {
12508 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12509 return c
12510 }
12511
12512
12513
12514
12515 func (c *IssuerGetCall) IfNoneMatch(entityTag string) *IssuerGetCall {
12516 c.ifNoneMatch_ = entityTag
12517 return c
12518 }
12519
12520
12521 func (c *IssuerGetCall) Context(ctx context.Context) *IssuerGetCall {
12522 c.ctx_ = ctx
12523 return c
12524 }
12525
12526
12527
12528 func (c *IssuerGetCall) Header() http.Header {
12529 if c.header_ == nil {
12530 c.header_ = make(http.Header)
12531 }
12532 return c.header_
12533 }
12534
12535 func (c *IssuerGetCall) doRequest(alt string) (*http.Response, error) {
12536 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12537 if c.ifNoneMatch_ != "" {
12538 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12539 }
12540 var body io.Reader = nil
12541 c.urlParams_.Set("alt", alt)
12542 c.urlParams_.Set("prettyPrint", "false")
12543 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/issuer/{resourceId}")
12544 urls += "?" + c.urlParams_.Encode()
12545 req, err := http.NewRequest("GET", urls, body)
12546 if err != nil {
12547 return nil, err
12548 }
12549 req.Header = reqHeaders
12550 googleapi.Expand(req.URL, map[string]string{
12551 "resourceId": strconv.FormatInt(c.resourceId, 10),
12552 })
12553 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12554 }
12555
12556
12557
12558
12559
12560
12561 func (c *IssuerGetCall) Do(opts ...googleapi.CallOption) (*Issuer, error) {
12562 gensupport.SetOptions(c.urlParams_, opts...)
12563 res, err := c.doRequest("json")
12564 if res != nil && res.StatusCode == http.StatusNotModified {
12565 if res.Body != nil {
12566 res.Body.Close()
12567 }
12568 return nil, gensupport.WrapError(&googleapi.Error{
12569 Code: res.StatusCode,
12570 Header: res.Header,
12571 })
12572 }
12573 if err != nil {
12574 return nil, err
12575 }
12576 defer googleapi.CloseBody(res)
12577 if err := googleapi.CheckResponse(res); err != nil {
12578 return nil, gensupport.WrapError(err)
12579 }
12580 ret := &Issuer{
12581 ServerResponse: googleapi.ServerResponse{
12582 Header: res.Header,
12583 HTTPStatusCode: res.StatusCode,
12584 },
12585 }
12586 target := &ret
12587 if err := gensupport.DecodeResponse(target, res); err != nil {
12588 return nil, err
12589 }
12590 return ret, nil
12591 }
12592
12593 type IssuerInsertCall struct {
12594 s *Service
12595 issuer *Issuer
12596 urlParams_ gensupport.URLParams
12597 ctx_ context.Context
12598 header_ http.Header
12599 }
12600
12601
12602 func (r *IssuerService) Insert(issuer *Issuer) *IssuerInsertCall {
12603 c := &IssuerInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12604 c.issuer = issuer
12605 return c
12606 }
12607
12608
12609
12610
12611 func (c *IssuerInsertCall) Fields(s ...googleapi.Field) *IssuerInsertCall {
12612 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12613 return c
12614 }
12615
12616
12617 func (c *IssuerInsertCall) Context(ctx context.Context) *IssuerInsertCall {
12618 c.ctx_ = ctx
12619 return c
12620 }
12621
12622
12623
12624 func (c *IssuerInsertCall) Header() http.Header {
12625 if c.header_ == nil {
12626 c.header_ = make(http.Header)
12627 }
12628 return c.header_
12629 }
12630
12631 func (c *IssuerInsertCall) doRequest(alt string) (*http.Response, error) {
12632 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12633 var body io.Reader = nil
12634 body, err := googleapi.WithoutDataWrapper.JSONReader(c.issuer)
12635 if err != nil {
12636 return nil, err
12637 }
12638 c.urlParams_.Set("alt", alt)
12639 c.urlParams_.Set("prettyPrint", "false")
12640 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/issuer")
12641 urls += "?" + c.urlParams_.Encode()
12642 req, err := http.NewRequest("POST", urls, body)
12643 if err != nil {
12644 return nil, err
12645 }
12646 req.Header = reqHeaders
12647 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12648 }
12649
12650
12651
12652
12653
12654
12655 func (c *IssuerInsertCall) Do(opts ...googleapi.CallOption) (*Issuer, error) {
12656 gensupport.SetOptions(c.urlParams_, opts...)
12657 res, err := c.doRequest("json")
12658 if res != nil && res.StatusCode == http.StatusNotModified {
12659 if res.Body != nil {
12660 res.Body.Close()
12661 }
12662 return nil, gensupport.WrapError(&googleapi.Error{
12663 Code: res.StatusCode,
12664 Header: res.Header,
12665 })
12666 }
12667 if err != nil {
12668 return nil, err
12669 }
12670 defer googleapi.CloseBody(res)
12671 if err := googleapi.CheckResponse(res); err != nil {
12672 return nil, gensupport.WrapError(err)
12673 }
12674 ret := &Issuer{
12675 ServerResponse: googleapi.ServerResponse{
12676 Header: res.Header,
12677 HTTPStatusCode: res.StatusCode,
12678 },
12679 }
12680 target := &ret
12681 if err := gensupport.DecodeResponse(target, res); err != nil {
12682 return nil, err
12683 }
12684 return ret, nil
12685 }
12686
12687 type IssuerListCall struct {
12688 s *Service
12689 urlParams_ gensupport.URLParams
12690 ifNoneMatch_ string
12691 ctx_ context.Context
12692 header_ http.Header
12693 }
12694
12695
12696 func (r *IssuerService) List() *IssuerListCall {
12697 c := &IssuerListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12698 return c
12699 }
12700
12701
12702
12703
12704 func (c *IssuerListCall) Fields(s ...googleapi.Field) *IssuerListCall {
12705 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12706 return c
12707 }
12708
12709
12710
12711
12712 func (c *IssuerListCall) IfNoneMatch(entityTag string) *IssuerListCall {
12713 c.ifNoneMatch_ = entityTag
12714 return c
12715 }
12716
12717
12718 func (c *IssuerListCall) Context(ctx context.Context) *IssuerListCall {
12719 c.ctx_ = ctx
12720 return c
12721 }
12722
12723
12724
12725 func (c *IssuerListCall) Header() http.Header {
12726 if c.header_ == nil {
12727 c.header_ = make(http.Header)
12728 }
12729 return c.header_
12730 }
12731
12732 func (c *IssuerListCall) doRequest(alt string) (*http.Response, error) {
12733 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12734 if c.ifNoneMatch_ != "" {
12735 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12736 }
12737 var body io.Reader = nil
12738 c.urlParams_.Set("alt", alt)
12739 c.urlParams_.Set("prettyPrint", "false")
12740 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/issuer")
12741 urls += "?" + c.urlParams_.Encode()
12742 req, err := http.NewRequest("GET", urls, body)
12743 if err != nil {
12744 return nil, err
12745 }
12746 req.Header = reqHeaders
12747 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12748 }
12749
12750
12751
12752
12753
12754
12755
12756 func (c *IssuerListCall) Do(opts ...googleapi.CallOption) (*IssuerListResponse, error) {
12757 gensupport.SetOptions(c.urlParams_, opts...)
12758 res, err := c.doRequest("json")
12759 if res != nil && res.StatusCode == http.StatusNotModified {
12760 if res.Body != nil {
12761 res.Body.Close()
12762 }
12763 return nil, gensupport.WrapError(&googleapi.Error{
12764 Code: res.StatusCode,
12765 Header: res.Header,
12766 })
12767 }
12768 if err != nil {
12769 return nil, err
12770 }
12771 defer googleapi.CloseBody(res)
12772 if err := googleapi.CheckResponse(res); err != nil {
12773 return nil, gensupport.WrapError(err)
12774 }
12775 ret := &IssuerListResponse{
12776 ServerResponse: googleapi.ServerResponse{
12777 Header: res.Header,
12778 HTTPStatusCode: res.StatusCode,
12779 },
12780 }
12781 target := &ret
12782 if err := gensupport.DecodeResponse(target, res); err != nil {
12783 return nil, err
12784 }
12785 return ret, nil
12786 }
12787
12788 type IssuerPatchCall struct {
12789 s *Service
12790 resourceId int64
12791 issuer *Issuer
12792 urlParams_ gensupport.URLParams
12793 ctx_ context.Context
12794 header_ http.Header
12795 }
12796
12797
12798
12799
12800
12801 func (r *IssuerService) Patch(resourceId int64, issuer *Issuer) *IssuerPatchCall {
12802 c := &IssuerPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12803 c.resourceId = resourceId
12804 c.issuer = issuer
12805 return c
12806 }
12807
12808
12809
12810
12811 func (c *IssuerPatchCall) Fields(s ...googleapi.Field) *IssuerPatchCall {
12812 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12813 return c
12814 }
12815
12816
12817 func (c *IssuerPatchCall) Context(ctx context.Context) *IssuerPatchCall {
12818 c.ctx_ = ctx
12819 return c
12820 }
12821
12822
12823
12824 func (c *IssuerPatchCall) Header() http.Header {
12825 if c.header_ == nil {
12826 c.header_ = make(http.Header)
12827 }
12828 return c.header_
12829 }
12830
12831 func (c *IssuerPatchCall) doRequest(alt string) (*http.Response, error) {
12832 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12833 var body io.Reader = nil
12834 body, err := googleapi.WithoutDataWrapper.JSONReader(c.issuer)
12835 if err != nil {
12836 return nil, err
12837 }
12838 c.urlParams_.Set("alt", alt)
12839 c.urlParams_.Set("prettyPrint", "false")
12840 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/issuer/{resourceId}")
12841 urls += "?" + c.urlParams_.Encode()
12842 req, err := http.NewRequest("PATCH", urls, body)
12843 if err != nil {
12844 return nil, err
12845 }
12846 req.Header = reqHeaders
12847 googleapi.Expand(req.URL, map[string]string{
12848 "resourceId": strconv.FormatInt(c.resourceId, 10),
12849 })
12850 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12851 }
12852
12853
12854
12855
12856
12857
12858 func (c *IssuerPatchCall) Do(opts ...googleapi.CallOption) (*Issuer, error) {
12859 gensupport.SetOptions(c.urlParams_, opts...)
12860 res, err := c.doRequest("json")
12861 if res != nil && res.StatusCode == http.StatusNotModified {
12862 if res.Body != nil {
12863 res.Body.Close()
12864 }
12865 return nil, gensupport.WrapError(&googleapi.Error{
12866 Code: res.StatusCode,
12867 Header: res.Header,
12868 })
12869 }
12870 if err != nil {
12871 return nil, err
12872 }
12873 defer googleapi.CloseBody(res)
12874 if err := googleapi.CheckResponse(res); err != nil {
12875 return nil, gensupport.WrapError(err)
12876 }
12877 ret := &Issuer{
12878 ServerResponse: googleapi.ServerResponse{
12879 Header: res.Header,
12880 HTTPStatusCode: res.StatusCode,
12881 },
12882 }
12883 target := &ret
12884 if err := gensupport.DecodeResponse(target, res); err != nil {
12885 return nil, err
12886 }
12887 return ret, nil
12888 }
12889
12890 type IssuerUpdateCall struct {
12891 s *Service
12892 resourceId int64
12893 issuer *Issuer
12894 urlParams_ gensupport.URLParams
12895 ctx_ context.Context
12896 header_ http.Header
12897 }
12898
12899
12900
12901
12902 func (r *IssuerService) Update(resourceId int64, issuer *Issuer) *IssuerUpdateCall {
12903 c := &IssuerUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12904 c.resourceId = resourceId
12905 c.issuer = issuer
12906 return c
12907 }
12908
12909
12910
12911
12912 func (c *IssuerUpdateCall) Fields(s ...googleapi.Field) *IssuerUpdateCall {
12913 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12914 return c
12915 }
12916
12917
12918 func (c *IssuerUpdateCall) Context(ctx context.Context) *IssuerUpdateCall {
12919 c.ctx_ = ctx
12920 return c
12921 }
12922
12923
12924
12925 func (c *IssuerUpdateCall) Header() http.Header {
12926 if c.header_ == nil {
12927 c.header_ = make(http.Header)
12928 }
12929 return c.header_
12930 }
12931
12932 func (c *IssuerUpdateCall) doRequest(alt string) (*http.Response, error) {
12933 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12934 var body io.Reader = nil
12935 body, err := googleapi.WithoutDataWrapper.JSONReader(c.issuer)
12936 if err != nil {
12937 return nil, err
12938 }
12939 c.urlParams_.Set("alt", alt)
12940 c.urlParams_.Set("prettyPrint", "false")
12941 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/issuer/{resourceId}")
12942 urls += "?" + c.urlParams_.Encode()
12943 req, err := http.NewRequest("PUT", urls, body)
12944 if err != nil {
12945 return nil, err
12946 }
12947 req.Header = reqHeaders
12948 googleapi.Expand(req.URL, map[string]string{
12949 "resourceId": strconv.FormatInt(c.resourceId, 10),
12950 })
12951 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12952 }
12953
12954
12955
12956
12957
12958
12959 func (c *IssuerUpdateCall) Do(opts ...googleapi.CallOption) (*Issuer, error) {
12960 gensupport.SetOptions(c.urlParams_, opts...)
12961 res, err := c.doRequest("json")
12962 if res != nil && res.StatusCode == http.StatusNotModified {
12963 if res.Body != nil {
12964 res.Body.Close()
12965 }
12966 return nil, gensupport.WrapError(&googleapi.Error{
12967 Code: res.StatusCode,
12968 Header: res.Header,
12969 })
12970 }
12971 if err != nil {
12972 return nil, err
12973 }
12974 defer googleapi.CloseBody(res)
12975 if err := googleapi.CheckResponse(res); err != nil {
12976 return nil, gensupport.WrapError(err)
12977 }
12978 ret := &Issuer{
12979 ServerResponse: googleapi.ServerResponse{
12980 Header: res.Header,
12981 HTTPStatusCode: res.StatusCode,
12982 },
12983 }
12984 target := &ret
12985 if err := gensupport.DecodeResponse(target, res); err != nil {
12986 return nil, err
12987 }
12988 return ret, nil
12989 }
12990
12991 type JwtInsertCall struct {
12992 s *Service
12993 jwtresource *JwtResource
12994 urlParams_ gensupport.URLParams
12995 ctx_ context.Context
12996 header_ http.Header
12997 }
12998
12999
13000 func (r *JwtService) Insert(jwtresource *JwtResource) *JwtInsertCall {
13001 c := &JwtInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13002 c.jwtresource = jwtresource
13003 return c
13004 }
13005
13006
13007
13008
13009 func (c *JwtInsertCall) Fields(s ...googleapi.Field) *JwtInsertCall {
13010 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13011 return c
13012 }
13013
13014
13015 func (c *JwtInsertCall) Context(ctx context.Context) *JwtInsertCall {
13016 c.ctx_ = ctx
13017 return c
13018 }
13019
13020
13021
13022 func (c *JwtInsertCall) Header() http.Header {
13023 if c.header_ == nil {
13024 c.header_ = make(http.Header)
13025 }
13026 return c.header_
13027 }
13028
13029 func (c *JwtInsertCall) doRequest(alt string) (*http.Response, error) {
13030 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13031 var body io.Reader = nil
13032 body, err := googleapi.WithoutDataWrapper.JSONReader(c.jwtresource)
13033 if err != nil {
13034 return nil, err
13035 }
13036 c.urlParams_.Set("alt", alt)
13037 c.urlParams_.Set("prettyPrint", "false")
13038 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/jwt")
13039 urls += "?" + c.urlParams_.Encode()
13040 req, err := http.NewRequest("POST", urls, body)
13041 if err != nil {
13042 return nil, err
13043 }
13044 req.Header = reqHeaders
13045 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13046 }
13047
13048
13049
13050
13051
13052
13053
13054 func (c *JwtInsertCall) Do(opts ...googleapi.CallOption) (*JwtInsertResponse, error) {
13055 gensupport.SetOptions(c.urlParams_, opts...)
13056 res, err := c.doRequest("json")
13057 if res != nil && res.StatusCode == http.StatusNotModified {
13058 if res.Body != nil {
13059 res.Body.Close()
13060 }
13061 return nil, gensupport.WrapError(&googleapi.Error{
13062 Code: res.StatusCode,
13063 Header: res.Header,
13064 })
13065 }
13066 if err != nil {
13067 return nil, err
13068 }
13069 defer googleapi.CloseBody(res)
13070 if err := googleapi.CheckResponse(res); err != nil {
13071 return nil, gensupport.WrapError(err)
13072 }
13073 ret := &JwtInsertResponse{
13074 ServerResponse: googleapi.ServerResponse{
13075 Header: res.Header,
13076 HTTPStatusCode: res.StatusCode,
13077 },
13078 }
13079 target := &ret
13080 if err := gensupport.DecodeResponse(target, res); err != nil {
13081 return nil, err
13082 }
13083 return ret, nil
13084 }
13085
13086 type LoyaltyclassAddmessageCall struct {
13087 s *Service
13088 resourceId string
13089 addmessagerequest *AddMessageRequest
13090 urlParams_ gensupport.URLParams
13091 ctx_ context.Context
13092 header_ http.Header
13093 }
13094
13095
13096
13097
13098
13099
13100
13101
13102
13103 func (r *LoyaltyclassService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *LoyaltyclassAddmessageCall {
13104 c := &LoyaltyclassAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13105 c.resourceId = resourceId
13106 c.addmessagerequest = addmessagerequest
13107 return c
13108 }
13109
13110
13111
13112
13113 func (c *LoyaltyclassAddmessageCall) Fields(s ...googleapi.Field) *LoyaltyclassAddmessageCall {
13114 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13115 return c
13116 }
13117
13118
13119 func (c *LoyaltyclassAddmessageCall) Context(ctx context.Context) *LoyaltyclassAddmessageCall {
13120 c.ctx_ = ctx
13121 return c
13122 }
13123
13124
13125
13126 func (c *LoyaltyclassAddmessageCall) Header() http.Header {
13127 if c.header_ == nil {
13128 c.header_ = make(http.Header)
13129 }
13130 return c.header_
13131 }
13132
13133 func (c *LoyaltyclassAddmessageCall) doRequest(alt string) (*http.Response, error) {
13134 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13135 var body io.Reader = nil
13136 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
13137 if err != nil {
13138 return nil, err
13139 }
13140 c.urlParams_.Set("alt", alt)
13141 c.urlParams_.Set("prettyPrint", "false")
13142 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyClass/{resourceId}/addMessage")
13143 urls += "?" + c.urlParams_.Encode()
13144 req, err := http.NewRequest("POST", urls, body)
13145 if err != nil {
13146 return nil, err
13147 }
13148 req.Header = reqHeaders
13149 googleapi.Expand(req.URL, map[string]string{
13150 "resourceId": c.resourceId,
13151 })
13152 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13153 }
13154
13155
13156
13157
13158
13159
13160
13161 func (c *LoyaltyclassAddmessageCall) Do(opts ...googleapi.CallOption) (*LoyaltyClassAddMessageResponse, error) {
13162 gensupport.SetOptions(c.urlParams_, opts...)
13163 res, err := c.doRequest("json")
13164 if res != nil && res.StatusCode == http.StatusNotModified {
13165 if res.Body != nil {
13166 res.Body.Close()
13167 }
13168 return nil, gensupport.WrapError(&googleapi.Error{
13169 Code: res.StatusCode,
13170 Header: res.Header,
13171 })
13172 }
13173 if err != nil {
13174 return nil, err
13175 }
13176 defer googleapi.CloseBody(res)
13177 if err := googleapi.CheckResponse(res); err != nil {
13178 return nil, gensupport.WrapError(err)
13179 }
13180 ret := &LoyaltyClassAddMessageResponse{
13181 ServerResponse: googleapi.ServerResponse{
13182 Header: res.Header,
13183 HTTPStatusCode: res.StatusCode,
13184 },
13185 }
13186 target := &ret
13187 if err := gensupport.DecodeResponse(target, res); err != nil {
13188 return nil, err
13189 }
13190 return ret, nil
13191 }
13192
13193 type LoyaltyclassGetCall struct {
13194 s *Service
13195 resourceId string
13196 urlParams_ gensupport.URLParams
13197 ifNoneMatch_ string
13198 ctx_ context.Context
13199 header_ http.Header
13200 }
13201
13202
13203
13204
13205
13206
13207
13208
13209 func (r *LoyaltyclassService) Get(resourceId string) *LoyaltyclassGetCall {
13210 c := &LoyaltyclassGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13211 c.resourceId = resourceId
13212 return c
13213 }
13214
13215
13216
13217
13218 func (c *LoyaltyclassGetCall) Fields(s ...googleapi.Field) *LoyaltyclassGetCall {
13219 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13220 return c
13221 }
13222
13223
13224
13225
13226 func (c *LoyaltyclassGetCall) IfNoneMatch(entityTag string) *LoyaltyclassGetCall {
13227 c.ifNoneMatch_ = entityTag
13228 return c
13229 }
13230
13231
13232 func (c *LoyaltyclassGetCall) Context(ctx context.Context) *LoyaltyclassGetCall {
13233 c.ctx_ = ctx
13234 return c
13235 }
13236
13237
13238
13239 func (c *LoyaltyclassGetCall) Header() http.Header {
13240 if c.header_ == nil {
13241 c.header_ = make(http.Header)
13242 }
13243 return c.header_
13244 }
13245
13246 func (c *LoyaltyclassGetCall) doRequest(alt string) (*http.Response, error) {
13247 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13248 if c.ifNoneMatch_ != "" {
13249 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13250 }
13251 var body io.Reader = nil
13252 c.urlParams_.Set("alt", alt)
13253 c.urlParams_.Set("prettyPrint", "false")
13254 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyClass/{resourceId}")
13255 urls += "?" + c.urlParams_.Encode()
13256 req, err := http.NewRequest("GET", urls, body)
13257 if err != nil {
13258 return nil, err
13259 }
13260 req.Header = reqHeaders
13261 googleapi.Expand(req.URL, map[string]string{
13262 "resourceId": c.resourceId,
13263 })
13264 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13265 }
13266
13267
13268
13269
13270
13271
13272 func (c *LoyaltyclassGetCall) Do(opts ...googleapi.CallOption) (*LoyaltyClass, error) {
13273 gensupport.SetOptions(c.urlParams_, opts...)
13274 res, err := c.doRequest("json")
13275 if res != nil && res.StatusCode == http.StatusNotModified {
13276 if res.Body != nil {
13277 res.Body.Close()
13278 }
13279 return nil, gensupport.WrapError(&googleapi.Error{
13280 Code: res.StatusCode,
13281 Header: res.Header,
13282 })
13283 }
13284 if err != nil {
13285 return nil, err
13286 }
13287 defer googleapi.CloseBody(res)
13288 if err := googleapi.CheckResponse(res); err != nil {
13289 return nil, gensupport.WrapError(err)
13290 }
13291 ret := &LoyaltyClass{
13292 ServerResponse: googleapi.ServerResponse{
13293 Header: res.Header,
13294 HTTPStatusCode: res.StatusCode,
13295 },
13296 }
13297 target := &ret
13298 if err := gensupport.DecodeResponse(target, res); err != nil {
13299 return nil, err
13300 }
13301 return ret, nil
13302 }
13303
13304 type LoyaltyclassInsertCall struct {
13305 s *Service
13306 loyaltyclass *LoyaltyClass
13307 urlParams_ gensupport.URLParams
13308 ctx_ context.Context
13309 header_ http.Header
13310 }
13311
13312
13313 func (r *LoyaltyclassService) Insert(loyaltyclass *LoyaltyClass) *LoyaltyclassInsertCall {
13314 c := &LoyaltyclassInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13315 c.loyaltyclass = loyaltyclass
13316 return c
13317 }
13318
13319
13320
13321
13322 func (c *LoyaltyclassInsertCall) Fields(s ...googleapi.Field) *LoyaltyclassInsertCall {
13323 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13324 return c
13325 }
13326
13327
13328 func (c *LoyaltyclassInsertCall) Context(ctx context.Context) *LoyaltyclassInsertCall {
13329 c.ctx_ = ctx
13330 return c
13331 }
13332
13333
13334
13335 func (c *LoyaltyclassInsertCall) Header() http.Header {
13336 if c.header_ == nil {
13337 c.header_ = make(http.Header)
13338 }
13339 return c.header_
13340 }
13341
13342 func (c *LoyaltyclassInsertCall) doRequest(alt string) (*http.Response, error) {
13343 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13344 var body io.Reader = nil
13345 body, err := googleapi.WithoutDataWrapper.JSONReader(c.loyaltyclass)
13346 if err != nil {
13347 return nil, err
13348 }
13349 c.urlParams_.Set("alt", alt)
13350 c.urlParams_.Set("prettyPrint", "false")
13351 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyClass")
13352 urls += "?" + c.urlParams_.Encode()
13353 req, err := http.NewRequest("POST", urls, body)
13354 if err != nil {
13355 return nil, err
13356 }
13357 req.Header = reqHeaders
13358 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13359 }
13360
13361
13362
13363
13364
13365
13366 func (c *LoyaltyclassInsertCall) Do(opts ...googleapi.CallOption) (*LoyaltyClass, error) {
13367 gensupport.SetOptions(c.urlParams_, opts...)
13368 res, err := c.doRequest("json")
13369 if res != nil && res.StatusCode == http.StatusNotModified {
13370 if res.Body != nil {
13371 res.Body.Close()
13372 }
13373 return nil, gensupport.WrapError(&googleapi.Error{
13374 Code: res.StatusCode,
13375 Header: res.Header,
13376 })
13377 }
13378 if err != nil {
13379 return nil, err
13380 }
13381 defer googleapi.CloseBody(res)
13382 if err := googleapi.CheckResponse(res); err != nil {
13383 return nil, gensupport.WrapError(err)
13384 }
13385 ret := &LoyaltyClass{
13386 ServerResponse: googleapi.ServerResponse{
13387 Header: res.Header,
13388 HTTPStatusCode: res.StatusCode,
13389 },
13390 }
13391 target := &ret
13392 if err := gensupport.DecodeResponse(target, res); err != nil {
13393 return nil, err
13394 }
13395 return ret, nil
13396 }
13397
13398 type LoyaltyclassListCall struct {
13399 s *Service
13400 urlParams_ gensupport.URLParams
13401 ifNoneMatch_ string
13402 ctx_ context.Context
13403 header_ http.Header
13404 }
13405
13406
13407 func (r *LoyaltyclassService) List() *LoyaltyclassListCall {
13408 c := &LoyaltyclassListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13409 return c
13410 }
13411
13412
13413
13414 func (c *LoyaltyclassListCall) IssuerId(issuerId int64) *LoyaltyclassListCall {
13415 c.urlParams_.Set("issuerId", fmt.Sprint(issuerId))
13416 return c
13417 }
13418
13419
13420
13421
13422 func (c *LoyaltyclassListCall) MaxResults(maxResults int64) *LoyaltyclassListCall {
13423 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
13424 return c
13425 }
13426
13427
13428
13429
13430
13431
13432
13433 func (c *LoyaltyclassListCall) Token(token string) *LoyaltyclassListCall {
13434 c.urlParams_.Set("token", token)
13435 return c
13436 }
13437
13438
13439
13440
13441 func (c *LoyaltyclassListCall) Fields(s ...googleapi.Field) *LoyaltyclassListCall {
13442 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13443 return c
13444 }
13445
13446
13447
13448
13449 func (c *LoyaltyclassListCall) IfNoneMatch(entityTag string) *LoyaltyclassListCall {
13450 c.ifNoneMatch_ = entityTag
13451 return c
13452 }
13453
13454
13455 func (c *LoyaltyclassListCall) Context(ctx context.Context) *LoyaltyclassListCall {
13456 c.ctx_ = ctx
13457 return c
13458 }
13459
13460
13461
13462 func (c *LoyaltyclassListCall) Header() http.Header {
13463 if c.header_ == nil {
13464 c.header_ = make(http.Header)
13465 }
13466 return c.header_
13467 }
13468
13469 func (c *LoyaltyclassListCall) doRequest(alt string) (*http.Response, error) {
13470 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13471 if c.ifNoneMatch_ != "" {
13472 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13473 }
13474 var body io.Reader = nil
13475 c.urlParams_.Set("alt", alt)
13476 c.urlParams_.Set("prettyPrint", "false")
13477 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyClass")
13478 urls += "?" + c.urlParams_.Encode()
13479 req, err := http.NewRequest("GET", urls, body)
13480 if err != nil {
13481 return nil, err
13482 }
13483 req.Header = reqHeaders
13484 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13485 }
13486
13487
13488
13489
13490
13491
13492
13493 func (c *LoyaltyclassListCall) Do(opts ...googleapi.CallOption) (*LoyaltyClassListResponse, error) {
13494 gensupport.SetOptions(c.urlParams_, opts...)
13495 res, err := c.doRequest("json")
13496 if res != nil && res.StatusCode == http.StatusNotModified {
13497 if res.Body != nil {
13498 res.Body.Close()
13499 }
13500 return nil, gensupport.WrapError(&googleapi.Error{
13501 Code: res.StatusCode,
13502 Header: res.Header,
13503 })
13504 }
13505 if err != nil {
13506 return nil, err
13507 }
13508 defer googleapi.CloseBody(res)
13509 if err := googleapi.CheckResponse(res); err != nil {
13510 return nil, gensupport.WrapError(err)
13511 }
13512 ret := &LoyaltyClassListResponse{
13513 ServerResponse: googleapi.ServerResponse{
13514 Header: res.Header,
13515 HTTPStatusCode: res.StatusCode,
13516 },
13517 }
13518 target := &ret
13519 if err := gensupport.DecodeResponse(target, res); err != nil {
13520 return nil, err
13521 }
13522 return ret, nil
13523 }
13524
13525 type LoyaltyclassPatchCall struct {
13526 s *Service
13527 resourceId string
13528 loyaltyclass *LoyaltyClass
13529 urlParams_ gensupport.URLParams
13530 ctx_ context.Context
13531 header_ http.Header
13532 }
13533
13534
13535
13536
13537
13538
13539
13540
13541
13542 func (r *LoyaltyclassService) Patch(resourceId string, loyaltyclass *LoyaltyClass) *LoyaltyclassPatchCall {
13543 c := &LoyaltyclassPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13544 c.resourceId = resourceId
13545 c.loyaltyclass = loyaltyclass
13546 return c
13547 }
13548
13549
13550
13551
13552 func (c *LoyaltyclassPatchCall) Fields(s ...googleapi.Field) *LoyaltyclassPatchCall {
13553 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13554 return c
13555 }
13556
13557
13558 func (c *LoyaltyclassPatchCall) Context(ctx context.Context) *LoyaltyclassPatchCall {
13559 c.ctx_ = ctx
13560 return c
13561 }
13562
13563
13564
13565 func (c *LoyaltyclassPatchCall) Header() http.Header {
13566 if c.header_ == nil {
13567 c.header_ = make(http.Header)
13568 }
13569 return c.header_
13570 }
13571
13572 func (c *LoyaltyclassPatchCall) doRequest(alt string) (*http.Response, error) {
13573 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13574 var body io.Reader = nil
13575 body, err := googleapi.WithoutDataWrapper.JSONReader(c.loyaltyclass)
13576 if err != nil {
13577 return nil, err
13578 }
13579 c.urlParams_.Set("alt", alt)
13580 c.urlParams_.Set("prettyPrint", "false")
13581 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyClass/{resourceId}")
13582 urls += "?" + c.urlParams_.Encode()
13583 req, err := http.NewRequest("PATCH", urls, body)
13584 if err != nil {
13585 return nil, err
13586 }
13587 req.Header = reqHeaders
13588 googleapi.Expand(req.URL, map[string]string{
13589 "resourceId": c.resourceId,
13590 })
13591 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13592 }
13593
13594
13595
13596
13597
13598
13599 func (c *LoyaltyclassPatchCall) Do(opts ...googleapi.CallOption) (*LoyaltyClass, error) {
13600 gensupport.SetOptions(c.urlParams_, opts...)
13601 res, err := c.doRequest("json")
13602 if res != nil && res.StatusCode == http.StatusNotModified {
13603 if res.Body != nil {
13604 res.Body.Close()
13605 }
13606 return nil, gensupport.WrapError(&googleapi.Error{
13607 Code: res.StatusCode,
13608 Header: res.Header,
13609 })
13610 }
13611 if err != nil {
13612 return nil, err
13613 }
13614 defer googleapi.CloseBody(res)
13615 if err := googleapi.CheckResponse(res); err != nil {
13616 return nil, gensupport.WrapError(err)
13617 }
13618 ret := &LoyaltyClass{
13619 ServerResponse: googleapi.ServerResponse{
13620 Header: res.Header,
13621 HTTPStatusCode: res.StatusCode,
13622 },
13623 }
13624 target := &ret
13625 if err := gensupport.DecodeResponse(target, res); err != nil {
13626 return nil, err
13627 }
13628 return ret, nil
13629 }
13630
13631 type LoyaltyclassUpdateCall struct {
13632 s *Service
13633 resourceId string
13634 loyaltyclass *LoyaltyClass
13635 urlParams_ gensupport.URLParams
13636 ctx_ context.Context
13637 header_ http.Header
13638 }
13639
13640
13641
13642
13643
13644
13645
13646
13647 func (r *LoyaltyclassService) Update(resourceId string, loyaltyclass *LoyaltyClass) *LoyaltyclassUpdateCall {
13648 c := &LoyaltyclassUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13649 c.resourceId = resourceId
13650 c.loyaltyclass = loyaltyclass
13651 return c
13652 }
13653
13654
13655
13656
13657 func (c *LoyaltyclassUpdateCall) Fields(s ...googleapi.Field) *LoyaltyclassUpdateCall {
13658 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13659 return c
13660 }
13661
13662
13663 func (c *LoyaltyclassUpdateCall) Context(ctx context.Context) *LoyaltyclassUpdateCall {
13664 c.ctx_ = ctx
13665 return c
13666 }
13667
13668
13669
13670 func (c *LoyaltyclassUpdateCall) Header() http.Header {
13671 if c.header_ == nil {
13672 c.header_ = make(http.Header)
13673 }
13674 return c.header_
13675 }
13676
13677 func (c *LoyaltyclassUpdateCall) doRequest(alt string) (*http.Response, error) {
13678 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13679 var body io.Reader = nil
13680 body, err := googleapi.WithoutDataWrapper.JSONReader(c.loyaltyclass)
13681 if err != nil {
13682 return nil, err
13683 }
13684 c.urlParams_.Set("alt", alt)
13685 c.urlParams_.Set("prettyPrint", "false")
13686 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyClass/{resourceId}")
13687 urls += "?" + c.urlParams_.Encode()
13688 req, err := http.NewRequest("PUT", urls, body)
13689 if err != nil {
13690 return nil, err
13691 }
13692 req.Header = reqHeaders
13693 googleapi.Expand(req.URL, map[string]string{
13694 "resourceId": c.resourceId,
13695 })
13696 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13697 }
13698
13699
13700
13701
13702
13703
13704 func (c *LoyaltyclassUpdateCall) Do(opts ...googleapi.CallOption) (*LoyaltyClass, error) {
13705 gensupport.SetOptions(c.urlParams_, opts...)
13706 res, err := c.doRequest("json")
13707 if res != nil && res.StatusCode == http.StatusNotModified {
13708 if res.Body != nil {
13709 res.Body.Close()
13710 }
13711 return nil, gensupport.WrapError(&googleapi.Error{
13712 Code: res.StatusCode,
13713 Header: res.Header,
13714 })
13715 }
13716 if err != nil {
13717 return nil, err
13718 }
13719 defer googleapi.CloseBody(res)
13720 if err := googleapi.CheckResponse(res); err != nil {
13721 return nil, gensupport.WrapError(err)
13722 }
13723 ret := &LoyaltyClass{
13724 ServerResponse: googleapi.ServerResponse{
13725 Header: res.Header,
13726 HTTPStatusCode: res.StatusCode,
13727 },
13728 }
13729 target := &ret
13730 if err := gensupport.DecodeResponse(target, res); err != nil {
13731 return nil, err
13732 }
13733 return ret, nil
13734 }
13735
13736 type LoyaltyobjectAddmessageCall struct {
13737 s *Service
13738 resourceId string
13739 addmessagerequest *AddMessageRequest
13740 urlParams_ gensupport.URLParams
13741 ctx_ context.Context
13742 header_ http.Header
13743 }
13744
13745
13746
13747
13748
13749
13750
13751
13752
13753 func (r *LoyaltyobjectService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *LoyaltyobjectAddmessageCall {
13754 c := &LoyaltyobjectAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13755 c.resourceId = resourceId
13756 c.addmessagerequest = addmessagerequest
13757 return c
13758 }
13759
13760
13761
13762
13763 func (c *LoyaltyobjectAddmessageCall) Fields(s ...googleapi.Field) *LoyaltyobjectAddmessageCall {
13764 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13765 return c
13766 }
13767
13768
13769 func (c *LoyaltyobjectAddmessageCall) Context(ctx context.Context) *LoyaltyobjectAddmessageCall {
13770 c.ctx_ = ctx
13771 return c
13772 }
13773
13774
13775
13776 func (c *LoyaltyobjectAddmessageCall) Header() http.Header {
13777 if c.header_ == nil {
13778 c.header_ = make(http.Header)
13779 }
13780 return c.header_
13781 }
13782
13783 func (c *LoyaltyobjectAddmessageCall) doRequest(alt string) (*http.Response, error) {
13784 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13785 var body io.Reader = nil
13786 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
13787 if err != nil {
13788 return nil, err
13789 }
13790 c.urlParams_.Set("alt", alt)
13791 c.urlParams_.Set("prettyPrint", "false")
13792 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyObject/{resourceId}/addMessage")
13793 urls += "?" + c.urlParams_.Encode()
13794 req, err := http.NewRequest("POST", urls, body)
13795 if err != nil {
13796 return nil, err
13797 }
13798 req.Header = reqHeaders
13799 googleapi.Expand(req.URL, map[string]string{
13800 "resourceId": c.resourceId,
13801 })
13802 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13803 }
13804
13805
13806
13807
13808
13809
13810
13811 func (c *LoyaltyobjectAddmessageCall) Do(opts ...googleapi.CallOption) (*LoyaltyObjectAddMessageResponse, error) {
13812 gensupport.SetOptions(c.urlParams_, opts...)
13813 res, err := c.doRequest("json")
13814 if res != nil && res.StatusCode == http.StatusNotModified {
13815 if res.Body != nil {
13816 res.Body.Close()
13817 }
13818 return nil, gensupport.WrapError(&googleapi.Error{
13819 Code: res.StatusCode,
13820 Header: res.Header,
13821 })
13822 }
13823 if err != nil {
13824 return nil, err
13825 }
13826 defer googleapi.CloseBody(res)
13827 if err := googleapi.CheckResponse(res); err != nil {
13828 return nil, gensupport.WrapError(err)
13829 }
13830 ret := &LoyaltyObjectAddMessageResponse{
13831 ServerResponse: googleapi.ServerResponse{
13832 Header: res.Header,
13833 HTTPStatusCode: res.StatusCode,
13834 },
13835 }
13836 target := &ret
13837 if err := gensupport.DecodeResponse(target, res); err != nil {
13838 return nil, err
13839 }
13840 return ret, nil
13841 }
13842
13843 type LoyaltyobjectGetCall struct {
13844 s *Service
13845 resourceId string
13846 urlParams_ gensupport.URLParams
13847 ifNoneMatch_ string
13848 ctx_ context.Context
13849 header_ http.Header
13850 }
13851
13852
13853
13854
13855
13856
13857
13858
13859 func (r *LoyaltyobjectService) Get(resourceId string) *LoyaltyobjectGetCall {
13860 c := &LoyaltyobjectGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13861 c.resourceId = resourceId
13862 return c
13863 }
13864
13865
13866
13867
13868 func (c *LoyaltyobjectGetCall) Fields(s ...googleapi.Field) *LoyaltyobjectGetCall {
13869 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13870 return c
13871 }
13872
13873
13874
13875
13876 func (c *LoyaltyobjectGetCall) IfNoneMatch(entityTag string) *LoyaltyobjectGetCall {
13877 c.ifNoneMatch_ = entityTag
13878 return c
13879 }
13880
13881
13882 func (c *LoyaltyobjectGetCall) Context(ctx context.Context) *LoyaltyobjectGetCall {
13883 c.ctx_ = ctx
13884 return c
13885 }
13886
13887
13888
13889 func (c *LoyaltyobjectGetCall) Header() http.Header {
13890 if c.header_ == nil {
13891 c.header_ = make(http.Header)
13892 }
13893 return c.header_
13894 }
13895
13896 func (c *LoyaltyobjectGetCall) doRequest(alt string) (*http.Response, error) {
13897 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13898 if c.ifNoneMatch_ != "" {
13899 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13900 }
13901 var body io.Reader = nil
13902 c.urlParams_.Set("alt", alt)
13903 c.urlParams_.Set("prettyPrint", "false")
13904 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyObject/{resourceId}")
13905 urls += "?" + c.urlParams_.Encode()
13906 req, err := http.NewRequest("GET", urls, body)
13907 if err != nil {
13908 return nil, err
13909 }
13910 req.Header = reqHeaders
13911 googleapi.Expand(req.URL, map[string]string{
13912 "resourceId": c.resourceId,
13913 })
13914 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13915 }
13916
13917
13918
13919
13920
13921
13922 func (c *LoyaltyobjectGetCall) Do(opts ...googleapi.CallOption) (*LoyaltyObject, error) {
13923 gensupport.SetOptions(c.urlParams_, opts...)
13924 res, err := c.doRequest("json")
13925 if res != nil && res.StatusCode == http.StatusNotModified {
13926 if res.Body != nil {
13927 res.Body.Close()
13928 }
13929 return nil, gensupport.WrapError(&googleapi.Error{
13930 Code: res.StatusCode,
13931 Header: res.Header,
13932 })
13933 }
13934 if err != nil {
13935 return nil, err
13936 }
13937 defer googleapi.CloseBody(res)
13938 if err := googleapi.CheckResponse(res); err != nil {
13939 return nil, gensupport.WrapError(err)
13940 }
13941 ret := &LoyaltyObject{
13942 ServerResponse: googleapi.ServerResponse{
13943 Header: res.Header,
13944 HTTPStatusCode: res.StatusCode,
13945 },
13946 }
13947 target := &ret
13948 if err := gensupport.DecodeResponse(target, res); err != nil {
13949 return nil, err
13950 }
13951 return ret, nil
13952 }
13953
13954 type LoyaltyobjectInsertCall struct {
13955 s *Service
13956 loyaltyobject *LoyaltyObject
13957 urlParams_ gensupport.URLParams
13958 ctx_ context.Context
13959 header_ http.Header
13960 }
13961
13962
13963 func (r *LoyaltyobjectService) Insert(loyaltyobject *LoyaltyObject) *LoyaltyobjectInsertCall {
13964 c := &LoyaltyobjectInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13965 c.loyaltyobject = loyaltyobject
13966 return c
13967 }
13968
13969
13970
13971
13972 func (c *LoyaltyobjectInsertCall) Fields(s ...googleapi.Field) *LoyaltyobjectInsertCall {
13973 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13974 return c
13975 }
13976
13977
13978 func (c *LoyaltyobjectInsertCall) Context(ctx context.Context) *LoyaltyobjectInsertCall {
13979 c.ctx_ = ctx
13980 return c
13981 }
13982
13983
13984
13985 func (c *LoyaltyobjectInsertCall) Header() http.Header {
13986 if c.header_ == nil {
13987 c.header_ = make(http.Header)
13988 }
13989 return c.header_
13990 }
13991
13992 func (c *LoyaltyobjectInsertCall) doRequest(alt string) (*http.Response, error) {
13993 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13994 var body io.Reader = nil
13995 body, err := googleapi.WithoutDataWrapper.JSONReader(c.loyaltyobject)
13996 if err != nil {
13997 return nil, err
13998 }
13999 c.urlParams_.Set("alt", alt)
14000 c.urlParams_.Set("prettyPrint", "false")
14001 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyObject")
14002 urls += "?" + c.urlParams_.Encode()
14003 req, err := http.NewRequest("POST", urls, body)
14004 if err != nil {
14005 return nil, err
14006 }
14007 req.Header = reqHeaders
14008 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14009 }
14010
14011
14012
14013
14014
14015
14016 func (c *LoyaltyobjectInsertCall) Do(opts ...googleapi.CallOption) (*LoyaltyObject, 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, gensupport.WrapError(&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, gensupport.WrapError(err)
14034 }
14035 ret := &LoyaltyObject{
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 type LoyaltyobjectListCall struct {
14049 s *Service
14050 urlParams_ gensupport.URLParams
14051 ifNoneMatch_ string
14052 ctx_ context.Context
14053 header_ http.Header
14054 }
14055
14056
14057 func (r *LoyaltyobjectService) List() *LoyaltyobjectListCall {
14058 c := &LoyaltyobjectListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14059 return c
14060 }
14061
14062
14063
14064 func (c *LoyaltyobjectListCall) ClassId(classId string) *LoyaltyobjectListCall {
14065 c.urlParams_.Set("classId", classId)
14066 return c
14067 }
14068
14069
14070
14071
14072 func (c *LoyaltyobjectListCall) MaxResults(maxResults int64) *LoyaltyobjectListCall {
14073 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
14074 return c
14075 }
14076
14077
14078
14079
14080
14081
14082
14083 func (c *LoyaltyobjectListCall) Token(token string) *LoyaltyobjectListCall {
14084 c.urlParams_.Set("token", token)
14085 return c
14086 }
14087
14088
14089
14090
14091 func (c *LoyaltyobjectListCall) Fields(s ...googleapi.Field) *LoyaltyobjectListCall {
14092 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14093 return c
14094 }
14095
14096
14097
14098
14099 func (c *LoyaltyobjectListCall) IfNoneMatch(entityTag string) *LoyaltyobjectListCall {
14100 c.ifNoneMatch_ = entityTag
14101 return c
14102 }
14103
14104
14105 func (c *LoyaltyobjectListCall) Context(ctx context.Context) *LoyaltyobjectListCall {
14106 c.ctx_ = ctx
14107 return c
14108 }
14109
14110
14111
14112 func (c *LoyaltyobjectListCall) Header() http.Header {
14113 if c.header_ == nil {
14114 c.header_ = make(http.Header)
14115 }
14116 return c.header_
14117 }
14118
14119 func (c *LoyaltyobjectListCall) doRequest(alt string) (*http.Response, error) {
14120 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14121 if c.ifNoneMatch_ != "" {
14122 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14123 }
14124 var body io.Reader = nil
14125 c.urlParams_.Set("alt", alt)
14126 c.urlParams_.Set("prettyPrint", "false")
14127 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyObject")
14128 urls += "?" + c.urlParams_.Encode()
14129 req, err := http.NewRequest("GET", urls, body)
14130 if err != nil {
14131 return nil, err
14132 }
14133 req.Header = reqHeaders
14134 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14135 }
14136
14137
14138
14139
14140
14141
14142
14143 func (c *LoyaltyobjectListCall) Do(opts ...googleapi.CallOption) (*LoyaltyObjectListResponse, error) {
14144 gensupport.SetOptions(c.urlParams_, opts...)
14145 res, err := c.doRequest("json")
14146 if res != nil && res.StatusCode == http.StatusNotModified {
14147 if res.Body != nil {
14148 res.Body.Close()
14149 }
14150 return nil, gensupport.WrapError(&googleapi.Error{
14151 Code: res.StatusCode,
14152 Header: res.Header,
14153 })
14154 }
14155 if err != nil {
14156 return nil, err
14157 }
14158 defer googleapi.CloseBody(res)
14159 if err := googleapi.CheckResponse(res); err != nil {
14160 return nil, gensupport.WrapError(err)
14161 }
14162 ret := &LoyaltyObjectListResponse{
14163 ServerResponse: googleapi.ServerResponse{
14164 Header: res.Header,
14165 HTTPStatusCode: res.StatusCode,
14166 },
14167 }
14168 target := &ret
14169 if err := gensupport.DecodeResponse(target, res); err != nil {
14170 return nil, err
14171 }
14172 return ret, nil
14173 }
14174
14175 type LoyaltyobjectModifylinkedofferobjectsCall struct {
14176 s *Service
14177 resourceId string
14178 modifylinkedofferobjectsrequest *ModifyLinkedOfferObjectsRequest
14179 urlParams_ gensupport.URLParams
14180 ctx_ context.Context
14181 header_ http.Header
14182 }
14183
14184
14185
14186
14187
14188
14189
14190
14191
14192 func (r *LoyaltyobjectService) Modifylinkedofferobjects(resourceId string, modifylinkedofferobjectsrequest *ModifyLinkedOfferObjectsRequest) *LoyaltyobjectModifylinkedofferobjectsCall {
14193 c := &LoyaltyobjectModifylinkedofferobjectsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14194 c.resourceId = resourceId
14195 c.modifylinkedofferobjectsrequest = modifylinkedofferobjectsrequest
14196 return c
14197 }
14198
14199
14200
14201
14202 func (c *LoyaltyobjectModifylinkedofferobjectsCall) Fields(s ...googleapi.Field) *LoyaltyobjectModifylinkedofferobjectsCall {
14203 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14204 return c
14205 }
14206
14207
14208 func (c *LoyaltyobjectModifylinkedofferobjectsCall) Context(ctx context.Context) *LoyaltyobjectModifylinkedofferobjectsCall {
14209 c.ctx_ = ctx
14210 return c
14211 }
14212
14213
14214
14215 func (c *LoyaltyobjectModifylinkedofferobjectsCall) Header() http.Header {
14216 if c.header_ == nil {
14217 c.header_ = make(http.Header)
14218 }
14219 return c.header_
14220 }
14221
14222 func (c *LoyaltyobjectModifylinkedofferobjectsCall) doRequest(alt string) (*http.Response, error) {
14223 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14224 var body io.Reader = nil
14225 body, err := googleapi.WithoutDataWrapper.JSONReader(c.modifylinkedofferobjectsrequest)
14226 if err != nil {
14227 return nil, err
14228 }
14229 c.urlParams_.Set("alt", alt)
14230 c.urlParams_.Set("prettyPrint", "false")
14231 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyObject/{resourceId}/modifyLinkedOfferObjects")
14232 urls += "?" + c.urlParams_.Encode()
14233 req, err := http.NewRequest("POST", urls, body)
14234 if err != nil {
14235 return nil, err
14236 }
14237 req.Header = reqHeaders
14238 googleapi.Expand(req.URL, map[string]string{
14239 "resourceId": c.resourceId,
14240 })
14241 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14242 }
14243
14244
14245
14246
14247
14248
14249 func (c *LoyaltyobjectModifylinkedofferobjectsCall) Do(opts ...googleapi.CallOption) (*LoyaltyObject, error) {
14250 gensupport.SetOptions(c.urlParams_, opts...)
14251 res, err := c.doRequest("json")
14252 if res != nil && res.StatusCode == http.StatusNotModified {
14253 if res.Body != nil {
14254 res.Body.Close()
14255 }
14256 return nil, gensupport.WrapError(&googleapi.Error{
14257 Code: res.StatusCode,
14258 Header: res.Header,
14259 })
14260 }
14261 if err != nil {
14262 return nil, err
14263 }
14264 defer googleapi.CloseBody(res)
14265 if err := googleapi.CheckResponse(res); err != nil {
14266 return nil, gensupport.WrapError(err)
14267 }
14268 ret := &LoyaltyObject{
14269 ServerResponse: googleapi.ServerResponse{
14270 Header: res.Header,
14271 HTTPStatusCode: res.StatusCode,
14272 },
14273 }
14274 target := &ret
14275 if err := gensupport.DecodeResponse(target, res); err != nil {
14276 return nil, err
14277 }
14278 return ret, nil
14279 }
14280
14281 type LoyaltyobjectPatchCall struct {
14282 s *Service
14283 resourceId string
14284 loyaltyobject *LoyaltyObject
14285 urlParams_ gensupport.URLParams
14286 ctx_ context.Context
14287 header_ http.Header
14288 }
14289
14290
14291
14292
14293
14294
14295
14296
14297
14298 func (r *LoyaltyobjectService) Patch(resourceId string, loyaltyobject *LoyaltyObject) *LoyaltyobjectPatchCall {
14299 c := &LoyaltyobjectPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14300 c.resourceId = resourceId
14301 c.loyaltyobject = loyaltyobject
14302 return c
14303 }
14304
14305
14306
14307
14308 func (c *LoyaltyobjectPatchCall) Fields(s ...googleapi.Field) *LoyaltyobjectPatchCall {
14309 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14310 return c
14311 }
14312
14313
14314 func (c *LoyaltyobjectPatchCall) Context(ctx context.Context) *LoyaltyobjectPatchCall {
14315 c.ctx_ = ctx
14316 return c
14317 }
14318
14319
14320
14321 func (c *LoyaltyobjectPatchCall) Header() http.Header {
14322 if c.header_ == nil {
14323 c.header_ = make(http.Header)
14324 }
14325 return c.header_
14326 }
14327
14328 func (c *LoyaltyobjectPatchCall) doRequest(alt string) (*http.Response, error) {
14329 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14330 var body io.Reader = nil
14331 body, err := googleapi.WithoutDataWrapper.JSONReader(c.loyaltyobject)
14332 if err != nil {
14333 return nil, err
14334 }
14335 c.urlParams_.Set("alt", alt)
14336 c.urlParams_.Set("prettyPrint", "false")
14337 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyObject/{resourceId}")
14338 urls += "?" + c.urlParams_.Encode()
14339 req, err := http.NewRequest("PATCH", urls, body)
14340 if err != nil {
14341 return nil, err
14342 }
14343 req.Header = reqHeaders
14344 googleapi.Expand(req.URL, map[string]string{
14345 "resourceId": c.resourceId,
14346 })
14347 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14348 }
14349
14350
14351
14352
14353
14354
14355 func (c *LoyaltyobjectPatchCall) Do(opts ...googleapi.CallOption) (*LoyaltyObject, error) {
14356 gensupport.SetOptions(c.urlParams_, opts...)
14357 res, err := c.doRequest("json")
14358 if res != nil && res.StatusCode == http.StatusNotModified {
14359 if res.Body != nil {
14360 res.Body.Close()
14361 }
14362 return nil, gensupport.WrapError(&googleapi.Error{
14363 Code: res.StatusCode,
14364 Header: res.Header,
14365 })
14366 }
14367 if err != nil {
14368 return nil, err
14369 }
14370 defer googleapi.CloseBody(res)
14371 if err := googleapi.CheckResponse(res); err != nil {
14372 return nil, gensupport.WrapError(err)
14373 }
14374 ret := &LoyaltyObject{
14375 ServerResponse: googleapi.ServerResponse{
14376 Header: res.Header,
14377 HTTPStatusCode: res.StatusCode,
14378 },
14379 }
14380 target := &ret
14381 if err := gensupport.DecodeResponse(target, res); err != nil {
14382 return nil, err
14383 }
14384 return ret, nil
14385 }
14386
14387 type LoyaltyobjectUpdateCall struct {
14388 s *Service
14389 resourceId string
14390 loyaltyobject *LoyaltyObject
14391 urlParams_ gensupport.URLParams
14392 ctx_ context.Context
14393 header_ http.Header
14394 }
14395
14396
14397
14398
14399
14400
14401
14402
14403 func (r *LoyaltyobjectService) Update(resourceId string, loyaltyobject *LoyaltyObject) *LoyaltyobjectUpdateCall {
14404 c := &LoyaltyobjectUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14405 c.resourceId = resourceId
14406 c.loyaltyobject = loyaltyobject
14407 return c
14408 }
14409
14410
14411
14412
14413 func (c *LoyaltyobjectUpdateCall) Fields(s ...googleapi.Field) *LoyaltyobjectUpdateCall {
14414 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14415 return c
14416 }
14417
14418
14419 func (c *LoyaltyobjectUpdateCall) Context(ctx context.Context) *LoyaltyobjectUpdateCall {
14420 c.ctx_ = ctx
14421 return c
14422 }
14423
14424
14425
14426 func (c *LoyaltyobjectUpdateCall) Header() http.Header {
14427 if c.header_ == nil {
14428 c.header_ = make(http.Header)
14429 }
14430 return c.header_
14431 }
14432
14433 func (c *LoyaltyobjectUpdateCall) doRequest(alt string) (*http.Response, error) {
14434 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14435 var body io.Reader = nil
14436 body, err := googleapi.WithoutDataWrapper.JSONReader(c.loyaltyobject)
14437 if err != nil {
14438 return nil, err
14439 }
14440 c.urlParams_.Set("alt", alt)
14441 c.urlParams_.Set("prettyPrint", "false")
14442 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/loyaltyObject/{resourceId}")
14443 urls += "?" + c.urlParams_.Encode()
14444 req, err := http.NewRequest("PUT", urls, body)
14445 if err != nil {
14446 return nil, err
14447 }
14448 req.Header = reqHeaders
14449 googleapi.Expand(req.URL, map[string]string{
14450 "resourceId": c.resourceId,
14451 })
14452 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14453 }
14454
14455
14456
14457
14458
14459
14460 func (c *LoyaltyobjectUpdateCall) Do(opts ...googleapi.CallOption) (*LoyaltyObject, error) {
14461 gensupport.SetOptions(c.urlParams_, opts...)
14462 res, err := c.doRequest("json")
14463 if res != nil && res.StatusCode == http.StatusNotModified {
14464 if res.Body != nil {
14465 res.Body.Close()
14466 }
14467 return nil, gensupport.WrapError(&googleapi.Error{
14468 Code: res.StatusCode,
14469 Header: res.Header,
14470 })
14471 }
14472 if err != nil {
14473 return nil, err
14474 }
14475 defer googleapi.CloseBody(res)
14476 if err := googleapi.CheckResponse(res); err != nil {
14477 return nil, gensupport.WrapError(err)
14478 }
14479 ret := &LoyaltyObject{
14480 ServerResponse: googleapi.ServerResponse{
14481 Header: res.Header,
14482 HTTPStatusCode: res.StatusCode,
14483 },
14484 }
14485 target := &ret
14486 if err := gensupport.DecodeResponse(target, res); err != nil {
14487 return nil, err
14488 }
14489 return ret, nil
14490 }
14491
14492 type MediaDownloadCall struct {
14493 s *Service
14494 resourceId string
14495 urlParams_ gensupport.URLParams
14496 ifNoneMatch_ string
14497 ctx_ context.Context
14498 header_ http.Header
14499 }
14500
14501
14502
14503
14504
14505
14506
14507
14508
14509 func (r *MediaService) Download(resourceId string) *MediaDownloadCall {
14510 c := &MediaDownloadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14511 c.resourceId = resourceId
14512 return c
14513 }
14514
14515
14516
14517
14518 func (c *MediaDownloadCall) Fields(s ...googleapi.Field) *MediaDownloadCall {
14519 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14520 return c
14521 }
14522
14523
14524
14525
14526 func (c *MediaDownloadCall) IfNoneMatch(entityTag string) *MediaDownloadCall {
14527 c.ifNoneMatch_ = entityTag
14528 return c
14529 }
14530
14531
14532 func (c *MediaDownloadCall) Context(ctx context.Context) *MediaDownloadCall {
14533 c.ctx_ = ctx
14534 return c
14535 }
14536
14537
14538
14539 func (c *MediaDownloadCall) Header() http.Header {
14540 if c.header_ == nil {
14541 c.header_ = make(http.Header)
14542 }
14543 return c.header_
14544 }
14545
14546 func (c *MediaDownloadCall) doRequest(alt string) (*http.Response, error) {
14547 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14548 if c.ifNoneMatch_ != "" {
14549 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14550 }
14551 var body io.Reader = nil
14552 c.urlParams_.Set("alt", alt)
14553 c.urlParams_.Set("prettyPrint", "false")
14554 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitObject/{resourceId}/downloadRotatingBarcodeValues")
14555 urls += "?" + c.urlParams_.Encode()
14556 req, err := http.NewRequest("GET", urls, body)
14557 if err != nil {
14558 return nil, err
14559 }
14560 req.Header = reqHeaders
14561 googleapi.Expand(req.URL, map[string]string{
14562 "resourceId": c.resourceId,
14563 })
14564 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14565 }
14566
14567
14568
14569
14570 func (c *MediaDownloadCall) Download(opts ...googleapi.CallOption) (*http.Response, error) {
14571 gensupport.SetOptions(c.urlParams_, opts...)
14572 res, err := c.doRequest("media")
14573 if err != nil {
14574 return nil, err
14575 }
14576 if err := googleapi.CheckResponse(res); err != nil {
14577 res.Body.Close()
14578 return nil, gensupport.WrapError(err)
14579 }
14580 return res, nil
14581 }
14582
14583
14584
14585
14586
14587
14588 func (c *MediaDownloadCall) Do(opts ...googleapi.CallOption) (*Media, error) {
14589 gensupport.SetOptions(c.urlParams_, opts...)
14590 res, err := c.doRequest("json")
14591 if res != nil && res.StatusCode == http.StatusNotModified {
14592 if res.Body != nil {
14593 res.Body.Close()
14594 }
14595 return nil, gensupport.WrapError(&googleapi.Error{
14596 Code: res.StatusCode,
14597 Header: res.Header,
14598 })
14599 }
14600 if err != nil {
14601 return nil, err
14602 }
14603 defer googleapi.CloseBody(res)
14604 if err := googleapi.CheckResponse(res); err != nil {
14605 return nil, gensupport.WrapError(err)
14606 }
14607 ret := &Media{
14608 ServerResponse: googleapi.ServerResponse{
14609 Header: res.Header,
14610 HTTPStatusCode: res.StatusCode,
14611 },
14612 }
14613 target := &ret
14614 if err := gensupport.DecodeResponse(target, res); err != nil {
14615 return nil, err
14616 }
14617 return ret, nil
14618 }
14619
14620 type MediaUploadCall struct {
14621 s *Service
14622 resourceId string
14623 transitobjectuploadrotatingbarcodevaluesrequest *TransitObjectUploadRotatingBarcodeValuesRequest
14624 urlParams_ gensupport.URLParams
14625 mediaInfo_ *gensupport.MediaInfo
14626 ctx_ context.Context
14627 header_ http.Header
14628 }
14629
14630
14631
14632
14633
14634
14635
14636
14637
14638
14639
14640 func (r *MediaService) Upload(resourceId string, transitobjectuploadrotatingbarcodevaluesrequest *TransitObjectUploadRotatingBarcodeValuesRequest) *MediaUploadCall {
14641 c := &MediaUploadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14642 c.resourceId = resourceId
14643 c.transitobjectuploadrotatingbarcodevaluesrequest = transitobjectuploadrotatingbarcodevaluesrequest
14644 return c
14645 }
14646
14647
14648
14649
14650
14651
14652
14653
14654 func (c *MediaUploadCall) Media(r io.Reader, options ...googleapi.MediaOption) *MediaUploadCall {
14655 c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
14656 return c
14657 }
14658
14659
14660
14661
14662
14663
14664
14665
14666
14667
14668 func (c *MediaUploadCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *MediaUploadCall {
14669 c.ctx_ = ctx
14670 c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
14671 return c
14672 }
14673
14674
14675
14676
14677
14678 func (c *MediaUploadCall) ProgressUpdater(pu googleapi.ProgressUpdater) *MediaUploadCall {
14679 c.mediaInfo_.SetProgressUpdater(pu)
14680 return c
14681 }
14682
14683
14684
14685
14686 func (c *MediaUploadCall) Fields(s ...googleapi.Field) *MediaUploadCall {
14687 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14688 return c
14689 }
14690
14691
14692
14693
14694 func (c *MediaUploadCall) Context(ctx context.Context) *MediaUploadCall {
14695 c.ctx_ = ctx
14696 return c
14697 }
14698
14699
14700
14701 func (c *MediaUploadCall) Header() http.Header {
14702 if c.header_ == nil {
14703 c.header_ = make(http.Header)
14704 }
14705 return c.header_
14706 }
14707
14708 func (c *MediaUploadCall) doRequest(alt string) (*http.Response, error) {
14709 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14710 var body io.Reader = nil
14711 body, err := googleapi.WithoutDataWrapper.JSONReader(c.transitobjectuploadrotatingbarcodevaluesrequest)
14712 if err != nil {
14713 return nil, err
14714 }
14715 c.urlParams_.Set("alt", alt)
14716 c.urlParams_.Set("prettyPrint", "false")
14717 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitObject/{resourceId}/uploadRotatingBarcodeValues")
14718 if c.mediaInfo_ != nil {
14719 urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/walletobjects/v1/transitObject/{resourceId}/uploadRotatingBarcodeValues")
14720 c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
14721 }
14722 if body == nil {
14723 body = new(bytes.Buffer)
14724 reqHeaders.Set("Content-Type", "application/json")
14725 }
14726 body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
14727 defer cleanup()
14728 urls += "?" + c.urlParams_.Encode()
14729 req, err := http.NewRequest("POST", urls, body)
14730 if err != nil {
14731 return nil, err
14732 }
14733 req.Header = reqHeaders
14734 req.GetBody = getBody
14735 googleapi.Expand(req.URL, map[string]string{
14736 "resourceId": c.resourceId,
14737 })
14738 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14739 }
14740
14741
14742
14743
14744
14745
14746
14747 func (c *MediaUploadCall) Do(opts ...googleapi.CallOption) (*TransitObjectUploadRotatingBarcodeValuesResponse, error) {
14748 gensupport.SetOptions(c.urlParams_, opts...)
14749 res, err := c.doRequest("json")
14750 if res != nil && res.StatusCode == http.StatusNotModified {
14751 if res.Body != nil {
14752 res.Body.Close()
14753 }
14754 return nil, gensupport.WrapError(&googleapi.Error{
14755 Code: res.StatusCode,
14756 Header: res.Header,
14757 })
14758 }
14759 if err != nil {
14760 return nil, err
14761 }
14762 defer googleapi.CloseBody(res)
14763 if err := googleapi.CheckResponse(res); err != nil {
14764 return nil, gensupport.WrapError(err)
14765 }
14766 rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
14767 if rx != nil {
14768 rx.Client = c.s.client
14769 rx.UserAgent = c.s.userAgent()
14770 ctx := c.ctx_
14771 if ctx == nil {
14772 ctx = context.TODO()
14773 }
14774 res, err = rx.Upload(ctx)
14775 if err != nil {
14776 return nil, err
14777 }
14778 defer res.Body.Close()
14779 if err := googleapi.CheckResponse(res); err != nil {
14780 return nil, gensupport.WrapError(err)
14781 }
14782 }
14783 ret := &TransitObjectUploadRotatingBarcodeValuesResponse{
14784 ServerResponse: googleapi.ServerResponse{
14785 Header: res.Header,
14786 HTTPStatusCode: res.StatusCode,
14787 },
14788 }
14789 target := &ret
14790 if err := gensupport.DecodeResponse(target, res); err != nil {
14791 return nil, err
14792 }
14793 return ret, nil
14794 }
14795
14796 type OfferclassAddmessageCall struct {
14797 s *Service
14798 resourceId string
14799 addmessagerequest *AddMessageRequest
14800 urlParams_ gensupport.URLParams
14801 ctx_ context.Context
14802 header_ http.Header
14803 }
14804
14805
14806
14807
14808
14809
14810
14811
14812
14813 func (r *OfferclassService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *OfferclassAddmessageCall {
14814 c := &OfferclassAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14815 c.resourceId = resourceId
14816 c.addmessagerequest = addmessagerequest
14817 return c
14818 }
14819
14820
14821
14822
14823 func (c *OfferclassAddmessageCall) Fields(s ...googleapi.Field) *OfferclassAddmessageCall {
14824 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14825 return c
14826 }
14827
14828
14829 func (c *OfferclassAddmessageCall) Context(ctx context.Context) *OfferclassAddmessageCall {
14830 c.ctx_ = ctx
14831 return c
14832 }
14833
14834
14835
14836 func (c *OfferclassAddmessageCall) Header() http.Header {
14837 if c.header_ == nil {
14838 c.header_ = make(http.Header)
14839 }
14840 return c.header_
14841 }
14842
14843 func (c *OfferclassAddmessageCall) doRequest(alt string) (*http.Response, error) {
14844 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14845 var body io.Reader = nil
14846 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
14847 if err != nil {
14848 return nil, err
14849 }
14850 c.urlParams_.Set("alt", alt)
14851 c.urlParams_.Set("prettyPrint", "false")
14852 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerClass/{resourceId}/addMessage")
14853 urls += "?" + c.urlParams_.Encode()
14854 req, err := http.NewRequest("POST", urls, body)
14855 if err != nil {
14856 return nil, err
14857 }
14858 req.Header = reqHeaders
14859 googleapi.Expand(req.URL, map[string]string{
14860 "resourceId": c.resourceId,
14861 })
14862 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14863 }
14864
14865
14866
14867
14868
14869
14870
14871 func (c *OfferclassAddmessageCall) Do(opts ...googleapi.CallOption) (*OfferClassAddMessageResponse, error) {
14872 gensupport.SetOptions(c.urlParams_, opts...)
14873 res, err := c.doRequest("json")
14874 if res != nil && res.StatusCode == http.StatusNotModified {
14875 if res.Body != nil {
14876 res.Body.Close()
14877 }
14878 return nil, gensupport.WrapError(&googleapi.Error{
14879 Code: res.StatusCode,
14880 Header: res.Header,
14881 })
14882 }
14883 if err != nil {
14884 return nil, err
14885 }
14886 defer googleapi.CloseBody(res)
14887 if err := googleapi.CheckResponse(res); err != nil {
14888 return nil, gensupport.WrapError(err)
14889 }
14890 ret := &OfferClassAddMessageResponse{
14891 ServerResponse: googleapi.ServerResponse{
14892 Header: res.Header,
14893 HTTPStatusCode: res.StatusCode,
14894 },
14895 }
14896 target := &ret
14897 if err := gensupport.DecodeResponse(target, res); err != nil {
14898 return nil, err
14899 }
14900 return ret, nil
14901 }
14902
14903 type OfferclassGetCall struct {
14904 s *Service
14905 resourceId string
14906 urlParams_ gensupport.URLParams
14907 ifNoneMatch_ string
14908 ctx_ context.Context
14909 header_ http.Header
14910 }
14911
14912
14913
14914
14915
14916
14917
14918
14919 func (r *OfferclassService) Get(resourceId string) *OfferclassGetCall {
14920 c := &OfferclassGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14921 c.resourceId = resourceId
14922 return c
14923 }
14924
14925
14926
14927
14928 func (c *OfferclassGetCall) Fields(s ...googleapi.Field) *OfferclassGetCall {
14929 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14930 return c
14931 }
14932
14933
14934
14935
14936 func (c *OfferclassGetCall) IfNoneMatch(entityTag string) *OfferclassGetCall {
14937 c.ifNoneMatch_ = entityTag
14938 return c
14939 }
14940
14941
14942 func (c *OfferclassGetCall) Context(ctx context.Context) *OfferclassGetCall {
14943 c.ctx_ = ctx
14944 return c
14945 }
14946
14947
14948
14949 func (c *OfferclassGetCall) Header() http.Header {
14950 if c.header_ == nil {
14951 c.header_ = make(http.Header)
14952 }
14953 return c.header_
14954 }
14955
14956 func (c *OfferclassGetCall) doRequest(alt string) (*http.Response, error) {
14957 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14958 if c.ifNoneMatch_ != "" {
14959 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14960 }
14961 var body io.Reader = nil
14962 c.urlParams_.Set("alt", alt)
14963 c.urlParams_.Set("prettyPrint", "false")
14964 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerClass/{resourceId}")
14965 urls += "?" + c.urlParams_.Encode()
14966 req, err := http.NewRequest("GET", urls, body)
14967 if err != nil {
14968 return nil, err
14969 }
14970 req.Header = reqHeaders
14971 googleapi.Expand(req.URL, map[string]string{
14972 "resourceId": c.resourceId,
14973 })
14974 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14975 }
14976
14977
14978
14979
14980
14981
14982 func (c *OfferclassGetCall) Do(opts ...googleapi.CallOption) (*OfferClass, error) {
14983 gensupport.SetOptions(c.urlParams_, opts...)
14984 res, err := c.doRequest("json")
14985 if res != nil && res.StatusCode == http.StatusNotModified {
14986 if res.Body != nil {
14987 res.Body.Close()
14988 }
14989 return nil, gensupport.WrapError(&googleapi.Error{
14990 Code: res.StatusCode,
14991 Header: res.Header,
14992 })
14993 }
14994 if err != nil {
14995 return nil, err
14996 }
14997 defer googleapi.CloseBody(res)
14998 if err := googleapi.CheckResponse(res); err != nil {
14999 return nil, gensupport.WrapError(err)
15000 }
15001 ret := &OfferClass{
15002 ServerResponse: googleapi.ServerResponse{
15003 Header: res.Header,
15004 HTTPStatusCode: res.StatusCode,
15005 },
15006 }
15007 target := &ret
15008 if err := gensupport.DecodeResponse(target, res); err != nil {
15009 return nil, err
15010 }
15011 return ret, nil
15012 }
15013
15014 type OfferclassInsertCall struct {
15015 s *Service
15016 offerclass *OfferClass
15017 urlParams_ gensupport.URLParams
15018 ctx_ context.Context
15019 header_ http.Header
15020 }
15021
15022
15023 func (r *OfferclassService) Insert(offerclass *OfferClass) *OfferclassInsertCall {
15024 c := &OfferclassInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15025 c.offerclass = offerclass
15026 return c
15027 }
15028
15029
15030
15031
15032 func (c *OfferclassInsertCall) Fields(s ...googleapi.Field) *OfferclassInsertCall {
15033 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15034 return c
15035 }
15036
15037
15038 func (c *OfferclassInsertCall) Context(ctx context.Context) *OfferclassInsertCall {
15039 c.ctx_ = ctx
15040 return c
15041 }
15042
15043
15044
15045 func (c *OfferclassInsertCall) Header() http.Header {
15046 if c.header_ == nil {
15047 c.header_ = make(http.Header)
15048 }
15049 return c.header_
15050 }
15051
15052 func (c *OfferclassInsertCall) doRequest(alt string) (*http.Response, error) {
15053 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15054 var body io.Reader = nil
15055 body, err := googleapi.WithoutDataWrapper.JSONReader(c.offerclass)
15056 if err != nil {
15057 return nil, err
15058 }
15059 c.urlParams_.Set("alt", alt)
15060 c.urlParams_.Set("prettyPrint", "false")
15061 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerClass")
15062 urls += "?" + c.urlParams_.Encode()
15063 req, err := http.NewRequest("POST", urls, body)
15064 if err != nil {
15065 return nil, err
15066 }
15067 req.Header = reqHeaders
15068 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15069 }
15070
15071
15072
15073
15074
15075
15076 func (c *OfferclassInsertCall) Do(opts ...googleapi.CallOption) (*OfferClass, error) {
15077 gensupport.SetOptions(c.urlParams_, opts...)
15078 res, err := c.doRequest("json")
15079 if res != nil && res.StatusCode == http.StatusNotModified {
15080 if res.Body != nil {
15081 res.Body.Close()
15082 }
15083 return nil, gensupport.WrapError(&googleapi.Error{
15084 Code: res.StatusCode,
15085 Header: res.Header,
15086 })
15087 }
15088 if err != nil {
15089 return nil, err
15090 }
15091 defer googleapi.CloseBody(res)
15092 if err := googleapi.CheckResponse(res); err != nil {
15093 return nil, gensupport.WrapError(err)
15094 }
15095 ret := &OfferClass{
15096 ServerResponse: googleapi.ServerResponse{
15097 Header: res.Header,
15098 HTTPStatusCode: res.StatusCode,
15099 },
15100 }
15101 target := &ret
15102 if err := gensupport.DecodeResponse(target, res); err != nil {
15103 return nil, err
15104 }
15105 return ret, nil
15106 }
15107
15108 type OfferclassListCall struct {
15109 s *Service
15110 urlParams_ gensupport.URLParams
15111 ifNoneMatch_ string
15112 ctx_ context.Context
15113 header_ http.Header
15114 }
15115
15116
15117 func (r *OfferclassService) List() *OfferclassListCall {
15118 c := &OfferclassListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15119 return c
15120 }
15121
15122
15123
15124 func (c *OfferclassListCall) IssuerId(issuerId int64) *OfferclassListCall {
15125 c.urlParams_.Set("issuerId", fmt.Sprint(issuerId))
15126 return c
15127 }
15128
15129
15130
15131
15132 func (c *OfferclassListCall) MaxResults(maxResults int64) *OfferclassListCall {
15133 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
15134 return c
15135 }
15136
15137
15138
15139
15140
15141
15142
15143 func (c *OfferclassListCall) Token(token string) *OfferclassListCall {
15144 c.urlParams_.Set("token", token)
15145 return c
15146 }
15147
15148
15149
15150
15151 func (c *OfferclassListCall) Fields(s ...googleapi.Field) *OfferclassListCall {
15152 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15153 return c
15154 }
15155
15156
15157
15158
15159 func (c *OfferclassListCall) IfNoneMatch(entityTag string) *OfferclassListCall {
15160 c.ifNoneMatch_ = entityTag
15161 return c
15162 }
15163
15164
15165 func (c *OfferclassListCall) Context(ctx context.Context) *OfferclassListCall {
15166 c.ctx_ = ctx
15167 return c
15168 }
15169
15170
15171
15172 func (c *OfferclassListCall) Header() http.Header {
15173 if c.header_ == nil {
15174 c.header_ = make(http.Header)
15175 }
15176 return c.header_
15177 }
15178
15179 func (c *OfferclassListCall) doRequest(alt string) (*http.Response, error) {
15180 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15181 if c.ifNoneMatch_ != "" {
15182 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15183 }
15184 var body io.Reader = nil
15185 c.urlParams_.Set("alt", alt)
15186 c.urlParams_.Set("prettyPrint", "false")
15187 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerClass")
15188 urls += "?" + c.urlParams_.Encode()
15189 req, err := http.NewRequest("GET", urls, body)
15190 if err != nil {
15191 return nil, err
15192 }
15193 req.Header = reqHeaders
15194 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15195 }
15196
15197
15198
15199
15200
15201
15202
15203 func (c *OfferclassListCall) Do(opts ...googleapi.CallOption) (*OfferClassListResponse, error) {
15204 gensupport.SetOptions(c.urlParams_, opts...)
15205 res, err := c.doRequest("json")
15206 if res != nil && res.StatusCode == http.StatusNotModified {
15207 if res.Body != nil {
15208 res.Body.Close()
15209 }
15210 return nil, gensupport.WrapError(&googleapi.Error{
15211 Code: res.StatusCode,
15212 Header: res.Header,
15213 })
15214 }
15215 if err != nil {
15216 return nil, err
15217 }
15218 defer googleapi.CloseBody(res)
15219 if err := googleapi.CheckResponse(res); err != nil {
15220 return nil, gensupport.WrapError(err)
15221 }
15222 ret := &OfferClassListResponse{
15223 ServerResponse: googleapi.ServerResponse{
15224 Header: res.Header,
15225 HTTPStatusCode: res.StatusCode,
15226 },
15227 }
15228 target := &ret
15229 if err := gensupport.DecodeResponse(target, res); err != nil {
15230 return nil, err
15231 }
15232 return ret, nil
15233 }
15234
15235 type OfferclassPatchCall struct {
15236 s *Service
15237 resourceId string
15238 offerclass *OfferClass
15239 urlParams_ gensupport.URLParams
15240 ctx_ context.Context
15241 header_ http.Header
15242 }
15243
15244
15245
15246
15247
15248
15249
15250
15251
15252 func (r *OfferclassService) Patch(resourceId string, offerclass *OfferClass) *OfferclassPatchCall {
15253 c := &OfferclassPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15254 c.resourceId = resourceId
15255 c.offerclass = offerclass
15256 return c
15257 }
15258
15259
15260
15261
15262 func (c *OfferclassPatchCall) Fields(s ...googleapi.Field) *OfferclassPatchCall {
15263 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15264 return c
15265 }
15266
15267
15268 func (c *OfferclassPatchCall) Context(ctx context.Context) *OfferclassPatchCall {
15269 c.ctx_ = ctx
15270 return c
15271 }
15272
15273
15274
15275 func (c *OfferclassPatchCall) Header() http.Header {
15276 if c.header_ == nil {
15277 c.header_ = make(http.Header)
15278 }
15279 return c.header_
15280 }
15281
15282 func (c *OfferclassPatchCall) doRequest(alt string) (*http.Response, error) {
15283 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15284 var body io.Reader = nil
15285 body, err := googleapi.WithoutDataWrapper.JSONReader(c.offerclass)
15286 if err != nil {
15287 return nil, err
15288 }
15289 c.urlParams_.Set("alt", alt)
15290 c.urlParams_.Set("prettyPrint", "false")
15291 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerClass/{resourceId}")
15292 urls += "?" + c.urlParams_.Encode()
15293 req, err := http.NewRequest("PATCH", urls, body)
15294 if err != nil {
15295 return nil, err
15296 }
15297 req.Header = reqHeaders
15298 googleapi.Expand(req.URL, map[string]string{
15299 "resourceId": c.resourceId,
15300 })
15301 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15302 }
15303
15304
15305
15306
15307
15308
15309 func (c *OfferclassPatchCall) Do(opts ...googleapi.CallOption) (*OfferClass, error) {
15310 gensupport.SetOptions(c.urlParams_, opts...)
15311 res, err := c.doRequest("json")
15312 if res != nil && res.StatusCode == http.StatusNotModified {
15313 if res.Body != nil {
15314 res.Body.Close()
15315 }
15316 return nil, gensupport.WrapError(&googleapi.Error{
15317 Code: res.StatusCode,
15318 Header: res.Header,
15319 })
15320 }
15321 if err != nil {
15322 return nil, err
15323 }
15324 defer googleapi.CloseBody(res)
15325 if err := googleapi.CheckResponse(res); err != nil {
15326 return nil, gensupport.WrapError(err)
15327 }
15328 ret := &OfferClass{
15329 ServerResponse: googleapi.ServerResponse{
15330 Header: res.Header,
15331 HTTPStatusCode: res.StatusCode,
15332 },
15333 }
15334 target := &ret
15335 if err := gensupport.DecodeResponse(target, res); err != nil {
15336 return nil, err
15337 }
15338 return ret, nil
15339 }
15340
15341 type OfferclassUpdateCall struct {
15342 s *Service
15343 resourceId string
15344 offerclass *OfferClass
15345 urlParams_ gensupport.URLParams
15346 ctx_ context.Context
15347 header_ http.Header
15348 }
15349
15350
15351
15352
15353
15354
15355
15356
15357 func (r *OfferclassService) Update(resourceId string, offerclass *OfferClass) *OfferclassUpdateCall {
15358 c := &OfferclassUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15359 c.resourceId = resourceId
15360 c.offerclass = offerclass
15361 return c
15362 }
15363
15364
15365
15366
15367 func (c *OfferclassUpdateCall) Fields(s ...googleapi.Field) *OfferclassUpdateCall {
15368 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15369 return c
15370 }
15371
15372
15373 func (c *OfferclassUpdateCall) Context(ctx context.Context) *OfferclassUpdateCall {
15374 c.ctx_ = ctx
15375 return c
15376 }
15377
15378
15379
15380 func (c *OfferclassUpdateCall) Header() http.Header {
15381 if c.header_ == nil {
15382 c.header_ = make(http.Header)
15383 }
15384 return c.header_
15385 }
15386
15387 func (c *OfferclassUpdateCall) doRequest(alt string) (*http.Response, error) {
15388 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15389 var body io.Reader = nil
15390 body, err := googleapi.WithoutDataWrapper.JSONReader(c.offerclass)
15391 if err != nil {
15392 return nil, err
15393 }
15394 c.urlParams_.Set("alt", alt)
15395 c.urlParams_.Set("prettyPrint", "false")
15396 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerClass/{resourceId}")
15397 urls += "?" + c.urlParams_.Encode()
15398 req, err := http.NewRequest("PUT", urls, body)
15399 if err != nil {
15400 return nil, err
15401 }
15402 req.Header = reqHeaders
15403 googleapi.Expand(req.URL, map[string]string{
15404 "resourceId": c.resourceId,
15405 })
15406 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15407 }
15408
15409
15410
15411
15412
15413
15414 func (c *OfferclassUpdateCall) Do(opts ...googleapi.CallOption) (*OfferClass, error) {
15415 gensupport.SetOptions(c.urlParams_, opts...)
15416 res, err := c.doRequest("json")
15417 if res != nil && res.StatusCode == http.StatusNotModified {
15418 if res.Body != nil {
15419 res.Body.Close()
15420 }
15421 return nil, gensupport.WrapError(&googleapi.Error{
15422 Code: res.StatusCode,
15423 Header: res.Header,
15424 })
15425 }
15426 if err != nil {
15427 return nil, err
15428 }
15429 defer googleapi.CloseBody(res)
15430 if err := googleapi.CheckResponse(res); err != nil {
15431 return nil, gensupport.WrapError(err)
15432 }
15433 ret := &OfferClass{
15434 ServerResponse: googleapi.ServerResponse{
15435 Header: res.Header,
15436 HTTPStatusCode: res.StatusCode,
15437 },
15438 }
15439 target := &ret
15440 if err := gensupport.DecodeResponse(target, res); err != nil {
15441 return nil, err
15442 }
15443 return ret, nil
15444 }
15445
15446 type OfferobjectAddmessageCall struct {
15447 s *Service
15448 resourceId string
15449 addmessagerequest *AddMessageRequest
15450 urlParams_ gensupport.URLParams
15451 ctx_ context.Context
15452 header_ http.Header
15453 }
15454
15455
15456
15457
15458
15459
15460
15461
15462
15463 func (r *OfferobjectService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *OfferobjectAddmessageCall {
15464 c := &OfferobjectAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15465 c.resourceId = resourceId
15466 c.addmessagerequest = addmessagerequest
15467 return c
15468 }
15469
15470
15471
15472
15473 func (c *OfferobjectAddmessageCall) Fields(s ...googleapi.Field) *OfferobjectAddmessageCall {
15474 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15475 return c
15476 }
15477
15478
15479 func (c *OfferobjectAddmessageCall) Context(ctx context.Context) *OfferobjectAddmessageCall {
15480 c.ctx_ = ctx
15481 return c
15482 }
15483
15484
15485
15486 func (c *OfferobjectAddmessageCall) Header() http.Header {
15487 if c.header_ == nil {
15488 c.header_ = make(http.Header)
15489 }
15490 return c.header_
15491 }
15492
15493 func (c *OfferobjectAddmessageCall) doRequest(alt string) (*http.Response, error) {
15494 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15495 var body io.Reader = nil
15496 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
15497 if err != nil {
15498 return nil, err
15499 }
15500 c.urlParams_.Set("alt", alt)
15501 c.urlParams_.Set("prettyPrint", "false")
15502 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerObject/{resourceId}/addMessage")
15503 urls += "?" + c.urlParams_.Encode()
15504 req, err := http.NewRequest("POST", urls, body)
15505 if err != nil {
15506 return nil, err
15507 }
15508 req.Header = reqHeaders
15509 googleapi.Expand(req.URL, map[string]string{
15510 "resourceId": c.resourceId,
15511 })
15512 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15513 }
15514
15515
15516
15517
15518
15519
15520
15521 func (c *OfferobjectAddmessageCall) Do(opts ...googleapi.CallOption) (*OfferObjectAddMessageResponse, error) {
15522 gensupport.SetOptions(c.urlParams_, opts...)
15523 res, err := c.doRequest("json")
15524 if res != nil && res.StatusCode == http.StatusNotModified {
15525 if res.Body != nil {
15526 res.Body.Close()
15527 }
15528 return nil, gensupport.WrapError(&googleapi.Error{
15529 Code: res.StatusCode,
15530 Header: res.Header,
15531 })
15532 }
15533 if err != nil {
15534 return nil, err
15535 }
15536 defer googleapi.CloseBody(res)
15537 if err := googleapi.CheckResponse(res); err != nil {
15538 return nil, gensupport.WrapError(err)
15539 }
15540 ret := &OfferObjectAddMessageResponse{
15541 ServerResponse: googleapi.ServerResponse{
15542 Header: res.Header,
15543 HTTPStatusCode: res.StatusCode,
15544 },
15545 }
15546 target := &ret
15547 if err := gensupport.DecodeResponse(target, res); err != nil {
15548 return nil, err
15549 }
15550 return ret, nil
15551 }
15552
15553 type OfferobjectGetCall struct {
15554 s *Service
15555 resourceId string
15556 urlParams_ gensupport.URLParams
15557 ifNoneMatch_ string
15558 ctx_ context.Context
15559 header_ http.Header
15560 }
15561
15562
15563
15564
15565
15566
15567
15568
15569 func (r *OfferobjectService) Get(resourceId string) *OfferobjectGetCall {
15570 c := &OfferobjectGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15571 c.resourceId = resourceId
15572 return c
15573 }
15574
15575
15576
15577
15578 func (c *OfferobjectGetCall) Fields(s ...googleapi.Field) *OfferobjectGetCall {
15579 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15580 return c
15581 }
15582
15583
15584
15585
15586 func (c *OfferobjectGetCall) IfNoneMatch(entityTag string) *OfferobjectGetCall {
15587 c.ifNoneMatch_ = entityTag
15588 return c
15589 }
15590
15591
15592 func (c *OfferobjectGetCall) Context(ctx context.Context) *OfferobjectGetCall {
15593 c.ctx_ = ctx
15594 return c
15595 }
15596
15597
15598
15599 func (c *OfferobjectGetCall) Header() http.Header {
15600 if c.header_ == nil {
15601 c.header_ = make(http.Header)
15602 }
15603 return c.header_
15604 }
15605
15606 func (c *OfferobjectGetCall) doRequest(alt string) (*http.Response, error) {
15607 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15608 if c.ifNoneMatch_ != "" {
15609 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15610 }
15611 var body io.Reader = nil
15612 c.urlParams_.Set("alt", alt)
15613 c.urlParams_.Set("prettyPrint", "false")
15614 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerObject/{resourceId}")
15615 urls += "?" + c.urlParams_.Encode()
15616 req, err := http.NewRequest("GET", urls, body)
15617 if err != nil {
15618 return nil, err
15619 }
15620 req.Header = reqHeaders
15621 googleapi.Expand(req.URL, map[string]string{
15622 "resourceId": c.resourceId,
15623 })
15624 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15625 }
15626
15627
15628
15629
15630
15631
15632 func (c *OfferobjectGetCall) Do(opts ...googleapi.CallOption) (*OfferObject, error) {
15633 gensupport.SetOptions(c.urlParams_, opts...)
15634 res, err := c.doRequest("json")
15635 if res != nil && res.StatusCode == http.StatusNotModified {
15636 if res.Body != nil {
15637 res.Body.Close()
15638 }
15639 return nil, gensupport.WrapError(&googleapi.Error{
15640 Code: res.StatusCode,
15641 Header: res.Header,
15642 })
15643 }
15644 if err != nil {
15645 return nil, err
15646 }
15647 defer googleapi.CloseBody(res)
15648 if err := googleapi.CheckResponse(res); err != nil {
15649 return nil, gensupport.WrapError(err)
15650 }
15651 ret := &OfferObject{
15652 ServerResponse: googleapi.ServerResponse{
15653 Header: res.Header,
15654 HTTPStatusCode: res.StatusCode,
15655 },
15656 }
15657 target := &ret
15658 if err := gensupport.DecodeResponse(target, res); err != nil {
15659 return nil, err
15660 }
15661 return ret, nil
15662 }
15663
15664 type OfferobjectInsertCall struct {
15665 s *Service
15666 offerobject *OfferObject
15667 urlParams_ gensupport.URLParams
15668 ctx_ context.Context
15669 header_ http.Header
15670 }
15671
15672
15673 func (r *OfferobjectService) Insert(offerobject *OfferObject) *OfferobjectInsertCall {
15674 c := &OfferobjectInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15675 c.offerobject = offerobject
15676 return c
15677 }
15678
15679
15680
15681
15682 func (c *OfferobjectInsertCall) Fields(s ...googleapi.Field) *OfferobjectInsertCall {
15683 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15684 return c
15685 }
15686
15687
15688 func (c *OfferobjectInsertCall) Context(ctx context.Context) *OfferobjectInsertCall {
15689 c.ctx_ = ctx
15690 return c
15691 }
15692
15693
15694
15695 func (c *OfferobjectInsertCall) Header() http.Header {
15696 if c.header_ == nil {
15697 c.header_ = make(http.Header)
15698 }
15699 return c.header_
15700 }
15701
15702 func (c *OfferobjectInsertCall) doRequest(alt string) (*http.Response, error) {
15703 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15704 var body io.Reader = nil
15705 body, err := googleapi.WithoutDataWrapper.JSONReader(c.offerobject)
15706 if err != nil {
15707 return nil, err
15708 }
15709 c.urlParams_.Set("alt", alt)
15710 c.urlParams_.Set("prettyPrint", "false")
15711 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerObject")
15712 urls += "?" + c.urlParams_.Encode()
15713 req, err := http.NewRequest("POST", urls, body)
15714 if err != nil {
15715 return nil, err
15716 }
15717 req.Header = reqHeaders
15718 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15719 }
15720
15721
15722
15723
15724
15725
15726 func (c *OfferobjectInsertCall) Do(opts ...googleapi.CallOption) (*OfferObject, error) {
15727 gensupport.SetOptions(c.urlParams_, opts...)
15728 res, err := c.doRequest("json")
15729 if res != nil && res.StatusCode == http.StatusNotModified {
15730 if res.Body != nil {
15731 res.Body.Close()
15732 }
15733 return nil, gensupport.WrapError(&googleapi.Error{
15734 Code: res.StatusCode,
15735 Header: res.Header,
15736 })
15737 }
15738 if err != nil {
15739 return nil, err
15740 }
15741 defer googleapi.CloseBody(res)
15742 if err := googleapi.CheckResponse(res); err != nil {
15743 return nil, gensupport.WrapError(err)
15744 }
15745 ret := &OfferObject{
15746 ServerResponse: googleapi.ServerResponse{
15747 Header: res.Header,
15748 HTTPStatusCode: res.StatusCode,
15749 },
15750 }
15751 target := &ret
15752 if err := gensupport.DecodeResponse(target, res); err != nil {
15753 return nil, err
15754 }
15755 return ret, nil
15756 }
15757
15758 type OfferobjectListCall struct {
15759 s *Service
15760 urlParams_ gensupport.URLParams
15761 ifNoneMatch_ string
15762 ctx_ context.Context
15763 header_ http.Header
15764 }
15765
15766
15767 func (r *OfferobjectService) List() *OfferobjectListCall {
15768 c := &OfferobjectListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15769 return c
15770 }
15771
15772
15773
15774 func (c *OfferobjectListCall) ClassId(classId string) *OfferobjectListCall {
15775 c.urlParams_.Set("classId", classId)
15776 return c
15777 }
15778
15779
15780
15781
15782 func (c *OfferobjectListCall) MaxResults(maxResults int64) *OfferobjectListCall {
15783 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
15784 return c
15785 }
15786
15787
15788
15789
15790
15791
15792
15793 func (c *OfferobjectListCall) Token(token string) *OfferobjectListCall {
15794 c.urlParams_.Set("token", token)
15795 return c
15796 }
15797
15798
15799
15800
15801 func (c *OfferobjectListCall) Fields(s ...googleapi.Field) *OfferobjectListCall {
15802 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15803 return c
15804 }
15805
15806
15807
15808
15809 func (c *OfferobjectListCall) IfNoneMatch(entityTag string) *OfferobjectListCall {
15810 c.ifNoneMatch_ = entityTag
15811 return c
15812 }
15813
15814
15815 func (c *OfferobjectListCall) Context(ctx context.Context) *OfferobjectListCall {
15816 c.ctx_ = ctx
15817 return c
15818 }
15819
15820
15821
15822 func (c *OfferobjectListCall) Header() http.Header {
15823 if c.header_ == nil {
15824 c.header_ = make(http.Header)
15825 }
15826 return c.header_
15827 }
15828
15829 func (c *OfferobjectListCall) doRequest(alt string) (*http.Response, error) {
15830 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15831 if c.ifNoneMatch_ != "" {
15832 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15833 }
15834 var body io.Reader = nil
15835 c.urlParams_.Set("alt", alt)
15836 c.urlParams_.Set("prettyPrint", "false")
15837 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerObject")
15838 urls += "?" + c.urlParams_.Encode()
15839 req, err := http.NewRequest("GET", urls, body)
15840 if err != nil {
15841 return nil, err
15842 }
15843 req.Header = reqHeaders
15844 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15845 }
15846
15847
15848
15849
15850
15851
15852
15853 func (c *OfferobjectListCall) Do(opts ...googleapi.CallOption) (*OfferObjectListResponse, error) {
15854 gensupport.SetOptions(c.urlParams_, opts...)
15855 res, err := c.doRequest("json")
15856 if res != nil && res.StatusCode == http.StatusNotModified {
15857 if res.Body != nil {
15858 res.Body.Close()
15859 }
15860 return nil, gensupport.WrapError(&googleapi.Error{
15861 Code: res.StatusCode,
15862 Header: res.Header,
15863 })
15864 }
15865 if err != nil {
15866 return nil, err
15867 }
15868 defer googleapi.CloseBody(res)
15869 if err := googleapi.CheckResponse(res); err != nil {
15870 return nil, gensupport.WrapError(err)
15871 }
15872 ret := &OfferObjectListResponse{
15873 ServerResponse: googleapi.ServerResponse{
15874 Header: res.Header,
15875 HTTPStatusCode: res.StatusCode,
15876 },
15877 }
15878 target := &ret
15879 if err := gensupport.DecodeResponse(target, res); err != nil {
15880 return nil, err
15881 }
15882 return ret, nil
15883 }
15884
15885 type OfferobjectPatchCall struct {
15886 s *Service
15887 resourceId string
15888 offerobject *OfferObject
15889 urlParams_ gensupport.URLParams
15890 ctx_ context.Context
15891 header_ http.Header
15892 }
15893
15894
15895
15896
15897
15898
15899
15900
15901
15902 func (r *OfferobjectService) Patch(resourceId string, offerobject *OfferObject) *OfferobjectPatchCall {
15903 c := &OfferobjectPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15904 c.resourceId = resourceId
15905 c.offerobject = offerobject
15906 return c
15907 }
15908
15909
15910
15911
15912 func (c *OfferobjectPatchCall) Fields(s ...googleapi.Field) *OfferobjectPatchCall {
15913 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15914 return c
15915 }
15916
15917
15918 func (c *OfferobjectPatchCall) Context(ctx context.Context) *OfferobjectPatchCall {
15919 c.ctx_ = ctx
15920 return c
15921 }
15922
15923
15924
15925 func (c *OfferobjectPatchCall) Header() http.Header {
15926 if c.header_ == nil {
15927 c.header_ = make(http.Header)
15928 }
15929 return c.header_
15930 }
15931
15932 func (c *OfferobjectPatchCall) doRequest(alt string) (*http.Response, error) {
15933 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15934 var body io.Reader = nil
15935 body, err := googleapi.WithoutDataWrapper.JSONReader(c.offerobject)
15936 if err != nil {
15937 return nil, err
15938 }
15939 c.urlParams_.Set("alt", alt)
15940 c.urlParams_.Set("prettyPrint", "false")
15941 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerObject/{resourceId}")
15942 urls += "?" + c.urlParams_.Encode()
15943 req, err := http.NewRequest("PATCH", urls, body)
15944 if err != nil {
15945 return nil, err
15946 }
15947 req.Header = reqHeaders
15948 googleapi.Expand(req.URL, map[string]string{
15949 "resourceId": c.resourceId,
15950 })
15951 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15952 }
15953
15954
15955
15956
15957
15958
15959 func (c *OfferobjectPatchCall) Do(opts ...googleapi.CallOption) (*OfferObject, error) {
15960 gensupport.SetOptions(c.urlParams_, opts...)
15961 res, err := c.doRequest("json")
15962 if res != nil && res.StatusCode == http.StatusNotModified {
15963 if res.Body != nil {
15964 res.Body.Close()
15965 }
15966 return nil, gensupport.WrapError(&googleapi.Error{
15967 Code: res.StatusCode,
15968 Header: res.Header,
15969 })
15970 }
15971 if err != nil {
15972 return nil, err
15973 }
15974 defer googleapi.CloseBody(res)
15975 if err := googleapi.CheckResponse(res); err != nil {
15976 return nil, gensupport.WrapError(err)
15977 }
15978 ret := &OfferObject{
15979 ServerResponse: googleapi.ServerResponse{
15980 Header: res.Header,
15981 HTTPStatusCode: res.StatusCode,
15982 },
15983 }
15984 target := &ret
15985 if err := gensupport.DecodeResponse(target, res); err != nil {
15986 return nil, err
15987 }
15988 return ret, nil
15989 }
15990
15991 type OfferobjectUpdateCall struct {
15992 s *Service
15993 resourceId string
15994 offerobject *OfferObject
15995 urlParams_ gensupport.URLParams
15996 ctx_ context.Context
15997 header_ http.Header
15998 }
15999
16000
16001
16002
16003
16004
16005
16006
16007 func (r *OfferobjectService) Update(resourceId string, offerobject *OfferObject) *OfferobjectUpdateCall {
16008 c := &OfferobjectUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16009 c.resourceId = resourceId
16010 c.offerobject = offerobject
16011 return c
16012 }
16013
16014
16015
16016
16017 func (c *OfferobjectUpdateCall) Fields(s ...googleapi.Field) *OfferobjectUpdateCall {
16018 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16019 return c
16020 }
16021
16022
16023 func (c *OfferobjectUpdateCall) Context(ctx context.Context) *OfferobjectUpdateCall {
16024 c.ctx_ = ctx
16025 return c
16026 }
16027
16028
16029
16030 func (c *OfferobjectUpdateCall) Header() http.Header {
16031 if c.header_ == nil {
16032 c.header_ = make(http.Header)
16033 }
16034 return c.header_
16035 }
16036
16037 func (c *OfferobjectUpdateCall) doRequest(alt string) (*http.Response, error) {
16038 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16039 var body io.Reader = nil
16040 body, err := googleapi.WithoutDataWrapper.JSONReader(c.offerobject)
16041 if err != nil {
16042 return nil, err
16043 }
16044 c.urlParams_.Set("alt", alt)
16045 c.urlParams_.Set("prettyPrint", "false")
16046 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/offerObject/{resourceId}")
16047 urls += "?" + c.urlParams_.Encode()
16048 req, err := http.NewRequest("PUT", urls, body)
16049 if err != nil {
16050 return nil, err
16051 }
16052 req.Header = reqHeaders
16053 googleapi.Expand(req.URL, map[string]string{
16054 "resourceId": c.resourceId,
16055 })
16056 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16057 }
16058
16059
16060
16061
16062
16063
16064 func (c *OfferobjectUpdateCall) Do(opts ...googleapi.CallOption) (*OfferObject, error) {
16065 gensupport.SetOptions(c.urlParams_, opts...)
16066 res, err := c.doRequest("json")
16067 if res != nil && res.StatusCode == http.StatusNotModified {
16068 if res.Body != nil {
16069 res.Body.Close()
16070 }
16071 return nil, gensupport.WrapError(&googleapi.Error{
16072 Code: res.StatusCode,
16073 Header: res.Header,
16074 })
16075 }
16076 if err != nil {
16077 return nil, err
16078 }
16079 defer googleapi.CloseBody(res)
16080 if err := googleapi.CheckResponse(res); err != nil {
16081 return nil, gensupport.WrapError(err)
16082 }
16083 ret := &OfferObject{
16084 ServerResponse: googleapi.ServerResponse{
16085 Header: res.Header,
16086 HTTPStatusCode: res.StatusCode,
16087 },
16088 }
16089 target := &ret
16090 if err := gensupport.DecodeResponse(target, res); err != nil {
16091 return nil, err
16092 }
16093 return ret, nil
16094 }
16095
16096 type PermissionsGetCall struct {
16097 s *Service
16098 resourceId int64
16099 urlParams_ gensupport.URLParams
16100 ifNoneMatch_ string
16101 ctx_ context.Context
16102 header_ http.Header
16103 }
16104
16105
16106
16107
16108
16109 func (r *PermissionsService) Get(resourceId int64) *PermissionsGetCall {
16110 c := &PermissionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16111 c.resourceId = resourceId
16112 return c
16113 }
16114
16115
16116
16117
16118 func (c *PermissionsGetCall) Fields(s ...googleapi.Field) *PermissionsGetCall {
16119 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16120 return c
16121 }
16122
16123
16124
16125
16126 func (c *PermissionsGetCall) IfNoneMatch(entityTag string) *PermissionsGetCall {
16127 c.ifNoneMatch_ = entityTag
16128 return c
16129 }
16130
16131
16132 func (c *PermissionsGetCall) Context(ctx context.Context) *PermissionsGetCall {
16133 c.ctx_ = ctx
16134 return c
16135 }
16136
16137
16138
16139 func (c *PermissionsGetCall) Header() http.Header {
16140 if c.header_ == nil {
16141 c.header_ = make(http.Header)
16142 }
16143 return c.header_
16144 }
16145
16146 func (c *PermissionsGetCall) doRequest(alt string) (*http.Response, error) {
16147 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16148 if c.ifNoneMatch_ != "" {
16149 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16150 }
16151 var body io.Reader = nil
16152 c.urlParams_.Set("alt", alt)
16153 c.urlParams_.Set("prettyPrint", "false")
16154 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/permissions/{resourceId}")
16155 urls += "?" + c.urlParams_.Encode()
16156 req, err := http.NewRequest("GET", urls, body)
16157 if err != nil {
16158 return nil, err
16159 }
16160 req.Header = reqHeaders
16161 googleapi.Expand(req.URL, map[string]string{
16162 "resourceId": strconv.FormatInt(c.resourceId, 10),
16163 })
16164 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16165 }
16166
16167
16168
16169
16170
16171
16172 func (c *PermissionsGetCall) Do(opts ...googleapi.CallOption) (*Permissions, error) {
16173 gensupport.SetOptions(c.urlParams_, opts...)
16174 res, err := c.doRequest("json")
16175 if res != nil && res.StatusCode == http.StatusNotModified {
16176 if res.Body != nil {
16177 res.Body.Close()
16178 }
16179 return nil, gensupport.WrapError(&googleapi.Error{
16180 Code: res.StatusCode,
16181 Header: res.Header,
16182 })
16183 }
16184 if err != nil {
16185 return nil, err
16186 }
16187 defer googleapi.CloseBody(res)
16188 if err := googleapi.CheckResponse(res); err != nil {
16189 return nil, gensupport.WrapError(err)
16190 }
16191 ret := &Permissions{
16192 ServerResponse: googleapi.ServerResponse{
16193 Header: res.Header,
16194 HTTPStatusCode: res.StatusCode,
16195 },
16196 }
16197 target := &ret
16198 if err := gensupport.DecodeResponse(target, res); err != nil {
16199 return nil, err
16200 }
16201 return ret, nil
16202 }
16203
16204 type PermissionsUpdateCall struct {
16205 s *Service
16206 resourceId int64
16207 permissions *Permissions
16208 urlParams_ gensupport.URLParams
16209 ctx_ context.Context
16210 header_ http.Header
16211 }
16212
16213
16214
16215
16216
16217 func (r *PermissionsService) Update(resourceId int64, permissions *Permissions) *PermissionsUpdateCall {
16218 c := &PermissionsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16219 c.resourceId = resourceId
16220 c.permissions = permissions
16221 return c
16222 }
16223
16224
16225
16226
16227 func (c *PermissionsUpdateCall) Fields(s ...googleapi.Field) *PermissionsUpdateCall {
16228 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16229 return c
16230 }
16231
16232
16233 func (c *PermissionsUpdateCall) Context(ctx context.Context) *PermissionsUpdateCall {
16234 c.ctx_ = ctx
16235 return c
16236 }
16237
16238
16239
16240 func (c *PermissionsUpdateCall) Header() http.Header {
16241 if c.header_ == nil {
16242 c.header_ = make(http.Header)
16243 }
16244 return c.header_
16245 }
16246
16247 func (c *PermissionsUpdateCall) doRequest(alt string) (*http.Response, error) {
16248 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16249 var body io.Reader = nil
16250 body, err := googleapi.WithoutDataWrapper.JSONReader(c.permissions)
16251 if err != nil {
16252 return nil, err
16253 }
16254 c.urlParams_.Set("alt", alt)
16255 c.urlParams_.Set("prettyPrint", "false")
16256 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/permissions/{resourceId}")
16257 urls += "?" + c.urlParams_.Encode()
16258 req, err := http.NewRequest("PUT", urls, body)
16259 if err != nil {
16260 return nil, err
16261 }
16262 req.Header = reqHeaders
16263 googleapi.Expand(req.URL, map[string]string{
16264 "resourceId": strconv.FormatInt(c.resourceId, 10),
16265 })
16266 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16267 }
16268
16269
16270
16271
16272
16273
16274 func (c *PermissionsUpdateCall) Do(opts ...googleapi.CallOption) (*Permissions, error) {
16275 gensupport.SetOptions(c.urlParams_, opts...)
16276 res, err := c.doRequest("json")
16277 if res != nil && res.StatusCode == http.StatusNotModified {
16278 if res.Body != nil {
16279 res.Body.Close()
16280 }
16281 return nil, gensupport.WrapError(&googleapi.Error{
16282 Code: res.StatusCode,
16283 Header: res.Header,
16284 })
16285 }
16286 if err != nil {
16287 return nil, err
16288 }
16289 defer googleapi.CloseBody(res)
16290 if err := googleapi.CheckResponse(res); err != nil {
16291 return nil, gensupport.WrapError(err)
16292 }
16293 ret := &Permissions{
16294 ServerResponse: googleapi.ServerResponse{
16295 Header: res.Header,
16296 HTTPStatusCode: res.StatusCode,
16297 },
16298 }
16299 target := &ret
16300 if err := gensupport.DecodeResponse(target, res); err != nil {
16301 return nil, err
16302 }
16303 return ret, nil
16304 }
16305
16306 type SmarttapInsertCall struct {
16307 s *Service
16308 smarttap *SmartTap
16309 urlParams_ gensupport.URLParams
16310 ctx_ context.Context
16311 header_ http.Header
16312 }
16313
16314
16315 func (r *SmarttapService) Insert(smarttap *SmartTap) *SmarttapInsertCall {
16316 c := &SmarttapInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16317 c.smarttap = smarttap
16318 return c
16319 }
16320
16321
16322
16323
16324 func (c *SmarttapInsertCall) Fields(s ...googleapi.Field) *SmarttapInsertCall {
16325 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16326 return c
16327 }
16328
16329
16330 func (c *SmarttapInsertCall) Context(ctx context.Context) *SmarttapInsertCall {
16331 c.ctx_ = ctx
16332 return c
16333 }
16334
16335
16336
16337 func (c *SmarttapInsertCall) Header() http.Header {
16338 if c.header_ == nil {
16339 c.header_ = make(http.Header)
16340 }
16341 return c.header_
16342 }
16343
16344 func (c *SmarttapInsertCall) doRequest(alt string) (*http.Response, error) {
16345 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16346 var body io.Reader = nil
16347 body, err := googleapi.WithoutDataWrapper.JSONReader(c.smarttap)
16348 if err != nil {
16349 return nil, err
16350 }
16351 c.urlParams_.Set("alt", alt)
16352 c.urlParams_.Set("prettyPrint", "false")
16353 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/smartTap")
16354 urls += "?" + c.urlParams_.Encode()
16355 req, err := http.NewRequest("POST", urls, body)
16356 if err != nil {
16357 return nil, err
16358 }
16359 req.Header = reqHeaders
16360 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16361 }
16362
16363
16364
16365
16366
16367
16368 func (c *SmarttapInsertCall) Do(opts ...googleapi.CallOption) (*SmartTap, error) {
16369 gensupport.SetOptions(c.urlParams_, opts...)
16370 res, err := c.doRequest("json")
16371 if res != nil && res.StatusCode == http.StatusNotModified {
16372 if res.Body != nil {
16373 res.Body.Close()
16374 }
16375 return nil, gensupport.WrapError(&googleapi.Error{
16376 Code: res.StatusCode,
16377 Header: res.Header,
16378 })
16379 }
16380 if err != nil {
16381 return nil, err
16382 }
16383 defer googleapi.CloseBody(res)
16384 if err := googleapi.CheckResponse(res); err != nil {
16385 return nil, gensupport.WrapError(err)
16386 }
16387 ret := &SmartTap{
16388 ServerResponse: googleapi.ServerResponse{
16389 Header: res.Header,
16390 HTTPStatusCode: res.StatusCode,
16391 },
16392 }
16393 target := &ret
16394 if err := gensupport.DecodeResponse(target, res); err != nil {
16395 return nil, err
16396 }
16397 return ret, nil
16398 }
16399
16400 type TransitclassAddmessageCall struct {
16401 s *Service
16402 resourceId string
16403 addmessagerequest *AddMessageRequest
16404 urlParams_ gensupport.URLParams
16405 ctx_ context.Context
16406 header_ http.Header
16407 }
16408
16409
16410
16411
16412
16413
16414
16415
16416
16417 func (r *TransitclassService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *TransitclassAddmessageCall {
16418 c := &TransitclassAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16419 c.resourceId = resourceId
16420 c.addmessagerequest = addmessagerequest
16421 return c
16422 }
16423
16424
16425
16426
16427 func (c *TransitclassAddmessageCall) Fields(s ...googleapi.Field) *TransitclassAddmessageCall {
16428 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16429 return c
16430 }
16431
16432
16433 func (c *TransitclassAddmessageCall) Context(ctx context.Context) *TransitclassAddmessageCall {
16434 c.ctx_ = ctx
16435 return c
16436 }
16437
16438
16439
16440 func (c *TransitclassAddmessageCall) Header() http.Header {
16441 if c.header_ == nil {
16442 c.header_ = make(http.Header)
16443 }
16444 return c.header_
16445 }
16446
16447 func (c *TransitclassAddmessageCall) doRequest(alt string) (*http.Response, error) {
16448 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16449 var body io.Reader = nil
16450 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
16451 if err != nil {
16452 return nil, err
16453 }
16454 c.urlParams_.Set("alt", alt)
16455 c.urlParams_.Set("prettyPrint", "false")
16456 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitClass/{resourceId}/addMessage")
16457 urls += "?" + c.urlParams_.Encode()
16458 req, err := http.NewRequest("POST", urls, body)
16459 if err != nil {
16460 return nil, err
16461 }
16462 req.Header = reqHeaders
16463 googleapi.Expand(req.URL, map[string]string{
16464 "resourceId": c.resourceId,
16465 })
16466 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16467 }
16468
16469
16470
16471
16472
16473
16474
16475 func (c *TransitclassAddmessageCall) Do(opts ...googleapi.CallOption) (*TransitClassAddMessageResponse, error) {
16476 gensupport.SetOptions(c.urlParams_, opts...)
16477 res, err := c.doRequest("json")
16478 if res != nil && res.StatusCode == http.StatusNotModified {
16479 if res.Body != nil {
16480 res.Body.Close()
16481 }
16482 return nil, gensupport.WrapError(&googleapi.Error{
16483 Code: res.StatusCode,
16484 Header: res.Header,
16485 })
16486 }
16487 if err != nil {
16488 return nil, err
16489 }
16490 defer googleapi.CloseBody(res)
16491 if err := googleapi.CheckResponse(res); err != nil {
16492 return nil, gensupport.WrapError(err)
16493 }
16494 ret := &TransitClassAddMessageResponse{
16495 ServerResponse: googleapi.ServerResponse{
16496 Header: res.Header,
16497 HTTPStatusCode: res.StatusCode,
16498 },
16499 }
16500 target := &ret
16501 if err := gensupport.DecodeResponse(target, res); err != nil {
16502 return nil, err
16503 }
16504 return ret, nil
16505 }
16506
16507 type TransitclassGetCall struct {
16508 s *Service
16509 resourceId string
16510 urlParams_ gensupport.URLParams
16511 ifNoneMatch_ string
16512 ctx_ context.Context
16513 header_ http.Header
16514 }
16515
16516
16517
16518
16519
16520
16521
16522
16523 func (r *TransitclassService) Get(resourceId string) *TransitclassGetCall {
16524 c := &TransitclassGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16525 c.resourceId = resourceId
16526 return c
16527 }
16528
16529
16530
16531
16532 func (c *TransitclassGetCall) Fields(s ...googleapi.Field) *TransitclassGetCall {
16533 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16534 return c
16535 }
16536
16537
16538
16539
16540 func (c *TransitclassGetCall) IfNoneMatch(entityTag string) *TransitclassGetCall {
16541 c.ifNoneMatch_ = entityTag
16542 return c
16543 }
16544
16545
16546 func (c *TransitclassGetCall) Context(ctx context.Context) *TransitclassGetCall {
16547 c.ctx_ = ctx
16548 return c
16549 }
16550
16551
16552
16553 func (c *TransitclassGetCall) Header() http.Header {
16554 if c.header_ == nil {
16555 c.header_ = make(http.Header)
16556 }
16557 return c.header_
16558 }
16559
16560 func (c *TransitclassGetCall) doRequest(alt string) (*http.Response, error) {
16561 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16562 if c.ifNoneMatch_ != "" {
16563 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16564 }
16565 var body io.Reader = nil
16566 c.urlParams_.Set("alt", alt)
16567 c.urlParams_.Set("prettyPrint", "false")
16568 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitClass/{resourceId}")
16569 urls += "?" + c.urlParams_.Encode()
16570 req, err := http.NewRequest("GET", urls, body)
16571 if err != nil {
16572 return nil, err
16573 }
16574 req.Header = reqHeaders
16575 googleapi.Expand(req.URL, map[string]string{
16576 "resourceId": c.resourceId,
16577 })
16578 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16579 }
16580
16581
16582
16583
16584
16585
16586 func (c *TransitclassGetCall) Do(opts ...googleapi.CallOption) (*TransitClass, error) {
16587 gensupport.SetOptions(c.urlParams_, opts...)
16588 res, err := c.doRequest("json")
16589 if res != nil && res.StatusCode == http.StatusNotModified {
16590 if res.Body != nil {
16591 res.Body.Close()
16592 }
16593 return nil, gensupport.WrapError(&googleapi.Error{
16594 Code: res.StatusCode,
16595 Header: res.Header,
16596 })
16597 }
16598 if err != nil {
16599 return nil, err
16600 }
16601 defer googleapi.CloseBody(res)
16602 if err := googleapi.CheckResponse(res); err != nil {
16603 return nil, gensupport.WrapError(err)
16604 }
16605 ret := &TransitClass{
16606 ServerResponse: googleapi.ServerResponse{
16607 Header: res.Header,
16608 HTTPStatusCode: res.StatusCode,
16609 },
16610 }
16611 target := &ret
16612 if err := gensupport.DecodeResponse(target, res); err != nil {
16613 return nil, err
16614 }
16615 return ret, nil
16616 }
16617
16618 type TransitclassInsertCall struct {
16619 s *Service
16620 transitclass *TransitClass
16621 urlParams_ gensupport.URLParams
16622 ctx_ context.Context
16623 header_ http.Header
16624 }
16625
16626
16627 func (r *TransitclassService) Insert(transitclass *TransitClass) *TransitclassInsertCall {
16628 c := &TransitclassInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16629 c.transitclass = transitclass
16630 return c
16631 }
16632
16633
16634
16635
16636 func (c *TransitclassInsertCall) Fields(s ...googleapi.Field) *TransitclassInsertCall {
16637 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16638 return c
16639 }
16640
16641
16642 func (c *TransitclassInsertCall) Context(ctx context.Context) *TransitclassInsertCall {
16643 c.ctx_ = ctx
16644 return c
16645 }
16646
16647
16648
16649 func (c *TransitclassInsertCall) Header() http.Header {
16650 if c.header_ == nil {
16651 c.header_ = make(http.Header)
16652 }
16653 return c.header_
16654 }
16655
16656 func (c *TransitclassInsertCall) doRequest(alt string) (*http.Response, error) {
16657 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16658 var body io.Reader = nil
16659 body, err := googleapi.WithoutDataWrapper.JSONReader(c.transitclass)
16660 if err != nil {
16661 return nil, err
16662 }
16663 c.urlParams_.Set("alt", alt)
16664 c.urlParams_.Set("prettyPrint", "false")
16665 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitClass")
16666 urls += "?" + c.urlParams_.Encode()
16667 req, err := http.NewRequest("POST", urls, body)
16668 if err != nil {
16669 return nil, err
16670 }
16671 req.Header = reqHeaders
16672 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16673 }
16674
16675
16676
16677
16678
16679
16680 func (c *TransitclassInsertCall) Do(opts ...googleapi.CallOption) (*TransitClass, error) {
16681 gensupport.SetOptions(c.urlParams_, opts...)
16682 res, err := c.doRequest("json")
16683 if res != nil && res.StatusCode == http.StatusNotModified {
16684 if res.Body != nil {
16685 res.Body.Close()
16686 }
16687 return nil, gensupport.WrapError(&googleapi.Error{
16688 Code: res.StatusCode,
16689 Header: res.Header,
16690 })
16691 }
16692 if err != nil {
16693 return nil, err
16694 }
16695 defer googleapi.CloseBody(res)
16696 if err := googleapi.CheckResponse(res); err != nil {
16697 return nil, gensupport.WrapError(err)
16698 }
16699 ret := &TransitClass{
16700 ServerResponse: googleapi.ServerResponse{
16701 Header: res.Header,
16702 HTTPStatusCode: res.StatusCode,
16703 },
16704 }
16705 target := &ret
16706 if err := gensupport.DecodeResponse(target, res); err != nil {
16707 return nil, err
16708 }
16709 return ret, nil
16710 }
16711
16712 type TransitclassListCall struct {
16713 s *Service
16714 urlParams_ gensupport.URLParams
16715 ifNoneMatch_ string
16716 ctx_ context.Context
16717 header_ http.Header
16718 }
16719
16720
16721 func (r *TransitclassService) List() *TransitclassListCall {
16722 c := &TransitclassListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16723 return c
16724 }
16725
16726
16727
16728 func (c *TransitclassListCall) IssuerId(issuerId int64) *TransitclassListCall {
16729 c.urlParams_.Set("issuerId", fmt.Sprint(issuerId))
16730 return c
16731 }
16732
16733
16734
16735
16736 func (c *TransitclassListCall) MaxResults(maxResults int64) *TransitclassListCall {
16737 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
16738 return c
16739 }
16740
16741
16742
16743
16744
16745
16746
16747 func (c *TransitclassListCall) Token(token string) *TransitclassListCall {
16748 c.urlParams_.Set("token", token)
16749 return c
16750 }
16751
16752
16753
16754
16755 func (c *TransitclassListCall) Fields(s ...googleapi.Field) *TransitclassListCall {
16756 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16757 return c
16758 }
16759
16760
16761
16762
16763 func (c *TransitclassListCall) IfNoneMatch(entityTag string) *TransitclassListCall {
16764 c.ifNoneMatch_ = entityTag
16765 return c
16766 }
16767
16768
16769 func (c *TransitclassListCall) Context(ctx context.Context) *TransitclassListCall {
16770 c.ctx_ = ctx
16771 return c
16772 }
16773
16774
16775
16776 func (c *TransitclassListCall) Header() http.Header {
16777 if c.header_ == nil {
16778 c.header_ = make(http.Header)
16779 }
16780 return c.header_
16781 }
16782
16783 func (c *TransitclassListCall) doRequest(alt string) (*http.Response, error) {
16784 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16785 if c.ifNoneMatch_ != "" {
16786 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16787 }
16788 var body io.Reader = nil
16789 c.urlParams_.Set("alt", alt)
16790 c.urlParams_.Set("prettyPrint", "false")
16791 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitClass")
16792 urls += "?" + c.urlParams_.Encode()
16793 req, err := http.NewRequest("GET", urls, body)
16794 if err != nil {
16795 return nil, err
16796 }
16797 req.Header = reqHeaders
16798 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16799 }
16800
16801
16802
16803
16804
16805
16806
16807 func (c *TransitclassListCall) Do(opts ...googleapi.CallOption) (*TransitClassListResponse, error) {
16808 gensupport.SetOptions(c.urlParams_, opts...)
16809 res, err := c.doRequest("json")
16810 if res != nil && res.StatusCode == http.StatusNotModified {
16811 if res.Body != nil {
16812 res.Body.Close()
16813 }
16814 return nil, gensupport.WrapError(&googleapi.Error{
16815 Code: res.StatusCode,
16816 Header: res.Header,
16817 })
16818 }
16819 if err != nil {
16820 return nil, err
16821 }
16822 defer googleapi.CloseBody(res)
16823 if err := googleapi.CheckResponse(res); err != nil {
16824 return nil, gensupport.WrapError(err)
16825 }
16826 ret := &TransitClassListResponse{
16827 ServerResponse: googleapi.ServerResponse{
16828 Header: res.Header,
16829 HTTPStatusCode: res.StatusCode,
16830 },
16831 }
16832 target := &ret
16833 if err := gensupport.DecodeResponse(target, res); err != nil {
16834 return nil, err
16835 }
16836 return ret, nil
16837 }
16838
16839 type TransitclassPatchCall struct {
16840 s *Service
16841 resourceId string
16842 transitclass *TransitClass
16843 urlParams_ gensupport.URLParams
16844 ctx_ context.Context
16845 header_ http.Header
16846 }
16847
16848
16849
16850
16851
16852
16853
16854
16855
16856 func (r *TransitclassService) Patch(resourceId string, transitclass *TransitClass) *TransitclassPatchCall {
16857 c := &TransitclassPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16858 c.resourceId = resourceId
16859 c.transitclass = transitclass
16860 return c
16861 }
16862
16863
16864
16865
16866 func (c *TransitclassPatchCall) Fields(s ...googleapi.Field) *TransitclassPatchCall {
16867 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16868 return c
16869 }
16870
16871
16872 func (c *TransitclassPatchCall) Context(ctx context.Context) *TransitclassPatchCall {
16873 c.ctx_ = ctx
16874 return c
16875 }
16876
16877
16878
16879 func (c *TransitclassPatchCall) Header() http.Header {
16880 if c.header_ == nil {
16881 c.header_ = make(http.Header)
16882 }
16883 return c.header_
16884 }
16885
16886 func (c *TransitclassPatchCall) doRequest(alt string) (*http.Response, error) {
16887 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16888 var body io.Reader = nil
16889 body, err := googleapi.WithoutDataWrapper.JSONReader(c.transitclass)
16890 if err != nil {
16891 return nil, err
16892 }
16893 c.urlParams_.Set("alt", alt)
16894 c.urlParams_.Set("prettyPrint", "false")
16895 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitClass/{resourceId}")
16896 urls += "?" + c.urlParams_.Encode()
16897 req, err := http.NewRequest("PATCH", urls, body)
16898 if err != nil {
16899 return nil, err
16900 }
16901 req.Header = reqHeaders
16902 googleapi.Expand(req.URL, map[string]string{
16903 "resourceId": c.resourceId,
16904 })
16905 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16906 }
16907
16908
16909
16910
16911
16912
16913 func (c *TransitclassPatchCall) Do(opts ...googleapi.CallOption) (*TransitClass, error) {
16914 gensupport.SetOptions(c.urlParams_, opts...)
16915 res, err := c.doRequest("json")
16916 if res != nil && res.StatusCode == http.StatusNotModified {
16917 if res.Body != nil {
16918 res.Body.Close()
16919 }
16920 return nil, gensupport.WrapError(&googleapi.Error{
16921 Code: res.StatusCode,
16922 Header: res.Header,
16923 })
16924 }
16925 if err != nil {
16926 return nil, err
16927 }
16928 defer googleapi.CloseBody(res)
16929 if err := googleapi.CheckResponse(res); err != nil {
16930 return nil, gensupport.WrapError(err)
16931 }
16932 ret := &TransitClass{
16933 ServerResponse: googleapi.ServerResponse{
16934 Header: res.Header,
16935 HTTPStatusCode: res.StatusCode,
16936 },
16937 }
16938 target := &ret
16939 if err := gensupport.DecodeResponse(target, res); err != nil {
16940 return nil, err
16941 }
16942 return ret, nil
16943 }
16944
16945 type TransitclassUpdateCall struct {
16946 s *Service
16947 resourceId string
16948 transitclass *TransitClass
16949 urlParams_ gensupport.URLParams
16950 ctx_ context.Context
16951 header_ http.Header
16952 }
16953
16954
16955
16956
16957
16958
16959
16960
16961 func (r *TransitclassService) Update(resourceId string, transitclass *TransitClass) *TransitclassUpdateCall {
16962 c := &TransitclassUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16963 c.resourceId = resourceId
16964 c.transitclass = transitclass
16965 return c
16966 }
16967
16968
16969
16970
16971 func (c *TransitclassUpdateCall) Fields(s ...googleapi.Field) *TransitclassUpdateCall {
16972 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16973 return c
16974 }
16975
16976
16977 func (c *TransitclassUpdateCall) Context(ctx context.Context) *TransitclassUpdateCall {
16978 c.ctx_ = ctx
16979 return c
16980 }
16981
16982
16983
16984 func (c *TransitclassUpdateCall) Header() http.Header {
16985 if c.header_ == nil {
16986 c.header_ = make(http.Header)
16987 }
16988 return c.header_
16989 }
16990
16991 func (c *TransitclassUpdateCall) doRequest(alt string) (*http.Response, error) {
16992 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16993 var body io.Reader = nil
16994 body, err := googleapi.WithoutDataWrapper.JSONReader(c.transitclass)
16995 if err != nil {
16996 return nil, err
16997 }
16998 c.urlParams_.Set("alt", alt)
16999 c.urlParams_.Set("prettyPrint", "false")
17000 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitClass/{resourceId}")
17001 urls += "?" + c.urlParams_.Encode()
17002 req, err := http.NewRequest("PUT", urls, body)
17003 if err != nil {
17004 return nil, err
17005 }
17006 req.Header = reqHeaders
17007 googleapi.Expand(req.URL, map[string]string{
17008 "resourceId": c.resourceId,
17009 })
17010 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17011 }
17012
17013
17014
17015
17016
17017
17018 func (c *TransitclassUpdateCall) Do(opts ...googleapi.CallOption) (*TransitClass, error) {
17019 gensupport.SetOptions(c.urlParams_, opts...)
17020 res, err := c.doRequest("json")
17021 if res != nil && res.StatusCode == http.StatusNotModified {
17022 if res.Body != nil {
17023 res.Body.Close()
17024 }
17025 return nil, gensupport.WrapError(&googleapi.Error{
17026 Code: res.StatusCode,
17027 Header: res.Header,
17028 })
17029 }
17030 if err != nil {
17031 return nil, err
17032 }
17033 defer googleapi.CloseBody(res)
17034 if err := googleapi.CheckResponse(res); err != nil {
17035 return nil, gensupport.WrapError(err)
17036 }
17037 ret := &TransitClass{
17038 ServerResponse: googleapi.ServerResponse{
17039 Header: res.Header,
17040 HTTPStatusCode: res.StatusCode,
17041 },
17042 }
17043 target := &ret
17044 if err := gensupport.DecodeResponse(target, res); err != nil {
17045 return nil, err
17046 }
17047 return ret, nil
17048 }
17049
17050 type TransitobjectAddmessageCall struct {
17051 s *Service
17052 resourceId string
17053 addmessagerequest *AddMessageRequest
17054 urlParams_ gensupport.URLParams
17055 ctx_ context.Context
17056 header_ http.Header
17057 }
17058
17059
17060
17061
17062
17063
17064
17065
17066
17067 func (r *TransitobjectService) Addmessage(resourceId string, addmessagerequest *AddMessageRequest) *TransitobjectAddmessageCall {
17068 c := &TransitobjectAddmessageCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17069 c.resourceId = resourceId
17070 c.addmessagerequest = addmessagerequest
17071 return c
17072 }
17073
17074
17075
17076
17077 func (c *TransitobjectAddmessageCall) Fields(s ...googleapi.Field) *TransitobjectAddmessageCall {
17078 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17079 return c
17080 }
17081
17082
17083 func (c *TransitobjectAddmessageCall) Context(ctx context.Context) *TransitobjectAddmessageCall {
17084 c.ctx_ = ctx
17085 return c
17086 }
17087
17088
17089
17090 func (c *TransitobjectAddmessageCall) Header() http.Header {
17091 if c.header_ == nil {
17092 c.header_ = make(http.Header)
17093 }
17094 return c.header_
17095 }
17096
17097 func (c *TransitobjectAddmessageCall) doRequest(alt string) (*http.Response, error) {
17098 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17099 var body io.Reader = nil
17100 body, err := googleapi.WithoutDataWrapper.JSONReader(c.addmessagerequest)
17101 if err != nil {
17102 return nil, err
17103 }
17104 c.urlParams_.Set("alt", alt)
17105 c.urlParams_.Set("prettyPrint", "false")
17106 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitObject/{resourceId}/addMessage")
17107 urls += "?" + c.urlParams_.Encode()
17108 req, err := http.NewRequest("POST", urls, body)
17109 if err != nil {
17110 return nil, err
17111 }
17112 req.Header = reqHeaders
17113 googleapi.Expand(req.URL, map[string]string{
17114 "resourceId": c.resourceId,
17115 })
17116 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17117 }
17118
17119
17120
17121
17122
17123
17124
17125 func (c *TransitobjectAddmessageCall) Do(opts ...googleapi.CallOption) (*TransitObjectAddMessageResponse, error) {
17126 gensupport.SetOptions(c.urlParams_, opts...)
17127 res, err := c.doRequest("json")
17128 if res != nil && res.StatusCode == http.StatusNotModified {
17129 if res.Body != nil {
17130 res.Body.Close()
17131 }
17132 return nil, gensupport.WrapError(&googleapi.Error{
17133 Code: res.StatusCode,
17134 Header: res.Header,
17135 })
17136 }
17137 if err != nil {
17138 return nil, err
17139 }
17140 defer googleapi.CloseBody(res)
17141 if err := googleapi.CheckResponse(res); err != nil {
17142 return nil, gensupport.WrapError(err)
17143 }
17144 ret := &TransitObjectAddMessageResponse{
17145 ServerResponse: googleapi.ServerResponse{
17146 Header: res.Header,
17147 HTTPStatusCode: res.StatusCode,
17148 },
17149 }
17150 target := &ret
17151 if err := gensupport.DecodeResponse(target, res); err != nil {
17152 return nil, err
17153 }
17154 return ret, nil
17155 }
17156
17157 type TransitobjectGetCall struct {
17158 s *Service
17159 resourceId string
17160 urlParams_ gensupport.URLParams
17161 ifNoneMatch_ string
17162 ctx_ context.Context
17163 header_ http.Header
17164 }
17165
17166
17167
17168
17169
17170
17171
17172
17173 func (r *TransitobjectService) Get(resourceId string) *TransitobjectGetCall {
17174 c := &TransitobjectGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17175 c.resourceId = resourceId
17176 return c
17177 }
17178
17179
17180
17181
17182 func (c *TransitobjectGetCall) Fields(s ...googleapi.Field) *TransitobjectGetCall {
17183 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17184 return c
17185 }
17186
17187
17188
17189
17190 func (c *TransitobjectGetCall) IfNoneMatch(entityTag string) *TransitobjectGetCall {
17191 c.ifNoneMatch_ = entityTag
17192 return c
17193 }
17194
17195
17196 func (c *TransitobjectGetCall) Context(ctx context.Context) *TransitobjectGetCall {
17197 c.ctx_ = ctx
17198 return c
17199 }
17200
17201
17202
17203 func (c *TransitobjectGetCall) Header() http.Header {
17204 if c.header_ == nil {
17205 c.header_ = make(http.Header)
17206 }
17207 return c.header_
17208 }
17209
17210 func (c *TransitobjectGetCall) doRequest(alt string) (*http.Response, error) {
17211 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17212 if c.ifNoneMatch_ != "" {
17213 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17214 }
17215 var body io.Reader = nil
17216 c.urlParams_.Set("alt", alt)
17217 c.urlParams_.Set("prettyPrint", "false")
17218 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitObject/{resourceId}")
17219 urls += "?" + c.urlParams_.Encode()
17220 req, err := http.NewRequest("GET", urls, body)
17221 if err != nil {
17222 return nil, err
17223 }
17224 req.Header = reqHeaders
17225 googleapi.Expand(req.URL, map[string]string{
17226 "resourceId": c.resourceId,
17227 })
17228 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17229 }
17230
17231
17232
17233
17234
17235
17236 func (c *TransitobjectGetCall) Do(opts ...googleapi.CallOption) (*TransitObject, error) {
17237 gensupport.SetOptions(c.urlParams_, opts...)
17238 res, err := c.doRequest("json")
17239 if res != nil && res.StatusCode == http.StatusNotModified {
17240 if res.Body != nil {
17241 res.Body.Close()
17242 }
17243 return nil, gensupport.WrapError(&googleapi.Error{
17244 Code: res.StatusCode,
17245 Header: res.Header,
17246 })
17247 }
17248 if err != nil {
17249 return nil, err
17250 }
17251 defer googleapi.CloseBody(res)
17252 if err := googleapi.CheckResponse(res); err != nil {
17253 return nil, gensupport.WrapError(err)
17254 }
17255 ret := &TransitObject{
17256 ServerResponse: googleapi.ServerResponse{
17257 Header: res.Header,
17258 HTTPStatusCode: res.StatusCode,
17259 },
17260 }
17261 target := &ret
17262 if err := gensupport.DecodeResponse(target, res); err != nil {
17263 return nil, err
17264 }
17265 return ret, nil
17266 }
17267
17268 type TransitobjectInsertCall struct {
17269 s *Service
17270 transitobject *TransitObject
17271 urlParams_ gensupport.URLParams
17272 ctx_ context.Context
17273 header_ http.Header
17274 }
17275
17276
17277 func (r *TransitobjectService) Insert(transitobject *TransitObject) *TransitobjectInsertCall {
17278 c := &TransitobjectInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17279 c.transitobject = transitobject
17280 return c
17281 }
17282
17283
17284
17285
17286 func (c *TransitobjectInsertCall) Fields(s ...googleapi.Field) *TransitobjectInsertCall {
17287 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17288 return c
17289 }
17290
17291
17292 func (c *TransitobjectInsertCall) Context(ctx context.Context) *TransitobjectInsertCall {
17293 c.ctx_ = ctx
17294 return c
17295 }
17296
17297
17298
17299 func (c *TransitobjectInsertCall) Header() http.Header {
17300 if c.header_ == nil {
17301 c.header_ = make(http.Header)
17302 }
17303 return c.header_
17304 }
17305
17306 func (c *TransitobjectInsertCall) doRequest(alt string) (*http.Response, error) {
17307 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17308 var body io.Reader = nil
17309 body, err := googleapi.WithoutDataWrapper.JSONReader(c.transitobject)
17310 if err != nil {
17311 return nil, err
17312 }
17313 c.urlParams_.Set("alt", alt)
17314 c.urlParams_.Set("prettyPrint", "false")
17315 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitObject")
17316 urls += "?" + c.urlParams_.Encode()
17317 req, err := http.NewRequest("POST", urls, body)
17318 if err != nil {
17319 return nil, err
17320 }
17321 req.Header = reqHeaders
17322 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17323 }
17324
17325
17326
17327
17328
17329
17330 func (c *TransitobjectInsertCall) Do(opts ...googleapi.CallOption) (*TransitObject, error) {
17331 gensupport.SetOptions(c.urlParams_, opts...)
17332 res, err := c.doRequest("json")
17333 if res != nil && res.StatusCode == http.StatusNotModified {
17334 if res.Body != nil {
17335 res.Body.Close()
17336 }
17337 return nil, gensupport.WrapError(&googleapi.Error{
17338 Code: res.StatusCode,
17339 Header: res.Header,
17340 })
17341 }
17342 if err != nil {
17343 return nil, err
17344 }
17345 defer googleapi.CloseBody(res)
17346 if err := googleapi.CheckResponse(res); err != nil {
17347 return nil, gensupport.WrapError(err)
17348 }
17349 ret := &TransitObject{
17350 ServerResponse: googleapi.ServerResponse{
17351 Header: res.Header,
17352 HTTPStatusCode: res.StatusCode,
17353 },
17354 }
17355 target := &ret
17356 if err := gensupport.DecodeResponse(target, res); err != nil {
17357 return nil, err
17358 }
17359 return ret, nil
17360 }
17361
17362 type TransitobjectListCall struct {
17363 s *Service
17364 urlParams_ gensupport.URLParams
17365 ifNoneMatch_ string
17366 ctx_ context.Context
17367 header_ http.Header
17368 }
17369
17370
17371 func (r *TransitobjectService) List() *TransitobjectListCall {
17372 c := &TransitobjectListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17373 return c
17374 }
17375
17376
17377
17378 func (c *TransitobjectListCall) ClassId(classId string) *TransitobjectListCall {
17379 c.urlParams_.Set("classId", classId)
17380 return c
17381 }
17382
17383
17384
17385
17386 func (c *TransitobjectListCall) MaxResults(maxResults int64) *TransitobjectListCall {
17387 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
17388 return c
17389 }
17390
17391
17392
17393
17394
17395
17396
17397 func (c *TransitobjectListCall) Token(token string) *TransitobjectListCall {
17398 c.urlParams_.Set("token", token)
17399 return c
17400 }
17401
17402
17403
17404
17405 func (c *TransitobjectListCall) Fields(s ...googleapi.Field) *TransitobjectListCall {
17406 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17407 return c
17408 }
17409
17410
17411
17412
17413 func (c *TransitobjectListCall) IfNoneMatch(entityTag string) *TransitobjectListCall {
17414 c.ifNoneMatch_ = entityTag
17415 return c
17416 }
17417
17418
17419 func (c *TransitobjectListCall) Context(ctx context.Context) *TransitobjectListCall {
17420 c.ctx_ = ctx
17421 return c
17422 }
17423
17424
17425
17426 func (c *TransitobjectListCall) Header() http.Header {
17427 if c.header_ == nil {
17428 c.header_ = make(http.Header)
17429 }
17430 return c.header_
17431 }
17432
17433 func (c *TransitobjectListCall) doRequest(alt string) (*http.Response, error) {
17434 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17435 if c.ifNoneMatch_ != "" {
17436 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17437 }
17438 var body io.Reader = nil
17439 c.urlParams_.Set("alt", alt)
17440 c.urlParams_.Set("prettyPrint", "false")
17441 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitObject")
17442 urls += "?" + c.urlParams_.Encode()
17443 req, err := http.NewRequest("GET", urls, body)
17444 if err != nil {
17445 return nil, err
17446 }
17447 req.Header = reqHeaders
17448 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17449 }
17450
17451
17452
17453
17454
17455
17456
17457 func (c *TransitobjectListCall) Do(opts ...googleapi.CallOption) (*TransitObjectListResponse, error) {
17458 gensupport.SetOptions(c.urlParams_, opts...)
17459 res, err := c.doRequest("json")
17460 if res != nil && res.StatusCode == http.StatusNotModified {
17461 if res.Body != nil {
17462 res.Body.Close()
17463 }
17464 return nil, gensupport.WrapError(&googleapi.Error{
17465 Code: res.StatusCode,
17466 Header: res.Header,
17467 })
17468 }
17469 if err != nil {
17470 return nil, err
17471 }
17472 defer googleapi.CloseBody(res)
17473 if err := googleapi.CheckResponse(res); err != nil {
17474 return nil, gensupport.WrapError(err)
17475 }
17476 ret := &TransitObjectListResponse{
17477 ServerResponse: googleapi.ServerResponse{
17478 Header: res.Header,
17479 HTTPStatusCode: res.StatusCode,
17480 },
17481 }
17482 target := &ret
17483 if err := gensupport.DecodeResponse(target, res); err != nil {
17484 return nil, err
17485 }
17486 return ret, nil
17487 }
17488
17489 type TransitobjectPatchCall struct {
17490 s *Service
17491 resourceId string
17492 transitobject *TransitObject
17493 urlParams_ gensupport.URLParams
17494 ctx_ context.Context
17495 header_ http.Header
17496 }
17497
17498
17499
17500
17501
17502
17503
17504
17505
17506 func (r *TransitobjectService) Patch(resourceId string, transitobject *TransitObject) *TransitobjectPatchCall {
17507 c := &TransitobjectPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17508 c.resourceId = resourceId
17509 c.transitobject = transitobject
17510 return c
17511 }
17512
17513
17514
17515
17516 func (c *TransitobjectPatchCall) Fields(s ...googleapi.Field) *TransitobjectPatchCall {
17517 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17518 return c
17519 }
17520
17521
17522 func (c *TransitobjectPatchCall) Context(ctx context.Context) *TransitobjectPatchCall {
17523 c.ctx_ = ctx
17524 return c
17525 }
17526
17527
17528
17529 func (c *TransitobjectPatchCall) Header() http.Header {
17530 if c.header_ == nil {
17531 c.header_ = make(http.Header)
17532 }
17533 return c.header_
17534 }
17535
17536 func (c *TransitobjectPatchCall) doRequest(alt string) (*http.Response, error) {
17537 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17538 var body io.Reader = nil
17539 body, err := googleapi.WithoutDataWrapper.JSONReader(c.transitobject)
17540 if err != nil {
17541 return nil, err
17542 }
17543 c.urlParams_.Set("alt", alt)
17544 c.urlParams_.Set("prettyPrint", "false")
17545 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitObject/{resourceId}")
17546 urls += "?" + c.urlParams_.Encode()
17547 req, err := http.NewRequest("PATCH", urls, body)
17548 if err != nil {
17549 return nil, err
17550 }
17551 req.Header = reqHeaders
17552 googleapi.Expand(req.URL, map[string]string{
17553 "resourceId": c.resourceId,
17554 })
17555 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17556 }
17557
17558
17559
17560
17561
17562
17563 func (c *TransitobjectPatchCall) Do(opts ...googleapi.CallOption) (*TransitObject, error) {
17564 gensupport.SetOptions(c.urlParams_, opts...)
17565 res, err := c.doRequest("json")
17566 if res != nil && res.StatusCode == http.StatusNotModified {
17567 if res.Body != nil {
17568 res.Body.Close()
17569 }
17570 return nil, gensupport.WrapError(&googleapi.Error{
17571 Code: res.StatusCode,
17572 Header: res.Header,
17573 })
17574 }
17575 if err != nil {
17576 return nil, err
17577 }
17578 defer googleapi.CloseBody(res)
17579 if err := googleapi.CheckResponse(res); err != nil {
17580 return nil, gensupport.WrapError(err)
17581 }
17582 ret := &TransitObject{
17583 ServerResponse: googleapi.ServerResponse{
17584 Header: res.Header,
17585 HTTPStatusCode: res.StatusCode,
17586 },
17587 }
17588 target := &ret
17589 if err := gensupport.DecodeResponse(target, res); err != nil {
17590 return nil, err
17591 }
17592 return ret, nil
17593 }
17594
17595 type TransitobjectUpdateCall struct {
17596 s *Service
17597 resourceId string
17598 transitobject *TransitObject
17599 urlParams_ gensupport.URLParams
17600 ctx_ context.Context
17601 header_ http.Header
17602 }
17603
17604
17605
17606
17607
17608
17609
17610
17611 func (r *TransitobjectService) Update(resourceId string, transitobject *TransitObject) *TransitobjectUpdateCall {
17612 c := &TransitobjectUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17613 c.resourceId = resourceId
17614 c.transitobject = transitobject
17615 return c
17616 }
17617
17618
17619
17620
17621 func (c *TransitobjectUpdateCall) Fields(s ...googleapi.Field) *TransitobjectUpdateCall {
17622 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17623 return c
17624 }
17625
17626
17627 func (c *TransitobjectUpdateCall) Context(ctx context.Context) *TransitobjectUpdateCall {
17628 c.ctx_ = ctx
17629 return c
17630 }
17631
17632
17633
17634 func (c *TransitobjectUpdateCall) Header() http.Header {
17635 if c.header_ == nil {
17636 c.header_ = make(http.Header)
17637 }
17638 return c.header_
17639 }
17640
17641 func (c *TransitobjectUpdateCall) doRequest(alt string) (*http.Response, error) {
17642 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17643 var body io.Reader = nil
17644 body, err := googleapi.WithoutDataWrapper.JSONReader(c.transitobject)
17645 if err != nil {
17646 return nil, err
17647 }
17648 c.urlParams_.Set("alt", alt)
17649 c.urlParams_.Set("prettyPrint", "false")
17650 urls := googleapi.ResolveRelative(c.s.BasePath, "walletobjects/v1/transitObject/{resourceId}")
17651 urls += "?" + c.urlParams_.Encode()
17652 req, err := http.NewRequest("PUT", urls, body)
17653 if err != nil {
17654 return nil, err
17655 }
17656 req.Header = reqHeaders
17657 googleapi.Expand(req.URL, map[string]string{
17658 "resourceId": c.resourceId,
17659 })
17660 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17661 }
17662
17663
17664
17665
17666
17667
17668 func (c *TransitobjectUpdateCall) Do(opts ...googleapi.CallOption) (*TransitObject, error) {
17669 gensupport.SetOptions(c.urlParams_, opts...)
17670 res, err := c.doRequest("json")
17671 if res != nil && res.StatusCode == http.StatusNotModified {
17672 if res.Body != nil {
17673 res.Body.Close()
17674 }
17675 return nil, gensupport.WrapError(&googleapi.Error{
17676 Code: res.StatusCode,
17677 Header: res.Header,
17678 })
17679 }
17680 if err != nil {
17681 return nil, err
17682 }
17683 defer googleapi.CloseBody(res)
17684 if err := googleapi.CheckResponse(res); err != nil {
17685 return nil, gensupport.WrapError(err)
17686 }
17687 ret := &TransitObject{
17688 ServerResponse: googleapi.ServerResponse{
17689 Header: res.Header,
17690 HTTPStatusCode: res.StatusCode,
17691 },
17692 }
17693 target := &ret
17694 if err := gensupport.DecodeResponse(target, res); err != nil {
17695 return nil, err
17696 }
17697 return ret, nil
17698 }
17699
View as plain text