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 books
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 = "books:v1"
90 const apiName = "books"
91 const apiVersion = "v1"
92 const basePath = "https://books.googleapis.com/"
93 const basePathTemplate = "https://books.UNIVERSE_DOMAIN/"
94 const mtlsBasePath = "https://books.mtls.googleapis.com/"
95
96
97 const (
98
99 BooksScope = "https://www.googleapis.com/auth/books"
100 )
101
102
103 func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
104 scopesOption := internaloption.WithDefaultScopes(
105 "https://www.googleapis.com/auth/books",
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.Bookshelves = NewBookshelvesService(s)
138 s.Cloudloading = NewCloudloadingService(s)
139 s.Dictionary = NewDictionaryService(s)
140 s.Familysharing = NewFamilysharingService(s)
141 s.Layers = NewLayersService(s)
142 s.Myconfig = NewMyconfigService(s)
143 s.Mylibrary = NewMylibraryService(s)
144 s.Notification = NewNotificationService(s)
145 s.Onboarding = NewOnboardingService(s)
146 s.Personalizedstream = NewPersonalizedstreamService(s)
147 s.Promooffer = NewPromoofferService(s)
148 s.Series = NewSeriesService(s)
149 s.Volumes = NewVolumesService(s)
150 return s, nil
151 }
152
153 type Service struct {
154 client *http.Client
155 BasePath string
156 UserAgent string
157
158 Bookshelves *BookshelvesService
159
160 Cloudloading *CloudloadingService
161
162 Dictionary *DictionaryService
163
164 Familysharing *FamilysharingService
165
166 Layers *LayersService
167
168 Myconfig *MyconfigService
169
170 Mylibrary *MylibraryService
171
172 Notification *NotificationService
173
174 Onboarding *OnboardingService
175
176 Personalizedstream *PersonalizedstreamService
177
178 Promooffer *PromoofferService
179
180 Series *SeriesService
181
182 Volumes *VolumesService
183 }
184
185 func (s *Service) userAgent() string {
186 if s.UserAgent == "" {
187 return googleapi.UserAgent
188 }
189 return googleapi.UserAgent + " " + s.UserAgent
190 }
191
192 func NewBookshelvesService(s *Service) *BookshelvesService {
193 rs := &BookshelvesService{s: s}
194 rs.Volumes = NewBookshelvesVolumesService(s)
195 return rs
196 }
197
198 type BookshelvesService struct {
199 s *Service
200
201 Volumes *BookshelvesVolumesService
202 }
203
204 func NewBookshelvesVolumesService(s *Service) *BookshelvesVolumesService {
205 rs := &BookshelvesVolumesService{s: s}
206 return rs
207 }
208
209 type BookshelvesVolumesService struct {
210 s *Service
211 }
212
213 func NewCloudloadingService(s *Service) *CloudloadingService {
214 rs := &CloudloadingService{s: s}
215 return rs
216 }
217
218 type CloudloadingService struct {
219 s *Service
220 }
221
222 func NewDictionaryService(s *Service) *DictionaryService {
223 rs := &DictionaryService{s: s}
224 return rs
225 }
226
227 type DictionaryService struct {
228 s *Service
229 }
230
231 func NewFamilysharingService(s *Service) *FamilysharingService {
232 rs := &FamilysharingService{s: s}
233 return rs
234 }
235
236 type FamilysharingService struct {
237 s *Service
238 }
239
240 func NewLayersService(s *Service) *LayersService {
241 rs := &LayersService{s: s}
242 rs.AnnotationData = NewLayersAnnotationDataService(s)
243 rs.VolumeAnnotations = NewLayersVolumeAnnotationsService(s)
244 return rs
245 }
246
247 type LayersService struct {
248 s *Service
249
250 AnnotationData *LayersAnnotationDataService
251
252 VolumeAnnotations *LayersVolumeAnnotationsService
253 }
254
255 func NewLayersAnnotationDataService(s *Service) *LayersAnnotationDataService {
256 rs := &LayersAnnotationDataService{s: s}
257 return rs
258 }
259
260 type LayersAnnotationDataService struct {
261 s *Service
262 }
263
264 func NewLayersVolumeAnnotationsService(s *Service) *LayersVolumeAnnotationsService {
265 rs := &LayersVolumeAnnotationsService{s: s}
266 return rs
267 }
268
269 type LayersVolumeAnnotationsService struct {
270 s *Service
271 }
272
273 func NewMyconfigService(s *Service) *MyconfigService {
274 rs := &MyconfigService{s: s}
275 return rs
276 }
277
278 type MyconfigService struct {
279 s *Service
280 }
281
282 func NewMylibraryService(s *Service) *MylibraryService {
283 rs := &MylibraryService{s: s}
284 rs.Annotations = NewMylibraryAnnotationsService(s)
285 rs.Bookshelves = NewMylibraryBookshelvesService(s)
286 rs.Readingpositions = NewMylibraryReadingpositionsService(s)
287 return rs
288 }
289
290 type MylibraryService struct {
291 s *Service
292
293 Annotations *MylibraryAnnotationsService
294
295 Bookshelves *MylibraryBookshelvesService
296
297 Readingpositions *MylibraryReadingpositionsService
298 }
299
300 func NewMylibraryAnnotationsService(s *Service) *MylibraryAnnotationsService {
301 rs := &MylibraryAnnotationsService{s: s}
302 return rs
303 }
304
305 type MylibraryAnnotationsService struct {
306 s *Service
307 }
308
309 func NewMylibraryBookshelvesService(s *Service) *MylibraryBookshelvesService {
310 rs := &MylibraryBookshelvesService{s: s}
311 rs.Volumes = NewMylibraryBookshelvesVolumesService(s)
312 return rs
313 }
314
315 type MylibraryBookshelvesService struct {
316 s *Service
317
318 Volumes *MylibraryBookshelvesVolumesService
319 }
320
321 func NewMylibraryBookshelvesVolumesService(s *Service) *MylibraryBookshelvesVolumesService {
322 rs := &MylibraryBookshelvesVolumesService{s: s}
323 return rs
324 }
325
326 type MylibraryBookshelvesVolumesService struct {
327 s *Service
328 }
329
330 func NewMylibraryReadingpositionsService(s *Service) *MylibraryReadingpositionsService {
331 rs := &MylibraryReadingpositionsService{s: s}
332 return rs
333 }
334
335 type MylibraryReadingpositionsService struct {
336 s *Service
337 }
338
339 func NewNotificationService(s *Service) *NotificationService {
340 rs := &NotificationService{s: s}
341 return rs
342 }
343
344 type NotificationService struct {
345 s *Service
346 }
347
348 func NewOnboardingService(s *Service) *OnboardingService {
349 rs := &OnboardingService{s: s}
350 return rs
351 }
352
353 type OnboardingService struct {
354 s *Service
355 }
356
357 func NewPersonalizedstreamService(s *Service) *PersonalizedstreamService {
358 rs := &PersonalizedstreamService{s: s}
359 return rs
360 }
361
362 type PersonalizedstreamService struct {
363 s *Service
364 }
365
366 func NewPromoofferService(s *Service) *PromoofferService {
367 rs := &PromoofferService{s: s}
368 return rs
369 }
370
371 type PromoofferService struct {
372 s *Service
373 }
374
375 func NewSeriesService(s *Service) *SeriesService {
376 rs := &SeriesService{s: s}
377 rs.Membership = NewSeriesMembershipService(s)
378 return rs
379 }
380
381 type SeriesService struct {
382 s *Service
383
384 Membership *SeriesMembershipService
385 }
386
387 func NewSeriesMembershipService(s *Service) *SeriesMembershipService {
388 rs := &SeriesMembershipService{s: s}
389 return rs
390 }
391
392 type SeriesMembershipService struct {
393 s *Service
394 }
395
396 func NewVolumesService(s *Service) *VolumesService {
397 rs := &VolumesService{s: s}
398 rs.Associated = NewVolumesAssociatedService(s)
399 rs.Mybooks = NewVolumesMybooksService(s)
400 rs.Recommended = NewVolumesRecommendedService(s)
401 rs.Useruploaded = NewVolumesUseruploadedService(s)
402 return rs
403 }
404
405 type VolumesService struct {
406 s *Service
407
408 Associated *VolumesAssociatedService
409
410 Mybooks *VolumesMybooksService
411
412 Recommended *VolumesRecommendedService
413
414 Useruploaded *VolumesUseruploadedService
415 }
416
417 func NewVolumesAssociatedService(s *Service) *VolumesAssociatedService {
418 rs := &VolumesAssociatedService{s: s}
419 return rs
420 }
421
422 type VolumesAssociatedService struct {
423 s *Service
424 }
425
426 func NewVolumesMybooksService(s *Service) *VolumesMybooksService {
427 rs := &VolumesMybooksService{s: s}
428 return rs
429 }
430
431 type VolumesMybooksService struct {
432 s *Service
433 }
434
435 func NewVolumesRecommendedService(s *Service) *VolumesRecommendedService {
436 rs := &VolumesRecommendedService{s: s}
437 return rs
438 }
439
440 type VolumesRecommendedService struct {
441 s *Service
442 }
443
444 func NewVolumesUseruploadedService(s *Service) *VolumesUseruploadedService {
445 rs := &VolumesUseruploadedService{s: s}
446 return rs
447 }
448
449 type VolumesUseruploadedService struct {
450 s *Service
451 }
452
453 type Annotation struct {
454
455
456
457 AfterSelectedText string `json:"afterSelectedText,omitempty"`
458
459
460
461 BeforeSelectedText string `json:"beforeSelectedText,omitempty"`
462
463 ClientVersionRanges *AnnotationClientVersionRanges `json:"clientVersionRanges,omitempty"`
464
465 Created string `json:"created,omitempty"`
466
467 CurrentVersionRanges *AnnotationCurrentVersionRanges `json:"currentVersionRanges,omitempty"`
468
469 Data string `json:"data,omitempty"`
470
471 Deleted bool `json:"deleted,omitempty"`
472
473 HighlightStyle string `json:"highlightStyle,omitempty"`
474
475 Id string `json:"id,omitempty"`
476
477 Kind string `json:"kind,omitempty"`
478
479 LayerId string `json:"layerId,omitempty"`
480 LayerSummary *AnnotationLayerSummary `json:"layerSummary,omitempty"`
481
482 PageIds []string `json:"pageIds,omitempty"`
483
484 SelectedText string `json:"selectedText,omitempty"`
485
486 SelfLink string `json:"selfLink,omitempty"`
487
488 Updated string `json:"updated,omitempty"`
489
490 VolumeId string `json:"volumeId,omitempty"`
491
492
493 googleapi.ServerResponse `json:"-"`
494
495
496
497
498
499 ForceSendFields []string `json:"-"`
500
501
502
503
504 NullFields []string `json:"-"`
505 }
506
507 func (s *Annotation) MarshalJSON() ([]byte, error) {
508 type NoMethod Annotation
509 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
510 }
511
512
513 type AnnotationClientVersionRanges struct {
514
515 CfiRange *BooksAnnotationsRange `json:"cfiRange,omitempty"`
516
517 ContentVersion string `json:"contentVersion,omitempty"`
518
519 GbImageRange *BooksAnnotationsRange `json:"gbImageRange,omitempty"`
520
521 GbTextRange *BooksAnnotationsRange `json:"gbTextRange,omitempty"`
522
523 ImageCfiRange *BooksAnnotationsRange `json:"imageCfiRange,omitempty"`
524
525
526
527
528
529 ForceSendFields []string `json:"-"`
530
531
532
533
534 NullFields []string `json:"-"`
535 }
536
537 func (s *AnnotationClientVersionRanges) MarshalJSON() ([]byte, error) {
538 type NoMethod AnnotationClientVersionRanges
539 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
540 }
541
542
543
544 type AnnotationCurrentVersionRanges struct {
545
546 CfiRange *BooksAnnotationsRange `json:"cfiRange,omitempty"`
547
548 ContentVersion string `json:"contentVersion,omitempty"`
549
550
551 GbImageRange *BooksAnnotationsRange `json:"gbImageRange,omitempty"`
552
553 GbTextRange *BooksAnnotationsRange `json:"gbTextRange,omitempty"`
554
555
556 ImageCfiRange *BooksAnnotationsRange `json:"imageCfiRange,omitempty"`
557
558
559
560
561
562 ForceSendFields []string `json:"-"`
563
564
565
566
567 NullFields []string `json:"-"`
568 }
569
570 func (s *AnnotationCurrentVersionRanges) MarshalJSON() ([]byte, error) {
571 type NoMethod AnnotationCurrentVersionRanges
572 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
573 }
574
575 type AnnotationLayerSummary struct {
576
577
578 AllowedCharacterCount int64 `json:"allowedCharacterCount,omitempty"`
579
580
581 LimitType string `json:"limitType,omitempty"`
582
583
584 RemainingCharacterCount int64 `json:"remainingCharacterCount,omitempty"`
585
586
587
588
589
590 ForceSendFields []string `json:"-"`
591
592
593
594
595 NullFields []string `json:"-"`
596 }
597
598 func (s *AnnotationLayerSummary) MarshalJSON() ([]byte, error) {
599 type NoMethod AnnotationLayerSummary
600 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
601 }
602
603 type Annotations struct {
604
605 Items []*Annotation `json:"items,omitempty"`
606
607 Kind string `json:"kind,omitempty"`
608
609
610 NextPageToken string `json:"nextPageToken,omitempty"`
611
612
613 TotalItems int64 `json:"totalItems,omitempty"`
614
615
616 googleapi.ServerResponse `json:"-"`
617
618
619
620
621
622 ForceSendFields []string `json:"-"`
623
624
625
626
627 NullFields []string `json:"-"`
628 }
629
630 func (s *Annotations) MarshalJSON() ([]byte, error) {
631 type NoMethod Annotations
632 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
633 }
634
635 type AnnotationsSummary struct {
636 Kind string `json:"kind,omitempty"`
637 Layers []*AnnotationsSummaryLayers `json:"layers,omitempty"`
638
639
640 googleapi.ServerResponse `json:"-"`
641
642
643
644
645
646 ForceSendFields []string `json:"-"`
647
648
649
650
651 NullFields []string `json:"-"`
652 }
653
654 func (s *AnnotationsSummary) MarshalJSON() ([]byte, error) {
655 type NoMethod AnnotationsSummary
656 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
657 }
658
659 type AnnotationsSummaryLayers struct {
660 AllowedCharacterCount int64 `json:"allowedCharacterCount,omitempty"`
661 LayerId string `json:"layerId,omitempty"`
662 LimitType string `json:"limitType,omitempty"`
663 RemainingCharacterCount int64 `json:"remainingCharacterCount,omitempty"`
664 Updated string `json:"updated,omitempty"`
665
666
667
668
669
670 ForceSendFields []string `json:"-"`
671
672
673
674
675 NullFields []string `json:"-"`
676 }
677
678 func (s *AnnotationsSummaryLayers) MarshalJSON() ([]byte, error) {
679 type NoMethod AnnotationsSummaryLayers
680 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
681 }
682
683 type Annotationsdata struct {
684
685 Items []*GeoAnnotationdata `json:"items,omitempty"`
686
687 Kind string `json:"kind,omitempty"`
688
689
690 NextPageToken string `json:"nextPageToken,omitempty"`
691
692 TotalItems int64 `json:"totalItems,omitempty"`
693
694
695 googleapi.ServerResponse `json:"-"`
696
697
698
699
700
701 ForceSendFields []string `json:"-"`
702
703
704
705
706 NullFields []string `json:"-"`
707 }
708
709 func (s *Annotationsdata) MarshalJSON() ([]byte, error) {
710 type NoMethod Annotationsdata
711 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
712 }
713
714 type BooksAnnotationsRange struct {
715
716 EndOffset string `json:"endOffset,omitempty"`
717
718 EndPosition string `json:"endPosition,omitempty"`
719
720 StartOffset string `json:"startOffset,omitempty"`
721
722 StartPosition string `json:"startPosition,omitempty"`
723
724
725
726
727
728 ForceSendFields []string `json:"-"`
729
730
731
732
733 NullFields []string `json:"-"`
734 }
735
736 func (s *BooksAnnotationsRange) MarshalJSON() ([]byte, error) {
737 type NoMethod BooksAnnotationsRange
738 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
739 }
740
741 type BooksCloudloadingResource struct {
742 Author string `json:"author,omitempty"`
743 ProcessingState string `json:"processingState,omitempty"`
744 Title string `json:"title,omitempty"`
745 VolumeId string `json:"volumeId,omitempty"`
746
747
748 googleapi.ServerResponse `json:"-"`
749
750
751
752
753
754 ForceSendFields []string `json:"-"`
755
756
757
758
759 NullFields []string `json:"-"`
760 }
761
762 func (s *BooksCloudloadingResource) MarshalJSON() ([]byte, error) {
763 type NoMethod BooksCloudloadingResource
764 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
765 }
766
767 type BooksVolumesRecommendedRateResponse struct {
768 ConsistencyToken string `json:"consistency_token,omitempty"`
769
770
771 googleapi.ServerResponse `json:"-"`
772
773
774
775
776
777 ForceSendFields []string `json:"-"`
778
779
780
781
782 NullFields []string `json:"-"`
783 }
784
785 func (s *BooksVolumesRecommendedRateResponse) MarshalJSON() ([]byte, error) {
786 type NoMethod BooksVolumesRecommendedRateResponse
787 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
788 }
789
790 type Bookshelf struct {
791
792 Access string `json:"access,omitempty"`
793
794
795 Created string `json:"created,omitempty"`
796
797 Description string `json:"description,omitempty"`
798
799 Id int64 `json:"id,omitempty"`
800
801 Kind string `json:"kind,omitempty"`
802
803 SelfLink string `json:"selfLink,omitempty"`
804
805 Title string `json:"title,omitempty"`
806
807
808 Updated string `json:"updated,omitempty"`
809
810 VolumeCount int64 `json:"volumeCount,omitempty"`
811
812
813 VolumesLastUpdated string `json:"volumesLastUpdated,omitempty"`
814
815
816 googleapi.ServerResponse `json:"-"`
817
818
819
820
821
822 ForceSendFields []string `json:"-"`
823
824
825
826
827 NullFields []string `json:"-"`
828 }
829
830 func (s *Bookshelf) MarshalJSON() ([]byte, error) {
831 type NoMethod Bookshelf
832 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
833 }
834
835 type Bookshelves struct {
836
837 Items []*Bookshelf `json:"items,omitempty"`
838
839 Kind string `json:"kind,omitempty"`
840
841
842 googleapi.ServerResponse `json:"-"`
843
844
845
846
847
848 ForceSendFields []string `json:"-"`
849
850
851
852
853 NullFields []string `json:"-"`
854 }
855
856 func (s *Bookshelves) MarshalJSON() ([]byte, error) {
857 type NoMethod Bookshelves
858 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
859 }
860
861 type Category struct {
862
863 Items []*CategoryItems `json:"items,omitempty"`
864
865 Kind string `json:"kind,omitempty"`
866
867
868 googleapi.ServerResponse `json:"-"`
869
870
871
872
873
874 ForceSendFields []string `json:"-"`
875
876
877
878
879 NullFields []string `json:"-"`
880 }
881
882 func (s *Category) MarshalJSON() ([]byte, error) {
883 type NoMethod Category
884 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
885 }
886
887 type CategoryItems struct {
888 BadgeUrl string `json:"badgeUrl,omitempty"`
889 CategoryId string `json:"categoryId,omitempty"`
890 Name string `json:"name,omitempty"`
891
892
893
894
895
896 ForceSendFields []string `json:"-"`
897
898
899
900
901 NullFields []string `json:"-"`
902 }
903
904 func (s *CategoryItems) MarshalJSON() ([]byte, error) {
905 type NoMethod CategoryItems
906 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
907 }
908
909 type ConcurrentAccessRestriction struct {
910
911 DeviceAllowed bool `json:"deviceAllowed,omitempty"`
912
913 Kind string `json:"kind,omitempty"`
914
915
916 MaxConcurrentDevices int64 `json:"maxConcurrentDevices,omitempty"`
917
918 Message string `json:"message,omitempty"`
919
920
921 Nonce string `json:"nonce,omitempty"`
922
923 ReasonCode string `json:"reasonCode,omitempty"`
924
925 Restricted bool `json:"restricted,omitempty"`
926
927 Signature string `json:"signature,omitempty"`
928
929
930 Source string `json:"source,omitempty"`
931
932 TimeWindowSeconds int64 `json:"timeWindowSeconds,omitempty"`
933
934 VolumeId string `json:"volumeId,omitempty"`
935
936
937
938
939
940 ForceSendFields []string `json:"-"`
941
942
943
944
945 NullFields []string `json:"-"`
946 }
947
948 func (s *ConcurrentAccessRestriction) MarshalJSON() ([]byte, error) {
949 type NoMethod ConcurrentAccessRestriction
950 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
951 }
952
953 type DictionaryAnnotationdata struct {
954
955 AnnotationType string `json:"annotationType,omitempty"`
956
957
958 Data *Dictlayerdata `json:"data,omitempty"`
959
960 EncodedData string `json:"encodedData,omitempty"`
961
962 Id string `json:"id,omitempty"`
963
964 Kind string `json:"kind,omitempty"`
965
966 LayerId string `json:"layerId,omitempty"`
967
968 SelfLink string `json:"selfLink,omitempty"`
969
970
971 Updated string `json:"updated,omitempty"`
972
973 VolumeId string `json:"volumeId,omitempty"`
974
975
976 googleapi.ServerResponse `json:"-"`
977
978
979
980
981
982 ForceSendFields []string `json:"-"`
983
984
985
986
987 NullFields []string `json:"-"`
988 }
989
990 func (s *DictionaryAnnotationdata) MarshalJSON() ([]byte, error) {
991 type NoMethod DictionaryAnnotationdata
992 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
993 }
994
995 type Dictlayerdata struct {
996 Common *DictlayerdataCommon `json:"common,omitempty"`
997 Dict *DictlayerdataDict `json:"dict,omitempty"`
998 Kind string `json:"kind,omitempty"`
999
1000
1001
1002
1003
1004 ForceSendFields []string `json:"-"`
1005
1006
1007
1008
1009 NullFields []string `json:"-"`
1010 }
1011
1012 func (s *Dictlayerdata) MarshalJSON() ([]byte, error) {
1013 type NoMethod Dictlayerdata
1014 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1015 }
1016
1017 type DictlayerdataCommon struct {
1018
1019
1020 Title string `json:"title,omitempty"`
1021
1022
1023
1024
1025
1026 ForceSendFields []string `json:"-"`
1027
1028
1029
1030
1031 NullFields []string `json:"-"`
1032 }
1033
1034 func (s *DictlayerdataCommon) MarshalJSON() ([]byte, error) {
1035 type NoMethod DictlayerdataCommon
1036 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1037 }
1038
1039 type DictlayerdataDict struct {
1040
1041 Source *DictlayerdataDictSource `json:"source,omitempty"`
1042 Words []*DictlayerdataDictWords `json:"words,omitempty"`
1043
1044
1045
1046
1047
1048 ForceSendFields []string `json:"-"`
1049
1050
1051
1052
1053 NullFields []string `json:"-"`
1054 }
1055
1056 func (s *DictlayerdataDict) MarshalJSON() ([]byte, error) {
1057 type NoMethod DictlayerdataDict
1058 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1059 }
1060
1061
1062
1063 type DictlayerdataDictSource struct {
1064 Attribution string `json:"attribution,omitempty"`
1065 Url string `json:"url,omitempty"`
1066
1067
1068
1069
1070
1071 ForceSendFields []string `json:"-"`
1072
1073
1074
1075
1076 NullFields []string `json:"-"`
1077 }
1078
1079 func (s *DictlayerdataDictSource) MarshalJSON() ([]byte, error) {
1080 type NoMethod DictlayerdataDictSource
1081 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1082 }
1083
1084 type DictlayerdataDictWords struct {
1085 Derivatives []*DictlayerdataDictWordsDerivatives `json:"derivatives,omitempty"`
1086 Examples []*DictlayerdataDictWordsExamples `json:"examples,omitempty"`
1087 Senses []*DictlayerdataDictWordsSenses `json:"senses,omitempty"`
1088
1089
1090 Source *DictlayerdataDictWordsSource `json:"source,omitempty"`
1091
1092
1093
1094
1095
1096 ForceSendFields []string `json:"-"`
1097
1098
1099
1100
1101 NullFields []string `json:"-"`
1102 }
1103
1104 func (s *DictlayerdataDictWords) MarshalJSON() ([]byte, error) {
1105 type NoMethod DictlayerdataDictWords
1106 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1107 }
1108
1109 type DictlayerdataDictWordsDerivatives struct {
1110 Source *DictlayerdataDictWordsDerivativesSource `json:"source,omitempty"`
1111 Text string `json:"text,omitempty"`
1112
1113
1114
1115
1116
1117 ForceSendFields []string `json:"-"`
1118
1119
1120
1121
1122 NullFields []string `json:"-"`
1123 }
1124
1125 func (s *DictlayerdataDictWordsDerivatives) MarshalJSON() ([]byte, error) {
1126 type NoMethod DictlayerdataDictWordsDerivatives
1127 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1128 }
1129
1130 type DictlayerdataDictWordsDerivativesSource struct {
1131 Attribution string `json:"attribution,omitempty"`
1132 Url string `json:"url,omitempty"`
1133
1134
1135
1136
1137
1138 ForceSendFields []string `json:"-"`
1139
1140
1141
1142
1143 NullFields []string `json:"-"`
1144 }
1145
1146 func (s *DictlayerdataDictWordsDerivativesSource) MarshalJSON() ([]byte, error) {
1147 type NoMethod DictlayerdataDictWordsDerivativesSource
1148 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1149 }
1150
1151 type DictlayerdataDictWordsExamples struct {
1152 Source *DictlayerdataDictWordsExamplesSource `json:"source,omitempty"`
1153 Text string `json:"text,omitempty"`
1154
1155
1156
1157
1158
1159 ForceSendFields []string `json:"-"`
1160
1161
1162
1163
1164 NullFields []string `json:"-"`
1165 }
1166
1167 func (s *DictlayerdataDictWordsExamples) MarshalJSON() ([]byte, error) {
1168 type NoMethod DictlayerdataDictWordsExamples
1169 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1170 }
1171
1172 type DictlayerdataDictWordsExamplesSource struct {
1173 Attribution string `json:"attribution,omitempty"`
1174 Url string `json:"url,omitempty"`
1175
1176
1177
1178
1179
1180 ForceSendFields []string `json:"-"`
1181
1182
1183
1184
1185 NullFields []string `json:"-"`
1186 }
1187
1188 func (s *DictlayerdataDictWordsExamplesSource) MarshalJSON() ([]byte, error) {
1189 type NoMethod DictlayerdataDictWordsExamplesSource
1190 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1191 }
1192
1193 type DictlayerdataDictWordsSenses struct {
1194 Conjugations []*DictlayerdataDictWordsSensesConjugations `json:"conjugations,omitempty"`
1195 Definitions []*DictlayerdataDictWordsSensesDefinitions `json:"definitions,omitempty"`
1196 PartOfSpeech string `json:"partOfSpeech,omitempty"`
1197 Pronunciation string `json:"pronunciation,omitempty"`
1198 PronunciationUrl string `json:"pronunciationUrl,omitempty"`
1199 Source *DictlayerdataDictWordsSensesSource `json:"source,omitempty"`
1200 Syllabification string `json:"syllabification,omitempty"`
1201 Synonyms []*DictlayerdataDictWordsSensesSynonyms `json:"synonyms,omitempty"`
1202
1203
1204
1205
1206
1207 ForceSendFields []string `json:"-"`
1208
1209
1210
1211
1212 NullFields []string `json:"-"`
1213 }
1214
1215 func (s *DictlayerdataDictWordsSenses) MarshalJSON() ([]byte, error) {
1216 type NoMethod DictlayerdataDictWordsSenses
1217 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1218 }
1219
1220 type DictlayerdataDictWordsSensesConjugations struct {
1221 Type string `json:"type,omitempty"`
1222 Value string `json:"value,omitempty"`
1223
1224
1225
1226
1227
1228 ForceSendFields []string `json:"-"`
1229
1230
1231
1232
1233 NullFields []string `json:"-"`
1234 }
1235
1236 func (s *DictlayerdataDictWordsSensesConjugations) MarshalJSON() ([]byte, error) {
1237 type NoMethod DictlayerdataDictWordsSensesConjugations
1238 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1239 }
1240
1241 type DictlayerdataDictWordsSensesDefinitions struct {
1242 Definition string `json:"definition,omitempty"`
1243 Examples []*DictlayerdataDictWordsSensesDefinitionsExamples `json:"examples,omitempty"`
1244
1245
1246
1247
1248
1249 ForceSendFields []string `json:"-"`
1250
1251
1252
1253
1254 NullFields []string `json:"-"`
1255 }
1256
1257 func (s *DictlayerdataDictWordsSensesDefinitions) MarshalJSON() ([]byte, error) {
1258 type NoMethod DictlayerdataDictWordsSensesDefinitions
1259 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1260 }
1261
1262 type DictlayerdataDictWordsSensesDefinitionsExamples struct {
1263 Source *DictlayerdataDictWordsSensesDefinitionsExamplesSource `json:"source,omitempty"`
1264 Text string `json:"text,omitempty"`
1265
1266
1267
1268
1269
1270 ForceSendFields []string `json:"-"`
1271
1272
1273
1274
1275 NullFields []string `json:"-"`
1276 }
1277
1278 func (s *DictlayerdataDictWordsSensesDefinitionsExamples) MarshalJSON() ([]byte, error) {
1279 type NoMethod DictlayerdataDictWordsSensesDefinitionsExamples
1280 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1281 }
1282
1283 type DictlayerdataDictWordsSensesDefinitionsExamplesSource struct {
1284 Attribution string `json:"attribution,omitempty"`
1285 Url string `json:"url,omitempty"`
1286
1287
1288
1289
1290
1291 ForceSendFields []string `json:"-"`
1292
1293
1294
1295
1296 NullFields []string `json:"-"`
1297 }
1298
1299 func (s *DictlayerdataDictWordsSensesDefinitionsExamplesSource) MarshalJSON() ([]byte, error) {
1300 type NoMethod DictlayerdataDictWordsSensesDefinitionsExamplesSource
1301 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1302 }
1303
1304 type DictlayerdataDictWordsSensesSource struct {
1305 Attribution string `json:"attribution,omitempty"`
1306 Url string `json:"url,omitempty"`
1307
1308
1309
1310
1311
1312 ForceSendFields []string `json:"-"`
1313
1314
1315
1316
1317 NullFields []string `json:"-"`
1318 }
1319
1320 func (s *DictlayerdataDictWordsSensesSource) MarshalJSON() ([]byte, error) {
1321 type NoMethod DictlayerdataDictWordsSensesSource
1322 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1323 }
1324
1325 type DictlayerdataDictWordsSensesSynonyms struct {
1326 Source *DictlayerdataDictWordsSensesSynonymsSource `json:"source,omitempty"`
1327 Text string `json:"text,omitempty"`
1328
1329
1330
1331
1332
1333 ForceSendFields []string `json:"-"`
1334
1335
1336
1337
1338 NullFields []string `json:"-"`
1339 }
1340
1341 func (s *DictlayerdataDictWordsSensesSynonyms) MarshalJSON() ([]byte, error) {
1342 type NoMethod DictlayerdataDictWordsSensesSynonyms
1343 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1344 }
1345
1346 type DictlayerdataDictWordsSensesSynonymsSource struct {
1347 Attribution string `json:"attribution,omitempty"`
1348 Url string `json:"url,omitempty"`
1349
1350
1351
1352
1353
1354 ForceSendFields []string `json:"-"`
1355
1356
1357
1358
1359 NullFields []string `json:"-"`
1360 }
1361
1362 func (s *DictlayerdataDictWordsSensesSynonymsSource) MarshalJSON() ([]byte, error) {
1363 type NoMethod DictlayerdataDictWordsSensesSynonymsSource
1364 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1365 }
1366
1367
1368
1369 type DictlayerdataDictWordsSource struct {
1370 Attribution string `json:"attribution,omitempty"`
1371 Url string `json:"url,omitempty"`
1372
1373
1374
1375
1376
1377 ForceSendFields []string `json:"-"`
1378
1379
1380
1381
1382 NullFields []string `json:"-"`
1383 }
1384
1385 func (s *DictlayerdataDictWordsSource) MarshalJSON() ([]byte, error) {
1386 type NoMethod DictlayerdataDictWordsSource
1387 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1388 }
1389
1390 type Discoveryclusters struct {
1391 Clusters []*DiscoveryclustersClusters `json:"clusters,omitempty"`
1392
1393 Kind string `json:"kind,omitempty"`
1394 TotalClusters int64 `json:"totalClusters,omitempty"`
1395
1396
1397 googleapi.ServerResponse `json:"-"`
1398
1399
1400
1401
1402
1403 ForceSendFields []string `json:"-"`
1404
1405
1406
1407
1408 NullFields []string `json:"-"`
1409 }
1410
1411 func (s *Discoveryclusters) MarshalJSON() ([]byte, error) {
1412 type NoMethod Discoveryclusters
1413 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1414 }
1415
1416 type DiscoveryclustersClusters struct {
1417 BannerWithContentContainer *DiscoveryclustersClustersBannerWithContentContainer `json:"banner_with_content_container,omitempty"`
1418 SubTitle string `json:"subTitle,omitempty"`
1419 Title string `json:"title,omitempty"`
1420 TotalVolumes int64 `json:"totalVolumes,omitempty"`
1421 Uid string `json:"uid,omitempty"`
1422 Volumes []*Volume `json:"volumes,omitempty"`
1423
1424
1425
1426
1427
1428 ForceSendFields []string `json:"-"`
1429
1430
1431
1432
1433 NullFields []string `json:"-"`
1434 }
1435
1436 func (s *DiscoveryclustersClusters) MarshalJSON() ([]byte, error) {
1437 type NoMethod DiscoveryclustersClusters
1438 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1439 }
1440
1441 type DiscoveryclustersClustersBannerWithContentContainer struct {
1442 FillColorArgb string `json:"fillColorArgb,omitempty"`
1443 ImageUrl string `json:"imageUrl,omitempty"`
1444 MaskColorArgb string `json:"maskColorArgb,omitempty"`
1445 MoreButtonText string `json:"moreButtonText,omitempty"`
1446 MoreButtonUrl string `json:"moreButtonUrl,omitempty"`
1447 TextColorArgb string `json:"textColorArgb,omitempty"`
1448
1449
1450
1451
1452
1453 ForceSendFields []string `json:"-"`
1454
1455
1456
1457
1458 NullFields []string `json:"-"`
1459 }
1460
1461 func (s *DiscoveryclustersClustersBannerWithContentContainer) MarshalJSON() ([]byte, error) {
1462 type NoMethod DiscoveryclustersClustersBannerWithContentContainer
1463 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1464 }
1465
1466 type DownloadAccessRestriction struct {
1467
1468
1469 DeviceAllowed bool `json:"deviceAllowed,omitempty"`
1470
1471
1472 DownloadsAcquired int64 `json:"downloadsAcquired,omitempty"`
1473
1474
1475 JustAcquired bool `json:"justAcquired,omitempty"`
1476
1477 Kind string `json:"kind,omitempty"`
1478
1479
1480 MaxDownloadDevices int64 `json:"maxDownloadDevices,omitempty"`
1481
1482 Message string `json:"message,omitempty"`
1483
1484
1485 Nonce string `json:"nonce,omitempty"`
1486
1487
1488
1489 ReasonCode string `json:"reasonCode,omitempty"`
1490
1491 Restricted bool `json:"restricted,omitempty"`
1492
1493 Signature string `json:"signature,omitempty"`
1494
1495
1496 Source string `json:"source,omitempty"`
1497
1498 VolumeId string `json:"volumeId,omitempty"`
1499
1500
1501
1502
1503
1504 ForceSendFields []string `json:"-"`
1505
1506
1507
1508
1509 NullFields []string `json:"-"`
1510 }
1511
1512 func (s *DownloadAccessRestriction) MarshalJSON() ([]byte, error) {
1513 type NoMethod DownloadAccessRestriction
1514 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1515 }
1516
1517 type DownloadAccesses struct {
1518
1519 DownloadAccessList []*DownloadAccessRestriction `json:"downloadAccessList,omitempty"`
1520
1521 Kind string `json:"kind,omitempty"`
1522
1523
1524 googleapi.ServerResponse `json:"-"`
1525
1526
1527
1528
1529
1530 ForceSendFields []string `json:"-"`
1531
1532
1533
1534
1535 NullFields []string `json:"-"`
1536 }
1537
1538 func (s *DownloadAccesses) MarshalJSON() ([]byte, error) {
1539 type NoMethod DownloadAccesses
1540 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1541 }
1542
1543
1544
1545
1546
1547 type Empty struct {
1548
1549 googleapi.ServerResponse `json:"-"`
1550 }
1551
1552 type FamilyInfo struct {
1553
1554 Kind string `json:"kind,omitempty"`
1555
1556 Membership *FamilyInfoMembership `json:"membership,omitempty"`
1557
1558
1559 googleapi.ServerResponse `json:"-"`
1560
1561
1562
1563
1564
1565 ForceSendFields []string `json:"-"`
1566
1567
1568
1569
1570 NullFields []string `json:"-"`
1571 }
1572
1573 func (s *FamilyInfo) MarshalJSON() ([]byte, error) {
1574 type NoMethod FamilyInfo
1575 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1576 }
1577
1578
1579
1580 type FamilyInfoMembership struct {
1581
1582 AcquirePermission string `json:"acquirePermission,omitempty"`
1583
1584 AgeGroup string `json:"ageGroup,omitempty"`
1585
1586 AllowedMaturityRating string `json:"allowedMaturityRating,omitempty"`
1587 IsInFamily bool `json:"isInFamily,omitempty"`
1588
1589 Role string `json:"role,omitempty"`
1590
1591
1592
1593
1594
1595 ForceSendFields []string `json:"-"`
1596
1597
1598
1599
1600 NullFields []string `json:"-"`
1601 }
1602
1603 func (s *FamilyInfoMembership) MarshalJSON() ([]byte, error) {
1604 type NoMethod FamilyInfoMembership
1605 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1606 }
1607
1608 type GeoAnnotationdata struct {
1609
1610 AnnotationType string `json:"annotationType,omitempty"`
1611
1612
1613 Data *Geolayerdata `json:"data,omitempty"`
1614
1615 EncodedData string `json:"encodedData,omitempty"`
1616
1617 Id string `json:"id,omitempty"`
1618
1619 Kind string `json:"kind,omitempty"`
1620
1621 LayerId string `json:"layerId,omitempty"`
1622
1623 SelfLink string `json:"selfLink,omitempty"`
1624
1625
1626 Updated string `json:"updated,omitempty"`
1627
1628 VolumeId string `json:"volumeId,omitempty"`
1629
1630
1631
1632
1633
1634 ForceSendFields []string `json:"-"`
1635
1636
1637
1638
1639 NullFields []string `json:"-"`
1640 }
1641
1642 func (s *GeoAnnotationdata) MarshalJSON() ([]byte, error) {
1643 type NoMethod GeoAnnotationdata
1644 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1645 }
1646
1647 type Geolayerdata struct {
1648 Common *GeolayerdataCommon `json:"common,omitempty"`
1649 Geo *GeolayerdataGeo `json:"geo,omitempty"`
1650 Kind string `json:"kind,omitempty"`
1651
1652
1653
1654
1655
1656 ForceSendFields []string `json:"-"`
1657
1658
1659
1660
1661 NullFields []string `json:"-"`
1662 }
1663
1664 func (s *Geolayerdata) MarshalJSON() ([]byte, error) {
1665 type NoMethod Geolayerdata
1666 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1667 }
1668
1669 type GeolayerdataCommon struct {
1670
1671 Lang string `json:"lang,omitempty"`
1672
1673 PreviewImageUrl string `json:"previewImageUrl,omitempty"`
1674
1675 Snippet string `json:"snippet,omitempty"`
1676
1677 SnippetUrl string `json:"snippetUrl,omitempty"`
1678
1679
1680 Title string `json:"title,omitempty"`
1681
1682
1683
1684
1685
1686 ForceSendFields []string `json:"-"`
1687
1688
1689
1690
1691 NullFields []string `json:"-"`
1692 }
1693
1694 func (s *GeolayerdataCommon) MarshalJSON() ([]byte, error) {
1695 type NoMethod GeolayerdataCommon
1696 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1697 }
1698
1699 type GeolayerdataGeo struct {
1700
1701
1702 Boundary []string `json:"boundary,omitempty"`
1703
1704
1705 CachePolicy string `json:"cachePolicy,omitempty"`
1706
1707 CountryCode string `json:"countryCode,omitempty"`
1708
1709 Latitude float64 `json:"latitude,omitempty"`
1710
1711 Longitude float64 `json:"longitude,omitempty"`
1712
1713
1714 MapType string `json:"mapType,omitempty"`
1715
1716
1717 Viewport *GeolayerdataGeoViewport `json:"viewport,omitempty"`
1718
1719
1720
1721
1722 Zoom int64 `json:"zoom,omitempty"`
1723
1724
1725
1726
1727
1728 ForceSendFields []string `json:"-"`
1729
1730
1731
1732
1733 NullFields []string `json:"-"`
1734 }
1735
1736 func (s *GeolayerdataGeo) MarshalJSON() ([]byte, error) {
1737 type NoMethod GeolayerdataGeo
1738 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1739 }
1740
1741 func (s *GeolayerdataGeo) UnmarshalJSON(data []byte) error {
1742 type NoMethod GeolayerdataGeo
1743 var s1 struct {
1744 Latitude gensupport.JSONFloat64 `json:"latitude"`
1745 Longitude gensupport.JSONFloat64 `json:"longitude"`
1746 *NoMethod
1747 }
1748 s1.NoMethod = (*NoMethod)(s)
1749 if err := json.Unmarshal(data, &s1); err != nil {
1750 return err
1751 }
1752 s.Latitude = float64(s1.Latitude)
1753 s.Longitude = float64(s1.Longitude)
1754 return nil
1755 }
1756
1757
1758
1759 type GeolayerdataGeoViewport struct {
1760 Hi *GeolayerdataGeoViewportHi `json:"hi,omitempty"`
1761 Lo *GeolayerdataGeoViewportLo `json:"lo,omitempty"`
1762
1763
1764
1765
1766
1767 ForceSendFields []string `json:"-"`
1768
1769
1770
1771
1772 NullFields []string `json:"-"`
1773 }
1774
1775 func (s *GeolayerdataGeoViewport) MarshalJSON() ([]byte, error) {
1776 type NoMethod GeolayerdataGeoViewport
1777 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1778 }
1779
1780 type GeolayerdataGeoViewportHi struct {
1781 Latitude float64 `json:"latitude,omitempty"`
1782 Longitude float64 `json:"longitude,omitempty"`
1783
1784
1785
1786
1787
1788 ForceSendFields []string `json:"-"`
1789
1790
1791
1792
1793 NullFields []string `json:"-"`
1794 }
1795
1796 func (s *GeolayerdataGeoViewportHi) MarshalJSON() ([]byte, error) {
1797 type NoMethod GeolayerdataGeoViewportHi
1798 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1799 }
1800
1801 func (s *GeolayerdataGeoViewportHi) UnmarshalJSON(data []byte) error {
1802 type NoMethod GeolayerdataGeoViewportHi
1803 var s1 struct {
1804 Latitude gensupport.JSONFloat64 `json:"latitude"`
1805 Longitude gensupport.JSONFloat64 `json:"longitude"`
1806 *NoMethod
1807 }
1808 s1.NoMethod = (*NoMethod)(s)
1809 if err := json.Unmarshal(data, &s1); err != nil {
1810 return err
1811 }
1812 s.Latitude = float64(s1.Latitude)
1813 s.Longitude = float64(s1.Longitude)
1814 return nil
1815 }
1816
1817 type GeolayerdataGeoViewportLo struct {
1818 Latitude float64 `json:"latitude,omitempty"`
1819 Longitude float64 `json:"longitude,omitempty"`
1820
1821
1822
1823
1824
1825 ForceSendFields []string `json:"-"`
1826
1827
1828
1829
1830 NullFields []string `json:"-"`
1831 }
1832
1833 func (s *GeolayerdataGeoViewportLo) MarshalJSON() ([]byte, error) {
1834 type NoMethod GeolayerdataGeoViewportLo
1835 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1836 }
1837
1838 func (s *GeolayerdataGeoViewportLo) UnmarshalJSON(data []byte) error {
1839 type NoMethod GeolayerdataGeoViewportLo
1840 var s1 struct {
1841 Latitude gensupport.JSONFloat64 `json:"latitude"`
1842 Longitude gensupport.JSONFloat64 `json:"longitude"`
1843 *NoMethod
1844 }
1845 s1.NoMethod = (*NoMethod)(s)
1846 if err := json.Unmarshal(data, &s1); err != nil {
1847 return err
1848 }
1849 s.Latitude = float64(s1.Latitude)
1850 s.Longitude = float64(s1.Longitude)
1851 return nil
1852 }
1853
1854 type Layersummaries struct {
1855
1856 Items []*Layersummary `json:"items,omitempty"`
1857
1858 Kind string `json:"kind,omitempty"`
1859
1860 TotalItems int64 `json:"totalItems,omitempty"`
1861
1862
1863 googleapi.ServerResponse `json:"-"`
1864
1865
1866
1867
1868
1869 ForceSendFields []string `json:"-"`
1870
1871
1872
1873
1874 NullFields []string `json:"-"`
1875 }
1876
1877 func (s *Layersummaries) MarshalJSON() ([]byte, error) {
1878 type NoMethod Layersummaries
1879 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1880 }
1881
1882 type Layersummary struct {
1883
1884 AnnotationCount int64 `json:"annotationCount,omitempty"`
1885
1886 AnnotationTypes []string `json:"annotationTypes,omitempty"`
1887
1888 AnnotationsDataLink string `json:"annotationsDataLink,omitempty"`
1889
1890 AnnotationsLink string `json:"annotationsLink,omitempty"`
1891
1892 ContentVersion string `json:"contentVersion,omitempty"`
1893
1894 DataCount int64 `json:"dataCount,omitempty"`
1895
1896 Id string `json:"id,omitempty"`
1897
1898 Kind string `json:"kind,omitempty"`
1899
1900 LayerId string `json:"layerId,omitempty"`
1901
1902 SelfLink string `json:"selfLink,omitempty"`
1903
1904
1905 Updated string `json:"updated,omitempty"`
1906
1907
1908
1909
1910 VolumeAnnotationsVersion string `json:"volumeAnnotationsVersion,omitempty"`
1911
1912 VolumeId string `json:"volumeId,omitempty"`
1913
1914
1915 googleapi.ServerResponse `json:"-"`
1916
1917
1918
1919
1920
1921 ForceSendFields []string `json:"-"`
1922
1923
1924
1925
1926 NullFields []string `json:"-"`
1927 }
1928
1929 func (s *Layersummary) MarshalJSON() ([]byte, error) {
1930 type NoMethod Layersummary
1931 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1932 }
1933
1934 type Metadata struct {
1935
1936 Items []*MetadataItems `json:"items,omitempty"`
1937
1938 Kind string `json:"kind,omitempty"`
1939
1940
1941 googleapi.ServerResponse `json:"-"`
1942
1943
1944
1945
1946
1947 ForceSendFields []string `json:"-"`
1948
1949
1950
1951
1952 NullFields []string `json:"-"`
1953 }
1954
1955 func (s *Metadata) MarshalJSON() ([]byte, error) {
1956 type NoMethod Metadata
1957 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1958 }
1959
1960 type MetadataItems struct {
1961 DownloadUrl string `json:"download_url,omitempty"`
1962 EncryptedKey string `json:"encrypted_key,omitempty"`
1963 Language string `json:"language,omitempty"`
1964 Size int64 `json:"size,omitempty,string"`
1965 Version int64 `json:"version,omitempty,string"`
1966
1967
1968
1969
1970
1971 ForceSendFields []string `json:"-"`
1972
1973
1974
1975
1976 NullFields []string `json:"-"`
1977 }
1978
1979 func (s *MetadataItems) MarshalJSON() ([]byte, error) {
1980 type NoMethod MetadataItems
1981 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1982 }
1983
1984 type Notification struct {
1985 Body string `json:"body,omitempty"`
1986
1987 CrmExperimentIds googleapi.Int64s `json:"crmExperimentIds,omitempty"`
1988 DocId string `json:"doc_id,omitempty"`
1989 DocType string `json:"doc_type,omitempty"`
1990 DontShowNotification bool `json:"dont_show_notification,omitempty"`
1991 IconUrl string `json:"iconUrl,omitempty"`
1992 IsDocumentMature bool `json:"is_document_mature,omitempty"`
1993
1994 Kind string `json:"kind,omitempty"`
1995 NotificationGroup string `json:"notificationGroup,omitempty"`
1996 NotificationType string `json:"notification_type,omitempty"`
1997 PcampaignId string `json:"pcampaign_id,omitempty"`
1998 Reason string `json:"reason,omitempty"`
1999 ShowNotificationSettingsAction bool `json:"show_notification_settings_action,omitempty"`
2000 TargetUrl string `json:"targetUrl,omitempty"`
2001 TimeToExpireMs int64 `json:"timeToExpireMs,omitempty,string"`
2002 Title string `json:"title,omitempty"`
2003
2004
2005 googleapi.ServerResponse `json:"-"`
2006
2007
2008
2009
2010
2011 ForceSendFields []string `json:"-"`
2012
2013
2014
2015
2016 NullFields []string `json:"-"`
2017 }
2018
2019 func (s *Notification) MarshalJSON() ([]byte, error) {
2020 type NoMethod Notification
2021 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2022 }
2023
2024 type Offers struct {
2025
2026 Items []*OffersItems `json:"items,omitempty"`
2027
2028 Kind string `json:"kind,omitempty"`
2029
2030
2031 googleapi.ServerResponse `json:"-"`
2032
2033
2034
2035
2036
2037 ForceSendFields []string `json:"-"`
2038
2039
2040
2041
2042 NullFields []string `json:"-"`
2043 }
2044
2045 func (s *Offers) MarshalJSON() ([]byte, error) {
2046 type NoMethod Offers
2047 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2048 }
2049
2050 type OffersItems struct {
2051 ArtUrl string `json:"artUrl,omitempty"`
2052 GservicesKey string `json:"gservicesKey,omitempty"`
2053 Id string `json:"id,omitempty"`
2054 Items []*OffersItemsItems `json:"items,omitempty"`
2055
2056
2057
2058
2059
2060 ForceSendFields []string `json:"-"`
2061
2062
2063
2064
2065 NullFields []string `json:"-"`
2066 }
2067
2068 func (s *OffersItems) MarshalJSON() ([]byte, error) {
2069 type NoMethod OffersItems
2070 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2071 }
2072
2073 type OffersItemsItems struct {
2074 Author string `json:"author,omitempty"`
2075 CanonicalVolumeLink string `json:"canonicalVolumeLink,omitempty"`
2076 CoverUrl string `json:"coverUrl,omitempty"`
2077 Description string `json:"description,omitempty"`
2078 Title string `json:"title,omitempty"`
2079 VolumeId string `json:"volumeId,omitempty"`
2080
2081
2082
2083
2084
2085 ForceSendFields []string `json:"-"`
2086
2087
2088
2089
2090 NullFields []string `json:"-"`
2091 }
2092
2093 func (s *OffersItemsItems) MarshalJSON() ([]byte, error) {
2094 type NoMethod OffersItemsItems
2095 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2096 }
2097
2098 type ReadingPosition struct {
2099
2100 EpubCfiPosition string `json:"epubCfiPosition,omitempty"`
2101
2102 GbImagePosition string `json:"gbImagePosition,omitempty"`
2103
2104 GbTextPosition string `json:"gbTextPosition,omitempty"`
2105
2106 Kind string `json:"kind,omitempty"`
2107
2108 PdfPosition string `json:"pdfPosition,omitempty"`
2109
2110
2111 Updated string `json:"updated,omitempty"`
2112
2113 VolumeId string `json:"volumeId,omitempty"`
2114
2115
2116 googleapi.ServerResponse `json:"-"`
2117
2118
2119
2120
2121
2122 ForceSendFields []string `json:"-"`
2123
2124
2125
2126
2127 NullFields []string `json:"-"`
2128 }
2129
2130 func (s *ReadingPosition) MarshalJSON() ([]byte, error) {
2131 type NoMethod ReadingPosition
2132 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2133 }
2134
2135 type RequestAccessData struct {
2136
2137 ConcurrentAccess *ConcurrentAccessRestriction `json:"concurrentAccess,omitempty"`
2138
2139 DownloadAccess *DownloadAccessRestriction `json:"downloadAccess,omitempty"`
2140
2141 Kind string `json:"kind,omitempty"`
2142
2143
2144 googleapi.ServerResponse `json:"-"`
2145
2146
2147
2148
2149
2150 ForceSendFields []string `json:"-"`
2151
2152
2153
2154
2155 NullFields []string `json:"-"`
2156 }
2157
2158 func (s *RequestAccessData) MarshalJSON() ([]byte, error) {
2159 type NoMethod RequestAccessData
2160 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2161 }
2162
2163 type Review struct {
2164
2165 Author *ReviewAuthor `json:"author,omitempty"`
2166
2167 Content string `json:"content,omitempty"`
2168
2169 Date string `json:"date,omitempty"`
2170
2171
2172 FullTextUrl string `json:"fullTextUrl,omitempty"`
2173
2174 Kind string `json:"kind,omitempty"`
2175
2176
2177 Rating string `json:"rating,omitempty"`
2178
2179
2180 Source *ReviewSource `json:"source,omitempty"`
2181
2182 Title string `json:"title,omitempty"`
2183
2184
2185 Type string `json:"type,omitempty"`
2186
2187 VolumeId string `json:"volumeId,omitempty"`
2188
2189
2190
2191
2192
2193 ForceSendFields []string `json:"-"`
2194
2195
2196
2197
2198 NullFields []string `json:"-"`
2199 }
2200
2201 func (s *Review) MarshalJSON() ([]byte, error) {
2202 type NoMethod Review
2203 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2204 }
2205
2206
2207 type ReviewAuthor struct {
2208
2209 DisplayName string `json:"displayName,omitempty"`
2210
2211
2212
2213
2214
2215 ForceSendFields []string `json:"-"`
2216
2217
2218
2219
2220 NullFields []string `json:"-"`
2221 }
2222
2223 func (s *ReviewAuthor) MarshalJSON() ([]byte, error) {
2224 type NoMethod ReviewAuthor
2225 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2226 }
2227
2228
2229
2230 type ReviewSource struct {
2231
2232 Description string `json:"description,omitempty"`
2233
2234 ExtraDescription string `json:"extraDescription,omitempty"`
2235
2236 Url string `json:"url,omitempty"`
2237
2238
2239
2240
2241
2242 ForceSendFields []string `json:"-"`
2243
2244
2245
2246
2247 NullFields []string `json:"-"`
2248 }
2249
2250 func (s *ReviewSource) MarshalJSON() ([]byte, error) {
2251 type NoMethod ReviewSource
2252 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2253 }
2254
2255 type Series struct {
2256
2257 Kind string `json:"kind,omitempty"`
2258 Series []*SeriesSeries `json:"series,omitempty"`
2259
2260
2261 googleapi.ServerResponse `json:"-"`
2262
2263
2264
2265
2266
2267 ForceSendFields []string `json:"-"`
2268
2269
2270
2271
2272 NullFields []string `json:"-"`
2273 }
2274
2275 func (s *Series) MarshalJSON() ([]byte, error) {
2276 type NoMethod Series
2277 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2278 }
2279
2280 type SeriesSeries struct {
2281 BannerImageUrl string `json:"bannerImageUrl,omitempty"`
2282 EligibleForSubscription bool `json:"eligibleForSubscription,omitempty"`
2283 ImageUrl string `json:"imageUrl,omitempty"`
2284 IsComplete bool `json:"isComplete,omitempty"`
2285 SeriesFormatType string `json:"seriesFormatType,omitempty"`
2286 SeriesId string `json:"seriesId,omitempty"`
2287 SeriesSubscriptionReleaseInfo *SeriesSeriesSeriesSubscriptionReleaseInfo `json:"seriesSubscriptionReleaseInfo,omitempty"`
2288 SeriesType string `json:"seriesType,omitempty"`
2289 SubscriptionId string `json:"subscriptionId,omitempty"`
2290 Title string `json:"title,omitempty"`
2291
2292
2293
2294
2295
2296 ForceSendFields []string `json:"-"`
2297
2298
2299
2300
2301 NullFields []string `json:"-"`
2302 }
2303
2304 func (s *SeriesSeries) MarshalJSON() ([]byte, error) {
2305 type NoMethod SeriesSeries
2306 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2307 }
2308
2309 type SeriesSeriesSeriesSubscriptionReleaseInfo struct {
2310 CancelTime string `json:"cancelTime,omitempty"`
2311 CurrentReleaseInfo *SeriesSeriesSeriesSubscriptionReleaseInfoCurrentReleaseInfo `json:"currentReleaseInfo,omitempty"`
2312 NextReleaseInfo *SeriesSeriesSeriesSubscriptionReleaseInfoNextReleaseInfo `json:"nextReleaseInfo,omitempty"`
2313 SeriesSubscriptionType string `json:"seriesSubscriptionType,omitempty"`
2314
2315
2316
2317
2318
2319 ForceSendFields []string `json:"-"`
2320
2321
2322
2323
2324 NullFields []string `json:"-"`
2325 }
2326
2327 func (s *SeriesSeriesSeriesSubscriptionReleaseInfo) MarshalJSON() ([]byte, error) {
2328 type NoMethod SeriesSeriesSeriesSubscriptionReleaseInfo
2329 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2330 }
2331
2332 type SeriesSeriesSeriesSubscriptionReleaseInfoCurrentReleaseInfo struct {
2333 AmountInMicros float64 `json:"amountInMicros,omitempty"`
2334 CurrencyCode string `json:"currencyCode,omitempty"`
2335 ReleaseNumber string `json:"releaseNumber,omitempty"`
2336 ReleaseTime string `json:"releaseTime,omitempty"`
2337
2338
2339
2340
2341
2342 ForceSendFields []string `json:"-"`
2343
2344
2345
2346
2347 NullFields []string `json:"-"`
2348 }
2349
2350 func (s *SeriesSeriesSeriesSubscriptionReleaseInfoCurrentReleaseInfo) MarshalJSON() ([]byte, error) {
2351 type NoMethod SeriesSeriesSeriesSubscriptionReleaseInfoCurrentReleaseInfo
2352 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2353 }
2354
2355 func (s *SeriesSeriesSeriesSubscriptionReleaseInfoCurrentReleaseInfo) UnmarshalJSON(data []byte) error {
2356 type NoMethod SeriesSeriesSeriesSubscriptionReleaseInfoCurrentReleaseInfo
2357 var s1 struct {
2358 AmountInMicros gensupport.JSONFloat64 `json:"amountInMicros"`
2359 *NoMethod
2360 }
2361 s1.NoMethod = (*NoMethod)(s)
2362 if err := json.Unmarshal(data, &s1); err != nil {
2363 return err
2364 }
2365 s.AmountInMicros = float64(s1.AmountInMicros)
2366 return nil
2367 }
2368
2369 type SeriesSeriesSeriesSubscriptionReleaseInfoNextReleaseInfo struct {
2370 AmountInMicros float64 `json:"amountInMicros,omitempty"`
2371 CurrencyCode string `json:"currencyCode,omitempty"`
2372 ReleaseNumber string `json:"releaseNumber,omitempty"`
2373 ReleaseTime string `json:"releaseTime,omitempty"`
2374
2375
2376
2377
2378
2379 ForceSendFields []string `json:"-"`
2380
2381
2382
2383
2384 NullFields []string `json:"-"`
2385 }
2386
2387 func (s *SeriesSeriesSeriesSubscriptionReleaseInfoNextReleaseInfo) MarshalJSON() ([]byte, error) {
2388 type NoMethod SeriesSeriesSeriesSubscriptionReleaseInfoNextReleaseInfo
2389 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2390 }
2391
2392 func (s *SeriesSeriesSeriesSubscriptionReleaseInfoNextReleaseInfo) UnmarshalJSON(data []byte) error {
2393 type NoMethod SeriesSeriesSeriesSubscriptionReleaseInfoNextReleaseInfo
2394 var s1 struct {
2395 AmountInMicros gensupport.JSONFloat64 `json:"amountInMicros"`
2396 *NoMethod
2397 }
2398 s1.NoMethod = (*NoMethod)(s)
2399 if err := json.Unmarshal(data, &s1); err != nil {
2400 return err
2401 }
2402 s.AmountInMicros = float64(s1.AmountInMicros)
2403 return nil
2404 }
2405
2406 type Seriesmembership struct {
2407
2408 Kind string `json:"kind,omitempty"`
2409 Member []*Volume `json:"member,omitempty"`
2410 NextPageToken string `json:"nextPageToken,omitempty"`
2411
2412
2413 googleapi.ServerResponse `json:"-"`
2414
2415
2416
2417
2418
2419 ForceSendFields []string `json:"-"`
2420
2421
2422
2423
2424 NullFields []string `json:"-"`
2425 }
2426
2427 func (s *Seriesmembership) MarshalJSON() ([]byte, error) {
2428 type NoMethod Seriesmembership
2429 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2430 }
2431
2432 type Usersettings struct {
2433
2434 Kind string `json:"kind,omitempty"`
2435
2436 NotesExport *UsersettingsNotesExport `json:"notesExport,omitempty"`
2437 Notification *UsersettingsNotification `json:"notification,omitempty"`
2438
2439
2440 googleapi.ServerResponse `json:"-"`
2441
2442
2443
2444
2445
2446 ForceSendFields []string `json:"-"`
2447
2448
2449
2450
2451 NullFields []string `json:"-"`
2452 }
2453
2454 func (s *Usersettings) MarshalJSON() ([]byte, error) {
2455 type NoMethod Usersettings
2456 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2457 }
2458
2459
2460
2461 type UsersettingsNotesExport struct {
2462 FolderName string `json:"folderName,omitempty"`
2463 IsEnabled bool `json:"isEnabled,omitempty"`
2464
2465
2466
2467
2468
2469 ForceSendFields []string `json:"-"`
2470
2471
2472
2473
2474 NullFields []string `json:"-"`
2475 }
2476
2477 func (s *UsersettingsNotesExport) MarshalJSON() ([]byte, error) {
2478 type NoMethod UsersettingsNotesExport
2479 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2480 }
2481
2482 type UsersettingsNotification struct {
2483 MatchMyInterests *UsersettingsNotificationMatchMyInterests `json:"matchMyInterests,omitempty"`
2484 MoreFromAuthors *UsersettingsNotificationMoreFromAuthors `json:"moreFromAuthors,omitempty"`
2485 MoreFromSeries *UsersettingsNotificationMoreFromSeries `json:"moreFromSeries,omitempty"`
2486 PriceDrop *UsersettingsNotificationPriceDrop `json:"priceDrop,omitempty"`
2487 RewardExpirations *UsersettingsNotificationRewardExpirations `json:"rewardExpirations,omitempty"`
2488
2489
2490
2491
2492
2493 ForceSendFields []string `json:"-"`
2494
2495
2496
2497
2498 NullFields []string `json:"-"`
2499 }
2500
2501 func (s *UsersettingsNotification) MarshalJSON() ([]byte, error) {
2502 type NoMethod UsersettingsNotification
2503 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2504 }
2505
2506 type UsersettingsNotificationMatchMyInterests struct {
2507 OptedState string `json:"opted_state,omitempty"`
2508
2509
2510
2511
2512
2513 ForceSendFields []string `json:"-"`
2514
2515
2516
2517
2518 NullFields []string `json:"-"`
2519 }
2520
2521 func (s *UsersettingsNotificationMatchMyInterests) MarshalJSON() ([]byte, error) {
2522 type NoMethod UsersettingsNotificationMatchMyInterests
2523 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2524 }
2525
2526 type UsersettingsNotificationMoreFromAuthors struct {
2527 OptedState string `json:"opted_state,omitempty"`
2528
2529
2530
2531
2532
2533 ForceSendFields []string `json:"-"`
2534
2535
2536
2537
2538 NullFields []string `json:"-"`
2539 }
2540
2541 func (s *UsersettingsNotificationMoreFromAuthors) MarshalJSON() ([]byte, error) {
2542 type NoMethod UsersettingsNotificationMoreFromAuthors
2543 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2544 }
2545
2546 type UsersettingsNotificationMoreFromSeries struct {
2547 OptedState string `json:"opted_state,omitempty"`
2548
2549
2550
2551
2552
2553 ForceSendFields []string `json:"-"`
2554
2555
2556
2557
2558 NullFields []string `json:"-"`
2559 }
2560
2561 func (s *UsersettingsNotificationMoreFromSeries) MarshalJSON() ([]byte, error) {
2562 type NoMethod UsersettingsNotificationMoreFromSeries
2563 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2564 }
2565
2566 type UsersettingsNotificationPriceDrop struct {
2567 OptedState string `json:"opted_state,omitempty"`
2568
2569
2570
2571
2572
2573 ForceSendFields []string `json:"-"`
2574
2575
2576
2577
2578 NullFields []string `json:"-"`
2579 }
2580
2581 func (s *UsersettingsNotificationPriceDrop) MarshalJSON() ([]byte, error) {
2582 type NoMethod UsersettingsNotificationPriceDrop
2583 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2584 }
2585
2586 type UsersettingsNotificationRewardExpirations struct {
2587 OptedState string `json:"opted_state,omitempty"`
2588
2589
2590
2591
2592
2593 ForceSendFields []string `json:"-"`
2594
2595
2596
2597
2598 NullFields []string `json:"-"`
2599 }
2600
2601 func (s *UsersettingsNotificationRewardExpirations) MarshalJSON() ([]byte, error) {
2602 type NoMethod UsersettingsNotificationRewardExpirations
2603 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2604 }
2605
2606 type Volume struct {
2607
2608
2609
2610 AccessInfo *VolumeAccessInfo `json:"accessInfo,omitempty"`
2611
2612
2613 Etag string `json:"etag,omitempty"`
2614
2615 Id string `json:"id,omitempty"`
2616
2617 Kind string `json:"kind,omitempty"`
2618
2619
2620 LayerInfo *VolumeLayerInfo `json:"layerInfo,omitempty"`
2621
2622 RecommendedInfo *VolumeRecommendedInfo `json:"recommendedInfo,omitempty"`
2623
2624
2625
2626
2627 SaleInfo *VolumeSaleInfo `json:"saleInfo,omitempty"`
2628
2629 SearchInfo *VolumeSearchInfo `json:"searchInfo,omitempty"`
2630
2631 SelfLink string `json:"selfLink,omitempty"`
2632
2633
2634 UserInfo *VolumeUserInfo `json:"userInfo,omitempty"`
2635
2636 VolumeInfo *VolumeVolumeInfo `json:"volumeInfo,omitempty"`
2637
2638
2639 googleapi.ServerResponse `json:"-"`
2640
2641
2642
2643
2644
2645 ForceSendFields []string `json:"-"`
2646
2647
2648
2649
2650 NullFields []string `json:"-"`
2651 }
2652
2653 func (s *Volume) MarshalJSON() ([]byte, error) {
2654 type NoMethod Volume
2655 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2656 }
2657
2658
2659
2660
2661 type VolumeAccessInfo struct {
2662
2663
2664
2665 AccessViewStatus string `json:"accessViewStatus,omitempty"`
2666
2667
2668 Country string `json:"country,omitempty"`
2669
2670
2671 DownloadAccess *DownloadAccessRestriction `json:"downloadAccess,omitempty"`
2672
2673
2674 DriveImportedContentLink string `json:"driveImportedContentLink,omitempty"`
2675
2676
2677 Embeddable bool `json:"embeddable,omitempty"`
2678
2679 Epub *VolumeAccessInfoEpub `json:"epub,omitempty"`
2680
2681
2682
2683 ExplicitOfflineLicenseManagement bool `json:"explicitOfflineLicenseManagement,omitempty"`
2684
2685 Pdf *VolumeAccessInfoPdf `json:"pdf,omitempty"`
2686
2687
2688 PublicDomain bool `json:"publicDomain,omitempty"`
2689
2690 QuoteSharingAllowed bool `json:"quoteSharingAllowed,omitempty"`
2691
2692
2693 TextToSpeechPermission string `json:"textToSpeechPermission,omitempty"`
2694
2695
2696 ViewOrderUrl string `json:"viewOrderUrl,omitempty"`
2697
2698
2699
2700
2701
2702
2703 Viewability string `json:"viewability,omitempty"`
2704
2705
2706 WebReaderLink string `json:"webReaderLink,omitempty"`
2707
2708
2709
2710
2711
2712 ForceSendFields []string `json:"-"`
2713
2714
2715
2716
2717 NullFields []string `json:"-"`
2718 }
2719
2720 func (s *VolumeAccessInfo) MarshalJSON() ([]byte, error) {
2721 type NoMethod VolumeAccessInfo
2722 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2723 }
2724
2725
2726 type VolumeAccessInfoEpub struct {
2727
2728
2729 AcsTokenLink string `json:"acsTokenLink,omitempty"`
2730
2731 DownloadLink string `json:"downloadLink,omitempty"`
2732
2733
2734 IsAvailable bool `json:"isAvailable,omitempty"`
2735
2736
2737
2738
2739
2740 ForceSendFields []string `json:"-"`
2741
2742
2743
2744
2745 NullFields []string `json:"-"`
2746 }
2747
2748 func (s *VolumeAccessInfoEpub) MarshalJSON() ([]byte, error) {
2749 type NoMethod VolumeAccessInfoEpub
2750 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2751 }
2752
2753
2754 type VolumeAccessInfoPdf struct {
2755
2756
2757 AcsTokenLink string `json:"acsTokenLink,omitempty"`
2758
2759 DownloadLink string `json:"downloadLink,omitempty"`
2760
2761
2762 IsAvailable bool `json:"isAvailable,omitempty"`
2763
2764
2765
2766
2767
2768 ForceSendFields []string `json:"-"`
2769
2770
2771
2772
2773 NullFields []string `json:"-"`
2774 }
2775
2776 func (s *VolumeAccessInfoPdf) MarshalJSON() ([]byte, error) {
2777 type NoMethod VolumeAccessInfoPdf
2778 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2779 }
2780
2781
2782
2783 type VolumeLayerInfo struct {
2784
2785
2786 Layers []*VolumeLayerInfoLayers `json:"layers,omitempty"`
2787
2788
2789
2790
2791
2792 ForceSendFields []string `json:"-"`
2793
2794
2795
2796
2797 NullFields []string `json:"-"`
2798 }
2799
2800 func (s *VolumeLayerInfo) MarshalJSON() ([]byte, error) {
2801 type NoMethod VolumeLayerInfo
2802 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2803 }
2804
2805 type VolumeLayerInfoLayers struct {
2806
2807 LayerId string `json:"layerId,omitempty"`
2808
2809
2810
2811
2812 VolumeAnnotationsVersion string `json:"volumeAnnotationsVersion,omitempty"`
2813
2814
2815
2816
2817
2818 ForceSendFields []string `json:"-"`
2819
2820
2821
2822
2823 NullFields []string `json:"-"`
2824 }
2825
2826 func (s *VolumeLayerInfoLayers) MarshalJSON() ([]byte, error) {
2827 type NoMethod VolumeLayerInfoLayers
2828 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2829 }
2830
2831
2832 type VolumeRecommendedInfo struct {
2833
2834 Explanation string `json:"explanation,omitempty"`
2835
2836
2837
2838
2839
2840 ForceSendFields []string `json:"-"`
2841
2842
2843
2844
2845 NullFields []string `json:"-"`
2846 }
2847
2848 func (s *VolumeRecommendedInfo) MarshalJSON() ([]byte, error) {
2849 type NoMethod VolumeRecommendedInfo
2850 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2851 }
2852
2853
2854
2855
2856
2857 type VolumeSaleInfo struct {
2858
2859
2860 BuyLink string `json:"buyLink,omitempty"`
2861
2862
2863 Country string `json:"country,omitempty"`
2864
2865
2866 IsEbook bool `json:"isEbook,omitempty"`
2867
2868 ListPrice *VolumeSaleInfoListPrice `json:"listPrice,omitempty"`
2869
2870 Offers []*VolumeSaleInfoOffers `json:"offers,omitempty"`
2871
2872 OnSaleDate string `json:"onSaleDate,omitempty"`
2873
2874
2875
2876 RetailPrice *VolumeSaleInfoRetailPrice `json:"retailPrice,omitempty"`
2877
2878
2879
2880
2881 Saleability string `json:"saleability,omitempty"`
2882
2883
2884
2885
2886
2887 ForceSendFields []string `json:"-"`
2888
2889
2890
2891
2892 NullFields []string `json:"-"`
2893 }
2894
2895 func (s *VolumeSaleInfo) MarshalJSON() ([]byte, error) {
2896 type NoMethod VolumeSaleInfo
2897 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2898 }
2899
2900
2901 type VolumeSaleInfoListPrice struct {
2902
2903 Amount float64 `json:"amount,omitempty"`
2904
2905 CurrencyCode string `json:"currencyCode,omitempty"`
2906
2907
2908
2909
2910
2911 ForceSendFields []string `json:"-"`
2912
2913
2914
2915
2916 NullFields []string `json:"-"`
2917 }
2918
2919 func (s *VolumeSaleInfoListPrice) MarshalJSON() ([]byte, error) {
2920 type NoMethod VolumeSaleInfoListPrice
2921 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2922 }
2923
2924 func (s *VolumeSaleInfoListPrice) UnmarshalJSON(data []byte) error {
2925 type NoMethod VolumeSaleInfoListPrice
2926 var s1 struct {
2927 Amount gensupport.JSONFloat64 `json:"amount"`
2928 *NoMethod
2929 }
2930 s1.NoMethod = (*NoMethod)(s)
2931 if err := json.Unmarshal(data, &s1); err != nil {
2932 return err
2933 }
2934 s.Amount = float64(s1.Amount)
2935 return nil
2936 }
2937
2938 type VolumeSaleInfoOffers struct {
2939
2940 FinskyOfferType int64 `json:"finskyOfferType,omitempty"`
2941
2942 Giftable bool `json:"giftable,omitempty"`
2943
2944 ListPrice *VolumeSaleInfoOffersListPrice `json:"listPrice,omitempty"`
2945
2946 RentalDuration *VolumeSaleInfoOffersRentalDuration `json:"rentalDuration,omitempty"`
2947
2948 RetailPrice *VolumeSaleInfoOffersRetailPrice `json:"retailPrice,omitempty"`
2949
2950
2951
2952
2953
2954 ForceSendFields []string `json:"-"`
2955
2956
2957
2958
2959 NullFields []string `json:"-"`
2960 }
2961
2962 func (s *VolumeSaleInfoOffers) MarshalJSON() ([]byte, error) {
2963 type NoMethod VolumeSaleInfoOffers
2964 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2965 }
2966
2967
2968 type VolumeSaleInfoOffersListPrice struct {
2969 AmountInMicros float64 `json:"amountInMicros,omitempty"`
2970 CurrencyCode string `json:"currencyCode,omitempty"`
2971
2972
2973
2974
2975
2976 ForceSendFields []string `json:"-"`
2977
2978
2979
2980
2981 NullFields []string `json:"-"`
2982 }
2983
2984 func (s *VolumeSaleInfoOffersListPrice) MarshalJSON() ([]byte, error) {
2985 type NoMethod VolumeSaleInfoOffersListPrice
2986 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2987 }
2988
2989 func (s *VolumeSaleInfoOffersListPrice) UnmarshalJSON(data []byte) error {
2990 type NoMethod VolumeSaleInfoOffersListPrice
2991 var s1 struct {
2992 AmountInMicros gensupport.JSONFloat64 `json:"amountInMicros"`
2993 *NoMethod
2994 }
2995 s1.NoMethod = (*NoMethod)(s)
2996 if err := json.Unmarshal(data, &s1); err != nil {
2997 return err
2998 }
2999 s.AmountInMicros = float64(s1.AmountInMicros)
3000 return nil
3001 }
3002
3003
3004
3005 type VolumeSaleInfoOffersRentalDuration struct {
3006 Count float64 `json:"count,omitempty"`
3007 Unit string `json:"unit,omitempty"`
3008
3009
3010
3011
3012
3013 ForceSendFields []string `json:"-"`
3014
3015
3016
3017
3018 NullFields []string `json:"-"`
3019 }
3020
3021 func (s *VolumeSaleInfoOffersRentalDuration) MarshalJSON() ([]byte, error) {
3022 type NoMethod VolumeSaleInfoOffersRentalDuration
3023 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3024 }
3025
3026 func (s *VolumeSaleInfoOffersRentalDuration) UnmarshalJSON(data []byte) error {
3027 type NoMethod VolumeSaleInfoOffersRentalDuration
3028 var s1 struct {
3029 Count gensupport.JSONFloat64 `json:"count"`
3030 *NoMethod
3031 }
3032 s1.NoMethod = (*NoMethod)(s)
3033 if err := json.Unmarshal(data, &s1); err != nil {
3034 return err
3035 }
3036 s.Count = float64(s1.Count)
3037 return nil
3038 }
3039
3040
3041 type VolumeSaleInfoOffersRetailPrice struct {
3042 AmountInMicros float64 `json:"amountInMicros,omitempty"`
3043 CurrencyCode string `json:"currencyCode,omitempty"`
3044
3045
3046
3047
3048
3049 ForceSendFields []string `json:"-"`
3050
3051
3052
3053
3054 NullFields []string `json:"-"`
3055 }
3056
3057 func (s *VolumeSaleInfoOffersRetailPrice) MarshalJSON() ([]byte, error) {
3058 type NoMethod VolumeSaleInfoOffersRetailPrice
3059 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3060 }
3061
3062 func (s *VolumeSaleInfoOffersRetailPrice) UnmarshalJSON(data []byte) error {
3063 type NoMethod VolumeSaleInfoOffersRetailPrice
3064 var s1 struct {
3065 AmountInMicros gensupport.JSONFloat64 `json:"amountInMicros"`
3066 *NoMethod
3067 }
3068 s1.NoMethod = (*NoMethod)(s)
3069 if err := json.Unmarshal(data, &s1); err != nil {
3070 return err
3071 }
3072 s.AmountInMicros = float64(s1.AmountInMicros)
3073 return nil
3074 }
3075
3076
3077
3078
3079 type VolumeSaleInfoRetailPrice struct {
3080
3081 Amount float64 `json:"amount,omitempty"`
3082
3083 CurrencyCode string `json:"currencyCode,omitempty"`
3084
3085
3086
3087
3088
3089 ForceSendFields []string `json:"-"`
3090
3091
3092
3093
3094 NullFields []string `json:"-"`
3095 }
3096
3097 func (s *VolumeSaleInfoRetailPrice) MarshalJSON() ([]byte, error) {
3098 type NoMethod VolumeSaleInfoRetailPrice
3099 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3100 }
3101
3102 func (s *VolumeSaleInfoRetailPrice) UnmarshalJSON(data []byte) error {
3103 type NoMethod VolumeSaleInfoRetailPrice
3104 var s1 struct {
3105 Amount gensupport.JSONFloat64 `json:"amount"`
3106 *NoMethod
3107 }
3108 s1.NoMethod = (*NoMethod)(s)
3109 if err := json.Unmarshal(data, &s1); err != nil {
3110 return err
3111 }
3112 s.Amount = float64(s1.Amount)
3113 return nil
3114 }
3115
3116
3117 type VolumeSearchInfo struct {
3118
3119 TextSnippet string `json:"textSnippet,omitempty"`
3120
3121
3122
3123
3124
3125 ForceSendFields []string `json:"-"`
3126
3127
3128
3129
3130 NullFields []string `json:"-"`
3131 }
3132
3133 func (s *VolumeSearchInfo) MarshalJSON() ([]byte, error) {
3134 type NoMethod VolumeSearchInfo
3135 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3136 }
3137
3138
3139
3140 type VolumeUserInfo struct {
3141
3142
3143
3144 AcquiredTime string `json:"acquiredTime,omitempty"`
3145
3146 AcquisitionType int64 `json:"acquisitionType,omitempty"`
3147
3148 Copy *VolumeUserInfoCopy `json:"copy,omitempty"`
3149
3150 EntitlementType int64 `json:"entitlementType,omitempty"`
3151
3152 FamilySharing *VolumeUserInfoFamilySharing `json:"familySharing,omitempty"`
3153
3154
3155 IsFamilySharedFromUser bool `json:"isFamilySharedFromUser,omitempty"`
3156
3157
3158 IsFamilySharedToUser bool `json:"isFamilySharedToUser,omitempty"`
3159
3160 IsFamilySharingAllowed bool `json:"isFamilySharingAllowed,omitempty"`
3161
3162 IsFamilySharingDisabledByFop bool `json:"isFamilySharingDisabledByFop,omitempty"`
3163
3164 IsInMyBooks bool `json:"isInMyBooks,omitempty"`
3165
3166
3167 IsPreordered bool `json:"isPreordered,omitempty"`
3168
3169
3170 IsPurchased bool `json:"isPurchased,omitempty"`
3171
3172 IsUploaded bool `json:"isUploaded,omitempty"`
3173
3174
3175 ReadingPosition *ReadingPosition `json:"readingPosition,omitempty"`
3176
3177 RentalPeriod *VolumeUserInfoRentalPeriod `json:"rentalPeriod,omitempty"`
3178
3179 RentalState string `json:"rentalState,omitempty"`
3180
3181 Review *Review `json:"review,omitempty"`
3182
3183
3184
3185 Updated string `json:"updated,omitempty"`
3186 UserUploadedVolumeInfo *VolumeUserInfoUserUploadedVolumeInfo `json:"userUploadedVolumeInfo,omitempty"`
3187
3188
3189
3190
3191
3192 ForceSendFields []string `json:"-"`
3193
3194
3195
3196
3197 NullFields []string `json:"-"`
3198 }
3199
3200 func (s *VolumeUserInfo) MarshalJSON() ([]byte, error) {
3201 type NoMethod VolumeUserInfo
3202 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3203 }
3204
3205
3206 type VolumeUserInfoCopy struct {
3207 AllowedCharacterCount int64 `json:"allowedCharacterCount,omitempty"`
3208 LimitType string `json:"limitType,omitempty"`
3209 RemainingCharacterCount int64 `json:"remainingCharacterCount,omitempty"`
3210 Updated string `json:"updated,omitempty"`
3211
3212
3213
3214
3215
3216 ForceSendFields []string `json:"-"`
3217
3218
3219
3220
3221 NullFields []string `json:"-"`
3222 }
3223
3224 func (s *VolumeUserInfoCopy) MarshalJSON() ([]byte, error) {
3225 type NoMethod VolumeUserInfoCopy
3226 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3227 }
3228
3229
3230
3231 type VolumeUserInfoFamilySharing struct {
3232
3233 FamilyRole string `json:"familyRole,omitempty"`
3234
3235
3236
3237 IsSharingAllowed bool `json:"isSharingAllowed,omitempty"`
3238
3239
3240 IsSharingDisabledByFop bool `json:"isSharingDisabledByFop,omitempty"`
3241
3242
3243
3244
3245
3246 ForceSendFields []string `json:"-"`
3247
3248
3249
3250
3251 NullFields []string `json:"-"`
3252 }
3253
3254 func (s *VolumeUserInfoFamilySharing) MarshalJSON() ([]byte, error) {
3255 type NoMethod VolumeUserInfoFamilySharing
3256 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3257 }
3258
3259
3260 type VolumeUserInfoRentalPeriod struct {
3261 EndUtcSec int64 `json:"endUtcSec,omitempty,string"`
3262 StartUtcSec int64 `json:"startUtcSec,omitempty,string"`
3263
3264
3265
3266
3267
3268 ForceSendFields []string `json:"-"`
3269
3270
3271
3272
3273 NullFields []string `json:"-"`
3274 }
3275
3276 func (s *VolumeUserInfoRentalPeriod) MarshalJSON() ([]byte, error) {
3277 type NoMethod VolumeUserInfoRentalPeriod
3278 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3279 }
3280
3281 type VolumeUserInfoUserUploadedVolumeInfo struct {
3282 ProcessingState string `json:"processingState,omitempty"`
3283
3284
3285
3286
3287
3288 ForceSendFields []string `json:"-"`
3289
3290
3291
3292
3293 NullFields []string `json:"-"`
3294 }
3295
3296 func (s *VolumeUserInfoUserUploadedVolumeInfo) MarshalJSON() ([]byte, error) {
3297 type NoMethod VolumeUserInfoUserUploadedVolumeInfo
3298 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3299 }
3300
3301
3302 type VolumeVolumeInfo struct {
3303
3304 AllowAnonLogging bool `json:"allowAnonLogging,omitempty"`
3305
3306
3307 Authors []string `json:"authors,omitempty"`
3308
3309
3310 AverageRating float64 `json:"averageRating,omitempty"`
3311
3312 CanonicalVolumeLink string `json:"canonicalVolumeLink,omitempty"`
3313
3314
3315 Categories []string `json:"categories,omitempty"`
3316
3317 ComicsContent bool `json:"comicsContent,omitempty"`
3318
3319
3320 ContentVersion string `json:"contentVersion,omitempty"`
3321
3322
3323
3324 Description string `json:"description,omitempty"`
3325
3326 Dimensions *VolumeVolumeInfoDimensions `json:"dimensions,omitempty"`
3327
3328
3329 ImageLinks *VolumeVolumeInfoImageLinks `json:"imageLinks,omitempty"`
3330
3331 IndustryIdentifiers []*VolumeVolumeInfoIndustryIdentifiers `json:"industryIdentifiers,omitempty"`
3332
3333
3334 InfoLink string `json:"infoLink,omitempty"`
3335
3336
3337 Language string `json:"language,omitempty"`
3338
3339
3340
3341 MainCategory string `json:"mainCategory,omitempty"`
3342 MaturityRating string `json:"maturityRating,omitempty"`
3343
3344 PageCount int64 `json:"pageCount,omitempty"`
3345
3346
3347 PanelizationSummary *VolumeVolumeInfoPanelizationSummary `json:"panelizationSummary,omitempty"`
3348
3349 PreviewLink string `json:"previewLink,omitempty"`
3350
3351
3352 PrintType string `json:"printType,omitempty"`
3353
3354
3355 PrintedPageCount int64 `json:"printedPageCount,omitempty"`
3356
3357 PublishedDate string `json:"publishedDate,omitempty"`
3358
3359 Publisher string `json:"publisher,omitempty"`
3360
3361 RatingsCount int64 `json:"ratingsCount,omitempty"`
3362
3363 ReadingModes *VolumeVolumeInfoReadingModes `json:"readingModes,omitempty"`
3364
3365 SamplePageCount int64 `json:"samplePageCount,omitempty"`
3366 SeriesInfo *Volumeseriesinfo `json:"seriesInfo,omitempty"`
3367
3368 Subtitle string `json:"subtitle,omitempty"`
3369
3370 Title string `json:"title,omitempty"`
3371
3372
3373
3374
3375
3376 ForceSendFields []string `json:"-"`
3377
3378
3379
3380
3381 NullFields []string `json:"-"`
3382 }
3383
3384 func (s *VolumeVolumeInfo) MarshalJSON() ([]byte, error) {
3385 type NoMethod VolumeVolumeInfo
3386 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3387 }
3388
3389 func (s *VolumeVolumeInfo) UnmarshalJSON(data []byte) error {
3390 type NoMethod VolumeVolumeInfo
3391 var s1 struct {
3392 AverageRating gensupport.JSONFloat64 `json:"averageRating"`
3393 *NoMethod
3394 }
3395 s1.NoMethod = (*NoMethod)(s)
3396 if err := json.Unmarshal(data, &s1); err != nil {
3397 return err
3398 }
3399 s.AverageRating = float64(s1.AverageRating)
3400 return nil
3401 }
3402
3403
3404 type VolumeVolumeInfoDimensions struct {
3405
3406 Height string `json:"height,omitempty"`
3407
3408 Thickness string `json:"thickness,omitempty"`
3409
3410 Width string `json:"width,omitempty"`
3411
3412
3413
3414
3415
3416 ForceSendFields []string `json:"-"`
3417
3418
3419
3420
3421 NullFields []string `json:"-"`
3422 }
3423
3424 func (s *VolumeVolumeInfoDimensions) MarshalJSON() ([]byte, error) {
3425 type NoMethod VolumeVolumeInfoDimensions
3426 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3427 }
3428
3429
3430
3431 type VolumeVolumeInfoImageLinks struct {
3432
3433
3434 ExtraLarge string `json:"extraLarge,omitempty"`
3435
3436
3437 Large string `json:"large,omitempty"`
3438
3439
3440 Medium string `json:"medium,omitempty"`
3441
3442
3443 Small string `json:"small,omitempty"`
3444
3445
3446 SmallThumbnail string `json:"smallThumbnail,omitempty"`
3447
3448
3449 Thumbnail string `json:"thumbnail,omitempty"`
3450
3451
3452
3453
3454
3455 ForceSendFields []string `json:"-"`
3456
3457
3458
3459
3460 NullFields []string `json:"-"`
3461 }
3462
3463 func (s *VolumeVolumeInfoImageLinks) MarshalJSON() ([]byte, error) {
3464 type NoMethod VolumeVolumeInfoImageLinks
3465 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3466 }
3467
3468 type VolumeVolumeInfoIndustryIdentifiers struct {
3469
3470 Identifier string `json:"identifier,omitempty"`
3471
3472 Type string `json:"type,omitempty"`
3473
3474
3475
3476
3477
3478 ForceSendFields []string `json:"-"`
3479
3480
3481
3482
3483 NullFields []string `json:"-"`
3484 }
3485
3486 func (s *VolumeVolumeInfoIndustryIdentifiers) MarshalJSON() ([]byte, error) {
3487 type NoMethod VolumeVolumeInfoIndustryIdentifiers
3488 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3489 }
3490
3491
3492
3493 type VolumeVolumeInfoPanelizationSummary struct {
3494 ContainsEpubBubbles bool `json:"containsEpubBubbles,omitempty"`
3495 ContainsImageBubbles bool `json:"containsImageBubbles,omitempty"`
3496 EpubBubbleVersion string `json:"epubBubbleVersion,omitempty"`
3497 ImageBubbleVersion string `json:"imageBubbleVersion,omitempty"`
3498
3499
3500
3501
3502
3503 ForceSendFields []string `json:"-"`
3504
3505
3506
3507
3508 NullFields []string `json:"-"`
3509 }
3510
3511 func (s *VolumeVolumeInfoPanelizationSummary) MarshalJSON() ([]byte, error) {
3512 type NoMethod VolumeVolumeInfoPanelizationSummary
3513 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3514 }
3515
3516
3517 type VolumeVolumeInfoReadingModes struct {
3518 Image bool `json:"image,omitempty"`
3519 Text bool `json:"text,omitempty"`
3520
3521
3522
3523
3524
3525 ForceSendFields []string `json:"-"`
3526
3527
3528
3529
3530 NullFields []string `json:"-"`
3531 }
3532
3533 func (s *VolumeVolumeInfoReadingModes) MarshalJSON() ([]byte, error) {
3534 type NoMethod VolumeVolumeInfoReadingModes
3535 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3536 }
3537
3538 type Volume2 struct {
3539
3540 Items []*Volume `json:"items,omitempty"`
3541
3542 Kind string `json:"kind,omitempty"`
3543 NextPageToken string `json:"nextPageToken,omitempty"`
3544
3545
3546 googleapi.ServerResponse `json:"-"`
3547
3548
3549
3550
3551
3552 ForceSendFields []string `json:"-"`
3553
3554
3555
3556
3557 NullFields []string `json:"-"`
3558 }
3559
3560 func (s *Volume2) MarshalJSON() ([]byte, error) {
3561 type NoMethod Volume2
3562 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3563 }
3564
3565 type Volumeannotation struct {
3566
3567 AnnotationDataId string `json:"annotationDataId,omitempty"`
3568
3569 AnnotationDataLink string `json:"annotationDataLink,omitempty"`
3570
3571 AnnotationType string `json:"annotationType,omitempty"`
3572
3573 ContentRanges *VolumeannotationContentRanges `json:"contentRanges,omitempty"`
3574
3575 Data string `json:"data,omitempty"`
3576
3577 Deleted bool `json:"deleted,omitempty"`
3578
3579 Id string `json:"id,omitempty"`
3580
3581 Kind string `json:"kind,omitempty"`
3582
3583 LayerId string `json:"layerId,omitempty"`
3584
3585 PageIds []string `json:"pageIds,omitempty"`
3586
3587 SelectedText string `json:"selectedText,omitempty"`
3588
3589 SelfLink string `json:"selfLink,omitempty"`
3590
3591
3592 Updated string `json:"updated,omitempty"`
3593
3594 VolumeId string `json:"volumeId,omitempty"`
3595
3596
3597 googleapi.ServerResponse `json:"-"`
3598
3599
3600
3601
3602
3603 ForceSendFields []string `json:"-"`
3604
3605
3606
3607
3608 NullFields []string `json:"-"`
3609 }
3610
3611 func (s *Volumeannotation) MarshalJSON() ([]byte, error) {
3612 type NoMethod Volumeannotation
3613 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3614 }
3615
3616
3617
3618 type VolumeannotationContentRanges struct {
3619
3620 CfiRange *BooksAnnotationsRange `json:"cfiRange,omitempty"`
3621
3622 ContentVersion string `json:"contentVersion,omitempty"`
3623
3624
3625 GbImageRange *BooksAnnotationsRange `json:"gbImageRange,omitempty"`
3626
3627 GbTextRange *BooksAnnotationsRange `json:"gbTextRange,omitempty"`
3628
3629
3630
3631
3632
3633 ForceSendFields []string `json:"-"`
3634
3635
3636
3637
3638 NullFields []string `json:"-"`
3639 }
3640
3641 func (s *VolumeannotationContentRanges) MarshalJSON() ([]byte, error) {
3642 type NoMethod VolumeannotationContentRanges
3643 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3644 }
3645
3646 type Volumeannotations struct {
3647
3648 Items []*Volumeannotation `json:"items,omitempty"`
3649
3650 Kind string `json:"kind,omitempty"`
3651
3652
3653 NextPageToken string `json:"nextPageToken,omitempty"`
3654
3655 TotalItems int64 `json:"totalItems,omitempty"`
3656
3657
3658
3659
3660 Version string `json:"version,omitempty"`
3661
3662
3663 googleapi.ServerResponse `json:"-"`
3664
3665
3666
3667
3668
3669 ForceSendFields []string `json:"-"`
3670
3671
3672
3673
3674 NullFields []string `json:"-"`
3675 }
3676
3677 func (s *Volumeannotations) MarshalJSON() ([]byte, error) {
3678 type NoMethod Volumeannotations
3679 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3680 }
3681
3682 type Volumes struct {
3683
3684 Items []*Volume `json:"items,omitempty"`
3685
3686 Kind string `json:"kind,omitempty"`
3687
3688
3689 TotalItems int64 `json:"totalItems,omitempty"`
3690
3691
3692 googleapi.ServerResponse `json:"-"`
3693
3694
3695
3696
3697
3698 ForceSendFields []string `json:"-"`
3699
3700
3701
3702
3703 NullFields []string `json:"-"`
3704 }
3705
3706 func (s *Volumes) MarshalJSON() ([]byte, error) {
3707 type NoMethod Volumes
3708 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3709 }
3710
3711 type Volumeseriesinfo struct {
3712
3713
3714
3715 BookDisplayNumber string `json:"bookDisplayNumber,omitempty"`
3716
3717 Kind string `json:"kind,omitempty"`
3718
3719 ShortSeriesBookTitle string `json:"shortSeriesBookTitle,omitempty"`
3720 VolumeSeries []*VolumeseriesinfoVolumeSeries `json:"volumeSeries,omitempty"`
3721
3722
3723
3724
3725
3726 ForceSendFields []string `json:"-"`
3727
3728
3729
3730
3731 NullFields []string `json:"-"`
3732 }
3733
3734 func (s *Volumeseriesinfo) MarshalJSON() ([]byte, error) {
3735 type NoMethod Volumeseriesinfo
3736 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3737 }
3738
3739 type VolumeseriesinfoVolumeSeries struct {
3740
3741 Issue []*VolumeseriesinfoVolumeSeriesIssue `json:"issue,omitempty"`
3742
3743 OrderNumber int64 `json:"orderNumber,omitempty"`
3744
3745
3746 SeriesBookType string `json:"seriesBookType,omitempty"`
3747
3748 SeriesId string `json:"seriesId,omitempty"`
3749
3750
3751
3752
3753
3754 ForceSendFields []string `json:"-"`
3755
3756
3757
3758
3759 NullFields []string `json:"-"`
3760 }
3761
3762 func (s *VolumeseriesinfoVolumeSeries) MarshalJSON() ([]byte, error) {
3763 type NoMethod VolumeseriesinfoVolumeSeries
3764 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3765 }
3766
3767 type VolumeseriesinfoVolumeSeriesIssue struct {
3768 IssueDisplayNumber string `json:"issueDisplayNumber,omitempty"`
3769 IssueOrderNumber int64 `json:"issueOrderNumber,omitempty"`
3770
3771
3772
3773
3774
3775 ForceSendFields []string `json:"-"`
3776
3777
3778
3779
3780 NullFields []string `json:"-"`
3781 }
3782
3783 func (s *VolumeseriesinfoVolumeSeriesIssue) MarshalJSON() ([]byte, error) {
3784 type NoMethod VolumeseriesinfoVolumeSeriesIssue
3785 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3786 }
3787
3788 type BookshelvesGetCall struct {
3789 s *Service
3790 userId string
3791 shelf string
3792 urlParams_ gensupport.URLParams
3793 ifNoneMatch_ string
3794 ctx_ context.Context
3795 header_ http.Header
3796 }
3797
3798
3799
3800
3801
3802 func (r *BookshelvesService) Get(userId string, shelf string) *BookshelvesGetCall {
3803 c := &BookshelvesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
3804 c.userId = userId
3805 c.shelf = shelf
3806 return c
3807 }
3808
3809
3810
3811 func (c *BookshelvesGetCall) Source(source string) *BookshelvesGetCall {
3812 c.urlParams_.Set("source", source)
3813 return c
3814 }
3815
3816
3817
3818
3819 func (c *BookshelvesGetCall) Fields(s ...googleapi.Field) *BookshelvesGetCall {
3820 c.urlParams_.Set("fields", googleapi.CombineFields(s))
3821 return c
3822 }
3823
3824
3825
3826
3827 func (c *BookshelvesGetCall) IfNoneMatch(entityTag string) *BookshelvesGetCall {
3828 c.ifNoneMatch_ = entityTag
3829 return c
3830 }
3831
3832
3833 func (c *BookshelvesGetCall) Context(ctx context.Context) *BookshelvesGetCall {
3834 c.ctx_ = ctx
3835 return c
3836 }
3837
3838
3839
3840 func (c *BookshelvesGetCall) Header() http.Header {
3841 if c.header_ == nil {
3842 c.header_ = make(http.Header)
3843 }
3844 return c.header_
3845 }
3846
3847 func (c *BookshelvesGetCall) doRequest(alt string) (*http.Response, error) {
3848 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
3849 if c.ifNoneMatch_ != "" {
3850 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
3851 }
3852 var body io.Reader = nil
3853 c.urlParams_.Set("alt", alt)
3854 c.urlParams_.Set("prettyPrint", "false")
3855 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/users/{userId}/bookshelves/{shelf}")
3856 urls += "?" + c.urlParams_.Encode()
3857 req, err := http.NewRequest("GET", urls, body)
3858 if err != nil {
3859 return nil, err
3860 }
3861 req.Header = reqHeaders
3862 googleapi.Expand(req.URL, map[string]string{
3863 "userId": c.userId,
3864 "shelf": c.shelf,
3865 })
3866 return gensupport.SendRequest(c.ctx_, c.s.client, req)
3867 }
3868
3869
3870
3871
3872
3873
3874 func (c *BookshelvesGetCall) Do(opts ...googleapi.CallOption) (*Bookshelf, error) {
3875 gensupport.SetOptions(c.urlParams_, opts...)
3876 res, err := c.doRequest("json")
3877 if res != nil && res.StatusCode == http.StatusNotModified {
3878 if res.Body != nil {
3879 res.Body.Close()
3880 }
3881 return nil, gensupport.WrapError(&googleapi.Error{
3882 Code: res.StatusCode,
3883 Header: res.Header,
3884 })
3885 }
3886 if err != nil {
3887 return nil, err
3888 }
3889 defer googleapi.CloseBody(res)
3890 if err := googleapi.CheckResponse(res); err != nil {
3891 return nil, gensupport.WrapError(err)
3892 }
3893 ret := &Bookshelf{
3894 ServerResponse: googleapi.ServerResponse{
3895 Header: res.Header,
3896 HTTPStatusCode: res.StatusCode,
3897 },
3898 }
3899 target := &ret
3900 if err := gensupport.DecodeResponse(target, res); err != nil {
3901 return nil, err
3902 }
3903 return ret, nil
3904 }
3905
3906 type BookshelvesListCall struct {
3907 s *Service
3908 userId string
3909 urlParams_ gensupport.URLParams
3910 ifNoneMatch_ string
3911 ctx_ context.Context
3912 header_ http.Header
3913 }
3914
3915
3916
3917
3918 func (r *BookshelvesService) List(userId string) *BookshelvesListCall {
3919 c := &BookshelvesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
3920 c.userId = userId
3921 return c
3922 }
3923
3924
3925
3926 func (c *BookshelvesListCall) Source(source string) *BookshelvesListCall {
3927 c.urlParams_.Set("source", source)
3928 return c
3929 }
3930
3931
3932
3933
3934 func (c *BookshelvesListCall) Fields(s ...googleapi.Field) *BookshelvesListCall {
3935 c.urlParams_.Set("fields", googleapi.CombineFields(s))
3936 return c
3937 }
3938
3939
3940
3941
3942 func (c *BookshelvesListCall) IfNoneMatch(entityTag string) *BookshelvesListCall {
3943 c.ifNoneMatch_ = entityTag
3944 return c
3945 }
3946
3947
3948 func (c *BookshelvesListCall) Context(ctx context.Context) *BookshelvesListCall {
3949 c.ctx_ = ctx
3950 return c
3951 }
3952
3953
3954
3955 func (c *BookshelvesListCall) Header() http.Header {
3956 if c.header_ == nil {
3957 c.header_ = make(http.Header)
3958 }
3959 return c.header_
3960 }
3961
3962 func (c *BookshelvesListCall) doRequest(alt string) (*http.Response, error) {
3963 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
3964 if c.ifNoneMatch_ != "" {
3965 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
3966 }
3967 var body io.Reader = nil
3968 c.urlParams_.Set("alt", alt)
3969 c.urlParams_.Set("prettyPrint", "false")
3970 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/users/{userId}/bookshelves")
3971 urls += "?" + c.urlParams_.Encode()
3972 req, err := http.NewRequest("GET", urls, body)
3973 if err != nil {
3974 return nil, err
3975 }
3976 req.Header = reqHeaders
3977 googleapi.Expand(req.URL, map[string]string{
3978 "userId": c.userId,
3979 })
3980 return gensupport.SendRequest(c.ctx_, c.s.client, req)
3981 }
3982
3983
3984
3985
3986
3987
3988 func (c *BookshelvesListCall) Do(opts ...googleapi.CallOption) (*Bookshelves, error) {
3989 gensupport.SetOptions(c.urlParams_, opts...)
3990 res, err := c.doRequest("json")
3991 if res != nil && res.StatusCode == http.StatusNotModified {
3992 if res.Body != nil {
3993 res.Body.Close()
3994 }
3995 return nil, gensupport.WrapError(&googleapi.Error{
3996 Code: res.StatusCode,
3997 Header: res.Header,
3998 })
3999 }
4000 if err != nil {
4001 return nil, err
4002 }
4003 defer googleapi.CloseBody(res)
4004 if err := googleapi.CheckResponse(res); err != nil {
4005 return nil, gensupport.WrapError(err)
4006 }
4007 ret := &Bookshelves{
4008 ServerResponse: googleapi.ServerResponse{
4009 Header: res.Header,
4010 HTTPStatusCode: res.StatusCode,
4011 },
4012 }
4013 target := &ret
4014 if err := gensupport.DecodeResponse(target, res); err != nil {
4015 return nil, err
4016 }
4017 return ret, nil
4018 }
4019
4020 type BookshelvesVolumesListCall struct {
4021 s *Service
4022 userId string
4023 shelf string
4024 urlParams_ gensupport.URLParams
4025 ifNoneMatch_ string
4026 ctx_ context.Context
4027 header_ http.Header
4028 }
4029
4030
4031
4032
4033
4034 func (r *BookshelvesVolumesService) List(userId string, shelf string) *BookshelvesVolumesListCall {
4035 c := &BookshelvesVolumesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4036 c.userId = userId
4037 c.shelf = shelf
4038 return c
4039 }
4040
4041
4042
4043 func (c *BookshelvesVolumesListCall) MaxResults(maxResults int64) *BookshelvesVolumesListCall {
4044 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
4045 return c
4046 }
4047
4048
4049
4050 func (c *BookshelvesVolumesListCall) ShowPreorders(showPreorders bool) *BookshelvesVolumesListCall {
4051 c.urlParams_.Set("showPreorders", fmt.Sprint(showPreorders))
4052 return c
4053 }
4054
4055
4056
4057 func (c *BookshelvesVolumesListCall) Source(source string) *BookshelvesVolumesListCall {
4058 c.urlParams_.Set("source", source)
4059 return c
4060 }
4061
4062
4063
4064 func (c *BookshelvesVolumesListCall) StartIndex(startIndex int64) *BookshelvesVolumesListCall {
4065 c.urlParams_.Set("startIndex", fmt.Sprint(startIndex))
4066 return c
4067 }
4068
4069
4070
4071
4072 func (c *BookshelvesVolumesListCall) Fields(s ...googleapi.Field) *BookshelvesVolumesListCall {
4073 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4074 return c
4075 }
4076
4077
4078
4079
4080 func (c *BookshelvesVolumesListCall) IfNoneMatch(entityTag string) *BookshelvesVolumesListCall {
4081 c.ifNoneMatch_ = entityTag
4082 return c
4083 }
4084
4085
4086 func (c *BookshelvesVolumesListCall) Context(ctx context.Context) *BookshelvesVolumesListCall {
4087 c.ctx_ = ctx
4088 return c
4089 }
4090
4091
4092
4093 func (c *BookshelvesVolumesListCall) Header() http.Header {
4094 if c.header_ == nil {
4095 c.header_ = make(http.Header)
4096 }
4097 return c.header_
4098 }
4099
4100 func (c *BookshelvesVolumesListCall) doRequest(alt string) (*http.Response, error) {
4101 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4102 if c.ifNoneMatch_ != "" {
4103 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
4104 }
4105 var body io.Reader = nil
4106 c.urlParams_.Set("alt", alt)
4107 c.urlParams_.Set("prettyPrint", "false")
4108 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/users/{userId}/bookshelves/{shelf}/volumes")
4109 urls += "?" + c.urlParams_.Encode()
4110 req, err := http.NewRequest("GET", urls, body)
4111 if err != nil {
4112 return nil, err
4113 }
4114 req.Header = reqHeaders
4115 googleapi.Expand(req.URL, map[string]string{
4116 "userId": c.userId,
4117 "shelf": c.shelf,
4118 })
4119 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4120 }
4121
4122
4123
4124
4125
4126
4127 func (c *BookshelvesVolumesListCall) Do(opts ...googleapi.CallOption) (*Volumes, error) {
4128 gensupport.SetOptions(c.urlParams_, opts...)
4129 res, err := c.doRequest("json")
4130 if res != nil && res.StatusCode == http.StatusNotModified {
4131 if res.Body != nil {
4132 res.Body.Close()
4133 }
4134 return nil, gensupport.WrapError(&googleapi.Error{
4135 Code: res.StatusCode,
4136 Header: res.Header,
4137 })
4138 }
4139 if err != nil {
4140 return nil, err
4141 }
4142 defer googleapi.CloseBody(res)
4143 if err := googleapi.CheckResponse(res); err != nil {
4144 return nil, gensupport.WrapError(err)
4145 }
4146 ret := &Volumes{
4147 ServerResponse: googleapi.ServerResponse{
4148 Header: res.Header,
4149 HTTPStatusCode: res.StatusCode,
4150 },
4151 }
4152 target := &ret
4153 if err := gensupport.DecodeResponse(target, res); err != nil {
4154 return nil, err
4155 }
4156 return ret, nil
4157 }
4158
4159 type CloudloadingAddBookCall struct {
4160 s *Service
4161 urlParams_ gensupport.URLParams
4162 ctx_ context.Context
4163 header_ http.Header
4164 }
4165
4166
4167 func (r *CloudloadingService) AddBook() *CloudloadingAddBookCall {
4168 c := &CloudloadingAddBookCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4169 return c
4170 }
4171
4172
4173
4174 func (c *CloudloadingAddBookCall) DriveDocumentId(driveDocumentId string) *CloudloadingAddBookCall {
4175 c.urlParams_.Set("drive_document_id", driveDocumentId)
4176 return c
4177 }
4178
4179
4180
4181 func (c *CloudloadingAddBookCall) MimeType(mimeType string) *CloudloadingAddBookCall {
4182 c.urlParams_.Set("mime_type", mimeType)
4183 return c
4184 }
4185
4186
4187
4188 func (c *CloudloadingAddBookCall) Name(name string) *CloudloadingAddBookCall {
4189 c.urlParams_.Set("name", name)
4190 return c
4191 }
4192
4193
4194
4195 func (c *CloudloadingAddBookCall) UploadClientToken(uploadClientToken string) *CloudloadingAddBookCall {
4196 c.urlParams_.Set("upload_client_token", uploadClientToken)
4197 return c
4198 }
4199
4200
4201
4202
4203 func (c *CloudloadingAddBookCall) Fields(s ...googleapi.Field) *CloudloadingAddBookCall {
4204 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4205 return c
4206 }
4207
4208
4209 func (c *CloudloadingAddBookCall) Context(ctx context.Context) *CloudloadingAddBookCall {
4210 c.ctx_ = ctx
4211 return c
4212 }
4213
4214
4215
4216 func (c *CloudloadingAddBookCall) Header() http.Header {
4217 if c.header_ == nil {
4218 c.header_ = make(http.Header)
4219 }
4220 return c.header_
4221 }
4222
4223 func (c *CloudloadingAddBookCall) doRequest(alt string) (*http.Response, error) {
4224 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4225 var body io.Reader = nil
4226 c.urlParams_.Set("alt", alt)
4227 c.urlParams_.Set("prettyPrint", "false")
4228 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/cloudloading/addBook")
4229 urls += "?" + c.urlParams_.Encode()
4230 req, err := http.NewRequest("POST", urls, body)
4231 if err != nil {
4232 return nil, err
4233 }
4234 req.Header = reqHeaders
4235 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4236 }
4237
4238
4239
4240
4241
4242
4243
4244 func (c *CloudloadingAddBookCall) Do(opts ...googleapi.CallOption) (*BooksCloudloadingResource, error) {
4245 gensupport.SetOptions(c.urlParams_, opts...)
4246 res, err := c.doRequest("json")
4247 if res != nil && res.StatusCode == http.StatusNotModified {
4248 if res.Body != nil {
4249 res.Body.Close()
4250 }
4251 return nil, gensupport.WrapError(&googleapi.Error{
4252 Code: res.StatusCode,
4253 Header: res.Header,
4254 })
4255 }
4256 if err != nil {
4257 return nil, err
4258 }
4259 defer googleapi.CloseBody(res)
4260 if err := googleapi.CheckResponse(res); err != nil {
4261 return nil, gensupport.WrapError(err)
4262 }
4263 ret := &BooksCloudloadingResource{
4264 ServerResponse: googleapi.ServerResponse{
4265 Header: res.Header,
4266 HTTPStatusCode: res.StatusCode,
4267 },
4268 }
4269 target := &ret
4270 if err := gensupport.DecodeResponse(target, res); err != nil {
4271 return nil, err
4272 }
4273 return ret, nil
4274 }
4275
4276 type CloudloadingDeleteBookCall struct {
4277 s *Service
4278 urlParams_ gensupport.URLParams
4279 ctx_ context.Context
4280 header_ http.Header
4281 }
4282
4283
4284
4285
4286 func (r *CloudloadingService) DeleteBook(volumeId string) *CloudloadingDeleteBookCall {
4287 c := &CloudloadingDeleteBookCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4288 c.urlParams_.Set("volumeId", volumeId)
4289 return c
4290 }
4291
4292
4293
4294
4295 func (c *CloudloadingDeleteBookCall) Fields(s ...googleapi.Field) *CloudloadingDeleteBookCall {
4296 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4297 return c
4298 }
4299
4300
4301 func (c *CloudloadingDeleteBookCall) Context(ctx context.Context) *CloudloadingDeleteBookCall {
4302 c.ctx_ = ctx
4303 return c
4304 }
4305
4306
4307
4308 func (c *CloudloadingDeleteBookCall) Header() http.Header {
4309 if c.header_ == nil {
4310 c.header_ = make(http.Header)
4311 }
4312 return c.header_
4313 }
4314
4315 func (c *CloudloadingDeleteBookCall) doRequest(alt string) (*http.Response, error) {
4316 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4317 var body io.Reader = nil
4318 c.urlParams_.Set("alt", alt)
4319 c.urlParams_.Set("prettyPrint", "false")
4320 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/cloudloading/deleteBook")
4321 urls += "?" + c.urlParams_.Encode()
4322 req, err := http.NewRequest("POST", urls, body)
4323 if err != nil {
4324 return nil, err
4325 }
4326 req.Header = reqHeaders
4327 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4328 }
4329
4330
4331
4332
4333
4334
4335 func (c *CloudloadingDeleteBookCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
4336 gensupport.SetOptions(c.urlParams_, opts...)
4337 res, err := c.doRequest("json")
4338 if res != nil && res.StatusCode == http.StatusNotModified {
4339 if res.Body != nil {
4340 res.Body.Close()
4341 }
4342 return nil, gensupport.WrapError(&googleapi.Error{
4343 Code: res.StatusCode,
4344 Header: res.Header,
4345 })
4346 }
4347 if err != nil {
4348 return nil, err
4349 }
4350 defer googleapi.CloseBody(res)
4351 if err := googleapi.CheckResponse(res); err != nil {
4352 return nil, gensupport.WrapError(err)
4353 }
4354 ret := &Empty{
4355 ServerResponse: googleapi.ServerResponse{
4356 Header: res.Header,
4357 HTTPStatusCode: res.StatusCode,
4358 },
4359 }
4360 target := &ret
4361 if err := gensupport.DecodeResponse(target, res); err != nil {
4362 return nil, err
4363 }
4364 return ret, nil
4365 }
4366
4367 type CloudloadingUpdateBookCall struct {
4368 s *Service
4369 bookscloudloadingresource *BooksCloudloadingResource
4370 urlParams_ gensupport.URLParams
4371 ctx_ context.Context
4372 header_ http.Header
4373 }
4374
4375
4376 func (r *CloudloadingService) UpdateBook(bookscloudloadingresource *BooksCloudloadingResource) *CloudloadingUpdateBookCall {
4377 c := &CloudloadingUpdateBookCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4378 c.bookscloudloadingresource = bookscloudloadingresource
4379 return c
4380 }
4381
4382
4383
4384
4385 func (c *CloudloadingUpdateBookCall) Fields(s ...googleapi.Field) *CloudloadingUpdateBookCall {
4386 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4387 return c
4388 }
4389
4390
4391 func (c *CloudloadingUpdateBookCall) Context(ctx context.Context) *CloudloadingUpdateBookCall {
4392 c.ctx_ = ctx
4393 return c
4394 }
4395
4396
4397
4398 func (c *CloudloadingUpdateBookCall) Header() http.Header {
4399 if c.header_ == nil {
4400 c.header_ = make(http.Header)
4401 }
4402 return c.header_
4403 }
4404
4405 func (c *CloudloadingUpdateBookCall) doRequest(alt string) (*http.Response, error) {
4406 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
4407 var body io.Reader = nil
4408 body, err := googleapi.WithoutDataWrapper.JSONReader(c.bookscloudloadingresource)
4409 if err != nil {
4410 return nil, err
4411 }
4412 c.urlParams_.Set("alt", alt)
4413 c.urlParams_.Set("prettyPrint", "false")
4414 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/cloudloading/updateBook")
4415 urls += "?" + c.urlParams_.Encode()
4416 req, err := http.NewRequest("POST", urls, body)
4417 if err != nil {
4418 return nil, err
4419 }
4420 req.Header = reqHeaders
4421 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4422 }
4423
4424
4425
4426
4427
4428
4429
4430 func (c *CloudloadingUpdateBookCall) Do(opts ...googleapi.CallOption) (*BooksCloudloadingResource, error) {
4431 gensupport.SetOptions(c.urlParams_, opts...)
4432 res, err := c.doRequest("json")
4433 if res != nil && res.StatusCode == http.StatusNotModified {
4434 if res.Body != nil {
4435 res.Body.Close()
4436 }
4437 return nil, gensupport.WrapError(&googleapi.Error{
4438 Code: res.StatusCode,
4439 Header: res.Header,
4440 })
4441 }
4442 if err != nil {
4443 return nil, err
4444 }
4445 defer googleapi.CloseBody(res)
4446 if err := googleapi.CheckResponse(res); err != nil {
4447 return nil, gensupport.WrapError(err)
4448 }
4449 ret := &BooksCloudloadingResource{
4450 ServerResponse: googleapi.ServerResponse{
4451 Header: res.Header,
4452 HTTPStatusCode: res.StatusCode,
4453 },
4454 }
4455 target := &ret
4456 if err := gensupport.DecodeResponse(target, res); err != nil {
4457 return nil, err
4458 }
4459 return ret, nil
4460 }
4461
4462 type DictionaryListOfflineMetadataCall struct {
4463 s *Service
4464 urlParams_ gensupport.URLParams
4465 ifNoneMatch_ string
4466 ctx_ context.Context
4467 header_ http.Header
4468 }
4469
4470
4471
4472
4473 func (r *DictionaryService) ListOfflineMetadata(cpksver string) *DictionaryListOfflineMetadataCall {
4474 c := &DictionaryListOfflineMetadataCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4475 c.urlParams_.Set("cpksver", cpksver)
4476 return c
4477 }
4478
4479
4480
4481
4482 func (c *DictionaryListOfflineMetadataCall) Fields(s ...googleapi.Field) *DictionaryListOfflineMetadataCall {
4483 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4484 return c
4485 }
4486
4487
4488
4489
4490 func (c *DictionaryListOfflineMetadataCall) IfNoneMatch(entityTag string) *DictionaryListOfflineMetadataCall {
4491 c.ifNoneMatch_ = entityTag
4492 return c
4493 }
4494
4495
4496 func (c *DictionaryListOfflineMetadataCall) Context(ctx context.Context) *DictionaryListOfflineMetadataCall {
4497 c.ctx_ = ctx
4498 return c
4499 }
4500
4501
4502
4503 func (c *DictionaryListOfflineMetadataCall) Header() http.Header {
4504 if c.header_ == nil {
4505 c.header_ = make(http.Header)
4506 }
4507 return c.header_
4508 }
4509
4510 func (c *DictionaryListOfflineMetadataCall) doRequest(alt string) (*http.Response, error) {
4511 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4512 if c.ifNoneMatch_ != "" {
4513 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
4514 }
4515 var body io.Reader = nil
4516 c.urlParams_.Set("alt", alt)
4517 c.urlParams_.Set("prettyPrint", "false")
4518 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/dictionary/listOfflineMetadata")
4519 urls += "?" + c.urlParams_.Encode()
4520 req, err := http.NewRequest("GET", urls, body)
4521 if err != nil {
4522 return nil, err
4523 }
4524 req.Header = reqHeaders
4525 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4526 }
4527
4528
4529
4530
4531
4532
4533 func (c *DictionaryListOfflineMetadataCall) Do(opts ...googleapi.CallOption) (*Metadata, error) {
4534 gensupport.SetOptions(c.urlParams_, opts...)
4535 res, err := c.doRequest("json")
4536 if res != nil && res.StatusCode == http.StatusNotModified {
4537 if res.Body != nil {
4538 res.Body.Close()
4539 }
4540 return nil, gensupport.WrapError(&googleapi.Error{
4541 Code: res.StatusCode,
4542 Header: res.Header,
4543 })
4544 }
4545 if err != nil {
4546 return nil, err
4547 }
4548 defer googleapi.CloseBody(res)
4549 if err := googleapi.CheckResponse(res); err != nil {
4550 return nil, gensupport.WrapError(err)
4551 }
4552 ret := &Metadata{
4553 ServerResponse: googleapi.ServerResponse{
4554 Header: res.Header,
4555 HTTPStatusCode: res.StatusCode,
4556 },
4557 }
4558 target := &ret
4559 if err := gensupport.DecodeResponse(target, res); err != nil {
4560 return nil, err
4561 }
4562 return ret, nil
4563 }
4564
4565 type FamilysharingGetFamilyInfoCall struct {
4566 s *Service
4567 urlParams_ gensupport.URLParams
4568 ifNoneMatch_ string
4569 ctx_ context.Context
4570 header_ http.Header
4571 }
4572
4573
4574
4575 func (r *FamilysharingService) GetFamilyInfo() *FamilysharingGetFamilyInfoCall {
4576 c := &FamilysharingGetFamilyInfoCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4577 return c
4578 }
4579
4580
4581
4582 func (c *FamilysharingGetFamilyInfoCall) Source(source string) *FamilysharingGetFamilyInfoCall {
4583 c.urlParams_.Set("source", source)
4584 return c
4585 }
4586
4587
4588
4589
4590 func (c *FamilysharingGetFamilyInfoCall) Fields(s ...googleapi.Field) *FamilysharingGetFamilyInfoCall {
4591 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4592 return c
4593 }
4594
4595
4596
4597
4598 func (c *FamilysharingGetFamilyInfoCall) IfNoneMatch(entityTag string) *FamilysharingGetFamilyInfoCall {
4599 c.ifNoneMatch_ = entityTag
4600 return c
4601 }
4602
4603
4604 func (c *FamilysharingGetFamilyInfoCall) Context(ctx context.Context) *FamilysharingGetFamilyInfoCall {
4605 c.ctx_ = ctx
4606 return c
4607 }
4608
4609
4610
4611 func (c *FamilysharingGetFamilyInfoCall) Header() http.Header {
4612 if c.header_ == nil {
4613 c.header_ = make(http.Header)
4614 }
4615 return c.header_
4616 }
4617
4618 func (c *FamilysharingGetFamilyInfoCall) doRequest(alt string) (*http.Response, error) {
4619 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4620 if c.ifNoneMatch_ != "" {
4621 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
4622 }
4623 var body io.Reader = nil
4624 c.urlParams_.Set("alt", alt)
4625 c.urlParams_.Set("prettyPrint", "false")
4626 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/familysharing/getFamilyInfo")
4627 urls += "?" + c.urlParams_.Encode()
4628 req, err := http.NewRequest("GET", urls, body)
4629 if err != nil {
4630 return nil, err
4631 }
4632 req.Header = reqHeaders
4633 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4634 }
4635
4636
4637
4638
4639
4640
4641 func (c *FamilysharingGetFamilyInfoCall) Do(opts ...googleapi.CallOption) (*FamilyInfo, error) {
4642 gensupport.SetOptions(c.urlParams_, opts...)
4643 res, err := c.doRequest("json")
4644 if res != nil && res.StatusCode == http.StatusNotModified {
4645 if res.Body != nil {
4646 res.Body.Close()
4647 }
4648 return nil, gensupport.WrapError(&googleapi.Error{
4649 Code: res.StatusCode,
4650 Header: res.Header,
4651 })
4652 }
4653 if err != nil {
4654 return nil, err
4655 }
4656 defer googleapi.CloseBody(res)
4657 if err := googleapi.CheckResponse(res); err != nil {
4658 return nil, gensupport.WrapError(err)
4659 }
4660 ret := &FamilyInfo{
4661 ServerResponse: googleapi.ServerResponse{
4662 Header: res.Header,
4663 HTTPStatusCode: res.StatusCode,
4664 },
4665 }
4666 target := &ret
4667 if err := gensupport.DecodeResponse(target, res); err != nil {
4668 return nil, err
4669 }
4670 return ret, nil
4671 }
4672
4673 type FamilysharingShareCall struct {
4674 s *Service
4675 urlParams_ gensupport.URLParams
4676 ctx_ context.Context
4677 header_ http.Header
4678 }
4679
4680
4681
4682 func (r *FamilysharingService) Share() *FamilysharingShareCall {
4683 c := &FamilysharingShareCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4684 return c
4685 }
4686
4687
4688 func (c *FamilysharingShareCall) DocId(docId string) *FamilysharingShareCall {
4689 c.urlParams_.Set("docId", docId)
4690 return c
4691 }
4692
4693
4694
4695 func (c *FamilysharingShareCall) Source(source string) *FamilysharingShareCall {
4696 c.urlParams_.Set("source", source)
4697 return c
4698 }
4699
4700
4701 func (c *FamilysharingShareCall) VolumeId(volumeId string) *FamilysharingShareCall {
4702 c.urlParams_.Set("volumeId", volumeId)
4703 return c
4704 }
4705
4706
4707
4708
4709 func (c *FamilysharingShareCall) Fields(s ...googleapi.Field) *FamilysharingShareCall {
4710 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4711 return c
4712 }
4713
4714
4715 func (c *FamilysharingShareCall) Context(ctx context.Context) *FamilysharingShareCall {
4716 c.ctx_ = ctx
4717 return c
4718 }
4719
4720
4721
4722 func (c *FamilysharingShareCall) Header() http.Header {
4723 if c.header_ == nil {
4724 c.header_ = make(http.Header)
4725 }
4726 return c.header_
4727 }
4728
4729 func (c *FamilysharingShareCall) doRequest(alt string) (*http.Response, error) {
4730 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4731 var body io.Reader = nil
4732 c.urlParams_.Set("alt", alt)
4733 c.urlParams_.Set("prettyPrint", "false")
4734 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/familysharing/share")
4735 urls += "?" + c.urlParams_.Encode()
4736 req, err := http.NewRequest("POST", urls, body)
4737 if err != nil {
4738 return nil, err
4739 }
4740 req.Header = reqHeaders
4741 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4742 }
4743
4744
4745
4746
4747
4748
4749 func (c *FamilysharingShareCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
4750 gensupport.SetOptions(c.urlParams_, opts...)
4751 res, err := c.doRequest("json")
4752 if res != nil && res.StatusCode == http.StatusNotModified {
4753 if res.Body != nil {
4754 res.Body.Close()
4755 }
4756 return nil, gensupport.WrapError(&googleapi.Error{
4757 Code: res.StatusCode,
4758 Header: res.Header,
4759 })
4760 }
4761 if err != nil {
4762 return nil, err
4763 }
4764 defer googleapi.CloseBody(res)
4765 if err := googleapi.CheckResponse(res); err != nil {
4766 return nil, gensupport.WrapError(err)
4767 }
4768 ret := &Empty{
4769 ServerResponse: googleapi.ServerResponse{
4770 Header: res.Header,
4771 HTTPStatusCode: res.StatusCode,
4772 },
4773 }
4774 target := &ret
4775 if err := gensupport.DecodeResponse(target, res); err != nil {
4776 return nil, err
4777 }
4778 return ret, nil
4779 }
4780
4781 type FamilysharingUnshareCall struct {
4782 s *Service
4783 urlParams_ gensupport.URLParams
4784 ctx_ context.Context
4785 header_ http.Header
4786 }
4787
4788
4789
4790 func (r *FamilysharingService) Unshare() *FamilysharingUnshareCall {
4791 c := &FamilysharingUnshareCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4792 return c
4793 }
4794
4795
4796 func (c *FamilysharingUnshareCall) DocId(docId string) *FamilysharingUnshareCall {
4797 c.urlParams_.Set("docId", docId)
4798 return c
4799 }
4800
4801
4802
4803 func (c *FamilysharingUnshareCall) Source(source string) *FamilysharingUnshareCall {
4804 c.urlParams_.Set("source", source)
4805 return c
4806 }
4807
4808
4809 func (c *FamilysharingUnshareCall) VolumeId(volumeId string) *FamilysharingUnshareCall {
4810 c.urlParams_.Set("volumeId", volumeId)
4811 return c
4812 }
4813
4814
4815
4816
4817 func (c *FamilysharingUnshareCall) Fields(s ...googleapi.Field) *FamilysharingUnshareCall {
4818 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4819 return c
4820 }
4821
4822
4823 func (c *FamilysharingUnshareCall) Context(ctx context.Context) *FamilysharingUnshareCall {
4824 c.ctx_ = ctx
4825 return c
4826 }
4827
4828
4829
4830 func (c *FamilysharingUnshareCall) Header() http.Header {
4831 if c.header_ == nil {
4832 c.header_ = make(http.Header)
4833 }
4834 return c.header_
4835 }
4836
4837 func (c *FamilysharingUnshareCall) doRequest(alt string) (*http.Response, error) {
4838 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4839 var body io.Reader = nil
4840 c.urlParams_.Set("alt", alt)
4841 c.urlParams_.Set("prettyPrint", "false")
4842 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/familysharing/unshare")
4843 urls += "?" + c.urlParams_.Encode()
4844 req, err := http.NewRequest("POST", urls, body)
4845 if err != nil {
4846 return nil, err
4847 }
4848 req.Header = reqHeaders
4849 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4850 }
4851
4852
4853
4854
4855
4856
4857 func (c *FamilysharingUnshareCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
4858 gensupport.SetOptions(c.urlParams_, opts...)
4859 res, err := c.doRequest("json")
4860 if res != nil && res.StatusCode == http.StatusNotModified {
4861 if res.Body != nil {
4862 res.Body.Close()
4863 }
4864 return nil, gensupport.WrapError(&googleapi.Error{
4865 Code: res.StatusCode,
4866 Header: res.Header,
4867 })
4868 }
4869 if err != nil {
4870 return nil, err
4871 }
4872 defer googleapi.CloseBody(res)
4873 if err := googleapi.CheckResponse(res); err != nil {
4874 return nil, gensupport.WrapError(err)
4875 }
4876 ret := &Empty{
4877 ServerResponse: googleapi.ServerResponse{
4878 Header: res.Header,
4879 HTTPStatusCode: res.StatusCode,
4880 },
4881 }
4882 target := &ret
4883 if err := gensupport.DecodeResponse(target, res); err != nil {
4884 return nil, err
4885 }
4886 return ret, nil
4887 }
4888
4889 type LayersGetCall struct {
4890 s *Service
4891 volumeId string
4892 summaryId string
4893 urlParams_ gensupport.URLParams
4894 ifNoneMatch_ string
4895 ctx_ context.Context
4896 header_ http.Header
4897 }
4898
4899
4900
4901
4902
4903 func (r *LayersService) Get(volumeId string, summaryId string) *LayersGetCall {
4904 c := &LayersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4905 c.volumeId = volumeId
4906 c.summaryId = summaryId
4907 return c
4908 }
4909
4910
4911
4912 func (c *LayersGetCall) ContentVersion(contentVersion string) *LayersGetCall {
4913 c.urlParams_.Set("contentVersion", contentVersion)
4914 return c
4915 }
4916
4917
4918
4919 func (c *LayersGetCall) Source(source string) *LayersGetCall {
4920 c.urlParams_.Set("source", source)
4921 return c
4922 }
4923
4924
4925
4926
4927 func (c *LayersGetCall) Fields(s ...googleapi.Field) *LayersGetCall {
4928 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4929 return c
4930 }
4931
4932
4933
4934
4935 func (c *LayersGetCall) IfNoneMatch(entityTag string) *LayersGetCall {
4936 c.ifNoneMatch_ = entityTag
4937 return c
4938 }
4939
4940
4941 func (c *LayersGetCall) Context(ctx context.Context) *LayersGetCall {
4942 c.ctx_ = ctx
4943 return c
4944 }
4945
4946
4947
4948 func (c *LayersGetCall) Header() http.Header {
4949 if c.header_ == nil {
4950 c.header_ = make(http.Header)
4951 }
4952 return c.header_
4953 }
4954
4955 func (c *LayersGetCall) doRequest(alt string) (*http.Response, error) {
4956 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4957 if c.ifNoneMatch_ != "" {
4958 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
4959 }
4960 var body io.Reader = nil
4961 c.urlParams_.Set("alt", alt)
4962 c.urlParams_.Set("prettyPrint", "false")
4963 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/{volumeId}/layersummary/{summaryId}")
4964 urls += "?" + c.urlParams_.Encode()
4965 req, err := http.NewRequest("GET", urls, body)
4966 if err != nil {
4967 return nil, err
4968 }
4969 req.Header = reqHeaders
4970 googleapi.Expand(req.URL, map[string]string{
4971 "volumeId": c.volumeId,
4972 "summaryId": c.summaryId,
4973 })
4974 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4975 }
4976
4977
4978
4979
4980
4981
4982 func (c *LayersGetCall) Do(opts ...googleapi.CallOption) (*Layersummary, error) {
4983 gensupport.SetOptions(c.urlParams_, opts...)
4984 res, err := c.doRequest("json")
4985 if res != nil && res.StatusCode == http.StatusNotModified {
4986 if res.Body != nil {
4987 res.Body.Close()
4988 }
4989 return nil, gensupport.WrapError(&googleapi.Error{
4990 Code: res.StatusCode,
4991 Header: res.Header,
4992 })
4993 }
4994 if err != nil {
4995 return nil, err
4996 }
4997 defer googleapi.CloseBody(res)
4998 if err := googleapi.CheckResponse(res); err != nil {
4999 return nil, gensupport.WrapError(err)
5000 }
5001 ret := &Layersummary{
5002 ServerResponse: googleapi.ServerResponse{
5003 Header: res.Header,
5004 HTTPStatusCode: res.StatusCode,
5005 },
5006 }
5007 target := &ret
5008 if err := gensupport.DecodeResponse(target, res); err != nil {
5009 return nil, err
5010 }
5011 return ret, nil
5012 }
5013
5014 type LayersListCall struct {
5015 s *Service
5016 volumeId string
5017 urlParams_ gensupport.URLParams
5018 ifNoneMatch_ string
5019 ctx_ context.Context
5020 header_ http.Header
5021 }
5022
5023
5024
5025
5026 func (r *LayersService) List(volumeId string) *LayersListCall {
5027 c := &LayersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5028 c.volumeId = volumeId
5029 return c
5030 }
5031
5032
5033
5034 func (c *LayersListCall) ContentVersion(contentVersion string) *LayersListCall {
5035 c.urlParams_.Set("contentVersion", contentVersion)
5036 return c
5037 }
5038
5039
5040
5041 func (c *LayersListCall) MaxResults(maxResults int64) *LayersListCall {
5042 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
5043 return c
5044 }
5045
5046
5047
5048 func (c *LayersListCall) PageToken(pageToken string) *LayersListCall {
5049 c.urlParams_.Set("pageToken", pageToken)
5050 return c
5051 }
5052
5053
5054
5055 func (c *LayersListCall) Source(source string) *LayersListCall {
5056 c.urlParams_.Set("source", source)
5057 return c
5058 }
5059
5060
5061
5062
5063 func (c *LayersListCall) Fields(s ...googleapi.Field) *LayersListCall {
5064 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5065 return c
5066 }
5067
5068
5069
5070
5071 func (c *LayersListCall) IfNoneMatch(entityTag string) *LayersListCall {
5072 c.ifNoneMatch_ = entityTag
5073 return c
5074 }
5075
5076
5077 func (c *LayersListCall) Context(ctx context.Context) *LayersListCall {
5078 c.ctx_ = ctx
5079 return c
5080 }
5081
5082
5083
5084 func (c *LayersListCall) Header() http.Header {
5085 if c.header_ == nil {
5086 c.header_ = make(http.Header)
5087 }
5088 return c.header_
5089 }
5090
5091 func (c *LayersListCall) doRequest(alt string) (*http.Response, error) {
5092 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5093 if c.ifNoneMatch_ != "" {
5094 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5095 }
5096 var body io.Reader = nil
5097 c.urlParams_.Set("alt", alt)
5098 c.urlParams_.Set("prettyPrint", "false")
5099 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/{volumeId}/layersummary")
5100 urls += "?" + c.urlParams_.Encode()
5101 req, err := http.NewRequest("GET", urls, body)
5102 if err != nil {
5103 return nil, err
5104 }
5105 req.Header = reqHeaders
5106 googleapi.Expand(req.URL, map[string]string{
5107 "volumeId": c.volumeId,
5108 })
5109 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5110 }
5111
5112
5113
5114
5115
5116
5117 func (c *LayersListCall) Do(opts ...googleapi.CallOption) (*Layersummaries, error) {
5118 gensupport.SetOptions(c.urlParams_, opts...)
5119 res, err := c.doRequest("json")
5120 if res != nil && res.StatusCode == http.StatusNotModified {
5121 if res.Body != nil {
5122 res.Body.Close()
5123 }
5124 return nil, gensupport.WrapError(&googleapi.Error{
5125 Code: res.StatusCode,
5126 Header: res.Header,
5127 })
5128 }
5129 if err != nil {
5130 return nil, err
5131 }
5132 defer googleapi.CloseBody(res)
5133 if err := googleapi.CheckResponse(res); err != nil {
5134 return nil, gensupport.WrapError(err)
5135 }
5136 ret := &Layersummaries{
5137 ServerResponse: googleapi.ServerResponse{
5138 Header: res.Header,
5139 HTTPStatusCode: res.StatusCode,
5140 },
5141 }
5142 target := &ret
5143 if err := gensupport.DecodeResponse(target, res); err != nil {
5144 return nil, err
5145 }
5146 return ret, nil
5147 }
5148
5149 type LayersAnnotationDataGetCall struct {
5150 s *Service
5151 volumeId string
5152 layerId string
5153 annotationDataId string
5154 urlParams_ gensupport.URLParams
5155 ifNoneMatch_ string
5156 ctx_ context.Context
5157 header_ http.Header
5158 }
5159
5160
5161
5162
5163
5164
5165
5166
5167 func (r *LayersAnnotationDataService) Get(volumeId string, layerId string, annotationDataId string, contentVersion string) *LayersAnnotationDataGetCall {
5168 c := &LayersAnnotationDataGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5169 c.volumeId = volumeId
5170 c.layerId = layerId
5171 c.annotationDataId = annotationDataId
5172 c.urlParams_.Set("contentVersion", contentVersion)
5173 return c
5174 }
5175
5176
5177
5178 func (c *LayersAnnotationDataGetCall) AllowWebDefinitions(allowWebDefinitions bool) *LayersAnnotationDataGetCall {
5179 c.urlParams_.Set("allowWebDefinitions", fmt.Sprint(allowWebDefinitions))
5180 return c
5181 }
5182
5183
5184
5185 func (c *LayersAnnotationDataGetCall) H(h int64) *LayersAnnotationDataGetCall {
5186 c.urlParams_.Set("h", fmt.Sprint(h))
5187 return c
5188 }
5189
5190
5191
5192 func (c *LayersAnnotationDataGetCall) Locale(locale string) *LayersAnnotationDataGetCall {
5193 c.urlParams_.Set("locale", locale)
5194 return c
5195 }
5196
5197
5198
5199 func (c *LayersAnnotationDataGetCall) Scale(scale int64) *LayersAnnotationDataGetCall {
5200 c.urlParams_.Set("scale", fmt.Sprint(scale))
5201 return c
5202 }
5203
5204
5205
5206 func (c *LayersAnnotationDataGetCall) Source(source string) *LayersAnnotationDataGetCall {
5207 c.urlParams_.Set("source", source)
5208 return c
5209 }
5210
5211
5212
5213 func (c *LayersAnnotationDataGetCall) W(w int64) *LayersAnnotationDataGetCall {
5214 c.urlParams_.Set("w", fmt.Sprint(w))
5215 return c
5216 }
5217
5218
5219
5220
5221 func (c *LayersAnnotationDataGetCall) Fields(s ...googleapi.Field) *LayersAnnotationDataGetCall {
5222 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5223 return c
5224 }
5225
5226
5227
5228
5229 func (c *LayersAnnotationDataGetCall) IfNoneMatch(entityTag string) *LayersAnnotationDataGetCall {
5230 c.ifNoneMatch_ = entityTag
5231 return c
5232 }
5233
5234
5235 func (c *LayersAnnotationDataGetCall) Context(ctx context.Context) *LayersAnnotationDataGetCall {
5236 c.ctx_ = ctx
5237 return c
5238 }
5239
5240
5241
5242 func (c *LayersAnnotationDataGetCall) Header() http.Header {
5243 if c.header_ == nil {
5244 c.header_ = make(http.Header)
5245 }
5246 return c.header_
5247 }
5248
5249 func (c *LayersAnnotationDataGetCall) doRequest(alt string) (*http.Response, error) {
5250 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5251 if c.ifNoneMatch_ != "" {
5252 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5253 }
5254 var body io.Reader = nil
5255 c.urlParams_.Set("alt", alt)
5256 c.urlParams_.Set("prettyPrint", "false")
5257 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/{volumeId}/layers/{layerId}/data/{annotationDataId}")
5258 urls += "?" + c.urlParams_.Encode()
5259 req, err := http.NewRequest("GET", urls, body)
5260 if err != nil {
5261 return nil, err
5262 }
5263 req.Header = reqHeaders
5264 googleapi.Expand(req.URL, map[string]string{
5265 "volumeId": c.volumeId,
5266 "layerId": c.layerId,
5267 "annotationDataId": c.annotationDataId,
5268 })
5269 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5270 }
5271
5272
5273
5274
5275
5276
5277
5278 func (c *LayersAnnotationDataGetCall) Do(opts ...googleapi.CallOption) (*DictionaryAnnotationdata, error) {
5279 gensupport.SetOptions(c.urlParams_, opts...)
5280 res, err := c.doRequest("json")
5281 if res != nil && res.StatusCode == http.StatusNotModified {
5282 if res.Body != nil {
5283 res.Body.Close()
5284 }
5285 return nil, gensupport.WrapError(&googleapi.Error{
5286 Code: res.StatusCode,
5287 Header: res.Header,
5288 })
5289 }
5290 if err != nil {
5291 return nil, err
5292 }
5293 defer googleapi.CloseBody(res)
5294 if err := googleapi.CheckResponse(res); err != nil {
5295 return nil, gensupport.WrapError(err)
5296 }
5297 ret := &DictionaryAnnotationdata{
5298 ServerResponse: googleapi.ServerResponse{
5299 Header: res.Header,
5300 HTTPStatusCode: res.StatusCode,
5301 },
5302 }
5303 target := &ret
5304 if err := gensupport.DecodeResponse(target, res); err != nil {
5305 return nil, err
5306 }
5307 return ret, nil
5308 }
5309
5310 type LayersAnnotationDataListCall struct {
5311 s *Service
5312 volumeId string
5313 layerId string
5314 urlParams_ gensupport.URLParams
5315 ifNoneMatch_ string
5316 ctx_ context.Context
5317 header_ http.Header
5318 }
5319
5320
5321
5322
5323
5324
5325 func (r *LayersAnnotationDataService) List(volumeId string, layerId string, contentVersion string) *LayersAnnotationDataListCall {
5326 c := &LayersAnnotationDataListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5327 c.volumeId = volumeId
5328 c.layerId = layerId
5329 c.urlParams_.Set("contentVersion", contentVersion)
5330 return c
5331 }
5332
5333
5334
5335 func (c *LayersAnnotationDataListCall) AnnotationDataId(annotationDataId ...string) *LayersAnnotationDataListCall {
5336 c.urlParams_.SetMulti("annotationDataId", append([]string{}, annotationDataId...))
5337 return c
5338 }
5339
5340
5341
5342 func (c *LayersAnnotationDataListCall) H(h int64) *LayersAnnotationDataListCall {
5343 c.urlParams_.Set("h", fmt.Sprint(h))
5344 return c
5345 }
5346
5347
5348
5349 func (c *LayersAnnotationDataListCall) Locale(locale string) *LayersAnnotationDataListCall {
5350 c.urlParams_.Set("locale", locale)
5351 return c
5352 }
5353
5354
5355
5356 func (c *LayersAnnotationDataListCall) MaxResults(maxResults int64) *LayersAnnotationDataListCall {
5357 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
5358 return c
5359 }
5360
5361
5362
5363 func (c *LayersAnnotationDataListCall) PageToken(pageToken string) *LayersAnnotationDataListCall {
5364 c.urlParams_.Set("pageToken", pageToken)
5365 return c
5366 }
5367
5368
5369
5370 func (c *LayersAnnotationDataListCall) Scale(scale int64) *LayersAnnotationDataListCall {
5371 c.urlParams_.Set("scale", fmt.Sprint(scale))
5372 return c
5373 }
5374
5375
5376
5377 func (c *LayersAnnotationDataListCall) Source(source string) *LayersAnnotationDataListCall {
5378 c.urlParams_.Set("source", source)
5379 return c
5380 }
5381
5382
5383
5384 func (c *LayersAnnotationDataListCall) UpdatedMax(updatedMax string) *LayersAnnotationDataListCall {
5385 c.urlParams_.Set("updatedMax", updatedMax)
5386 return c
5387 }
5388
5389
5390
5391 func (c *LayersAnnotationDataListCall) UpdatedMin(updatedMin string) *LayersAnnotationDataListCall {
5392 c.urlParams_.Set("updatedMin", updatedMin)
5393 return c
5394 }
5395
5396
5397
5398 func (c *LayersAnnotationDataListCall) W(w int64) *LayersAnnotationDataListCall {
5399 c.urlParams_.Set("w", fmt.Sprint(w))
5400 return c
5401 }
5402
5403
5404
5405
5406 func (c *LayersAnnotationDataListCall) Fields(s ...googleapi.Field) *LayersAnnotationDataListCall {
5407 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5408 return c
5409 }
5410
5411
5412
5413
5414 func (c *LayersAnnotationDataListCall) IfNoneMatch(entityTag string) *LayersAnnotationDataListCall {
5415 c.ifNoneMatch_ = entityTag
5416 return c
5417 }
5418
5419
5420 func (c *LayersAnnotationDataListCall) Context(ctx context.Context) *LayersAnnotationDataListCall {
5421 c.ctx_ = ctx
5422 return c
5423 }
5424
5425
5426
5427 func (c *LayersAnnotationDataListCall) Header() http.Header {
5428 if c.header_ == nil {
5429 c.header_ = make(http.Header)
5430 }
5431 return c.header_
5432 }
5433
5434 func (c *LayersAnnotationDataListCall) doRequest(alt string) (*http.Response, error) {
5435 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5436 if c.ifNoneMatch_ != "" {
5437 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5438 }
5439 var body io.Reader = nil
5440 c.urlParams_.Set("alt", alt)
5441 c.urlParams_.Set("prettyPrint", "false")
5442 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/{volumeId}/layers/{layerId}/data")
5443 urls += "?" + c.urlParams_.Encode()
5444 req, err := http.NewRequest("GET", urls, body)
5445 if err != nil {
5446 return nil, err
5447 }
5448 req.Header = reqHeaders
5449 googleapi.Expand(req.URL, map[string]string{
5450 "volumeId": c.volumeId,
5451 "layerId": c.layerId,
5452 })
5453 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5454 }
5455
5456
5457
5458
5459
5460
5461
5462 func (c *LayersAnnotationDataListCall) Do(opts ...googleapi.CallOption) (*Annotationsdata, error) {
5463 gensupport.SetOptions(c.urlParams_, opts...)
5464 res, err := c.doRequest("json")
5465 if res != nil && res.StatusCode == http.StatusNotModified {
5466 if res.Body != nil {
5467 res.Body.Close()
5468 }
5469 return nil, gensupport.WrapError(&googleapi.Error{
5470 Code: res.StatusCode,
5471 Header: res.Header,
5472 })
5473 }
5474 if err != nil {
5475 return nil, err
5476 }
5477 defer googleapi.CloseBody(res)
5478 if err := googleapi.CheckResponse(res); err != nil {
5479 return nil, gensupport.WrapError(err)
5480 }
5481 ret := &Annotationsdata{
5482 ServerResponse: googleapi.ServerResponse{
5483 Header: res.Header,
5484 HTTPStatusCode: res.StatusCode,
5485 },
5486 }
5487 target := &ret
5488 if err := gensupport.DecodeResponse(target, res); err != nil {
5489 return nil, err
5490 }
5491 return ret, nil
5492 }
5493
5494
5495
5496
5497 func (c *LayersAnnotationDataListCall) Pages(ctx context.Context, f func(*Annotationsdata) error) error {
5498 c.ctx_ = ctx
5499 defer c.PageToken(c.urlParams_.Get("pageToken"))
5500 for {
5501 x, err := c.Do()
5502 if err != nil {
5503 return err
5504 }
5505 if err := f(x); err != nil {
5506 return err
5507 }
5508 if x.NextPageToken == "" {
5509 return nil
5510 }
5511 c.PageToken(x.NextPageToken)
5512 }
5513 }
5514
5515 type LayersVolumeAnnotationsGetCall struct {
5516 s *Service
5517 volumeId string
5518 layerId string
5519 annotationId string
5520 urlParams_ gensupport.URLParams
5521 ifNoneMatch_ string
5522 ctx_ context.Context
5523 header_ http.Header
5524 }
5525
5526
5527
5528
5529
5530
5531 func (r *LayersVolumeAnnotationsService) Get(volumeId string, layerId string, annotationId string) *LayersVolumeAnnotationsGetCall {
5532 c := &LayersVolumeAnnotationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5533 c.volumeId = volumeId
5534 c.layerId = layerId
5535 c.annotationId = annotationId
5536 return c
5537 }
5538
5539
5540
5541 func (c *LayersVolumeAnnotationsGetCall) Locale(locale string) *LayersVolumeAnnotationsGetCall {
5542 c.urlParams_.Set("locale", locale)
5543 return c
5544 }
5545
5546
5547
5548 func (c *LayersVolumeAnnotationsGetCall) Source(source string) *LayersVolumeAnnotationsGetCall {
5549 c.urlParams_.Set("source", source)
5550 return c
5551 }
5552
5553
5554
5555
5556 func (c *LayersVolumeAnnotationsGetCall) Fields(s ...googleapi.Field) *LayersVolumeAnnotationsGetCall {
5557 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5558 return c
5559 }
5560
5561
5562
5563
5564 func (c *LayersVolumeAnnotationsGetCall) IfNoneMatch(entityTag string) *LayersVolumeAnnotationsGetCall {
5565 c.ifNoneMatch_ = entityTag
5566 return c
5567 }
5568
5569
5570 func (c *LayersVolumeAnnotationsGetCall) Context(ctx context.Context) *LayersVolumeAnnotationsGetCall {
5571 c.ctx_ = ctx
5572 return c
5573 }
5574
5575
5576
5577 func (c *LayersVolumeAnnotationsGetCall) Header() http.Header {
5578 if c.header_ == nil {
5579 c.header_ = make(http.Header)
5580 }
5581 return c.header_
5582 }
5583
5584 func (c *LayersVolumeAnnotationsGetCall) doRequest(alt string) (*http.Response, error) {
5585 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5586 if c.ifNoneMatch_ != "" {
5587 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5588 }
5589 var body io.Reader = nil
5590 c.urlParams_.Set("alt", alt)
5591 c.urlParams_.Set("prettyPrint", "false")
5592 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/{volumeId}/layers/{layerId}/annotations/{annotationId}")
5593 urls += "?" + c.urlParams_.Encode()
5594 req, err := http.NewRequest("GET", urls, body)
5595 if err != nil {
5596 return nil, err
5597 }
5598 req.Header = reqHeaders
5599 googleapi.Expand(req.URL, map[string]string{
5600 "volumeId": c.volumeId,
5601 "layerId": c.layerId,
5602 "annotationId": c.annotationId,
5603 })
5604 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5605 }
5606
5607
5608
5609
5610
5611
5612
5613 func (c *LayersVolumeAnnotationsGetCall) Do(opts ...googleapi.CallOption) (*Volumeannotation, error) {
5614 gensupport.SetOptions(c.urlParams_, opts...)
5615 res, err := c.doRequest("json")
5616 if res != nil && res.StatusCode == http.StatusNotModified {
5617 if res.Body != nil {
5618 res.Body.Close()
5619 }
5620 return nil, gensupport.WrapError(&googleapi.Error{
5621 Code: res.StatusCode,
5622 Header: res.Header,
5623 })
5624 }
5625 if err != nil {
5626 return nil, err
5627 }
5628 defer googleapi.CloseBody(res)
5629 if err := googleapi.CheckResponse(res); err != nil {
5630 return nil, gensupport.WrapError(err)
5631 }
5632 ret := &Volumeannotation{
5633 ServerResponse: googleapi.ServerResponse{
5634 Header: res.Header,
5635 HTTPStatusCode: res.StatusCode,
5636 },
5637 }
5638 target := &ret
5639 if err := gensupport.DecodeResponse(target, res); err != nil {
5640 return nil, err
5641 }
5642 return ret, nil
5643 }
5644
5645 type LayersVolumeAnnotationsListCall struct {
5646 s *Service
5647 volumeId string
5648 layerId string
5649 urlParams_ gensupport.URLParams
5650 ifNoneMatch_ string
5651 ctx_ context.Context
5652 header_ http.Header
5653 }
5654
5655
5656
5657
5658
5659
5660 func (r *LayersVolumeAnnotationsService) List(volumeId string, layerId string, contentVersion string) *LayersVolumeAnnotationsListCall {
5661 c := &LayersVolumeAnnotationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5662 c.volumeId = volumeId
5663 c.layerId = layerId
5664 c.urlParams_.Set("contentVersion", contentVersion)
5665 return c
5666 }
5667
5668
5669
5670 func (c *LayersVolumeAnnotationsListCall) EndOffset(endOffset string) *LayersVolumeAnnotationsListCall {
5671 c.urlParams_.Set("endOffset", endOffset)
5672 return c
5673 }
5674
5675
5676
5677 func (c *LayersVolumeAnnotationsListCall) EndPosition(endPosition string) *LayersVolumeAnnotationsListCall {
5678 c.urlParams_.Set("endPosition", endPosition)
5679 return c
5680 }
5681
5682
5683
5684 func (c *LayersVolumeAnnotationsListCall) Locale(locale string) *LayersVolumeAnnotationsListCall {
5685 c.urlParams_.Set("locale", locale)
5686 return c
5687 }
5688
5689
5690
5691 func (c *LayersVolumeAnnotationsListCall) MaxResults(maxResults int64) *LayersVolumeAnnotationsListCall {
5692 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
5693 return c
5694 }
5695
5696
5697
5698 func (c *LayersVolumeAnnotationsListCall) PageToken(pageToken string) *LayersVolumeAnnotationsListCall {
5699 c.urlParams_.Set("pageToken", pageToken)
5700 return c
5701 }
5702
5703
5704
5705
5706 func (c *LayersVolumeAnnotationsListCall) ShowDeleted(showDeleted bool) *LayersVolumeAnnotationsListCall {
5707 c.urlParams_.Set("showDeleted", fmt.Sprint(showDeleted))
5708 return c
5709 }
5710
5711
5712
5713 func (c *LayersVolumeAnnotationsListCall) Source(source string) *LayersVolumeAnnotationsListCall {
5714 c.urlParams_.Set("source", source)
5715 return c
5716 }
5717
5718
5719
5720 func (c *LayersVolumeAnnotationsListCall) StartOffset(startOffset string) *LayersVolumeAnnotationsListCall {
5721 c.urlParams_.Set("startOffset", startOffset)
5722 return c
5723 }
5724
5725
5726
5727 func (c *LayersVolumeAnnotationsListCall) StartPosition(startPosition string) *LayersVolumeAnnotationsListCall {
5728 c.urlParams_.Set("startPosition", startPosition)
5729 return c
5730 }
5731
5732
5733
5734 func (c *LayersVolumeAnnotationsListCall) UpdatedMax(updatedMax string) *LayersVolumeAnnotationsListCall {
5735 c.urlParams_.Set("updatedMax", updatedMax)
5736 return c
5737 }
5738
5739
5740
5741 func (c *LayersVolumeAnnotationsListCall) UpdatedMin(updatedMin string) *LayersVolumeAnnotationsListCall {
5742 c.urlParams_.Set("updatedMin", updatedMin)
5743 return c
5744 }
5745
5746
5747
5748
5749 func (c *LayersVolumeAnnotationsListCall) VolumeAnnotationsVersion(volumeAnnotationsVersion string) *LayersVolumeAnnotationsListCall {
5750 c.urlParams_.Set("volumeAnnotationsVersion", volumeAnnotationsVersion)
5751 return c
5752 }
5753
5754
5755
5756
5757 func (c *LayersVolumeAnnotationsListCall) Fields(s ...googleapi.Field) *LayersVolumeAnnotationsListCall {
5758 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5759 return c
5760 }
5761
5762
5763
5764
5765 func (c *LayersVolumeAnnotationsListCall) IfNoneMatch(entityTag string) *LayersVolumeAnnotationsListCall {
5766 c.ifNoneMatch_ = entityTag
5767 return c
5768 }
5769
5770
5771 func (c *LayersVolumeAnnotationsListCall) Context(ctx context.Context) *LayersVolumeAnnotationsListCall {
5772 c.ctx_ = ctx
5773 return c
5774 }
5775
5776
5777
5778 func (c *LayersVolumeAnnotationsListCall) Header() http.Header {
5779 if c.header_ == nil {
5780 c.header_ = make(http.Header)
5781 }
5782 return c.header_
5783 }
5784
5785 func (c *LayersVolumeAnnotationsListCall) doRequest(alt string) (*http.Response, error) {
5786 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5787 if c.ifNoneMatch_ != "" {
5788 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5789 }
5790 var body io.Reader = nil
5791 c.urlParams_.Set("alt", alt)
5792 c.urlParams_.Set("prettyPrint", "false")
5793 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/{volumeId}/layers/{layerId}")
5794 urls += "?" + c.urlParams_.Encode()
5795 req, err := http.NewRequest("GET", urls, body)
5796 if err != nil {
5797 return nil, err
5798 }
5799 req.Header = reqHeaders
5800 googleapi.Expand(req.URL, map[string]string{
5801 "volumeId": c.volumeId,
5802 "layerId": c.layerId,
5803 })
5804 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5805 }
5806
5807
5808
5809
5810
5811
5812
5813 func (c *LayersVolumeAnnotationsListCall) Do(opts ...googleapi.CallOption) (*Volumeannotations, error) {
5814 gensupport.SetOptions(c.urlParams_, opts...)
5815 res, err := c.doRequest("json")
5816 if res != nil && res.StatusCode == http.StatusNotModified {
5817 if res.Body != nil {
5818 res.Body.Close()
5819 }
5820 return nil, gensupport.WrapError(&googleapi.Error{
5821 Code: res.StatusCode,
5822 Header: res.Header,
5823 })
5824 }
5825 if err != nil {
5826 return nil, err
5827 }
5828 defer googleapi.CloseBody(res)
5829 if err := googleapi.CheckResponse(res); err != nil {
5830 return nil, gensupport.WrapError(err)
5831 }
5832 ret := &Volumeannotations{
5833 ServerResponse: googleapi.ServerResponse{
5834 Header: res.Header,
5835 HTTPStatusCode: res.StatusCode,
5836 },
5837 }
5838 target := &ret
5839 if err := gensupport.DecodeResponse(target, res); err != nil {
5840 return nil, err
5841 }
5842 return ret, nil
5843 }
5844
5845
5846
5847
5848 func (c *LayersVolumeAnnotationsListCall) Pages(ctx context.Context, f func(*Volumeannotations) error) error {
5849 c.ctx_ = ctx
5850 defer c.PageToken(c.urlParams_.Get("pageToken"))
5851 for {
5852 x, err := c.Do()
5853 if err != nil {
5854 return err
5855 }
5856 if err := f(x); err != nil {
5857 return err
5858 }
5859 if x.NextPageToken == "" {
5860 return nil
5861 }
5862 c.PageToken(x.NextPageToken)
5863 }
5864 }
5865
5866 type MyconfigGetUserSettingsCall struct {
5867 s *Service
5868 urlParams_ gensupport.URLParams
5869 ifNoneMatch_ string
5870 ctx_ context.Context
5871 header_ http.Header
5872 }
5873
5874
5875 func (r *MyconfigService) GetUserSettings() *MyconfigGetUserSettingsCall {
5876 c := &MyconfigGetUserSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5877 return c
5878 }
5879
5880
5881
5882 func (c *MyconfigGetUserSettingsCall) Country(country string) *MyconfigGetUserSettingsCall {
5883 c.urlParams_.Set("country", country)
5884 return c
5885 }
5886
5887
5888
5889
5890 func (c *MyconfigGetUserSettingsCall) Fields(s ...googleapi.Field) *MyconfigGetUserSettingsCall {
5891 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5892 return c
5893 }
5894
5895
5896
5897
5898 func (c *MyconfigGetUserSettingsCall) IfNoneMatch(entityTag string) *MyconfigGetUserSettingsCall {
5899 c.ifNoneMatch_ = entityTag
5900 return c
5901 }
5902
5903
5904 func (c *MyconfigGetUserSettingsCall) Context(ctx context.Context) *MyconfigGetUserSettingsCall {
5905 c.ctx_ = ctx
5906 return c
5907 }
5908
5909
5910
5911 func (c *MyconfigGetUserSettingsCall) Header() http.Header {
5912 if c.header_ == nil {
5913 c.header_ = make(http.Header)
5914 }
5915 return c.header_
5916 }
5917
5918 func (c *MyconfigGetUserSettingsCall) doRequest(alt string) (*http.Response, error) {
5919 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5920 if c.ifNoneMatch_ != "" {
5921 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5922 }
5923 var body io.Reader = nil
5924 c.urlParams_.Set("alt", alt)
5925 c.urlParams_.Set("prettyPrint", "false")
5926 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/myconfig/getUserSettings")
5927 urls += "?" + c.urlParams_.Encode()
5928 req, err := http.NewRequest("GET", urls, body)
5929 if err != nil {
5930 return nil, err
5931 }
5932 req.Header = reqHeaders
5933 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5934 }
5935
5936
5937
5938
5939
5940
5941 func (c *MyconfigGetUserSettingsCall) Do(opts ...googleapi.CallOption) (*Usersettings, error) {
5942 gensupport.SetOptions(c.urlParams_, opts...)
5943 res, err := c.doRequest("json")
5944 if res != nil && res.StatusCode == http.StatusNotModified {
5945 if res.Body != nil {
5946 res.Body.Close()
5947 }
5948 return nil, gensupport.WrapError(&googleapi.Error{
5949 Code: res.StatusCode,
5950 Header: res.Header,
5951 })
5952 }
5953 if err != nil {
5954 return nil, err
5955 }
5956 defer googleapi.CloseBody(res)
5957 if err := googleapi.CheckResponse(res); err != nil {
5958 return nil, gensupport.WrapError(err)
5959 }
5960 ret := &Usersettings{
5961 ServerResponse: googleapi.ServerResponse{
5962 Header: res.Header,
5963 HTTPStatusCode: res.StatusCode,
5964 },
5965 }
5966 target := &ret
5967 if err := gensupport.DecodeResponse(target, res); err != nil {
5968 return nil, err
5969 }
5970 return ret, nil
5971 }
5972
5973 type MyconfigReleaseDownloadAccessCall struct {
5974 s *Service
5975 urlParams_ gensupport.URLParams
5976 ctx_ context.Context
5977 header_ http.Header
5978 }
5979
5980
5981
5982
5983
5984 func (r *MyconfigService) ReleaseDownloadAccess(cpksver string, volumeIds []string) *MyconfigReleaseDownloadAccessCall {
5985 c := &MyconfigReleaseDownloadAccessCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5986 c.urlParams_.Set("cpksver", cpksver)
5987 c.urlParams_.SetMulti("volumeIds", append([]string{}, volumeIds...))
5988 return c
5989 }
5990
5991
5992
5993 func (c *MyconfigReleaseDownloadAccessCall) Locale(locale string) *MyconfigReleaseDownloadAccessCall {
5994 c.urlParams_.Set("locale", locale)
5995 return c
5996 }
5997
5998
5999
6000 func (c *MyconfigReleaseDownloadAccessCall) Source(source string) *MyconfigReleaseDownloadAccessCall {
6001 c.urlParams_.Set("source", source)
6002 return c
6003 }
6004
6005
6006
6007
6008 func (c *MyconfigReleaseDownloadAccessCall) Fields(s ...googleapi.Field) *MyconfigReleaseDownloadAccessCall {
6009 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6010 return c
6011 }
6012
6013
6014 func (c *MyconfigReleaseDownloadAccessCall) Context(ctx context.Context) *MyconfigReleaseDownloadAccessCall {
6015 c.ctx_ = ctx
6016 return c
6017 }
6018
6019
6020
6021 func (c *MyconfigReleaseDownloadAccessCall) Header() http.Header {
6022 if c.header_ == nil {
6023 c.header_ = make(http.Header)
6024 }
6025 return c.header_
6026 }
6027
6028 func (c *MyconfigReleaseDownloadAccessCall) doRequest(alt string) (*http.Response, error) {
6029 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6030 var body io.Reader = nil
6031 c.urlParams_.Set("alt", alt)
6032 c.urlParams_.Set("prettyPrint", "false")
6033 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/myconfig/releaseDownloadAccess")
6034 urls += "?" + c.urlParams_.Encode()
6035 req, err := http.NewRequest("POST", urls, body)
6036 if err != nil {
6037 return nil, err
6038 }
6039 req.Header = reqHeaders
6040 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6041 }
6042
6043
6044
6045
6046
6047
6048
6049 func (c *MyconfigReleaseDownloadAccessCall) Do(opts ...googleapi.CallOption) (*DownloadAccesses, error) {
6050 gensupport.SetOptions(c.urlParams_, opts...)
6051 res, err := c.doRequest("json")
6052 if res != nil && res.StatusCode == http.StatusNotModified {
6053 if res.Body != nil {
6054 res.Body.Close()
6055 }
6056 return nil, gensupport.WrapError(&googleapi.Error{
6057 Code: res.StatusCode,
6058 Header: res.Header,
6059 })
6060 }
6061 if err != nil {
6062 return nil, err
6063 }
6064 defer googleapi.CloseBody(res)
6065 if err := googleapi.CheckResponse(res); err != nil {
6066 return nil, gensupport.WrapError(err)
6067 }
6068 ret := &DownloadAccesses{
6069 ServerResponse: googleapi.ServerResponse{
6070 Header: res.Header,
6071 HTTPStatusCode: res.StatusCode,
6072 },
6073 }
6074 target := &ret
6075 if err := gensupport.DecodeResponse(target, res); err != nil {
6076 return nil, err
6077 }
6078 return ret, nil
6079 }
6080
6081 type MyconfigRequestAccessCall struct {
6082 s *Service
6083 urlParams_ gensupport.URLParams
6084 ctx_ context.Context
6085 header_ http.Header
6086 }
6087
6088
6089
6090
6091
6092
6093
6094 func (r *MyconfigService) RequestAccess(cpksver string, nonce string, source string, volumeId string) *MyconfigRequestAccessCall {
6095 c := &MyconfigRequestAccessCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6096 c.urlParams_.Set("cpksver", cpksver)
6097 c.urlParams_.Set("nonce", nonce)
6098 c.urlParams_.Set("source", source)
6099 c.urlParams_.Set("volumeId", volumeId)
6100 return c
6101 }
6102
6103
6104
6105
6106
6107
6108
6109
6110
6111
6112 func (c *MyconfigRequestAccessCall) LicenseTypes(licenseTypes string) *MyconfigRequestAccessCall {
6113 c.urlParams_.Set("licenseTypes", licenseTypes)
6114 return c
6115 }
6116
6117
6118
6119 func (c *MyconfigRequestAccessCall) Locale(locale string) *MyconfigRequestAccessCall {
6120 c.urlParams_.Set("locale", locale)
6121 return c
6122 }
6123
6124
6125
6126
6127 func (c *MyconfigRequestAccessCall) Fields(s ...googleapi.Field) *MyconfigRequestAccessCall {
6128 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6129 return c
6130 }
6131
6132
6133 func (c *MyconfigRequestAccessCall) Context(ctx context.Context) *MyconfigRequestAccessCall {
6134 c.ctx_ = ctx
6135 return c
6136 }
6137
6138
6139
6140 func (c *MyconfigRequestAccessCall) Header() http.Header {
6141 if c.header_ == nil {
6142 c.header_ = make(http.Header)
6143 }
6144 return c.header_
6145 }
6146
6147 func (c *MyconfigRequestAccessCall) doRequest(alt string) (*http.Response, error) {
6148 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6149 var body io.Reader = nil
6150 c.urlParams_.Set("alt", alt)
6151 c.urlParams_.Set("prettyPrint", "false")
6152 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/myconfig/requestAccess")
6153 urls += "?" + c.urlParams_.Encode()
6154 req, err := http.NewRequest("POST", urls, body)
6155 if err != nil {
6156 return nil, err
6157 }
6158 req.Header = reqHeaders
6159 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6160 }
6161
6162
6163
6164
6165
6166
6167
6168 func (c *MyconfigRequestAccessCall) Do(opts ...googleapi.CallOption) (*RequestAccessData, error) {
6169 gensupport.SetOptions(c.urlParams_, opts...)
6170 res, err := c.doRequest("json")
6171 if res != nil && res.StatusCode == http.StatusNotModified {
6172 if res.Body != nil {
6173 res.Body.Close()
6174 }
6175 return nil, gensupport.WrapError(&googleapi.Error{
6176 Code: res.StatusCode,
6177 Header: res.Header,
6178 })
6179 }
6180 if err != nil {
6181 return nil, err
6182 }
6183 defer googleapi.CloseBody(res)
6184 if err := googleapi.CheckResponse(res); err != nil {
6185 return nil, gensupport.WrapError(err)
6186 }
6187 ret := &RequestAccessData{
6188 ServerResponse: googleapi.ServerResponse{
6189 Header: res.Header,
6190 HTTPStatusCode: res.StatusCode,
6191 },
6192 }
6193 target := &ret
6194 if err := gensupport.DecodeResponse(target, res); err != nil {
6195 return nil, err
6196 }
6197 return ret, nil
6198 }
6199
6200 type MyconfigSyncVolumeLicensesCall struct {
6201 s *Service
6202 urlParams_ gensupport.URLParams
6203 ctx_ context.Context
6204 header_ http.Header
6205 }
6206
6207
6208
6209
6210
6211
6212
6213 func (r *MyconfigService) SyncVolumeLicenses(cpksver string, nonce string, source string) *MyconfigSyncVolumeLicensesCall {
6214 c := &MyconfigSyncVolumeLicensesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6215 c.urlParams_.Set("cpksver", cpksver)
6216 c.urlParams_.Set("nonce", nonce)
6217 c.urlParams_.Set("source", source)
6218 return c
6219 }
6220
6221
6222
6223
6224
6225
6226
6227
6228 func (c *MyconfigSyncVolumeLicensesCall) Features(features ...string) *MyconfigSyncVolumeLicensesCall {
6229 c.urlParams_.SetMulti("features", append([]string{}, features...))
6230 return c
6231 }
6232
6233
6234
6235 func (c *MyconfigSyncVolumeLicensesCall) IncludeNonComicsSeries(includeNonComicsSeries bool) *MyconfigSyncVolumeLicensesCall {
6236 c.urlParams_.Set("includeNonComicsSeries", fmt.Sprint(includeNonComicsSeries))
6237 return c
6238 }
6239
6240
6241
6242 func (c *MyconfigSyncVolumeLicensesCall) Locale(locale string) *MyconfigSyncVolumeLicensesCall {
6243 c.urlParams_.Set("locale", locale)
6244 return c
6245 }
6246
6247
6248
6249 func (c *MyconfigSyncVolumeLicensesCall) ShowPreorders(showPreorders bool) *MyconfigSyncVolumeLicensesCall {
6250 c.urlParams_.Set("showPreorders", fmt.Sprint(showPreorders))
6251 return c
6252 }
6253
6254
6255
6256 func (c *MyconfigSyncVolumeLicensesCall) VolumeIds(volumeIds ...string) *MyconfigSyncVolumeLicensesCall {
6257 c.urlParams_.SetMulti("volumeIds", append([]string{}, volumeIds...))
6258 return c
6259 }
6260
6261
6262
6263
6264 func (c *MyconfigSyncVolumeLicensesCall) Fields(s ...googleapi.Field) *MyconfigSyncVolumeLicensesCall {
6265 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6266 return c
6267 }
6268
6269
6270 func (c *MyconfigSyncVolumeLicensesCall) Context(ctx context.Context) *MyconfigSyncVolumeLicensesCall {
6271 c.ctx_ = ctx
6272 return c
6273 }
6274
6275
6276
6277 func (c *MyconfigSyncVolumeLicensesCall) Header() http.Header {
6278 if c.header_ == nil {
6279 c.header_ = make(http.Header)
6280 }
6281 return c.header_
6282 }
6283
6284 func (c *MyconfigSyncVolumeLicensesCall) doRequest(alt string) (*http.Response, error) {
6285 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6286 var body io.Reader = nil
6287 c.urlParams_.Set("alt", alt)
6288 c.urlParams_.Set("prettyPrint", "false")
6289 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/myconfig/syncVolumeLicenses")
6290 urls += "?" + c.urlParams_.Encode()
6291 req, err := http.NewRequest("POST", urls, body)
6292 if err != nil {
6293 return nil, err
6294 }
6295 req.Header = reqHeaders
6296 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6297 }
6298
6299
6300
6301
6302
6303
6304 func (c *MyconfigSyncVolumeLicensesCall) Do(opts ...googleapi.CallOption) (*Volumes, error) {
6305 gensupport.SetOptions(c.urlParams_, opts...)
6306 res, err := c.doRequest("json")
6307 if res != nil && res.StatusCode == http.StatusNotModified {
6308 if res.Body != nil {
6309 res.Body.Close()
6310 }
6311 return nil, gensupport.WrapError(&googleapi.Error{
6312 Code: res.StatusCode,
6313 Header: res.Header,
6314 })
6315 }
6316 if err != nil {
6317 return nil, err
6318 }
6319 defer googleapi.CloseBody(res)
6320 if err := googleapi.CheckResponse(res); err != nil {
6321 return nil, gensupport.WrapError(err)
6322 }
6323 ret := &Volumes{
6324 ServerResponse: googleapi.ServerResponse{
6325 Header: res.Header,
6326 HTTPStatusCode: res.StatusCode,
6327 },
6328 }
6329 target := &ret
6330 if err := gensupport.DecodeResponse(target, res); err != nil {
6331 return nil, err
6332 }
6333 return ret, nil
6334 }
6335
6336 type MyconfigUpdateUserSettingsCall struct {
6337 s *Service
6338 usersettings *Usersettings
6339 urlParams_ gensupport.URLParams
6340 ctx_ context.Context
6341 header_ http.Header
6342 }
6343
6344
6345
6346
6347 func (r *MyconfigService) UpdateUserSettings(usersettings *Usersettings) *MyconfigUpdateUserSettingsCall {
6348 c := &MyconfigUpdateUserSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6349 c.usersettings = usersettings
6350 return c
6351 }
6352
6353
6354
6355
6356 func (c *MyconfigUpdateUserSettingsCall) Fields(s ...googleapi.Field) *MyconfigUpdateUserSettingsCall {
6357 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6358 return c
6359 }
6360
6361
6362 func (c *MyconfigUpdateUserSettingsCall) Context(ctx context.Context) *MyconfigUpdateUserSettingsCall {
6363 c.ctx_ = ctx
6364 return c
6365 }
6366
6367
6368
6369 func (c *MyconfigUpdateUserSettingsCall) Header() http.Header {
6370 if c.header_ == nil {
6371 c.header_ = make(http.Header)
6372 }
6373 return c.header_
6374 }
6375
6376 func (c *MyconfigUpdateUserSettingsCall) doRequest(alt string) (*http.Response, error) {
6377 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6378 var body io.Reader = nil
6379 body, err := googleapi.WithoutDataWrapper.JSONReader(c.usersettings)
6380 if err != nil {
6381 return nil, err
6382 }
6383 c.urlParams_.Set("alt", alt)
6384 c.urlParams_.Set("prettyPrint", "false")
6385 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/myconfig/updateUserSettings")
6386 urls += "?" + c.urlParams_.Encode()
6387 req, err := http.NewRequest("POST", urls, body)
6388 if err != nil {
6389 return nil, err
6390 }
6391 req.Header = reqHeaders
6392 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6393 }
6394
6395
6396
6397
6398
6399
6400 func (c *MyconfigUpdateUserSettingsCall) Do(opts ...googleapi.CallOption) (*Usersettings, error) {
6401 gensupport.SetOptions(c.urlParams_, opts...)
6402 res, err := c.doRequest("json")
6403 if res != nil && res.StatusCode == http.StatusNotModified {
6404 if res.Body != nil {
6405 res.Body.Close()
6406 }
6407 return nil, gensupport.WrapError(&googleapi.Error{
6408 Code: res.StatusCode,
6409 Header: res.Header,
6410 })
6411 }
6412 if err != nil {
6413 return nil, err
6414 }
6415 defer googleapi.CloseBody(res)
6416 if err := googleapi.CheckResponse(res); err != nil {
6417 return nil, gensupport.WrapError(err)
6418 }
6419 ret := &Usersettings{
6420 ServerResponse: googleapi.ServerResponse{
6421 Header: res.Header,
6422 HTTPStatusCode: res.StatusCode,
6423 },
6424 }
6425 target := &ret
6426 if err := gensupport.DecodeResponse(target, res); err != nil {
6427 return nil, err
6428 }
6429 return ret, nil
6430 }
6431
6432 type MylibraryAnnotationsDeleteCall struct {
6433 s *Service
6434 annotationId string
6435 urlParams_ gensupport.URLParams
6436 ctx_ context.Context
6437 header_ http.Header
6438 }
6439
6440
6441
6442
6443 func (r *MylibraryAnnotationsService) Delete(annotationId string) *MylibraryAnnotationsDeleteCall {
6444 c := &MylibraryAnnotationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6445 c.annotationId = annotationId
6446 return c
6447 }
6448
6449
6450
6451 func (c *MylibraryAnnotationsDeleteCall) Source(source string) *MylibraryAnnotationsDeleteCall {
6452 c.urlParams_.Set("source", source)
6453 return c
6454 }
6455
6456
6457
6458
6459 func (c *MylibraryAnnotationsDeleteCall) Fields(s ...googleapi.Field) *MylibraryAnnotationsDeleteCall {
6460 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6461 return c
6462 }
6463
6464
6465 func (c *MylibraryAnnotationsDeleteCall) Context(ctx context.Context) *MylibraryAnnotationsDeleteCall {
6466 c.ctx_ = ctx
6467 return c
6468 }
6469
6470
6471
6472 func (c *MylibraryAnnotationsDeleteCall) Header() http.Header {
6473 if c.header_ == nil {
6474 c.header_ = make(http.Header)
6475 }
6476 return c.header_
6477 }
6478
6479 func (c *MylibraryAnnotationsDeleteCall) doRequest(alt string) (*http.Response, error) {
6480 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6481 var body io.Reader = nil
6482 c.urlParams_.Set("alt", alt)
6483 c.urlParams_.Set("prettyPrint", "false")
6484 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/annotations/{annotationId}")
6485 urls += "?" + c.urlParams_.Encode()
6486 req, err := http.NewRequest("DELETE", urls, body)
6487 if err != nil {
6488 return nil, err
6489 }
6490 req.Header = reqHeaders
6491 googleapi.Expand(req.URL, map[string]string{
6492 "annotationId": c.annotationId,
6493 })
6494 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6495 }
6496
6497
6498
6499
6500
6501
6502 func (c *MylibraryAnnotationsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
6503 gensupport.SetOptions(c.urlParams_, opts...)
6504 res, err := c.doRequest("json")
6505 if res != nil && res.StatusCode == http.StatusNotModified {
6506 if res.Body != nil {
6507 res.Body.Close()
6508 }
6509 return nil, gensupport.WrapError(&googleapi.Error{
6510 Code: res.StatusCode,
6511 Header: res.Header,
6512 })
6513 }
6514 if err != nil {
6515 return nil, err
6516 }
6517 defer googleapi.CloseBody(res)
6518 if err := googleapi.CheckResponse(res); err != nil {
6519 return nil, gensupport.WrapError(err)
6520 }
6521 ret := &Empty{
6522 ServerResponse: googleapi.ServerResponse{
6523 Header: res.Header,
6524 HTTPStatusCode: res.StatusCode,
6525 },
6526 }
6527 target := &ret
6528 if err := gensupport.DecodeResponse(target, res); err != nil {
6529 return nil, err
6530 }
6531 return ret, nil
6532 }
6533
6534 type MylibraryAnnotationsInsertCall struct {
6535 s *Service
6536 annotation *Annotation
6537 urlParams_ gensupport.URLParams
6538 ctx_ context.Context
6539 header_ http.Header
6540 }
6541
6542
6543 func (r *MylibraryAnnotationsService) Insert(annotation *Annotation) *MylibraryAnnotationsInsertCall {
6544 c := &MylibraryAnnotationsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6545 c.annotation = annotation
6546 return c
6547 }
6548
6549
6550
6551 func (c *MylibraryAnnotationsInsertCall) AnnotationId(annotationId string) *MylibraryAnnotationsInsertCall {
6552 c.urlParams_.Set("annotationId", annotationId)
6553 return c
6554 }
6555
6556
6557
6558 func (c *MylibraryAnnotationsInsertCall) Country(country string) *MylibraryAnnotationsInsertCall {
6559 c.urlParams_.Set("country", country)
6560 return c
6561 }
6562
6563
6564
6565
6566 func (c *MylibraryAnnotationsInsertCall) ShowOnlySummaryInResponse(showOnlySummaryInResponse bool) *MylibraryAnnotationsInsertCall {
6567 c.urlParams_.Set("showOnlySummaryInResponse", fmt.Sprint(showOnlySummaryInResponse))
6568 return c
6569 }
6570
6571
6572
6573 func (c *MylibraryAnnotationsInsertCall) Source(source string) *MylibraryAnnotationsInsertCall {
6574 c.urlParams_.Set("source", source)
6575 return c
6576 }
6577
6578
6579
6580
6581 func (c *MylibraryAnnotationsInsertCall) Fields(s ...googleapi.Field) *MylibraryAnnotationsInsertCall {
6582 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6583 return c
6584 }
6585
6586
6587 func (c *MylibraryAnnotationsInsertCall) Context(ctx context.Context) *MylibraryAnnotationsInsertCall {
6588 c.ctx_ = ctx
6589 return c
6590 }
6591
6592
6593
6594 func (c *MylibraryAnnotationsInsertCall) Header() http.Header {
6595 if c.header_ == nil {
6596 c.header_ = make(http.Header)
6597 }
6598 return c.header_
6599 }
6600
6601 func (c *MylibraryAnnotationsInsertCall) doRequest(alt string) (*http.Response, error) {
6602 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6603 var body io.Reader = nil
6604 body, err := googleapi.WithoutDataWrapper.JSONReader(c.annotation)
6605 if err != nil {
6606 return nil, err
6607 }
6608 c.urlParams_.Set("alt", alt)
6609 c.urlParams_.Set("prettyPrint", "false")
6610 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/annotations")
6611 urls += "?" + c.urlParams_.Encode()
6612 req, err := http.NewRequest("POST", urls, body)
6613 if err != nil {
6614 return nil, err
6615 }
6616 req.Header = reqHeaders
6617 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6618 }
6619
6620
6621
6622
6623
6624
6625 func (c *MylibraryAnnotationsInsertCall) Do(opts ...googleapi.CallOption) (*Annotation, error) {
6626 gensupport.SetOptions(c.urlParams_, opts...)
6627 res, err := c.doRequest("json")
6628 if res != nil && res.StatusCode == http.StatusNotModified {
6629 if res.Body != nil {
6630 res.Body.Close()
6631 }
6632 return nil, gensupport.WrapError(&googleapi.Error{
6633 Code: res.StatusCode,
6634 Header: res.Header,
6635 })
6636 }
6637 if err != nil {
6638 return nil, err
6639 }
6640 defer googleapi.CloseBody(res)
6641 if err := googleapi.CheckResponse(res); err != nil {
6642 return nil, gensupport.WrapError(err)
6643 }
6644 ret := &Annotation{
6645 ServerResponse: googleapi.ServerResponse{
6646 Header: res.Header,
6647 HTTPStatusCode: res.StatusCode,
6648 },
6649 }
6650 target := &ret
6651 if err := gensupport.DecodeResponse(target, res); err != nil {
6652 return nil, err
6653 }
6654 return ret, nil
6655 }
6656
6657 type MylibraryAnnotationsListCall struct {
6658 s *Service
6659 urlParams_ gensupport.URLParams
6660 ifNoneMatch_ string
6661 ctx_ context.Context
6662 header_ http.Header
6663 }
6664
6665
6666 func (r *MylibraryAnnotationsService) List() *MylibraryAnnotationsListCall {
6667 c := &MylibraryAnnotationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6668 return c
6669 }
6670
6671
6672
6673 func (c *MylibraryAnnotationsListCall) ContentVersion(contentVersion string) *MylibraryAnnotationsListCall {
6674 c.urlParams_.Set("contentVersion", contentVersion)
6675 return c
6676 }
6677
6678
6679
6680 func (c *MylibraryAnnotationsListCall) LayerId(layerId string) *MylibraryAnnotationsListCall {
6681 c.urlParams_.Set("layerId", layerId)
6682 return c
6683 }
6684
6685
6686
6687 func (c *MylibraryAnnotationsListCall) LayerIds(layerIds ...string) *MylibraryAnnotationsListCall {
6688 c.urlParams_.SetMulti("layerIds", append([]string{}, layerIds...))
6689 return c
6690 }
6691
6692
6693
6694 func (c *MylibraryAnnotationsListCall) MaxResults(maxResults int64) *MylibraryAnnotationsListCall {
6695 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
6696 return c
6697 }
6698
6699
6700
6701 func (c *MylibraryAnnotationsListCall) PageToken(pageToken string) *MylibraryAnnotationsListCall {
6702 c.urlParams_.Set("pageToken", pageToken)
6703 return c
6704 }
6705
6706
6707
6708
6709 func (c *MylibraryAnnotationsListCall) ShowDeleted(showDeleted bool) *MylibraryAnnotationsListCall {
6710 c.urlParams_.Set("showDeleted", fmt.Sprint(showDeleted))
6711 return c
6712 }
6713
6714
6715
6716 func (c *MylibraryAnnotationsListCall) Source(source string) *MylibraryAnnotationsListCall {
6717 c.urlParams_.Set("source", source)
6718 return c
6719 }
6720
6721
6722
6723 func (c *MylibraryAnnotationsListCall) UpdatedMax(updatedMax string) *MylibraryAnnotationsListCall {
6724 c.urlParams_.Set("updatedMax", updatedMax)
6725 return c
6726 }
6727
6728
6729
6730 func (c *MylibraryAnnotationsListCall) UpdatedMin(updatedMin string) *MylibraryAnnotationsListCall {
6731 c.urlParams_.Set("updatedMin", updatedMin)
6732 return c
6733 }
6734
6735
6736
6737 func (c *MylibraryAnnotationsListCall) VolumeId(volumeId string) *MylibraryAnnotationsListCall {
6738 c.urlParams_.Set("volumeId", volumeId)
6739 return c
6740 }
6741
6742
6743
6744
6745 func (c *MylibraryAnnotationsListCall) Fields(s ...googleapi.Field) *MylibraryAnnotationsListCall {
6746 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6747 return c
6748 }
6749
6750
6751
6752
6753 func (c *MylibraryAnnotationsListCall) IfNoneMatch(entityTag string) *MylibraryAnnotationsListCall {
6754 c.ifNoneMatch_ = entityTag
6755 return c
6756 }
6757
6758
6759 func (c *MylibraryAnnotationsListCall) Context(ctx context.Context) *MylibraryAnnotationsListCall {
6760 c.ctx_ = ctx
6761 return c
6762 }
6763
6764
6765
6766 func (c *MylibraryAnnotationsListCall) Header() http.Header {
6767 if c.header_ == nil {
6768 c.header_ = make(http.Header)
6769 }
6770 return c.header_
6771 }
6772
6773 func (c *MylibraryAnnotationsListCall) doRequest(alt string) (*http.Response, error) {
6774 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6775 if c.ifNoneMatch_ != "" {
6776 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6777 }
6778 var body io.Reader = nil
6779 c.urlParams_.Set("alt", alt)
6780 c.urlParams_.Set("prettyPrint", "false")
6781 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/annotations")
6782 urls += "?" + c.urlParams_.Encode()
6783 req, err := http.NewRequest("GET", urls, body)
6784 if err != nil {
6785 return nil, err
6786 }
6787 req.Header = reqHeaders
6788 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6789 }
6790
6791
6792
6793
6794
6795
6796 func (c *MylibraryAnnotationsListCall) Do(opts ...googleapi.CallOption) (*Annotations, error) {
6797 gensupport.SetOptions(c.urlParams_, opts...)
6798 res, err := c.doRequest("json")
6799 if res != nil && res.StatusCode == http.StatusNotModified {
6800 if res.Body != nil {
6801 res.Body.Close()
6802 }
6803 return nil, gensupport.WrapError(&googleapi.Error{
6804 Code: res.StatusCode,
6805 Header: res.Header,
6806 })
6807 }
6808 if err != nil {
6809 return nil, err
6810 }
6811 defer googleapi.CloseBody(res)
6812 if err := googleapi.CheckResponse(res); err != nil {
6813 return nil, gensupport.WrapError(err)
6814 }
6815 ret := &Annotations{
6816 ServerResponse: googleapi.ServerResponse{
6817 Header: res.Header,
6818 HTTPStatusCode: res.StatusCode,
6819 },
6820 }
6821 target := &ret
6822 if err := gensupport.DecodeResponse(target, res); err != nil {
6823 return nil, err
6824 }
6825 return ret, nil
6826 }
6827
6828
6829
6830
6831 func (c *MylibraryAnnotationsListCall) Pages(ctx context.Context, f func(*Annotations) error) error {
6832 c.ctx_ = ctx
6833 defer c.PageToken(c.urlParams_.Get("pageToken"))
6834 for {
6835 x, err := c.Do()
6836 if err != nil {
6837 return err
6838 }
6839 if err := f(x); err != nil {
6840 return err
6841 }
6842 if x.NextPageToken == "" {
6843 return nil
6844 }
6845 c.PageToken(x.NextPageToken)
6846 }
6847 }
6848
6849 type MylibraryAnnotationsSummaryCall struct {
6850 s *Service
6851 urlParams_ gensupport.URLParams
6852 ctx_ context.Context
6853 header_ http.Header
6854 }
6855
6856
6857
6858
6859
6860 func (r *MylibraryAnnotationsService) Summary(layerIds []string, volumeId string) *MylibraryAnnotationsSummaryCall {
6861 c := &MylibraryAnnotationsSummaryCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6862 c.urlParams_.SetMulti("layerIds", append([]string{}, layerIds...))
6863 c.urlParams_.Set("volumeId", volumeId)
6864 return c
6865 }
6866
6867
6868
6869 func (c *MylibraryAnnotationsSummaryCall) Source(source string) *MylibraryAnnotationsSummaryCall {
6870 c.urlParams_.Set("source", source)
6871 return c
6872 }
6873
6874
6875
6876
6877 func (c *MylibraryAnnotationsSummaryCall) Fields(s ...googleapi.Field) *MylibraryAnnotationsSummaryCall {
6878 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6879 return c
6880 }
6881
6882
6883 func (c *MylibraryAnnotationsSummaryCall) Context(ctx context.Context) *MylibraryAnnotationsSummaryCall {
6884 c.ctx_ = ctx
6885 return c
6886 }
6887
6888
6889
6890 func (c *MylibraryAnnotationsSummaryCall) Header() http.Header {
6891 if c.header_ == nil {
6892 c.header_ = make(http.Header)
6893 }
6894 return c.header_
6895 }
6896
6897 func (c *MylibraryAnnotationsSummaryCall) doRequest(alt string) (*http.Response, error) {
6898 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6899 var body io.Reader = nil
6900 c.urlParams_.Set("alt", alt)
6901 c.urlParams_.Set("prettyPrint", "false")
6902 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/annotations/summary")
6903 urls += "?" + c.urlParams_.Encode()
6904 req, err := http.NewRequest("POST", urls, body)
6905 if err != nil {
6906 return nil, err
6907 }
6908 req.Header = reqHeaders
6909 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6910 }
6911
6912
6913
6914
6915
6916
6917
6918 func (c *MylibraryAnnotationsSummaryCall) Do(opts ...googleapi.CallOption) (*AnnotationsSummary, error) {
6919 gensupport.SetOptions(c.urlParams_, opts...)
6920 res, err := c.doRequest("json")
6921 if res != nil && res.StatusCode == http.StatusNotModified {
6922 if res.Body != nil {
6923 res.Body.Close()
6924 }
6925 return nil, gensupport.WrapError(&googleapi.Error{
6926 Code: res.StatusCode,
6927 Header: res.Header,
6928 })
6929 }
6930 if err != nil {
6931 return nil, err
6932 }
6933 defer googleapi.CloseBody(res)
6934 if err := googleapi.CheckResponse(res); err != nil {
6935 return nil, gensupport.WrapError(err)
6936 }
6937 ret := &AnnotationsSummary{
6938 ServerResponse: googleapi.ServerResponse{
6939 Header: res.Header,
6940 HTTPStatusCode: res.StatusCode,
6941 },
6942 }
6943 target := &ret
6944 if err := gensupport.DecodeResponse(target, res); err != nil {
6945 return nil, err
6946 }
6947 return ret, nil
6948 }
6949
6950 type MylibraryAnnotationsUpdateCall struct {
6951 s *Service
6952 annotationId string
6953 annotation *Annotation
6954 urlParams_ gensupport.URLParams
6955 ctx_ context.Context
6956 header_ http.Header
6957 }
6958
6959
6960
6961
6962 func (r *MylibraryAnnotationsService) Update(annotationId string, annotation *Annotation) *MylibraryAnnotationsUpdateCall {
6963 c := &MylibraryAnnotationsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6964 c.annotationId = annotationId
6965 c.annotation = annotation
6966 return c
6967 }
6968
6969
6970
6971 func (c *MylibraryAnnotationsUpdateCall) Source(source string) *MylibraryAnnotationsUpdateCall {
6972 c.urlParams_.Set("source", source)
6973 return c
6974 }
6975
6976
6977
6978
6979 func (c *MylibraryAnnotationsUpdateCall) Fields(s ...googleapi.Field) *MylibraryAnnotationsUpdateCall {
6980 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6981 return c
6982 }
6983
6984
6985 func (c *MylibraryAnnotationsUpdateCall) Context(ctx context.Context) *MylibraryAnnotationsUpdateCall {
6986 c.ctx_ = ctx
6987 return c
6988 }
6989
6990
6991
6992 func (c *MylibraryAnnotationsUpdateCall) Header() http.Header {
6993 if c.header_ == nil {
6994 c.header_ = make(http.Header)
6995 }
6996 return c.header_
6997 }
6998
6999 func (c *MylibraryAnnotationsUpdateCall) doRequest(alt string) (*http.Response, error) {
7000 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7001 var body io.Reader = nil
7002 body, err := googleapi.WithoutDataWrapper.JSONReader(c.annotation)
7003 if err != nil {
7004 return nil, err
7005 }
7006 c.urlParams_.Set("alt", alt)
7007 c.urlParams_.Set("prettyPrint", "false")
7008 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/annotations/{annotationId}")
7009 urls += "?" + c.urlParams_.Encode()
7010 req, err := http.NewRequest("PUT", urls, body)
7011 if err != nil {
7012 return nil, err
7013 }
7014 req.Header = reqHeaders
7015 googleapi.Expand(req.URL, map[string]string{
7016 "annotationId": c.annotationId,
7017 })
7018 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7019 }
7020
7021
7022
7023
7024
7025
7026 func (c *MylibraryAnnotationsUpdateCall) Do(opts ...googleapi.CallOption) (*Annotation, error) {
7027 gensupport.SetOptions(c.urlParams_, opts...)
7028 res, err := c.doRequest("json")
7029 if res != nil && res.StatusCode == http.StatusNotModified {
7030 if res.Body != nil {
7031 res.Body.Close()
7032 }
7033 return nil, gensupport.WrapError(&googleapi.Error{
7034 Code: res.StatusCode,
7035 Header: res.Header,
7036 })
7037 }
7038 if err != nil {
7039 return nil, err
7040 }
7041 defer googleapi.CloseBody(res)
7042 if err := googleapi.CheckResponse(res); err != nil {
7043 return nil, gensupport.WrapError(err)
7044 }
7045 ret := &Annotation{
7046 ServerResponse: googleapi.ServerResponse{
7047 Header: res.Header,
7048 HTTPStatusCode: res.StatusCode,
7049 },
7050 }
7051 target := &ret
7052 if err := gensupport.DecodeResponse(target, res); err != nil {
7053 return nil, err
7054 }
7055 return ret, nil
7056 }
7057
7058 type MylibraryBookshelvesAddVolumeCall struct {
7059 s *Service
7060 shelf string
7061 urlParams_ gensupport.URLParams
7062 ctx_ context.Context
7063 header_ http.Header
7064 }
7065
7066
7067
7068
7069
7070 func (r *MylibraryBookshelvesService) AddVolume(shelf string, volumeId string) *MylibraryBookshelvesAddVolumeCall {
7071 c := &MylibraryBookshelvesAddVolumeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7072 c.shelf = shelf
7073 c.urlParams_.Set("volumeId", volumeId)
7074 return c
7075 }
7076
7077
7078
7079
7080
7081
7082
7083
7084
7085
7086 func (c *MylibraryBookshelvesAddVolumeCall) Reason(reason string) *MylibraryBookshelvesAddVolumeCall {
7087 c.urlParams_.Set("reason", reason)
7088 return c
7089 }
7090
7091
7092
7093 func (c *MylibraryBookshelvesAddVolumeCall) Source(source string) *MylibraryBookshelvesAddVolumeCall {
7094 c.urlParams_.Set("source", source)
7095 return c
7096 }
7097
7098
7099
7100
7101 func (c *MylibraryBookshelvesAddVolumeCall) Fields(s ...googleapi.Field) *MylibraryBookshelvesAddVolumeCall {
7102 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7103 return c
7104 }
7105
7106
7107 func (c *MylibraryBookshelvesAddVolumeCall) Context(ctx context.Context) *MylibraryBookshelvesAddVolumeCall {
7108 c.ctx_ = ctx
7109 return c
7110 }
7111
7112
7113
7114 func (c *MylibraryBookshelvesAddVolumeCall) Header() http.Header {
7115 if c.header_ == nil {
7116 c.header_ = make(http.Header)
7117 }
7118 return c.header_
7119 }
7120
7121 func (c *MylibraryBookshelvesAddVolumeCall) doRequest(alt string) (*http.Response, error) {
7122 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7123 var body io.Reader = nil
7124 c.urlParams_.Set("alt", alt)
7125 c.urlParams_.Set("prettyPrint", "false")
7126 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/bookshelves/{shelf}/addVolume")
7127 urls += "?" + c.urlParams_.Encode()
7128 req, err := http.NewRequest("POST", urls, body)
7129 if err != nil {
7130 return nil, err
7131 }
7132 req.Header = reqHeaders
7133 googleapi.Expand(req.URL, map[string]string{
7134 "shelf": c.shelf,
7135 })
7136 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7137 }
7138
7139
7140
7141
7142
7143
7144 func (c *MylibraryBookshelvesAddVolumeCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
7145 gensupport.SetOptions(c.urlParams_, opts...)
7146 res, err := c.doRequest("json")
7147 if res != nil && res.StatusCode == http.StatusNotModified {
7148 if res.Body != nil {
7149 res.Body.Close()
7150 }
7151 return nil, gensupport.WrapError(&googleapi.Error{
7152 Code: res.StatusCode,
7153 Header: res.Header,
7154 })
7155 }
7156 if err != nil {
7157 return nil, err
7158 }
7159 defer googleapi.CloseBody(res)
7160 if err := googleapi.CheckResponse(res); err != nil {
7161 return nil, gensupport.WrapError(err)
7162 }
7163 ret := &Empty{
7164 ServerResponse: googleapi.ServerResponse{
7165 Header: res.Header,
7166 HTTPStatusCode: res.StatusCode,
7167 },
7168 }
7169 target := &ret
7170 if err := gensupport.DecodeResponse(target, res); err != nil {
7171 return nil, err
7172 }
7173 return ret, nil
7174 }
7175
7176 type MylibraryBookshelvesClearVolumesCall struct {
7177 s *Service
7178 shelf string
7179 urlParams_ gensupport.URLParams
7180 ctx_ context.Context
7181 header_ http.Header
7182 }
7183
7184
7185
7186
7187 func (r *MylibraryBookshelvesService) ClearVolumes(shelf string) *MylibraryBookshelvesClearVolumesCall {
7188 c := &MylibraryBookshelvesClearVolumesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7189 c.shelf = shelf
7190 return c
7191 }
7192
7193
7194
7195 func (c *MylibraryBookshelvesClearVolumesCall) Source(source string) *MylibraryBookshelvesClearVolumesCall {
7196 c.urlParams_.Set("source", source)
7197 return c
7198 }
7199
7200
7201
7202
7203 func (c *MylibraryBookshelvesClearVolumesCall) Fields(s ...googleapi.Field) *MylibraryBookshelvesClearVolumesCall {
7204 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7205 return c
7206 }
7207
7208
7209 func (c *MylibraryBookshelvesClearVolumesCall) Context(ctx context.Context) *MylibraryBookshelvesClearVolumesCall {
7210 c.ctx_ = ctx
7211 return c
7212 }
7213
7214
7215
7216 func (c *MylibraryBookshelvesClearVolumesCall) Header() http.Header {
7217 if c.header_ == nil {
7218 c.header_ = make(http.Header)
7219 }
7220 return c.header_
7221 }
7222
7223 func (c *MylibraryBookshelvesClearVolumesCall) doRequest(alt string) (*http.Response, error) {
7224 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7225 var body io.Reader = nil
7226 c.urlParams_.Set("alt", alt)
7227 c.urlParams_.Set("prettyPrint", "false")
7228 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/bookshelves/{shelf}/clearVolumes")
7229 urls += "?" + c.urlParams_.Encode()
7230 req, err := http.NewRequest("POST", urls, body)
7231 if err != nil {
7232 return nil, err
7233 }
7234 req.Header = reqHeaders
7235 googleapi.Expand(req.URL, map[string]string{
7236 "shelf": c.shelf,
7237 })
7238 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7239 }
7240
7241
7242
7243
7244
7245
7246 func (c *MylibraryBookshelvesClearVolumesCall) Do(opts ...googleapi.CallOption) (*Empty, 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 := &Empty{
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 MylibraryBookshelvesGetCall struct {
7279 s *Service
7280 shelf string
7281 urlParams_ gensupport.URLParams
7282 ifNoneMatch_ string
7283 ctx_ context.Context
7284 header_ http.Header
7285 }
7286
7287
7288
7289
7290
7291 func (r *MylibraryBookshelvesService) Get(shelf string) *MylibraryBookshelvesGetCall {
7292 c := &MylibraryBookshelvesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7293 c.shelf = shelf
7294 return c
7295 }
7296
7297
7298
7299 func (c *MylibraryBookshelvesGetCall) Source(source string) *MylibraryBookshelvesGetCall {
7300 c.urlParams_.Set("source", source)
7301 return c
7302 }
7303
7304
7305
7306
7307 func (c *MylibraryBookshelvesGetCall) Fields(s ...googleapi.Field) *MylibraryBookshelvesGetCall {
7308 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7309 return c
7310 }
7311
7312
7313
7314
7315 func (c *MylibraryBookshelvesGetCall) IfNoneMatch(entityTag string) *MylibraryBookshelvesGetCall {
7316 c.ifNoneMatch_ = entityTag
7317 return c
7318 }
7319
7320
7321 func (c *MylibraryBookshelvesGetCall) Context(ctx context.Context) *MylibraryBookshelvesGetCall {
7322 c.ctx_ = ctx
7323 return c
7324 }
7325
7326
7327
7328 func (c *MylibraryBookshelvesGetCall) Header() http.Header {
7329 if c.header_ == nil {
7330 c.header_ = make(http.Header)
7331 }
7332 return c.header_
7333 }
7334
7335 func (c *MylibraryBookshelvesGetCall) doRequest(alt string) (*http.Response, error) {
7336 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7337 if c.ifNoneMatch_ != "" {
7338 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7339 }
7340 var body io.Reader = nil
7341 c.urlParams_.Set("alt", alt)
7342 c.urlParams_.Set("prettyPrint", "false")
7343 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/bookshelves/{shelf}")
7344 urls += "?" + c.urlParams_.Encode()
7345 req, err := http.NewRequest("GET", urls, body)
7346 if err != nil {
7347 return nil, err
7348 }
7349 req.Header = reqHeaders
7350 googleapi.Expand(req.URL, map[string]string{
7351 "shelf": c.shelf,
7352 })
7353 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7354 }
7355
7356
7357
7358
7359
7360
7361 func (c *MylibraryBookshelvesGetCall) Do(opts ...googleapi.CallOption) (*Bookshelf, error) {
7362 gensupport.SetOptions(c.urlParams_, opts...)
7363 res, err := c.doRequest("json")
7364 if res != nil && res.StatusCode == http.StatusNotModified {
7365 if res.Body != nil {
7366 res.Body.Close()
7367 }
7368 return nil, gensupport.WrapError(&googleapi.Error{
7369 Code: res.StatusCode,
7370 Header: res.Header,
7371 })
7372 }
7373 if err != nil {
7374 return nil, err
7375 }
7376 defer googleapi.CloseBody(res)
7377 if err := googleapi.CheckResponse(res); err != nil {
7378 return nil, gensupport.WrapError(err)
7379 }
7380 ret := &Bookshelf{
7381 ServerResponse: googleapi.ServerResponse{
7382 Header: res.Header,
7383 HTTPStatusCode: res.StatusCode,
7384 },
7385 }
7386 target := &ret
7387 if err := gensupport.DecodeResponse(target, res); err != nil {
7388 return nil, err
7389 }
7390 return ret, nil
7391 }
7392
7393 type MylibraryBookshelvesListCall struct {
7394 s *Service
7395 urlParams_ gensupport.URLParams
7396 ifNoneMatch_ string
7397 ctx_ context.Context
7398 header_ http.Header
7399 }
7400
7401
7402 func (r *MylibraryBookshelvesService) List() *MylibraryBookshelvesListCall {
7403 c := &MylibraryBookshelvesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7404 return c
7405 }
7406
7407
7408
7409 func (c *MylibraryBookshelvesListCall) Source(source string) *MylibraryBookshelvesListCall {
7410 c.urlParams_.Set("source", source)
7411 return c
7412 }
7413
7414
7415
7416
7417 func (c *MylibraryBookshelvesListCall) Fields(s ...googleapi.Field) *MylibraryBookshelvesListCall {
7418 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7419 return c
7420 }
7421
7422
7423
7424
7425 func (c *MylibraryBookshelvesListCall) IfNoneMatch(entityTag string) *MylibraryBookshelvesListCall {
7426 c.ifNoneMatch_ = entityTag
7427 return c
7428 }
7429
7430
7431 func (c *MylibraryBookshelvesListCall) Context(ctx context.Context) *MylibraryBookshelvesListCall {
7432 c.ctx_ = ctx
7433 return c
7434 }
7435
7436
7437
7438 func (c *MylibraryBookshelvesListCall) Header() http.Header {
7439 if c.header_ == nil {
7440 c.header_ = make(http.Header)
7441 }
7442 return c.header_
7443 }
7444
7445 func (c *MylibraryBookshelvesListCall) doRequest(alt string) (*http.Response, error) {
7446 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7447 if c.ifNoneMatch_ != "" {
7448 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7449 }
7450 var body io.Reader = nil
7451 c.urlParams_.Set("alt", alt)
7452 c.urlParams_.Set("prettyPrint", "false")
7453 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/bookshelves")
7454 urls += "?" + c.urlParams_.Encode()
7455 req, err := http.NewRequest("GET", urls, body)
7456 if err != nil {
7457 return nil, err
7458 }
7459 req.Header = reqHeaders
7460 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7461 }
7462
7463
7464
7465
7466
7467
7468 func (c *MylibraryBookshelvesListCall) Do(opts ...googleapi.CallOption) (*Bookshelves, error) {
7469 gensupport.SetOptions(c.urlParams_, opts...)
7470 res, err := c.doRequest("json")
7471 if res != nil && res.StatusCode == http.StatusNotModified {
7472 if res.Body != nil {
7473 res.Body.Close()
7474 }
7475 return nil, gensupport.WrapError(&googleapi.Error{
7476 Code: res.StatusCode,
7477 Header: res.Header,
7478 })
7479 }
7480 if err != nil {
7481 return nil, err
7482 }
7483 defer googleapi.CloseBody(res)
7484 if err := googleapi.CheckResponse(res); err != nil {
7485 return nil, gensupport.WrapError(err)
7486 }
7487 ret := &Bookshelves{
7488 ServerResponse: googleapi.ServerResponse{
7489 Header: res.Header,
7490 HTTPStatusCode: res.StatusCode,
7491 },
7492 }
7493 target := &ret
7494 if err := gensupport.DecodeResponse(target, res); err != nil {
7495 return nil, err
7496 }
7497 return ret, nil
7498 }
7499
7500 type MylibraryBookshelvesMoveVolumeCall struct {
7501 s *Service
7502 shelf string
7503 urlParams_ gensupport.URLParams
7504 ctx_ context.Context
7505 header_ http.Header
7506 }
7507
7508
7509
7510
7511
7512
7513
7514
7515 func (r *MylibraryBookshelvesService) MoveVolume(shelf string, volumeId string, volumePosition int64) *MylibraryBookshelvesMoveVolumeCall {
7516 c := &MylibraryBookshelvesMoveVolumeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7517 c.shelf = shelf
7518 c.urlParams_.Set("volumeId", volumeId)
7519 c.urlParams_.Set("volumePosition", fmt.Sprint(volumePosition))
7520 return c
7521 }
7522
7523
7524
7525 func (c *MylibraryBookshelvesMoveVolumeCall) Source(source string) *MylibraryBookshelvesMoveVolumeCall {
7526 c.urlParams_.Set("source", source)
7527 return c
7528 }
7529
7530
7531
7532
7533 func (c *MylibraryBookshelvesMoveVolumeCall) Fields(s ...googleapi.Field) *MylibraryBookshelvesMoveVolumeCall {
7534 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7535 return c
7536 }
7537
7538
7539 func (c *MylibraryBookshelvesMoveVolumeCall) Context(ctx context.Context) *MylibraryBookshelvesMoveVolumeCall {
7540 c.ctx_ = ctx
7541 return c
7542 }
7543
7544
7545
7546 func (c *MylibraryBookshelvesMoveVolumeCall) Header() http.Header {
7547 if c.header_ == nil {
7548 c.header_ = make(http.Header)
7549 }
7550 return c.header_
7551 }
7552
7553 func (c *MylibraryBookshelvesMoveVolumeCall) doRequest(alt string) (*http.Response, error) {
7554 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7555 var body io.Reader = nil
7556 c.urlParams_.Set("alt", alt)
7557 c.urlParams_.Set("prettyPrint", "false")
7558 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/bookshelves/{shelf}/moveVolume")
7559 urls += "?" + c.urlParams_.Encode()
7560 req, err := http.NewRequest("POST", urls, body)
7561 if err != nil {
7562 return nil, err
7563 }
7564 req.Header = reqHeaders
7565 googleapi.Expand(req.URL, map[string]string{
7566 "shelf": c.shelf,
7567 })
7568 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7569 }
7570
7571
7572
7573
7574
7575
7576 func (c *MylibraryBookshelvesMoveVolumeCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
7577 gensupport.SetOptions(c.urlParams_, opts...)
7578 res, err := c.doRequest("json")
7579 if res != nil && res.StatusCode == http.StatusNotModified {
7580 if res.Body != nil {
7581 res.Body.Close()
7582 }
7583 return nil, gensupport.WrapError(&googleapi.Error{
7584 Code: res.StatusCode,
7585 Header: res.Header,
7586 })
7587 }
7588 if err != nil {
7589 return nil, err
7590 }
7591 defer googleapi.CloseBody(res)
7592 if err := googleapi.CheckResponse(res); err != nil {
7593 return nil, gensupport.WrapError(err)
7594 }
7595 ret := &Empty{
7596 ServerResponse: googleapi.ServerResponse{
7597 Header: res.Header,
7598 HTTPStatusCode: res.StatusCode,
7599 },
7600 }
7601 target := &ret
7602 if err := gensupport.DecodeResponse(target, res); err != nil {
7603 return nil, err
7604 }
7605 return ret, nil
7606 }
7607
7608 type MylibraryBookshelvesRemoveVolumeCall struct {
7609 s *Service
7610 shelf string
7611 urlParams_ gensupport.URLParams
7612 ctx_ context.Context
7613 header_ http.Header
7614 }
7615
7616
7617
7618
7619
7620 func (r *MylibraryBookshelvesService) RemoveVolume(shelf string, volumeId string) *MylibraryBookshelvesRemoveVolumeCall {
7621 c := &MylibraryBookshelvesRemoveVolumeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7622 c.shelf = shelf
7623 c.urlParams_.Set("volumeId", volumeId)
7624 return c
7625 }
7626
7627
7628
7629
7630
7631
7632
7633
7634 func (c *MylibraryBookshelvesRemoveVolumeCall) Reason(reason string) *MylibraryBookshelvesRemoveVolumeCall {
7635 c.urlParams_.Set("reason", reason)
7636 return c
7637 }
7638
7639
7640
7641 func (c *MylibraryBookshelvesRemoveVolumeCall) Source(source string) *MylibraryBookshelvesRemoveVolumeCall {
7642 c.urlParams_.Set("source", source)
7643 return c
7644 }
7645
7646
7647
7648
7649 func (c *MylibraryBookshelvesRemoveVolumeCall) Fields(s ...googleapi.Field) *MylibraryBookshelvesRemoveVolumeCall {
7650 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7651 return c
7652 }
7653
7654
7655 func (c *MylibraryBookshelvesRemoveVolumeCall) Context(ctx context.Context) *MylibraryBookshelvesRemoveVolumeCall {
7656 c.ctx_ = ctx
7657 return c
7658 }
7659
7660
7661
7662 func (c *MylibraryBookshelvesRemoveVolumeCall) Header() http.Header {
7663 if c.header_ == nil {
7664 c.header_ = make(http.Header)
7665 }
7666 return c.header_
7667 }
7668
7669 func (c *MylibraryBookshelvesRemoveVolumeCall) doRequest(alt string) (*http.Response, error) {
7670 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7671 var body io.Reader = nil
7672 c.urlParams_.Set("alt", alt)
7673 c.urlParams_.Set("prettyPrint", "false")
7674 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/bookshelves/{shelf}/removeVolume")
7675 urls += "?" + c.urlParams_.Encode()
7676 req, err := http.NewRequest("POST", urls, body)
7677 if err != nil {
7678 return nil, err
7679 }
7680 req.Header = reqHeaders
7681 googleapi.Expand(req.URL, map[string]string{
7682 "shelf": c.shelf,
7683 })
7684 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7685 }
7686
7687
7688
7689
7690
7691
7692 func (c *MylibraryBookshelvesRemoveVolumeCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
7693 gensupport.SetOptions(c.urlParams_, opts...)
7694 res, err := c.doRequest("json")
7695 if res != nil && res.StatusCode == http.StatusNotModified {
7696 if res.Body != nil {
7697 res.Body.Close()
7698 }
7699 return nil, gensupport.WrapError(&googleapi.Error{
7700 Code: res.StatusCode,
7701 Header: res.Header,
7702 })
7703 }
7704 if err != nil {
7705 return nil, err
7706 }
7707 defer googleapi.CloseBody(res)
7708 if err := googleapi.CheckResponse(res); err != nil {
7709 return nil, gensupport.WrapError(err)
7710 }
7711 ret := &Empty{
7712 ServerResponse: googleapi.ServerResponse{
7713 Header: res.Header,
7714 HTTPStatusCode: res.StatusCode,
7715 },
7716 }
7717 target := &ret
7718 if err := gensupport.DecodeResponse(target, res); err != nil {
7719 return nil, err
7720 }
7721 return ret, nil
7722 }
7723
7724 type MylibraryBookshelvesVolumesListCall struct {
7725 s *Service
7726 shelf string
7727 urlParams_ gensupport.URLParams
7728 ifNoneMatch_ string
7729 ctx_ context.Context
7730 header_ http.Header
7731 }
7732
7733
7734
7735
7736 func (r *MylibraryBookshelvesVolumesService) List(shelf string) *MylibraryBookshelvesVolumesListCall {
7737 c := &MylibraryBookshelvesVolumesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7738 c.shelf = shelf
7739 return c
7740 }
7741
7742
7743
7744 func (c *MylibraryBookshelvesVolumesListCall) Country(country string) *MylibraryBookshelvesVolumesListCall {
7745 c.urlParams_.Set("country", country)
7746 return c
7747 }
7748
7749
7750
7751 func (c *MylibraryBookshelvesVolumesListCall) MaxResults(maxResults int64) *MylibraryBookshelvesVolumesListCall {
7752 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
7753 return c
7754 }
7755
7756
7757
7758
7759
7760
7761
7762
7763
7764 func (c *MylibraryBookshelvesVolumesListCall) Projection(projection string) *MylibraryBookshelvesVolumesListCall {
7765 c.urlParams_.Set("projection", projection)
7766 return c
7767 }
7768
7769
7770
7771 func (c *MylibraryBookshelvesVolumesListCall) Q(q string) *MylibraryBookshelvesVolumesListCall {
7772 c.urlParams_.Set("q", q)
7773 return c
7774 }
7775
7776
7777
7778 func (c *MylibraryBookshelvesVolumesListCall) ShowPreorders(showPreorders bool) *MylibraryBookshelvesVolumesListCall {
7779 c.urlParams_.Set("showPreorders", fmt.Sprint(showPreorders))
7780 return c
7781 }
7782
7783
7784
7785 func (c *MylibraryBookshelvesVolumesListCall) Source(source string) *MylibraryBookshelvesVolumesListCall {
7786 c.urlParams_.Set("source", source)
7787 return c
7788 }
7789
7790
7791
7792 func (c *MylibraryBookshelvesVolumesListCall) StartIndex(startIndex int64) *MylibraryBookshelvesVolumesListCall {
7793 c.urlParams_.Set("startIndex", fmt.Sprint(startIndex))
7794 return c
7795 }
7796
7797
7798
7799
7800 func (c *MylibraryBookshelvesVolumesListCall) Fields(s ...googleapi.Field) *MylibraryBookshelvesVolumesListCall {
7801 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7802 return c
7803 }
7804
7805
7806
7807
7808 func (c *MylibraryBookshelvesVolumesListCall) IfNoneMatch(entityTag string) *MylibraryBookshelvesVolumesListCall {
7809 c.ifNoneMatch_ = entityTag
7810 return c
7811 }
7812
7813
7814 func (c *MylibraryBookshelvesVolumesListCall) Context(ctx context.Context) *MylibraryBookshelvesVolumesListCall {
7815 c.ctx_ = ctx
7816 return c
7817 }
7818
7819
7820
7821 func (c *MylibraryBookshelvesVolumesListCall) Header() http.Header {
7822 if c.header_ == nil {
7823 c.header_ = make(http.Header)
7824 }
7825 return c.header_
7826 }
7827
7828 func (c *MylibraryBookshelvesVolumesListCall) doRequest(alt string) (*http.Response, error) {
7829 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7830 if c.ifNoneMatch_ != "" {
7831 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7832 }
7833 var body io.Reader = nil
7834 c.urlParams_.Set("alt", alt)
7835 c.urlParams_.Set("prettyPrint", "false")
7836 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/bookshelves/{shelf}/volumes")
7837 urls += "?" + c.urlParams_.Encode()
7838 req, err := http.NewRequest("GET", urls, body)
7839 if err != nil {
7840 return nil, err
7841 }
7842 req.Header = reqHeaders
7843 googleapi.Expand(req.URL, map[string]string{
7844 "shelf": c.shelf,
7845 })
7846 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7847 }
7848
7849
7850
7851
7852
7853
7854 func (c *MylibraryBookshelvesVolumesListCall) Do(opts ...googleapi.CallOption) (*Volumes, error) {
7855 gensupport.SetOptions(c.urlParams_, opts...)
7856 res, err := c.doRequest("json")
7857 if res != nil && res.StatusCode == http.StatusNotModified {
7858 if res.Body != nil {
7859 res.Body.Close()
7860 }
7861 return nil, gensupport.WrapError(&googleapi.Error{
7862 Code: res.StatusCode,
7863 Header: res.Header,
7864 })
7865 }
7866 if err != nil {
7867 return nil, err
7868 }
7869 defer googleapi.CloseBody(res)
7870 if err := googleapi.CheckResponse(res); err != nil {
7871 return nil, gensupport.WrapError(err)
7872 }
7873 ret := &Volumes{
7874 ServerResponse: googleapi.ServerResponse{
7875 Header: res.Header,
7876 HTTPStatusCode: res.StatusCode,
7877 },
7878 }
7879 target := &ret
7880 if err := gensupport.DecodeResponse(target, res); err != nil {
7881 return nil, err
7882 }
7883 return ret, nil
7884 }
7885
7886 type MylibraryReadingpositionsGetCall struct {
7887 s *Service
7888 volumeId string
7889 urlParams_ gensupport.URLParams
7890 ifNoneMatch_ string
7891 ctx_ context.Context
7892 header_ http.Header
7893 }
7894
7895
7896
7897
7898 func (r *MylibraryReadingpositionsService) Get(volumeId string) *MylibraryReadingpositionsGetCall {
7899 c := &MylibraryReadingpositionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7900 c.volumeId = volumeId
7901 return c
7902 }
7903
7904
7905
7906 func (c *MylibraryReadingpositionsGetCall) ContentVersion(contentVersion string) *MylibraryReadingpositionsGetCall {
7907 c.urlParams_.Set("contentVersion", contentVersion)
7908 return c
7909 }
7910
7911
7912
7913 func (c *MylibraryReadingpositionsGetCall) Source(source string) *MylibraryReadingpositionsGetCall {
7914 c.urlParams_.Set("source", source)
7915 return c
7916 }
7917
7918
7919
7920
7921 func (c *MylibraryReadingpositionsGetCall) Fields(s ...googleapi.Field) *MylibraryReadingpositionsGetCall {
7922 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7923 return c
7924 }
7925
7926
7927
7928
7929 func (c *MylibraryReadingpositionsGetCall) IfNoneMatch(entityTag string) *MylibraryReadingpositionsGetCall {
7930 c.ifNoneMatch_ = entityTag
7931 return c
7932 }
7933
7934
7935 func (c *MylibraryReadingpositionsGetCall) Context(ctx context.Context) *MylibraryReadingpositionsGetCall {
7936 c.ctx_ = ctx
7937 return c
7938 }
7939
7940
7941
7942 func (c *MylibraryReadingpositionsGetCall) Header() http.Header {
7943 if c.header_ == nil {
7944 c.header_ = make(http.Header)
7945 }
7946 return c.header_
7947 }
7948
7949 func (c *MylibraryReadingpositionsGetCall) doRequest(alt string) (*http.Response, error) {
7950 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7951 if c.ifNoneMatch_ != "" {
7952 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7953 }
7954 var body io.Reader = nil
7955 c.urlParams_.Set("alt", alt)
7956 c.urlParams_.Set("prettyPrint", "false")
7957 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/readingpositions/{volumeId}")
7958 urls += "?" + c.urlParams_.Encode()
7959 req, err := http.NewRequest("GET", urls, body)
7960 if err != nil {
7961 return nil, err
7962 }
7963 req.Header = reqHeaders
7964 googleapi.Expand(req.URL, map[string]string{
7965 "volumeId": c.volumeId,
7966 })
7967 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7968 }
7969
7970
7971
7972
7973
7974
7975
7976 func (c *MylibraryReadingpositionsGetCall) Do(opts ...googleapi.CallOption) (*ReadingPosition, error) {
7977 gensupport.SetOptions(c.urlParams_, opts...)
7978 res, err := c.doRequest("json")
7979 if res != nil && res.StatusCode == http.StatusNotModified {
7980 if res.Body != nil {
7981 res.Body.Close()
7982 }
7983 return nil, gensupport.WrapError(&googleapi.Error{
7984 Code: res.StatusCode,
7985 Header: res.Header,
7986 })
7987 }
7988 if err != nil {
7989 return nil, err
7990 }
7991 defer googleapi.CloseBody(res)
7992 if err := googleapi.CheckResponse(res); err != nil {
7993 return nil, gensupport.WrapError(err)
7994 }
7995 ret := &ReadingPosition{
7996 ServerResponse: googleapi.ServerResponse{
7997 Header: res.Header,
7998 HTTPStatusCode: res.StatusCode,
7999 },
8000 }
8001 target := &ret
8002 if err := gensupport.DecodeResponse(target, res); err != nil {
8003 return nil, err
8004 }
8005 return ret, nil
8006 }
8007
8008 type MylibraryReadingpositionsSetPositionCall struct {
8009 s *Service
8010 volumeId string
8011 urlParams_ gensupport.URLParams
8012 ctx_ context.Context
8013 header_ http.Header
8014 }
8015
8016
8017
8018
8019
8020
8021
8022 func (r *MylibraryReadingpositionsService) SetPosition(volumeId string, position string, timestamp string) *MylibraryReadingpositionsSetPositionCall {
8023 c := &MylibraryReadingpositionsSetPositionCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8024 c.volumeId = volumeId
8025 c.urlParams_.Set("position", position)
8026 c.urlParams_.Set("timestamp", timestamp)
8027 return c
8028 }
8029
8030
8031
8032
8033
8034
8035
8036
8037
8038
8039
8040
8041
8042 func (c *MylibraryReadingpositionsSetPositionCall) Action(action string) *MylibraryReadingpositionsSetPositionCall {
8043 c.urlParams_.Set("action", action)
8044 return c
8045 }
8046
8047
8048
8049 func (c *MylibraryReadingpositionsSetPositionCall) ContentVersion(contentVersion string) *MylibraryReadingpositionsSetPositionCall {
8050 c.urlParams_.Set("contentVersion", contentVersion)
8051 return c
8052 }
8053
8054
8055
8056 func (c *MylibraryReadingpositionsSetPositionCall) DeviceCookie(deviceCookie string) *MylibraryReadingpositionsSetPositionCall {
8057 c.urlParams_.Set("deviceCookie", deviceCookie)
8058 return c
8059 }
8060
8061
8062
8063 func (c *MylibraryReadingpositionsSetPositionCall) Source(source string) *MylibraryReadingpositionsSetPositionCall {
8064 c.urlParams_.Set("source", source)
8065 return c
8066 }
8067
8068
8069
8070
8071 func (c *MylibraryReadingpositionsSetPositionCall) Fields(s ...googleapi.Field) *MylibraryReadingpositionsSetPositionCall {
8072 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8073 return c
8074 }
8075
8076
8077 func (c *MylibraryReadingpositionsSetPositionCall) Context(ctx context.Context) *MylibraryReadingpositionsSetPositionCall {
8078 c.ctx_ = ctx
8079 return c
8080 }
8081
8082
8083
8084 func (c *MylibraryReadingpositionsSetPositionCall) Header() http.Header {
8085 if c.header_ == nil {
8086 c.header_ = make(http.Header)
8087 }
8088 return c.header_
8089 }
8090
8091 func (c *MylibraryReadingpositionsSetPositionCall) doRequest(alt string) (*http.Response, error) {
8092 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8093 var body io.Reader = nil
8094 c.urlParams_.Set("alt", alt)
8095 c.urlParams_.Set("prettyPrint", "false")
8096 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/mylibrary/readingpositions/{volumeId}/setPosition")
8097 urls += "?" + c.urlParams_.Encode()
8098 req, err := http.NewRequest("POST", urls, body)
8099 if err != nil {
8100 return nil, err
8101 }
8102 req.Header = reqHeaders
8103 googleapi.Expand(req.URL, map[string]string{
8104 "volumeId": c.volumeId,
8105 })
8106 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8107 }
8108
8109
8110
8111
8112
8113
8114 func (c *MylibraryReadingpositionsSetPositionCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
8115 gensupport.SetOptions(c.urlParams_, opts...)
8116 res, err := c.doRequest("json")
8117 if res != nil && res.StatusCode == http.StatusNotModified {
8118 if res.Body != nil {
8119 res.Body.Close()
8120 }
8121 return nil, gensupport.WrapError(&googleapi.Error{
8122 Code: res.StatusCode,
8123 Header: res.Header,
8124 })
8125 }
8126 if err != nil {
8127 return nil, err
8128 }
8129 defer googleapi.CloseBody(res)
8130 if err := googleapi.CheckResponse(res); err != nil {
8131 return nil, gensupport.WrapError(err)
8132 }
8133 ret := &Empty{
8134 ServerResponse: googleapi.ServerResponse{
8135 Header: res.Header,
8136 HTTPStatusCode: res.StatusCode,
8137 },
8138 }
8139 target := &ret
8140 if err := gensupport.DecodeResponse(target, res); err != nil {
8141 return nil, err
8142 }
8143 return ret, nil
8144 }
8145
8146 type NotificationGetCall struct {
8147 s *Service
8148 urlParams_ gensupport.URLParams
8149 ifNoneMatch_ string
8150 ctx_ context.Context
8151 header_ http.Header
8152 }
8153
8154
8155
8156
8157 func (r *NotificationService) Get(notificationId string) *NotificationGetCall {
8158 c := &NotificationGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8159 c.urlParams_.Set("notification_id", notificationId)
8160 return c
8161 }
8162
8163
8164
8165
8166 func (c *NotificationGetCall) Locale(locale string) *NotificationGetCall {
8167 c.urlParams_.Set("locale", locale)
8168 return c
8169 }
8170
8171
8172
8173 func (c *NotificationGetCall) Source(source string) *NotificationGetCall {
8174 c.urlParams_.Set("source", source)
8175 return c
8176 }
8177
8178
8179
8180
8181 func (c *NotificationGetCall) Fields(s ...googleapi.Field) *NotificationGetCall {
8182 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8183 return c
8184 }
8185
8186
8187
8188
8189 func (c *NotificationGetCall) IfNoneMatch(entityTag string) *NotificationGetCall {
8190 c.ifNoneMatch_ = entityTag
8191 return c
8192 }
8193
8194
8195 func (c *NotificationGetCall) Context(ctx context.Context) *NotificationGetCall {
8196 c.ctx_ = ctx
8197 return c
8198 }
8199
8200
8201
8202 func (c *NotificationGetCall) Header() http.Header {
8203 if c.header_ == nil {
8204 c.header_ = make(http.Header)
8205 }
8206 return c.header_
8207 }
8208
8209 func (c *NotificationGetCall) doRequest(alt string) (*http.Response, error) {
8210 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8211 if c.ifNoneMatch_ != "" {
8212 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8213 }
8214 var body io.Reader = nil
8215 c.urlParams_.Set("alt", alt)
8216 c.urlParams_.Set("prettyPrint", "false")
8217 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/notification/get")
8218 urls += "?" + c.urlParams_.Encode()
8219 req, err := http.NewRequest("GET", urls, body)
8220 if err != nil {
8221 return nil, err
8222 }
8223 req.Header = reqHeaders
8224 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8225 }
8226
8227
8228
8229
8230
8231
8232 func (c *NotificationGetCall) Do(opts ...googleapi.CallOption) (*Notification, error) {
8233 gensupport.SetOptions(c.urlParams_, opts...)
8234 res, err := c.doRequest("json")
8235 if res != nil && res.StatusCode == http.StatusNotModified {
8236 if res.Body != nil {
8237 res.Body.Close()
8238 }
8239 return nil, gensupport.WrapError(&googleapi.Error{
8240 Code: res.StatusCode,
8241 Header: res.Header,
8242 })
8243 }
8244 if err != nil {
8245 return nil, err
8246 }
8247 defer googleapi.CloseBody(res)
8248 if err := googleapi.CheckResponse(res); err != nil {
8249 return nil, gensupport.WrapError(err)
8250 }
8251 ret := &Notification{
8252 ServerResponse: googleapi.ServerResponse{
8253 Header: res.Header,
8254 HTTPStatusCode: res.StatusCode,
8255 },
8256 }
8257 target := &ret
8258 if err := gensupport.DecodeResponse(target, res); err != nil {
8259 return nil, err
8260 }
8261 return ret, nil
8262 }
8263
8264 type OnboardingListCategoriesCall struct {
8265 s *Service
8266 urlParams_ gensupport.URLParams
8267 ifNoneMatch_ string
8268 ctx_ context.Context
8269 header_ http.Header
8270 }
8271
8272
8273 func (r *OnboardingService) ListCategories() *OnboardingListCategoriesCall {
8274 c := &OnboardingListCategoriesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8275 return c
8276 }
8277
8278
8279
8280 func (c *OnboardingListCategoriesCall) Locale(locale string) *OnboardingListCategoriesCall {
8281 c.urlParams_.Set("locale", locale)
8282 return c
8283 }
8284
8285
8286
8287
8288 func (c *OnboardingListCategoriesCall) Fields(s ...googleapi.Field) *OnboardingListCategoriesCall {
8289 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8290 return c
8291 }
8292
8293
8294
8295
8296 func (c *OnboardingListCategoriesCall) IfNoneMatch(entityTag string) *OnboardingListCategoriesCall {
8297 c.ifNoneMatch_ = entityTag
8298 return c
8299 }
8300
8301
8302 func (c *OnboardingListCategoriesCall) Context(ctx context.Context) *OnboardingListCategoriesCall {
8303 c.ctx_ = ctx
8304 return c
8305 }
8306
8307
8308
8309 func (c *OnboardingListCategoriesCall) Header() http.Header {
8310 if c.header_ == nil {
8311 c.header_ = make(http.Header)
8312 }
8313 return c.header_
8314 }
8315
8316 func (c *OnboardingListCategoriesCall) doRequest(alt string) (*http.Response, error) {
8317 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8318 if c.ifNoneMatch_ != "" {
8319 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8320 }
8321 var body io.Reader = nil
8322 c.urlParams_.Set("alt", alt)
8323 c.urlParams_.Set("prettyPrint", "false")
8324 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/onboarding/listCategories")
8325 urls += "?" + c.urlParams_.Encode()
8326 req, err := http.NewRequest("GET", urls, body)
8327 if err != nil {
8328 return nil, err
8329 }
8330 req.Header = reqHeaders
8331 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8332 }
8333
8334
8335
8336
8337
8338
8339 func (c *OnboardingListCategoriesCall) Do(opts ...googleapi.CallOption) (*Category, error) {
8340 gensupport.SetOptions(c.urlParams_, opts...)
8341 res, err := c.doRequest("json")
8342 if res != nil && res.StatusCode == http.StatusNotModified {
8343 if res.Body != nil {
8344 res.Body.Close()
8345 }
8346 return nil, gensupport.WrapError(&googleapi.Error{
8347 Code: res.StatusCode,
8348 Header: res.Header,
8349 })
8350 }
8351 if err != nil {
8352 return nil, err
8353 }
8354 defer googleapi.CloseBody(res)
8355 if err := googleapi.CheckResponse(res); err != nil {
8356 return nil, gensupport.WrapError(err)
8357 }
8358 ret := &Category{
8359 ServerResponse: googleapi.ServerResponse{
8360 Header: res.Header,
8361 HTTPStatusCode: res.StatusCode,
8362 },
8363 }
8364 target := &ret
8365 if err := gensupport.DecodeResponse(target, res); err != nil {
8366 return nil, err
8367 }
8368 return ret, nil
8369 }
8370
8371 type OnboardingListCategoryVolumesCall struct {
8372 s *Service
8373 urlParams_ gensupport.URLParams
8374 ifNoneMatch_ string
8375 ctx_ context.Context
8376 header_ http.Header
8377 }
8378
8379
8380
8381 func (r *OnboardingService) ListCategoryVolumes() *OnboardingListCategoryVolumesCall {
8382 c := &OnboardingListCategoryVolumesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8383 return c
8384 }
8385
8386
8387
8388 func (c *OnboardingListCategoryVolumesCall) CategoryId(categoryId ...string) *OnboardingListCategoryVolumesCall {
8389 c.urlParams_.SetMulti("categoryId", append([]string{}, categoryId...))
8390 return c
8391 }
8392
8393
8394
8395 func (c *OnboardingListCategoryVolumesCall) Locale(locale string) *OnboardingListCategoryVolumesCall {
8396 c.urlParams_.Set("locale", locale)
8397 return c
8398 }
8399
8400
8401
8402
8403
8404
8405
8406
8407
8408
8409 func (c *OnboardingListCategoryVolumesCall) MaxAllowedMaturityRating(maxAllowedMaturityRating string) *OnboardingListCategoryVolumesCall {
8410 c.urlParams_.Set("maxAllowedMaturityRating", maxAllowedMaturityRating)
8411 return c
8412 }
8413
8414
8415
8416 func (c *OnboardingListCategoryVolumesCall) PageSize(pageSize int64) *OnboardingListCategoryVolumesCall {
8417 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
8418 return c
8419 }
8420
8421
8422
8423 func (c *OnboardingListCategoryVolumesCall) PageToken(pageToken string) *OnboardingListCategoryVolumesCall {
8424 c.urlParams_.Set("pageToken", pageToken)
8425 return c
8426 }
8427
8428
8429
8430
8431 func (c *OnboardingListCategoryVolumesCall) Fields(s ...googleapi.Field) *OnboardingListCategoryVolumesCall {
8432 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8433 return c
8434 }
8435
8436
8437
8438
8439 func (c *OnboardingListCategoryVolumesCall) IfNoneMatch(entityTag string) *OnboardingListCategoryVolumesCall {
8440 c.ifNoneMatch_ = entityTag
8441 return c
8442 }
8443
8444
8445 func (c *OnboardingListCategoryVolumesCall) Context(ctx context.Context) *OnboardingListCategoryVolumesCall {
8446 c.ctx_ = ctx
8447 return c
8448 }
8449
8450
8451
8452 func (c *OnboardingListCategoryVolumesCall) Header() http.Header {
8453 if c.header_ == nil {
8454 c.header_ = make(http.Header)
8455 }
8456 return c.header_
8457 }
8458
8459 func (c *OnboardingListCategoryVolumesCall) doRequest(alt string) (*http.Response, error) {
8460 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8461 if c.ifNoneMatch_ != "" {
8462 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8463 }
8464 var body io.Reader = nil
8465 c.urlParams_.Set("alt", alt)
8466 c.urlParams_.Set("prettyPrint", "false")
8467 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/onboarding/listCategoryVolumes")
8468 urls += "?" + c.urlParams_.Encode()
8469 req, err := http.NewRequest("GET", urls, body)
8470 if err != nil {
8471 return nil, err
8472 }
8473 req.Header = reqHeaders
8474 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8475 }
8476
8477
8478
8479
8480
8481
8482 func (c *OnboardingListCategoryVolumesCall) Do(opts ...googleapi.CallOption) (*Volume2, error) {
8483 gensupport.SetOptions(c.urlParams_, opts...)
8484 res, err := c.doRequest("json")
8485 if res != nil && res.StatusCode == http.StatusNotModified {
8486 if res.Body != nil {
8487 res.Body.Close()
8488 }
8489 return nil, gensupport.WrapError(&googleapi.Error{
8490 Code: res.StatusCode,
8491 Header: res.Header,
8492 })
8493 }
8494 if err != nil {
8495 return nil, err
8496 }
8497 defer googleapi.CloseBody(res)
8498 if err := googleapi.CheckResponse(res); err != nil {
8499 return nil, gensupport.WrapError(err)
8500 }
8501 ret := &Volume2{
8502 ServerResponse: googleapi.ServerResponse{
8503 Header: res.Header,
8504 HTTPStatusCode: res.StatusCode,
8505 },
8506 }
8507 target := &ret
8508 if err := gensupport.DecodeResponse(target, res); err != nil {
8509 return nil, err
8510 }
8511 return ret, nil
8512 }
8513
8514
8515
8516
8517 func (c *OnboardingListCategoryVolumesCall) Pages(ctx context.Context, f func(*Volume2) error) error {
8518 c.ctx_ = ctx
8519 defer c.PageToken(c.urlParams_.Get("pageToken"))
8520 for {
8521 x, err := c.Do()
8522 if err != nil {
8523 return err
8524 }
8525 if err := f(x); err != nil {
8526 return err
8527 }
8528 if x.NextPageToken == "" {
8529 return nil
8530 }
8531 c.PageToken(x.NextPageToken)
8532 }
8533 }
8534
8535 type PersonalizedstreamGetCall struct {
8536 s *Service
8537 urlParams_ gensupport.URLParams
8538 ifNoneMatch_ string
8539 ctx_ context.Context
8540 header_ http.Header
8541 }
8542
8543
8544 func (r *PersonalizedstreamService) Get() *PersonalizedstreamGetCall {
8545 c := &PersonalizedstreamGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8546 return c
8547 }
8548
8549
8550
8551 func (c *PersonalizedstreamGetCall) Locale(locale string) *PersonalizedstreamGetCall {
8552 c.urlParams_.Set("locale", locale)
8553 return c
8554 }
8555
8556
8557
8558
8559
8560
8561
8562
8563
8564
8565 func (c *PersonalizedstreamGetCall) MaxAllowedMaturityRating(maxAllowedMaturityRating string) *PersonalizedstreamGetCall {
8566 c.urlParams_.Set("maxAllowedMaturityRating", maxAllowedMaturityRating)
8567 return c
8568 }
8569
8570
8571
8572 func (c *PersonalizedstreamGetCall) Source(source string) *PersonalizedstreamGetCall {
8573 c.urlParams_.Set("source", source)
8574 return c
8575 }
8576
8577
8578
8579
8580 func (c *PersonalizedstreamGetCall) Fields(s ...googleapi.Field) *PersonalizedstreamGetCall {
8581 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8582 return c
8583 }
8584
8585
8586
8587
8588 func (c *PersonalizedstreamGetCall) IfNoneMatch(entityTag string) *PersonalizedstreamGetCall {
8589 c.ifNoneMatch_ = entityTag
8590 return c
8591 }
8592
8593
8594 func (c *PersonalizedstreamGetCall) Context(ctx context.Context) *PersonalizedstreamGetCall {
8595 c.ctx_ = ctx
8596 return c
8597 }
8598
8599
8600
8601 func (c *PersonalizedstreamGetCall) Header() http.Header {
8602 if c.header_ == nil {
8603 c.header_ = make(http.Header)
8604 }
8605 return c.header_
8606 }
8607
8608 func (c *PersonalizedstreamGetCall) doRequest(alt string) (*http.Response, error) {
8609 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8610 if c.ifNoneMatch_ != "" {
8611 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8612 }
8613 var body io.Reader = nil
8614 c.urlParams_.Set("alt", alt)
8615 c.urlParams_.Set("prettyPrint", "false")
8616 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/personalizedstream/get")
8617 urls += "?" + c.urlParams_.Encode()
8618 req, err := http.NewRequest("GET", urls, body)
8619 if err != nil {
8620 return nil, err
8621 }
8622 req.Header = reqHeaders
8623 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8624 }
8625
8626
8627
8628
8629
8630
8631
8632 func (c *PersonalizedstreamGetCall) Do(opts ...googleapi.CallOption) (*Discoveryclusters, error) {
8633 gensupport.SetOptions(c.urlParams_, opts...)
8634 res, err := c.doRequest("json")
8635 if res != nil && res.StatusCode == http.StatusNotModified {
8636 if res.Body != nil {
8637 res.Body.Close()
8638 }
8639 return nil, gensupport.WrapError(&googleapi.Error{
8640 Code: res.StatusCode,
8641 Header: res.Header,
8642 })
8643 }
8644 if err != nil {
8645 return nil, err
8646 }
8647 defer googleapi.CloseBody(res)
8648 if err := googleapi.CheckResponse(res); err != nil {
8649 return nil, gensupport.WrapError(err)
8650 }
8651 ret := &Discoveryclusters{
8652 ServerResponse: googleapi.ServerResponse{
8653 Header: res.Header,
8654 HTTPStatusCode: res.StatusCode,
8655 },
8656 }
8657 target := &ret
8658 if err := gensupport.DecodeResponse(target, res); err != nil {
8659 return nil, err
8660 }
8661 return ret, nil
8662 }
8663
8664 type PromoofferAcceptCall struct {
8665 s *Service
8666 urlParams_ gensupport.URLParams
8667 ctx_ context.Context
8668 header_ http.Header
8669 }
8670
8671
8672 func (r *PromoofferService) Accept() *PromoofferAcceptCall {
8673 c := &PromoofferAcceptCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8674 return c
8675 }
8676
8677
8678 func (c *PromoofferAcceptCall) AndroidId(androidId string) *PromoofferAcceptCall {
8679 c.urlParams_.Set("androidId", androidId)
8680 return c
8681 }
8682
8683
8684 func (c *PromoofferAcceptCall) Device(device string) *PromoofferAcceptCall {
8685 c.urlParams_.Set("device", device)
8686 return c
8687 }
8688
8689
8690 func (c *PromoofferAcceptCall) Manufacturer(manufacturer string) *PromoofferAcceptCall {
8691 c.urlParams_.Set("manufacturer", manufacturer)
8692 return c
8693 }
8694
8695
8696 func (c *PromoofferAcceptCall) Model(model string) *PromoofferAcceptCall {
8697 c.urlParams_.Set("model", model)
8698 return c
8699 }
8700
8701
8702 func (c *PromoofferAcceptCall) OfferId(offerId string) *PromoofferAcceptCall {
8703 c.urlParams_.Set("offerId", offerId)
8704 return c
8705 }
8706
8707
8708 func (c *PromoofferAcceptCall) Product(product string) *PromoofferAcceptCall {
8709 c.urlParams_.Set("product", product)
8710 return c
8711 }
8712
8713
8714 func (c *PromoofferAcceptCall) Serial(serial string) *PromoofferAcceptCall {
8715 c.urlParams_.Set("serial", serial)
8716 return c
8717 }
8718
8719
8720
8721 func (c *PromoofferAcceptCall) VolumeId(volumeId string) *PromoofferAcceptCall {
8722 c.urlParams_.Set("volumeId", volumeId)
8723 return c
8724 }
8725
8726
8727
8728
8729 func (c *PromoofferAcceptCall) Fields(s ...googleapi.Field) *PromoofferAcceptCall {
8730 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8731 return c
8732 }
8733
8734
8735 func (c *PromoofferAcceptCall) Context(ctx context.Context) *PromoofferAcceptCall {
8736 c.ctx_ = ctx
8737 return c
8738 }
8739
8740
8741
8742 func (c *PromoofferAcceptCall) Header() http.Header {
8743 if c.header_ == nil {
8744 c.header_ = make(http.Header)
8745 }
8746 return c.header_
8747 }
8748
8749 func (c *PromoofferAcceptCall) doRequest(alt string) (*http.Response, error) {
8750 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
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, "books/v1/promooffer/accept")
8755 urls += "?" + c.urlParams_.Encode()
8756 req, err := http.NewRequest("POST", urls, body)
8757 if err != nil {
8758 return nil, err
8759 }
8760 req.Header = reqHeaders
8761 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8762 }
8763
8764
8765
8766
8767
8768
8769 func (c *PromoofferAcceptCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
8770 gensupport.SetOptions(c.urlParams_, opts...)
8771 res, err := c.doRequest("json")
8772 if res != nil && res.StatusCode == http.StatusNotModified {
8773 if res.Body != nil {
8774 res.Body.Close()
8775 }
8776 return nil, gensupport.WrapError(&googleapi.Error{
8777 Code: res.StatusCode,
8778 Header: res.Header,
8779 })
8780 }
8781 if err != nil {
8782 return nil, err
8783 }
8784 defer googleapi.CloseBody(res)
8785 if err := googleapi.CheckResponse(res); err != nil {
8786 return nil, gensupport.WrapError(err)
8787 }
8788 ret := &Empty{
8789 ServerResponse: googleapi.ServerResponse{
8790 Header: res.Header,
8791 HTTPStatusCode: res.StatusCode,
8792 },
8793 }
8794 target := &ret
8795 if err := gensupport.DecodeResponse(target, res); err != nil {
8796 return nil, err
8797 }
8798 return ret, nil
8799 }
8800
8801 type PromoofferDismissCall struct {
8802 s *Service
8803 urlParams_ gensupport.URLParams
8804 ctx_ context.Context
8805 header_ http.Header
8806 }
8807
8808
8809 func (r *PromoofferService) Dismiss() *PromoofferDismissCall {
8810 c := &PromoofferDismissCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8811 return c
8812 }
8813
8814
8815 func (c *PromoofferDismissCall) AndroidId(androidId string) *PromoofferDismissCall {
8816 c.urlParams_.Set("androidId", androidId)
8817 return c
8818 }
8819
8820
8821 func (c *PromoofferDismissCall) Device(device string) *PromoofferDismissCall {
8822 c.urlParams_.Set("device", device)
8823 return c
8824 }
8825
8826
8827 func (c *PromoofferDismissCall) Manufacturer(manufacturer string) *PromoofferDismissCall {
8828 c.urlParams_.Set("manufacturer", manufacturer)
8829 return c
8830 }
8831
8832
8833 func (c *PromoofferDismissCall) Model(model string) *PromoofferDismissCall {
8834 c.urlParams_.Set("model", model)
8835 return c
8836 }
8837
8838
8839 func (c *PromoofferDismissCall) OfferId(offerId string) *PromoofferDismissCall {
8840 c.urlParams_.Set("offerId", offerId)
8841 return c
8842 }
8843
8844
8845 func (c *PromoofferDismissCall) Product(product string) *PromoofferDismissCall {
8846 c.urlParams_.Set("product", product)
8847 return c
8848 }
8849
8850
8851 func (c *PromoofferDismissCall) Serial(serial string) *PromoofferDismissCall {
8852 c.urlParams_.Set("serial", serial)
8853 return c
8854 }
8855
8856
8857
8858
8859 func (c *PromoofferDismissCall) Fields(s ...googleapi.Field) *PromoofferDismissCall {
8860 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8861 return c
8862 }
8863
8864
8865 func (c *PromoofferDismissCall) Context(ctx context.Context) *PromoofferDismissCall {
8866 c.ctx_ = ctx
8867 return c
8868 }
8869
8870
8871
8872 func (c *PromoofferDismissCall) Header() http.Header {
8873 if c.header_ == nil {
8874 c.header_ = make(http.Header)
8875 }
8876 return c.header_
8877 }
8878
8879 func (c *PromoofferDismissCall) doRequest(alt string) (*http.Response, error) {
8880 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8881 var body io.Reader = nil
8882 c.urlParams_.Set("alt", alt)
8883 c.urlParams_.Set("prettyPrint", "false")
8884 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/promooffer/dismiss")
8885 urls += "?" + c.urlParams_.Encode()
8886 req, err := http.NewRequest("POST", urls, body)
8887 if err != nil {
8888 return nil, err
8889 }
8890 req.Header = reqHeaders
8891 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8892 }
8893
8894
8895
8896
8897
8898
8899 func (c *PromoofferDismissCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
8900 gensupport.SetOptions(c.urlParams_, opts...)
8901 res, err := c.doRequest("json")
8902 if res != nil && res.StatusCode == http.StatusNotModified {
8903 if res.Body != nil {
8904 res.Body.Close()
8905 }
8906 return nil, gensupport.WrapError(&googleapi.Error{
8907 Code: res.StatusCode,
8908 Header: res.Header,
8909 })
8910 }
8911 if err != nil {
8912 return nil, err
8913 }
8914 defer googleapi.CloseBody(res)
8915 if err := googleapi.CheckResponse(res); err != nil {
8916 return nil, gensupport.WrapError(err)
8917 }
8918 ret := &Empty{
8919 ServerResponse: googleapi.ServerResponse{
8920 Header: res.Header,
8921 HTTPStatusCode: res.StatusCode,
8922 },
8923 }
8924 target := &ret
8925 if err := gensupport.DecodeResponse(target, res); err != nil {
8926 return nil, err
8927 }
8928 return ret, nil
8929 }
8930
8931 type PromoofferGetCall struct {
8932 s *Service
8933 urlParams_ gensupport.URLParams
8934 ifNoneMatch_ string
8935 ctx_ context.Context
8936 header_ http.Header
8937 }
8938
8939
8940 func (r *PromoofferService) Get() *PromoofferGetCall {
8941 c := &PromoofferGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8942 return c
8943 }
8944
8945
8946 func (c *PromoofferGetCall) AndroidId(androidId string) *PromoofferGetCall {
8947 c.urlParams_.Set("androidId", androidId)
8948 return c
8949 }
8950
8951
8952 func (c *PromoofferGetCall) Device(device string) *PromoofferGetCall {
8953 c.urlParams_.Set("device", device)
8954 return c
8955 }
8956
8957
8958 func (c *PromoofferGetCall) Manufacturer(manufacturer string) *PromoofferGetCall {
8959 c.urlParams_.Set("manufacturer", manufacturer)
8960 return c
8961 }
8962
8963
8964 func (c *PromoofferGetCall) Model(model string) *PromoofferGetCall {
8965 c.urlParams_.Set("model", model)
8966 return c
8967 }
8968
8969
8970 func (c *PromoofferGetCall) Product(product string) *PromoofferGetCall {
8971 c.urlParams_.Set("product", product)
8972 return c
8973 }
8974
8975
8976 func (c *PromoofferGetCall) Serial(serial string) *PromoofferGetCall {
8977 c.urlParams_.Set("serial", serial)
8978 return c
8979 }
8980
8981
8982
8983
8984 func (c *PromoofferGetCall) Fields(s ...googleapi.Field) *PromoofferGetCall {
8985 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8986 return c
8987 }
8988
8989
8990
8991
8992 func (c *PromoofferGetCall) IfNoneMatch(entityTag string) *PromoofferGetCall {
8993 c.ifNoneMatch_ = entityTag
8994 return c
8995 }
8996
8997
8998 func (c *PromoofferGetCall) Context(ctx context.Context) *PromoofferGetCall {
8999 c.ctx_ = ctx
9000 return c
9001 }
9002
9003
9004
9005 func (c *PromoofferGetCall) Header() http.Header {
9006 if c.header_ == nil {
9007 c.header_ = make(http.Header)
9008 }
9009 return c.header_
9010 }
9011
9012 func (c *PromoofferGetCall) doRequest(alt string) (*http.Response, error) {
9013 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9014 if c.ifNoneMatch_ != "" {
9015 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9016 }
9017 var body io.Reader = nil
9018 c.urlParams_.Set("alt", alt)
9019 c.urlParams_.Set("prettyPrint", "false")
9020 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/promooffer/get")
9021 urls += "?" + c.urlParams_.Encode()
9022 req, err := http.NewRequest("GET", urls, body)
9023 if err != nil {
9024 return nil, err
9025 }
9026 req.Header = reqHeaders
9027 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9028 }
9029
9030
9031
9032
9033
9034
9035 func (c *PromoofferGetCall) Do(opts ...googleapi.CallOption) (*Offers, error) {
9036 gensupport.SetOptions(c.urlParams_, opts...)
9037 res, err := c.doRequest("json")
9038 if res != nil && res.StatusCode == http.StatusNotModified {
9039 if res.Body != nil {
9040 res.Body.Close()
9041 }
9042 return nil, gensupport.WrapError(&googleapi.Error{
9043 Code: res.StatusCode,
9044 Header: res.Header,
9045 })
9046 }
9047 if err != nil {
9048 return nil, err
9049 }
9050 defer googleapi.CloseBody(res)
9051 if err := googleapi.CheckResponse(res); err != nil {
9052 return nil, gensupport.WrapError(err)
9053 }
9054 ret := &Offers{
9055 ServerResponse: googleapi.ServerResponse{
9056 Header: res.Header,
9057 HTTPStatusCode: res.StatusCode,
9058 },
9059 }
9060 target := &ret
9061 if err := gensupport.DecodeResponse(target, res); err != nil {
9062 return nil, err
9063 }
9064 return ret, nil
9065 }
9066
9067 type SeriesGetCall struct {
9068 s *Service
9069 urlParams_ gensupport.URLParams
9070 ifNoneMatch_ string
9071 ctx_ context.Context
9072 header_ http.Header
9073 }
9074
9075
9076
9077
9078 func (r *SeriesService) Get(seriesId []string) *SeriesGetCall {
9079 c := &SeriesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9080 c.urlParams_.SetMulti("series_id", append([]string{}, seriesId...))
9081 return c
9082 }
9083
9084
9085
9086
9087 func (c *SeriesGetCall) Fields(s ...googleapi.Field) *SeriesGetCall {
9088 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9089 return c
9090 }
9091
9092
9093
9094
9095 func (c *SeriesGetCall) IfNoneMatch(entityTag string) *SeriesGetCall {
9096 c.ifNoneMatch_ = entityTag
9097 return c
9098 }
9099
9100
9101 func (c *SeriesGetCall) Context(ctx context.Context) *SeriesGetCall {
9102 c.ctx_ = ctx
9103 return c
9104 }
9105
9106
9107
9108 func (c *SeriesGetCall) Header() http.Header {
9109 if c.header_ == nil {
9110 c.header_ = make(http.Header)
9111 }
9112 return c.header_
9113 }
9114
9115 func (c *SeriesGetCall) doRequest(alt string) (*http.Response, error) {
9116 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9117 if c.ifNoneMatch_ != "" {
9118 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9119 }
9120 var body io.Reader = nil
9121 c.urlParams_.Set("alt", alt)
9122 c.urlParams_.Set("prettyPrint", "false")
9123 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/series/get")
9124 urls += "?" + c.urlParams_.Encode()
9125 req, err := http.NewRequest("GET", urls, body)
9126 if err != nil {
9127 return nil, err
9128 }
9129 req.Header = reqHeaders
9130 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9131 }
9132
9133
9134
9135
9136
9137
9138 func (c *SeriesGetCall) Do(opts ...googleapi.CallOption) (*Series, error) {
9139 gensupport.SetOptions(c.urlParams_, opts...)
9140 res, err := c.doRequest("json")
9141 if res != nil && res.StatusCode == http.StatusNotModified {
9142 if res.Body != nil {
9143 res.Body.Close()
9144 }
9145 return nil, gensupport.WrapError(&googleapi.Error{
9146 Code: res.StatusCode,
9147 Header: res.Header,
9148 })
9149 }
9150 if err != nil {
9151 return nil, err
9152 }
9153 defer googleapi.CloseBody(res)
9154 if err := googleapi.CheckResponse(res); err != nil {
9155 return nil, gensupport.WrapError(err)
9156 }
9157 ret := &Series{
9158 ServerResponse: googleapi.ServerResponse{
9159 Header: res.Header,
9160 HTTPStatusCode: res.StatusCode,
9161 },
9162 }
9163 target := &ret
9164 if err := gensupport.DecodeResponse(target, res); err != nil {
9165 return nil, err
9166 }
9167 return ret, nil
9168 }
9169
9170 type SeriesMembershipGetCall struct {
9171 s *Service
9172 urlParams_ gensupport.URLParams
9173 ifNoneMatch_ string
9174 ctx_ context.Context
9175 header_ http.Header
9176 }
9177
9178
9179
9180
9181 func (r *SeriesMembershipService) Get(seriesId string) *SeriesMembershipGetCall {
9182 c := &SeriesMembershipGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9183 c.urlParams_.Set("series_id", seriesId)
9184 return c
9185 }
9186
9187
9188
9189 func (c *SeriesMembershipGetCall) PageSize(pageSize int64) *SeriesMembershipGetCall {
9190 c.urlParams_.Set("page_size", fmt.Sprint(pageSize))
9191 return c
9192 }
9193
9194
9195
9196 func (c *SeriesMembershipGetCall) PageToken(pageToken string) *SeriesMembershipGetCall {
9197 c.urlParams_.Set("page_token", pageToken)
9198 return c
9199 }
9200
9201
9202
9203
9204 func (c *SeriesMembershipGetCall) Fields(s ...googleapi.Field) *SeriesMembershipGetCall {
9205 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9206 return c
9207 }
9208
9209
9210
9211
9212 func (c *SeriesMembershipGetCall) IfNoneMatch(entityTag string) *SeriesMembershipGetCall {
9213 c.ifNoneMatch_ = entityTag
9214 return c
9215 }
9216
9217
9218 func (c *SeriesMembershipGetCall) Context(ctx context.Context) *SeriesMembershipGetCall {
9219 c.ctx_ = ctx
9220 return c
9221 }
9222
9223
9224
9225 func (c *SeriesMembershipGetCall) Header() http.Header {
9226 if c.header_ == nil {
9227 c.header_ = make(http.Header)
9228 }
9229 return c.header_
9230 }
9231
9232 func (c *SeriesMembershipGetCall) doRequest(alt string) (*http.Response, error) {
9233 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9234 if c.ifNoneMatch_ != "" {
9235 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9236 }
9237 var body io.Reader = nil
9238 c.urlParams_.Set("alt", alt)
9239 c.urlParams_.Set("prettyPrint", "false")
9240 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/series/membership/get")
9241 urls += "?" + c.urlParams_.Encode()
9242 req, err := http.NewRequest("GET", urls, body)
9243 if err != nil {
9244 return nil, err
9245 }
9246 req.Header = reqHeaders
9247 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9248 }
9249
9250
9251
9252
9253
9254
9255
9256 func (c *SeriesMembershipGetCall) Do(opts ...googleapi.CallOption) (*Seriesmembership, error) {
9257 gensupport.SetOptions(c.urlParams_, opts...)
9258 res, err := c.doRequest("json")
9259 if res != nil && res.StatusCode == http.StatusNotModified {
9260 if res.Body != nil {
9261 res.Body.Close()
9262 }
9263 return nil, gensupport.WrapError(&googleapi.Error{
9264 Code: res.StatusCode,
9265 Header: res.Header,
9266 })
9267 }
9268 if err != nil {
9269 return nil, err
9270 }
9271 defer googleapi.CloseBody(res)
9272 if err := googleapi.CheckResponse(res); err != nil {
9273 return nil, gensupport.WrapError(err)
9274 }
9275 ret := &Seriesmembership{
9276 ServerResponse: googleapi.ServerResponse{
9277 Header: res.Header,
9278 HTTPStatusCode: res.StatusCode,
9279 },
9280 }
9281 target := &ret
9282 if err := gensupport.DecodeResponse(target, res); err != nil {
9283 return nil, err
9284 }
9285 return ret, nil
9286 }
9287
9288 type VolumesGetCall struct {
9289 s *Service
9290 volumeId string
9291 urlParams_ gensupport.URLParams
9292 ifNoneMatch_ string
9293 ctx_ context.Context
9294 header_ http.Header
9295 }
9296
9297
9298
9299
9300 func (r *VolumesService) Get(volumeId string) *VolumesGetCall {
9301 c := &VolumesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9302 c.volumeId = volumeId
9303 return c
9304 }
9305
9306
9307
9308 func (c *VolumesGetCall) Country(country string) *VolumesGetCall {
9309 c.urlParams_.Set("country", country)
9310 return c
9311 }
9312
9313
9314
9315 func (c *VolumesGetCall) IncludeNonComicsSeries(includeNonComicsSeries bool) *VolumesGetCall {
9316 c.urlParams_.Set("includeNonComicsSeries", fmt.Sprint(includeNonComicsSeries))
9317 return c
9318 }
9319
9320
9321 func (c *VolumesGetCall) Partner(partner string) *VolumesGetCall {
9322 c.urlParams_.Set("partner", partner)
9323 return c
9324 }
9325
9326
9327
9328
9329
9330
9331
9332
9333
9334 func (c *VolumesGetCall) Projection(projection string) *VolumesGetCall {
9335 c.urlParams_.Set("projection", projection)
9336 return c
9337 }
9338
9339
9340
9341 func (c *VolumesGetCall) Source(source string) *VolumesGetCall {
9342 c.urlParams_.Set("source", source)
9343 return c
9344 }
9345
9346
9347
9348 func (c *VolumesGetCall) UserLibraryConsistentRead(userLibraryConsistentRead bool) *VolumesGetCall {
9349 c.urlParams_.Set("user_library_consistent_read", fmt.Sprint(userLibraryConsistentRead))
9350 return c
9351 }
9352
9353
9354
9355
9356 func (c *VolumesGetCall) Fields(s ...googleapi.Field) *VolumesGetCall {
9357 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9358 return c
9359 }
9360
9361
9362
9363
9364 func (c *VolumesGetCall) IfNoneMatch(entityTag string) *VolumesGetCall {
9365 c.ifNoneMatch_ = entityTag
9366 return c
9367 }
9368
9369
9370 func (c *VolumesGetCall) Context(ctx context.Context) *VolumesGetCall {
9371 c.ctx_ = ctx
9372 return c
9373 }
9374
9375
9376
9377 func (c *VolumesGetCall) Header() http.Header {
9378 if c.header_ == nil {
9379 c.header_ = make(http.Header)
9380 }
9381 return c.header_
9382 }
9383
9384 func (c *VolumesGetCall) doRequest(alt string) (*http.Response, error) {
9385 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9386 if c.ifNoneMatch_ != "" {
9387 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9388 }
9389 var body io.Reader = nil
9390 c.urlParams_.Set("alt", alt)
9391 c.urlParams_.Set("prettyPrint", "false")
9392 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/{volumeId}")
9393 urls += "?" + c.urlParams_.Encode()
9394 req, err := http.NewRequest("GET", urls, body)
9395 if err != nil {
9396 return nil, err
9397 }
9398 req.Header = reqHeaders
9399 googleapi.Expand(req.URL, map[string]string{
9400 "volumeId": c.volumeId,
9401 })
9402 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9403 }
9404
9405
9406
9407
9408
9409
9410 func (c *VolumesGetCall) Do(opts ...googleapi.CallOption) (*Volume, error) {
9411 gensupport.SetOptions(c.urlParams_, opts...)
9412 res, err := c.doRequest("json")
9413 if res != nil && res.StatusCode == http.StatusNotModified {
9414 if res.Body != nil {
9415 res.Body.Close()
9416 }
9417 return nil, gensupport.WrapError(&googleapi.Error{
9418 Code: res.StatusCode,
9419 Header: res.Header,
9420 })
9421 }
9422 if err != nil {
9423 return nil, err
9424 }
9425 defer googleapi.CloseBody(res)
9426 if err := googleapi.CheckResponse(res); err != nil {
9427 return nil, gensupport.WrapError(err)
9428 }
9429 ret := &Volume{
9430 ServerResponse: googleapi.ServerResponse{
9431 Header: res.Header,
9432 HTTPStatusCode: res.StatusCode,
9433 },
9434 }
9435 target := &ret
9436 if err := gensupport.DecodeResponse(target, res); err != nil {
9437 return nil, err
9438 }
9439 return ret, nil
9440 }
9441
9442 type VolumesListCall struct {
9443 s *Service
9444 urlParams_ gensupport.URLParams
9445 ifNoneMatch_ string
9446 ctx_ context.Context
9447 header_ http.Header
9448 }
9449
9450
9451
9452
9453 func (r *VolumesService) List(q string) *VolumesListCall {
9454 c := &VolumesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9455 c.urlParams_.Set("q", q)
9456 return c
9457 }
9458
9459
9460
9461
9462
9463
9464
9465
9466 func (c *VolumesListCall) Download(download string) *VolumesListCall {
9467 c.urlParams_.Set("download", download)
9468 return c
9469 }
9470
9471
9472
9473
9474
9475
9476
9477
9478
9479
9480
9481 func (c *VolumesListCall) Filter(filter string) *VolumesListCall {
9482 c.urlParams_.Set("filter", filter)
9483 return c
9484 }
9485
9486
9487
9488 func (c *VolumesListCall) LangRestrict(langRestrict string) *VolumesListCall {
9489 c.urlParams_.Set("langRestrict", langRestrict)
9490 return c
9491 }
9492
9493
9494
9495
9496
9497
9498
9499
9500
9501 func (c *VolumesListCall) LibraryRestrict(libraryRestrict string) *VolumesListCall {
9502 c.urlParams_.Set("libraryRestrict", libraryRestrict)
9503 return c
9504 }
9505
9506
9507
9508
9509
9510
9511
9512
9513
9514
9515 func (c *VolumesListCall) MaxAllowedMaturityRating(maxAllowedMaturityRating string) *VolumesListCall {
9516 c.urlParams_.Set("maxAllowedMaturityRating", maxAllowedMaturityRating)
9517 return c
9518 }
9519
9520
9521
9522 func (c *VolumesListCall) MaxResults(maxResults int64) *VolumesListCall {
9523 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
9524 return c
9525 }
9526
9527
9528
9529
9530
9531
9532
9533
9534 func (c *VolumesListCall) OrderBy(orderBy string) *VolumesListCall {
9535 c.urlParams_.Set("orderBy", orderBy)
9536 return c
9537 }
9538
9539
9540
9541 func (c *VolumesListCall) Partner(partner string) *VolumesListCall {
9542 c.urlParams_.Set("partner", partner)
9543 return c
9544 }
9545
9546
9547
9548
9549
9550
9551
9552
9553
9554
9555 func (c *VolumesListCall) PrintType(printType string) *VolumesListCall {
9556 c.urlParams_.Set("printType", printType)
9557 return c
9558 }
9559
9560
9561
9562
9563
9564
9565
9566
9567
9568 func (c *VolumesListCall) Projection(projection string) *VolumesListCall {
9569 c.urlParams_.Set("projection", projection)
9570 return c
9571 }
9572
9573
9574
9575 func (c *VolumesListCall) ShowPreorders(showPreorders bool) *VolumesListCall {
9576 c.urlParams_.Set("showPreorders", fmt.Sprint(showPreorders))
9577 return c
9578 }
9579
9580
9581
9582 func (c *VolumesListCall) Source(source string) *VolumesListCall {
9583 c.urlParams_.Set("source", source)
9584 return c
9585 }
9586
9587
9588
9589 func (c *VolumesListCall) StartIndex(startIndex int64) *VolumesListCall {
9590 c.urlParams_.Set("startIndex", fmt.Sprint(startIndex))
9591 return c
9592 }
9593
9594
9595
9596
9597 func (c *VolumesListCall) Fields(s ...googleapi.Field) *VolumesListCall {
9598 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9599 return c
9600 }
9601
9602
9603
9604
9605 func (c *VolumesListCall) IfNoneMatch(entityTag string) *VolumesListCall {
9606 c.ifNoneMatch_ = entityTag
9607 return c
9608 }
9609
9610
9611 func (c *VolumesListCall) Context(ctx context.Context) *VolumesListCall {
9612 c.ctx_ = ctx
9613 return c
9614 }
9615
9616
9617
9618 func (c *VolumesListCall) Header() http.Header {
9619 if c.header_ == nil {
9620 c.header_ = make(http.Header)
9621 }
9622 return c.header_
9623 }
9624
9625 func (c *VolumesListCall) doRequest(alt string) (*http.Response, error) {
9626 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9627 if c.ifNoneMatch_ != "" {
9628 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9629 }
9630 var body io.Reader = nil
9631 c.urlParams_.Set("alt", alt)
9632 c.urlParams_.Set("prettyPrint", "false")
9633 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes")
9634 urls += "?" + c.urlParams_.Encode()
9635 req, err := http.NewRequest("GET", urls, body)
9636 if err != nil {
9637 return nil, err
9638 }
9639 req.Header = reqHeaders
9640 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9641 }
9642
9643
9644
9645
9646
9647
9648 func (c *VolumesListCall) Do(opts ...googleapi.CallOption) (*Volumes, error) {
9649 gensupport.SetOptions(c.urlParams_, opts...)
9650 res, err := c.doRequest("json")
9651 if res != nil && res.StatusCode == http.StatusNotModified {
9652 if res.Body != nil {
9653 res.Body.Close()
9654 }
9655 return nil, gensupport.WrapError(&googleapi.Error{
9656 Code: res.StatusCode,
9657 Header: res.Header,
9658 })
9659 }
9660 if err != nil {
9661 return nil, err
9662 }
9663 defer googleapi.CloseBody(res)
9664 if err := googleapi.CheckResponse(res); err != nil {
9665 return nil, gensupport.WrapError(err)
9666 }
9667 ret := &Volumes{
9668 ServerResponse: googleapi.ServerResponse{
9669 Header: res.Header,
9670 HTTPStatusCode: res.StatusCode,
9671 },
9672 }
9673 target := &ret
9674 if err := gensupport.DecodeResponse(target, res); err != nil {
9675 return nil, err
9676 }
9677 return ret, nil
9678 }
9679
9680 type VolumesAssociatedListCall struct {
9681 s *Service
9682 volumeId string
9683 urlParams_ gensupport.URLParams
9684 ifNoneMatch_ string
9685 ctx_ context.Context
9686 header_ http.Header
9687 }
9688
9689
9690
9691
9692 func (r *VolumesAssociatedService) List(volumeId string) *VolumesAssociatedListCall {
9693 c := &VolumesAssociatedListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9694 c.volumeId = volumeId
9695 return c
9696 }
9697
9698
9699
9700
9701
9702
9703
9704
9705
9706 func (c *VolumesAssociatedListCall) Association(association string) *VolumesAssociatedListCall {
9707 c.urlParams_.Set("association", association)
9708 return c
9709 }
9710
9711
9712
9713 func (c *VolumesAssociatedListCall) Locale(locale string) *VolumesAssociatedListCall {
9714 c.urlParams_.Set("locale", locale)
9715 return c
9716 }
9717
9718
9719
9720
9721
9722
9723
9724
9725
9726
9727 func (c *VolumesAssociatedListCall) MaxAllowedMaturityRating(maxAllowedMaturityRating string) *VolumesAssociatedListCall {
9728 c.urlParams_.Set("maxAllowedMaturityRating", maxAllowedMaturityRating)
9729 return c
9730 }
9731
9732
9733
9734 func (c *VolumesAssociatedListCall) Source(source string) *VolumesAssociatedListCall {
9735 c.urlParams_.Set("source", source)
9736 return c
9737 }
9738
9739
9740
9741
9742 func (c *VolumesAssociatedListCall) Fields(s ...googleapi.Field) *VolumesAssociatedListCall {
9743 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9744 return c
9745 }
9746
9747
9748
9749
9750 func (c *VolumesAssociatedListCall) IfNoneMatch(entityTag string) *VolumesAssociatedListCall {
9751 c.ifNoneMatch_ = entityTag
9752 return c
9753 }
9754
9755
9756 func (c *VolumesAssociatedListCall) Context(ctx context.Context) *VolumesAssociatedListCall {
9757 c.ctx_ = ctx
9758 return c
9759 }
9760
9761
9762
9763 func (c *VolumesAssociatedListCall) Header() http.Header {
9764 if c.header_ == nil {
9765 c.header_ = make(http.Header)
9766 }
9767 return c.header_
9768 }
9769
9770 func (c *VolumesAssociatedListCall) doRequest(alt string) (*http.Response, error) {
9771 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9772 if c.ifNoneMatch_ != "" {
9773 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9774 }
9775 var body io.Reader = nil
9776 c.urlParams_.Set("alt", alt)
9777 c.urlParams_.Set("prettyPrint", "false")
9778 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/{volumeId}/associated")
9779 urls += "?" + c.urlParams_.Encode()
9780 req, err := http.NewRequest("GET", urls, body)
9781 if err != nil {
9782 return nil, err
9783 }
9784 req.Header = reqHeaders
9785 googleapi.Expand(req.URL, map[string]string{
9786 "volumeId": c.volumeId,
9787 })
9788 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9789 }
9790
9791
9792
9793
9794
9795
9796 func (c *VolumesAssociatedListCall) Do(opts ...googleapi.CallOption) (*Volumes, error) {
9797 gensupport.SetOptions(c.urlParams_, opts...)
9798 res, err := c.doRequest("json")
9799 if res != nil && res.StatusCode == http.StatusNotModified {
9800 if res.Body != nil {
9801 res.Body.Close()
9802 }
9803 return nil, gensupport.WrapError(&googleapi.Error{
9804 Code: res.StatusCode,
9805 Header: res.Header,
9806 })
9807 }
9808 if err != nil {
9809 return nil, err
9810 }
9811 defer googleapi.CloseBody(res)
9812 if err := googleapi.CheckResponse(res); err != nil {
9813 return nil, gensupport.WrapError(err)
9814 }
9815 ret := &Volumes{
9816 ServerResponse: googleapi.ServerResponse{
9817 Header: res.Header,
9818 HTTPStatusCode: res.StatusCode,
9819 },
9820 }
9821 target := &ret
9822 if err := gensupport.DecodeResponse(target, res); err != nil {
9823 return nil, err
9824 }
9825 return ret, nil
9826 }
9827
9828 type VolumesMybooksListCall struct {
9829 s *Service
9830 urlParams_ gensupport.URLParams
9831 ifNoneMatch_ string
9832 ctx_ context.Context
9833 header_ http.Header
9834 }
9835
9836
9837 func (r *VolumesMybooksService) List() *VolumesMybooksListCall {
9838 c := &VolumesMybooksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9839 return c
9840 }
9841
9842
9843
9844
9845
9846
9847
9848
9849
9850
9851
9852
9853
9854
9855
9856 func (c *VolumesMybooksListCall) AcquireMethod(acquireMethod ...string) *VolumesMybooksListCall {
9857 c.urlParams_.SetMulti("acquireMethod", append([]string{}, acquireMethod...))
9858 return c
9859 }
9860
9861
9862
9863 func (c *VolumesMybooksListCall) Country(country string) *VolumesMybooksListCall {
9864 c.urlParams_.Set("country", country)
9865 return c
9866 }
9867
9868
9869
9870 func (c *VolumesMybooksListCall) Locale(locale string) *VolumesMybooksListCall {
9871 c.urlParams_.Set("locale", locale)
9872 return c
9873 }
9874
9875
9876
9877 func (c *VolumesMybooksListCall) MaxResults(maxResults int64) *VolumesMybooksListCall {
9878 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
9879 return c
9880 }
9881
9882
9883
9884
9885
9886
9887
9888
9889
9890
9891
9892 func (c *VolumesMybooksListCall) ProcessingState(processingState ...string) *VolumesMybooksListCall {
9893 c.urlParams_.SetMulti("processingState", append([]string{}, processingState...))
9894 return c
9895 }
9896
9897
9898
9899 func (c *VolumesMybooksListCall) Source(source string) *VolumesMybooksListCall {
9900 c.urlParams_.Set("source", source)
9901 return c
9902 }
9903
9904
9905
9906 func (c *VolumesMybooksListCall) StartIndex(startIndex int64) *VolumesMybooksListCall {
9907 c.urlParams_.Set("startIndex", fmt.Sprint(startIndex))
9908 return c
9909 }
9910
9911
9912
9913
9914 func (c *VolumesMybooksListCall) Fields(s ...googleapi.Field) *VolumesMybooksListCall {
9915 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9916 return c
9917 }
9918
9919
9920
9921
9922 func (c *VolumesMybooksListCall) IfNoneMatch(entityTag string) *VolumesMybooksListCall {
9923 c.ifNoneMatch_ = entityTag
9924 return c
9925 }
9926
9927
9928 func (c *VolumesMybooksListCall) Context(ctx context.Context) *VolumesMybooksListCall {
9929 c.ctx_ = ctx
9930 return c
9931 }
9932
9933
9934
9935 func (c *VolumesMybooksListCall) Header() http.Header {
9936 if c.header_ == nil {
9937 c.header_ = make(http.Header)
9938 }
9939 return c.header_
9940 }
9941
9942 func (c *VolumesMybooksListCall) doRequest(alt string) (*http.Response, error) {
9943 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9944 if c.ifNoneMatch_ != "" {
9945 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9946 }
9947 var body io.Reader = nil
9948 c.urlParams_.Set("alt", alt)
9949 c.urlParams_.Set("prettyPrint", "false")
9950 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/mybooks")
9951 urls += "?" + c.urlParams_.Encode()
9952 req, err := http.NewRequest("GET", urls, body)
9953 if err != nil {
9954 return nil, err
9955 }
9956 req.Header = reqHeaders
9957 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9958 }
9959
9960
9961
9962
9963
9964
9965 func (c *VolumesMybooksListCall) Do(opts ...googleapi.CallOption) (*Volumes, error) {
9966 gensupport.SetOptions(c.urlParams_, opts...)
9967 res, err := c.doRequest("json")
9968 if res != nil && res.StatusCode == http.StatusNotModified {
9969 if res.Body != nil {
9970 res.Body.Close()
9971 }
9972 return nil, gensupport.WrapError(&googleapi.Error{
9973 Code: res.StatusCode,
9974 Header: res.Header,
9975 })
9976 }
9977 if err != nil {
9978 return nil, err
9979 }
9980 defer googleapi.CloseBody(res)
9981 if err := googleapi.CheckResponse(res); err != nil {
9982 return nil, gensupport.WrapError(err)
9983 }
9984 ret := &Volumes{
9985 ServerResponse: googleapi.ServerResponse{
9986 Header: res.Header,
9987 HTTPStatusCode: res.StatusCode,
9988 },
9989 }
9990 target := &ret
9991 if err := gensupport.DecodeResponse(target, res); err != nil {
9992 return nil, err
9993 }
9994 return ret, nil
9995 }
9996
9997 type VolumesRecommendedListCall struct {
9998 s *Service
9999 urlParams_ gensupport.URLParams
10000 ifNoneMatch_ string
10001 ctx_ context.Context
10002 header_ http.Header
10003 }
10004
10005
10006 func (r *VolumesRecommendedService) List() *VolumesRecommendedListCall {
10007 c := &VolumesRecommendedListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10008 return c
10009 }
10010
10011
10012
10013 func (c *VolumesRecommendedListCall) Locale(locale string) *VolumesRecommendedListCall {
10014 c.urlParams_.Set("locale", locale)
10015 return c
10016 }
10017
10018
10019
10020
10021
10022
10023
10024
10025
10026
10027 func (c *VolumesRecommendedListCall) MaxAllowedMaturityRating(maxAllowedMaturityRating string) *VolumesRecommendedListCall {
10028 c.urlParams_.Set("maxAllowedMaturityRating", maxAllowedMaturityRating)
10029 return c
10030 }
10031
10032
10033
10034 func (c *VolumesRecommendedListCall) Source(source string) *VolumesRecommendedListCall {
10035 c.urlParams_.Set("source", source)
10036 return c
10037 }
10038
10039
10040
10041
10042 func (c *VolumesRecommendedListCall) Fields(s ...googleapi.Field) *VolumesRecommendedListCall {
10043 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10044 return c
10045 }
10046
10047
10048
10049
10050 func (c *VolumesRecommendedListCall) IfNoneMatch(entityTag string) *VolumesRecommendedListCall {
10051 c.ifNoneMatch_ = entityTag
10052 return c
10053 }
10054
10055
10056 func (c *VolumesRecommendedListCall) Context(ctx context.Context) *VolumesRecommendedListCall {
10057 c.ctx_ = ctx
10058 return c
10059 }
10060
10061
10062
10063 func (c *VolumesRecommendedListCall) Header() http.Header {
10064 if c.header_ == nil {
10065 c.header_ = make(http.Header)
10066 }
10067 return c.header_
10068 }
10069
10070 func (c *VolumesRecommendedListCall) doRequest(alt string) (*http.Response, error) {
10071 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10072 if c.ifNoneMatch_ != "" {
10073 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10074 }
10075 var body io.Reader = nil
10076 c.urlParams_.Set("alt", alt)
10077 c.urlParams_.Set("prettyPrint", "false")
10078 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/recommended")
10079 urls += "?" + c.urlParams_.Encode()
10080 req, err := http.NewRequest("GET", urls, body)
10081 if err != nil {
10082 return nil, err
10083 }
10084 req.Header = reqHeaders
10085 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10086 }
10087
10088
10089
10090
10091
10092
10093 func (c *VolumesRecommendedListCall) Do(opts ...googleapi.CallOption) (*Volumes, error) {
10094 gensupport.SetOptions(c.urlParams_, opts...)
10095 res, err := c.doRequest("json")
10096 if res != nil && res.StatusCode == http.StatusNotModified {
10097 if res.Body != nil {
10098 res.Body.Close()
10099 }
10100 return nil, gensupport.WrapError(&googleapi.Error{
10101 Code: res.StatusCode,
10102 Header: res.Header,
10103 })
10104 }
10105 if err != nil {
10106 return nil, err
10107 }
10108 defer googleapi.CloseBody(res)
10109 if err := googleapi.CheckResponse(res); err != nil {
10110 return nil, gensupport.WrapError(err)
10111 }
10112 ret := &Volumes{
10113 ServerResponse: googleapi.ServerResponse{
10114 Header: res.Header,
10115 HTTPStatusCode: res.StatusCode,
10116 },
10117 }
10118 target := &ret
10119 if err := gensupport.DecodeResponse(target, res); err != nil {
10120 return nil, err
10121 }
10122 return ret, nil
10123 }
10124
10125 type VolumesRecommendedRateCall struct {
10126 s *Service
10127 urlParams_ gensupport.URLParams
10128 ctx_ context.Context
10129 header_ http.Header
10130 }
10131
10132
10133
10134
10135
10136 func (r *VolumesRecommendedService) Rate(rating string, volumeId string) *VolumesRecommendedRateCall {
10137 c := &VolumesRecommendedRateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10138 c.urlParams_.Set("rating", rating)
10139 c.urlParams_.Set("volumeId", volumeId)
10140 return c
10141 }
10142
10143
10144
10145 func (c *VolumesRecommendedRateCall) Locale(locale string) *VolumesRecommendedRateCall {
10146 c.urlParams_.Set("locale", locale)
10147 return c
10148 }
10149
10150
10151
10152 func (c *VolumesRecommendedRateCall) Source(source string) *VolumesRecommendedRateCall {
10153 c.urlParams_.Set("source", source)
10154 return c
10155 }
10156
10157
10158
10159
10160 func (c *VolumesRecommendedRateCall) Fields(s ...googleapi.Field) *VolumesRecommendedRateCall {
10161 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10162 return c
10163 }
10164
10165
10166 func (c *VolumesRecommendedRateCall) Context(ctx context.Context) *VolumesRecommendedRateCall {
10167 c.ctx_ = ctx
10168 return c
10169 }
10170
10171
10172
10173 func (c *VolumesRecommendedRateCall) Header() http.Header {
10174 if c.header_ == nil {
10175 c.header_ = make(http.Header)
10176 }
10177 return c.header_
10178 }
10179
10180 func (c *VolumesRecommendedRateCall) doRequest(alt string) (*http.Response, error) {
10181 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10182 var body io.Reader = nil
10183 c.urlParams_.Set("alt", alt)
10184 c.urlParams_.Set("prettyPrint", "false")
10185 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/recommended/rate")
10186 urls += "?" + c.urlParams_.Encode()
10187 req, err := http.NewRequest("POST", urls, body)
10188 if err != nil {
10189 return nil, err
10190 }
10191 req.Header = reqHeaders
10192 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10193 }
10194
10195
10196
10197
10198
10199
10200
10201 func (c *VolumesRecommendedRateCall) Do(opts ...googleapi.CallOption) (*BooksVolumesRecommendedRateResponse, error) {
10202 gensupport.SetOptions(c.urlParams_, opts...)
10203 res, err := c.doRequest("json")
10204 if res != nil && res.StatusCode == http.StatusNotModified {
10205 if res.Body != nil {
10206 res.Body.Close()
10207 }
10208 return nil, gensupport.WrapError(&googleapi.Error{
10209 Code: res.StatusCode,
10210 Header: res.Header,
10211 })
10212 }
10213 if err != nil {
10214 return nil, err
10215 }
10216 defer googleapi.CloseBody(res)
10217 if err := googleapi.CheckResponse(res); err != nil {
10218 return nil, gensupport.WrapError(err)
10219 }
10220 ret := &BooksVolumesRecommendedRateResponse{
10221 ServerResponse: googleapi.ServerResponse{
10222 Header: res.Header,
10223 HTTPStatusCode: res.StatusCode,
10224 },
10225 }
10226 target := &ret
10227 if err := gensupport.DecodeResponse(target, res); err != nil {
10228 return nil, err
10229 }
10230 return ret, nil
10231 }
10232
10233 type VolumesUseruploadedListCall struct {
10234 s *Service
10235 urlParams_ gensupport.URLParams
10236 ifNoneMatch_ string
10237 ctx_ context.Context
10238 header_ http.Header
10239 }
10240
10241
10242 func (r *VolumesUseruploadedService) List() *VolumesUseruploadedListCall {
10243 c := &VolumesUseruploadedListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10244 return c
10245 }
10246
10247
10248
10249 func (c *VolumesUseruploadedListCall) Locale(locale string) *VolumesUseruploadedListCall {
10250 c.urlParams_.Set("locale", locale)
10251 return c
10252 }
10253
10254
10255
10256 func (c *VolumesUseruploadedListCall) MaxResults(maxResults int64) *VolumesUseruploadedListCall {
10257 c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
10258 return c
10259 }
10260
10261
10262
10263
10264
10265
10266
10267
10268
10269
10270 func (c *VolumesUseruploadedListCall) ProcessingState(processingState ...string) *VolumesUseruploadedListCall {
10271 c.urlParams_.SetMulti("processingState", append([]string{}, processingState...))
10272 return c
10273 }
10274
10275
10276
10277 func (c *VolumesUseruploadedListCall) Source(source string) *VolumesUseruploadedListCall {
10278 c.urlParams_.Set("source", source)
10279 return c
10280 }
10281
10282
10283
10284 func (c *VolumesUseruploadedListCall) StartIndex(startIndex int64) *VolumesUseruploadedListCall {
10285 c.urlParams_.Set("startIndex", fmt.Sprint(startIndex))
10286 return c
10287 }
10288
10289
10290
10291
10292 func (c *VolumesUseruploadedListCall) VolumeId(volumeId ...string) *VolumesUseruploadedListCall {
10293 c.urlParams_.SetMulti("volumeId", append([]string{}, volumeId...))
10294 return c
10295 }
10296
10297
10298
10299
10300 func (c *VolumesUseruploadedListCall) Fields(s ...googleapi.Field) *VolumesUseruploadedListCall {
10301 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10302 return c
10303 }
10304
10305
10306
10307
10308 func (c *VolumesUseruploadedListCall) IfNoneMatch(entityTag string) *VolumesUseruploadedListCall {
10309 c.ifNoneMatch_ = entityTag
10310 return c
10311 }
10312
10313
10314 func (c *VolumesUseruploadedListCall) Context(ctx context.Context) *VolumesUseruploadedListCall {
10315 c.ctx_ = ctx
10316 return c
10317 }
10318
10319
10320
10321 func (c *VolumesUseruploadedListCall) Header() http.Header {
10322 if c.header_ == nil {
10323 c.header_ = make(http.Header)
10324 }
10325 return c.header_
10326 }
10327
10328 func (c *VolumesUseruploadedListCall) doRequest(alt string) (*http.Response, error) {
10329 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10330 if c.ifNoneMatch_ != "" {
10331 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10332 }
10333 var body io.Reader = nil
10334 c.urlParams_.Set("alt", alt)
10335 c.urlParams_.Set("prettyPrint", "false")
10336 urls := googleapi.ResolveRelative(c.s.BasePath, "books/v1/volumes/useruploaded")
10337 urls += "?" + c.urlParams_.Encode()
10338 req, err := http.NewRequest("GET", urls, body)
10339 if err != nil {
10340 return nil, err
10341 }
10342 req.Header = reqHeaders
10343 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10344 }
10345
10346
10347
10348
10349
10350
10351 func (c *VolumesUseruploadedListCall) Do(opts ...googleapi.CallOption) (*Volumes, error) {
10352 gensupport.SetOptions(c.urlParams_, opts...)
10353 res, err := c.doRequest("json")
10354 if res != nil && res.StatusCode == http.StatusNotModified {
10355 if res.Body != nil {
10356 res.Body.Close()
10357 }
10358 return nil, gensupport.WrapError(&googleapi.Error{
10359 Code: res.StatusCode,
10360 Header: res.Header,
10361 })
10362 }
10363 if err != nil {
10364 return nil, err
10365 }
10366 defer googleapi.CloseBody(res)
10367 if err := googleapi.CheckResponse(res); err != nil {
10368 return nil, gensupport.WrapError(err)
10369 }
10370 ret := &Volumes{
10371 ServerResponse: googleapi.ServerResponse{
10372 Header: res.Header,
10373 HTTPStatusCode: res.StatusCode,
10374 },
10375 }
10376 target := &ret
10377 if err := gensupport.DecodeResponse(target, res); err != nil {
10378 return nil, err
10379 }
10380 return ret, nil
10381 }
10382
View as plain text