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