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 package integrations
39
40 import (
41 "bytes"
42 "context"
43 "encoding/json"
44 "errors"
45 "fmt"
46 "io"
47 "net/http"
48 "net/url"
49 "strconv"
50 "strings"
51
52 googleapi "google.golang.org/api/googleapi"
53 internal "google.golang.org/api/internal"
54 gensupport "google.golang.org/api/internal/gensupport"
55 option "google.golang.org/api/option"
56 internaloption "google.golang.org/api/option/internaloption"
57 htransport "google.golang.org/api/transport/http"
58 )
59
60
61
62 var _ = bytes.NewBuffer
63 var _ = strconv.Itoa
64 var _ = fmt.Sprintf
65 var _ = json.NewDecoder
66 var _ = io.Copy
67 var _ = url.Parse
68 var _ = gensupport.MarshalJSON
69 var _ = googleapi.Version
70 var _ = errors.New
71 var _ = strings.Replace
72 var _ = context.Canceled
73 var _ = internaloption.WithDefaultEndpoint
74
75 const apiId = "integrations:v1"
76 const apiName = "integrations"
77 const apiVersion = "v1"
78 const basePath = "https://integrations.googleapis.com/"
79 const mtlsBasePath = "https://integrations.mtls.googleapis.com/"
80
81
82 const (
83
84
85 CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
86 )
87
88
89 func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
90 scopesOption := internaloption.WithDefaultScopes(
91 "https://www.googleapis.com/auth/cloud-platform",
92 )
93
94 opts = append([]option.ClientOption{scopesOption}, opts...)
95 opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
96 opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
97 client, endpoint, err := htransport.NewClient(ctx, opts...)
98 if err != nil {
99 return nil, err
100 }
101 s, err := New(client)
102 if err != nil {
103 return nil, err
104 }
105 if endpoint != "" {
106 s.BasePath = endpoint
107 }
108 return s, nil
109 }
110
111
112
113
114
115
116 func New(client *http.Client) (*Service, error) {
117 if client == nil {
118 return nil, errors.New("client is nil")
119 }
120 s := &Service{client: client, BasePath: basePath}
121 s.Callback = NewCallbackService(s)
122 s.ConnectorPlatformRegions = NewConnectorPlatformRegionsService(s)
123 s.Projects = NewProjectsService(s)
124 return s, nil
125 }
126
127 type Service struct {
128 client *http.Client
129 BasePath string
130 UserAgent string
131
132 Callback *CallbackService
133
134 ConnectorPlatformRegions *ConnectorPlatformRegionsService
135
136 Projects *ProjectsService
137 }
138
139 func (s *Service) userAgent() string {
140 if s.UserAgent == "" {
141 return googleapi.UserAgent
142 }
143 return googleapi.UserAgent + " " + s.UserAgent
144 }
145
146 func NewCallbackService(s *Service) *CallbackService {
147 rs := &CallbackService{s: s}
148 return rs
149 }
150
151 type CallbackService struct {
152 s *Service
153 }
154
155 func NewConnectorPlatformRegionsService(s *Service) *ConnectorPlatformRegionsService {
156 rs := &ConnectorPlatformRegionsService{s: s}
157 return rs
158 }
159
160 type ConnectorPlatformRegionsService struct {
161 s *Service
162 }
163
164 func NewProjectsService(s *Service) *ProjectsService {
165 rs := &ProjectsService{s: s}
166 rs.Locations = NewProjectsLocationsService(s)
167 return rs
168 }
169
170 type ProjectsService struct {
171 s *Service
172
173 Locations *ProjectsLocationsService
174 }
175
176 func NewProjectsLocationsService(s *Service) *ProjectsLocationsService {
177 rs := &ProjectsLocationsService{s: s}
178 rs.AppsScriptProjects = NewProjectsLocationsAppsScriptProjectsService(s)
179 rs.AuthConfigs = NewProjectsLocationsAuthConfigsService(s)
180 rs.Certificates = NewProjectsLocationsCertificatesService(s)
181 rs.Clients = NewProjectsLocationsClientsService(s)
182 rs.CloudFunctions = NewProjectsLocationsCloudFunctionsService(s)
183 rs.Connections = NewProjectsLocationsConnectionsService(s)
184 rs.Integrations = NewProjectsLocationsIntegrationsService(s)
185 rs.Products = NewProjectsLocationsProductsService(s)
186 rs.SfdcInstances = NewProjectsLocationsSfdcInstancesService(s)
187 return rs
188 }
189
190 type ProjectsLocationsService struct {
191 s *Service
192
193 AppsScriptProjects *ProjectsLocationsAppsScriptProjectsService
194
195 AuthConfigs *ProjectsLocationsAuthConfigsService
196
197 Certificates *ProjectsLocationsCertificatesService
198
199 Clients *ProjectsLocationsClientsService
200
201 CloudFunctions *ProjectsLocationsCloudFunctionsService
202
203 Connections *ProjectsLocationsConnectionsService
204
205 Integrations *ProjectsLocationsIntegrationsService
206
207 Products *ProjectsLocationsProductsService
208
209 SfdcInstances *ProjectsLocationsSfdcInstancesService
210 }
211
212 func NewProjectsLocationsAppsScriptProjectsService(s *Service) *ProjectsLocationsAppsScriptProjectsService {
213 rs := &ProjectsLocationsAppsScriptProjectsService{s: s}
214 return rs
215 }
216
217 type ProjectsLocationsAppsScriptProjectsService struct {
218 s *Service
219 }
220
221 func NewProjectsLocationsAuthConfigsService(s *Service) *ProjectsLocationsAuthConfigsService {
222 rs := &ProjectsLocationsAuthConfigsService{s: s}
223 return rs
224 }
225
226 type ProjectsLocationsAuthConfigsService struct {
227 s *Service
228 }
229
230 func NewProjectsLocationsCertificatesService(s *Service) *ProjectsLocationsCertificatesService {
231 rs := &ProjectsLocationsCertificatesService{s: s}
232 return rs
233 }
234
235 type ProjectsLocationsCertificatesService struct {
236 s *Service
237 }
238
239 func NewProjectsLocationsClientsService(s *Service) *ProjectsLocationsClientsService {
240 rs := &ProjectsLocationsClientsService{s: s}
241 return rs
242 }
243
244 type ProjectsLocationsClientsService struct {
245 s *Service
246 }
247
248 func NewProjectsLocationsCloudFunctionsService(s *Service) *ProjectsLocationsCloudFunctionsService {
249 rs := &ProjectsLocationsCloudFunctionsService{s: s}
250 return rs
251 }
252
253 type ProjectsLocationsCloudFunctionsService struct {
254 s *Service
255 }
256
257 func NewProjectsLocationsConnectionsService(s *Service) *ProjectsLocationsConnectionsService {
258 rs := &ProjectsLocationsConnectionsService{s: s}
259 rs.RuntimeActionSchemas = NewProjectsLocationsConnectionsRuntimeActionSchemasService(s)
260 rs.RuntimeEntitySchemas = NewProjectsLocationsConnectionsRuntimeEntitySchemasService(s)
261 return rs
262 }
263
264 type ProjectsLocationsConnectionsService struct {
265 s *Service
266
267 RuntimeActionSchemas *ProjectsLocationsConnectionsRuntimeActionSchemasService
268
269 RuntimeEntitySchemas *ProjectsLocationsConnectionsRuntimeEntitySchemasService
270 }
271
272 func NewProjectsLocationsConnectionsRuntimeActionSchemasService(s *Service) *ProjectsLocationsConnectionsRuntimeActionSchemasService {
273 rs := &ProjectsLocationsConnectionsRuntimeActionSchemasService{s: s}
274 return rs
275 }
276
277 type ProjectsLocationsConnectionsRuntimeActionSchemasService struct {
278 s *Service
279 }
280
281 func NewProjectsLocationsConnectionsRuntimeEntitySchemasService(s *Service) *ProjectsLocationsConnectionsRuntimeEntitySchemasService {
282 rs := &ProjectsLocationsConnectionsRuntimeEntitySchemasService{s: s}
283 return rs
284 }
285
286 type ProjectsLocationsConnectionsRuntimeEntitySchemasService struct {
287 s *Service
288 }
289
290 func NewProjectsLocationsIntegrationsService(s *Service) *ProjectsLocationsIntegrationsService {
291 rs := &ProjectsLocationsIntegrationsService{s: s}
292 rs.Executions = NewProjectsLocationsIntegrationsExecutionsService(s)
293 rs.Executionsnapshots = NewProjectsLocationsIntegrationsExecutionsnapshotsService(s)
294 rs.Versions = NewProjectsLocationsIntegrationsVersionsService(s)
295 return rs
296 }
297
298 type ProjectsLocationsIntegrationsService struct {
299 s *Service
300
301 Executions *ProjectsLocationsIntegrationsExecutionsService
302
303 Executionsnapshots *ProjectsLocationsIntegrationsExecutionsnapshotsService
304
305 Versions *ProjectsLocationsIntegrationsVersionsService
306 }
307
308 func NewProjectsLocationsIntegrationsExecutionsService(s *Service) *ProjectsLocationsIntegrationsExecutionsService {
309 rs := &ProjectsLocationsIntegrationsExecutionsService{s: s}
310 rs.Suspensions = NewProjectsLocationsIntegrationsExecutionsSuspensionsService(s)
311 return rs
312 }
313
314 type ProjectsLocationsIntegrationsExecutionsService struct {
315 s *Service
316
317 Suspensions *ProjectsLocationsIntegrationsExecutionsSuspensionsService
318 }
319
320 func NewProjectsLocationsIntegrationsExecutionsSuspensionsService(s *Service) *ProjectsLocationsIntegrationsExecutionsSuspensionsService {
321 rs := &ProjectsLocationsIntegrationsExecutionsSuspensionsService{s: s}
322 return rs
323 }
324
325 type ProjectsLocationsIntegrationsExecutionsSuspensionsService struct {
326 s *Service
327 }
328
329 func NewProjectsLocationsIntegrationsExecutionsnapshotsService(s *Service) *ProjectsLocationsIntegrationsExecutionsnapshotsService {
330 rs := &ProjectsLocationsIntegrationsExecutionsnapshotsService{s: s}
331 return rs
332 }
333
334 type ProjectsLocationsIntegrationsExecutionsnapshotsService struct {
335 s *Service
336 }
337
338 func NewProjectsLocationsIntegrationsVersionsService(s *Service) *ProjectsLocationsIntegrationsVersionsService {
339 rs := &ProjectsLocationsIntegrationsVersionsService{s: s}
340 return rs
341 }
342
343 type ProjectsLocationsIntegrationsVersionsService struct {
344 s *Service
345 }
346
347 func NewProjectsLocationsProductsService(s *Service) *ProjectsLocationsProductsService {
348 rs := &ProjectsLocationsProductsService{s: s}
349 rs.AuthConfigs = NewProjectsLocationsProductsAuthConfigsService(s)
350 rs.Certificates = NewProjectsLocationsProductsCertificatesService(s)
351 rs.CloudFunctions = NewProjectsLocationsProductsCloudFunctionsService(s)
352 rs.Integrations = NewProjectsLocationsProductsIntegrationsService(s)
353 rs.SfdcInstances = NewProjectsLocationsProductsSfdcInstancesService(s)
354 return rs
355 }
356
357 type ProjectsLocationsProductsService struct {
358 s *Service
359
360 AuthConfigs *ProjectsLocationsProductsAuthConfigsService
361
362 Certificates *ProjectsLocationsProductsCertificatesService
363
364 CloudFunctions *ProjectsLocationsProductsCloudFunctionsService
365
366 Integrations *ProjectsLocationsProductsIntegrationsService
367
368 SfdcInstances *ProjectsLocationsProductsSfdcInstancesService
369 }
370
371 func NewProjectsLocationsProductsAuthConfigsService(s *Service) *ProjectsLocationsProductsAuthConfigsService {
372 rs := &ProjectsLocationsProductsAuthConfigsService{s: s}
373 return rs
374 }
375
376 type ProjectsLocationsProductsAuthConfigsService struct {
377 s *Service
378 }
379
380 func NewProjectsLocationsProductsCertificatesService(s *Service) *ProjectsLocationsProductsCertificatesService {
381 rs := &ProjectsLocationsProductsCertificatesService{s: s}
382 return rs
383 }
384
385 type ProjectsLocationsProductsCertificatesService struct {
386 s *Service
387 }
388
389 func NewProjectsLocationsProductsCloudFunctionsService(s *Service) *ProjectsLocationsProductsCloudFunctionsService {
390 rs := &ProjectsLocationsProductsCloudFunctionsService{s: s}
391 return rs
392 }
393
394 type ProjectsLocationsProductsCloudFunctionsService struct {
395 s *Service
396 }
397
398 func NewProjectsLocationsProductsIntegrationsService(s *Service) *ProjectsLocationsProductsIntegrationsService {
399 rs := &ProjectsLocationsProductsIntegrationsService{s: s}
400 rs.Executions = NewProjectsLocationsProductsIntegrationsExecutionsService(s)
401 rs.Executionsnapshots = NewProjectsLocationsProductsIntegrationsExecutionsnapshotsService(s)
402 rs.Versions = NewProjectsLocationsProductsIntegrationsVersionsService(s)
403 return rs
404 }
405
406 type ProjectsLocationsProductsIntegrationsService struct {
407 s *Service
408
409 Executions *ProjectsLocationsProductsIntegrationsExecutionsService
410
411 Executionsnapshots *ProjectsLocationsProductsIntegrationsExecutionsnapshotsService
412
413 Versions *ProjectsLocationsProductsIntegrationsVersionsService
414 }
415
416 func NewProjectsLocationsProductsIntegrationsExecutionsService(s *Service) *ProjectsLocationsProductsIntegrationsExecutionsService {
417 rs := &ProjectsLocationsProductsIntegrationsExecutionsService{s: s}
418 rs.Suspensions = NewProjectsLocationsProductsIntegrationsExecutionsSuspensionsService(s)
419 return rs
420 }
421
422 type ProjectsLocationsProductsIntegrationsExecutionsService struct {
423 s *Service
424
425 Suspensions *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsService
426 }
427
428 func NewProjectsLocationsProductsIntegrationsExecutionsSuspensionsService(s *Service) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsService {
429 rs := &ProjectsLocationsProductsIntegrationsExecutionsSuspensionsService{s: s}
430 return rs
431 }
432
433 type ProjectsLocationsProductsIntegrationsExecutionsSuspensionsService struct {
434 s *Service
435 }
436
437 func NewProjectsLocationsProductsIntegrationsExecutionsnapshotsService(s *Service) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsService {
438 rs := &ProjectsLocationsProductsIntegrationsExecutionsnapshotsService{s: s}
439 return rs
440 }
441
442 type ProjectsLocationsProductsIntegrationsExecutionsnapshotsService struct {
443 s *Service
444 }
445
446 func NewProjectsLocationsProductsIntegrationsVersionsService(s *Service) *ProjectsLocationsProductsIntegrationsVersionsService {
447 rs := &ProjectsLocationsProductsIntegrationsVersionsService{s: s}
448 return rs
449 }
450
451 type ProjectsLocationsProductsIntegrationsVersionsService struct {
452 s *Service
453 }
454
455 func NewProjectsLocationsProductsSfdcInstancesService(s *Service) *ProjectsLocationsProductsSfdcInstancesService {
456 rs := &ProjectsLocationsProductsSfdcInstancesService{s: s}
457 rs.SfdcChannels = NewProjectsLocationsProductsSfdcInstancesSfdcChannelsService(s)
458 return rs
459 }
460
461 type ProjectsLocationsProductsSfdcInstancesService struct {
462 s *Service
463
464 SfdcChannels *ProjectsLocationsProductsSfdcInstancesSfdcChannelsService
465 }
466
467 func NewProjectsLocationsProductsSfdcInstancesSfdcChannelsService(s *Service) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsService {
468 rs := &ProjectsLocationsProductsSfdcInstancesSfdcChannelsService{s: s}
469 return rs
470 }
471
472 type ProjectsLocationsProductsSfdcInstancesSfdcChannelsService struct {
473 s *Service
474 }
475
476 func NewProjectsLocationsSfdcInstancesService(s *Service) *ProjectsLocationsSfdcInstancesService {
477 rs := &ProjectsLocationsSfdcInstancesService{s: s}
478 rs.SfdcChannels = NewProjectsLocationsSfdcInstancesSfdcChannelsService(s)
479 return rs
480 }
481
482 type ProjectsLocationsSfdcInstancesService struct {
483 s *Service
484
485 SfdcChannels *ProjectsLocationsSfdcInstancesSfdcChannelsService
486 }
487
488 func NewProjectsLocationsSfdcInstancesSfdcChannelsService(s *Service) *ProjectsLocationsSfdcInstancesSfdcChannelsService {
489 rs := &ProjectsLocationsSfdcInstancesSfdcChannelsService{s: s}
490 return rs
491 }
492
493 type ProjectsLocationsSfdcInstancesSfdcChannelsService struct {
494 s *Service
495 }
496
497
498
499 type CrmlogErrorCode struct {
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566 CommonErrorCode string `json:"commonErrorCode,omitempty"`
567
568
569
570
571
572
573
574 ForceSendFields []string `json:"-"`
575
576
577
578
579
580
581
582
583 NullFields []string `json:"-"`
584 }
585
586 func (s *CrmlogErrorCode) MarshalJSON() ([]byte, error) {
587 type NoMethod CrmlogErrorCode
588 raw := NoMethod(*s)
589 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
590 }
591
592 type EnterpriseCrmEventbusAuthconfigAuthConfigTaskParam struct {
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614 AllowedCredentialTypes []string `json:"allowedCredentialTypes,omitempty"`
615
616 AllowedServiceAccountInContext bool `json:"allowedServiceAccountInContext,omitempty"`
617
618
619 AuthConfigId string `json:"authConfigId,omitempty"`
620
621
622 Scope string `json:"scope,omitempty"`
623
624 UseServiceAccountInContext bool `json:"useServiceAccountInContext,omitempty"`
625
626
627
628
629
630
631
632
633 ForceSendFields []string `json:"-"`
634
635
636
637
638
639
640
641
642 NullFields []string `json:"-"`
643 }
644
645 func (s *EnterpriseCrmEventbusAuthconfigAuthConfigTaskParam) MarshalJSON() ([]byte, error) {
646 type NoMethod EnterpriseCrmEventbusAuthconfigAuthConfigTaskParam
647 raw := NoMethod(*s)
648 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
649 }
650
651
652
653
654
655 type EnterpriseCrmEventbusProtoAddress struct {
656
657 Email string `json:"email,omitempty"`
658
659 Name string `json:"name,omitempty"`
660
661 Tokens []*EnterpriseCrmEventbusProtoToken `json:"tokens,omitempty"`
662
663
664
665
666
667
668
669 ForceSendFields []string `json:"-"`
670
671
672
673
674
675
676
677 NullFields []string `json:"-"`
678 }
679
680 func (s *EnterpriseCrmEventbusProtoAddress) MarshalJSON() ([]byte, error) {
681 type NoMethod EnterpriseCrmEventbusProtoAddress
682 raw := NoMethod(*s)
683 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
684 }
685
686
687
688
689
690
691 type EnterpriseCrmEventbusProtoAttributes struct {
692
693
694
695
696
697
698
699
700
701
702
703 DataType string `json:"dataType,omitempty"`
704
705
706 DefaultValue *EnterpriseCrmEventbusProtoValueType `json:"defaultValue,omitempty"`
707
708
709
710 IsRequired bool `json:"isRequired,omitempty"`
711
712
713
714
715 IsSearchable bool `json:"isSearchable,omitempty"`
716
717
718
719 LogSettings *EnterpriseCrmEventbusProtoLogSettings `json:"logSettings,omitempty"`
720
721
722
723
724
725
726
727
728
729 Searchable string `json:"searchable,omitempty"`
730
731
732
733 TaskVisibility []string `json:"taskVisibility,omitempty"`
734
735
736
737
738
739
740
741 ForceSendFields []string `json:"-"`
742
743
744
745
746
747
748
749 NullFields []string `json:"-"`
750 }
751
752 func (s *EnterpriseCrmEventbusProtoAttributes) MarshalJSON() ([]byte, error) {
753 type NoMethod EnterpriseCrmEventbusProtoAttributes
754 raw := NoMethod(*s)
755 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
756 }
757
758
759
760 type EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList struct {
761 EnumStrings []string `json:"enumStrings,omitempty"`
762
763
764
765
766 FilterType string `json:"filterType,omitempty"`
767
768
769
770
771
772
773
774 ForceSendFields []string `json:"-"`
775
776
777
778
779
780
781
782 NullFields []string `json:"-"`
783 }
784
785 func (s *EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList) MarshalJSON() ([]byte, error) {
786 type NoMethod EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList
787 raw := NoMethod(*s)
788 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
789 }
790
791
792
793
794
795
796
797
798
799
800
801
802
803 type EnterpriseCrmEventbusProtoBaseAlertConfigThresholdValue struct {
804 Absolute int64 `json:"absolute,omitempty,string"`
805
806 Percentage int64 `json:"percentage,omitempty"`
807
808
809
810
811
812
813
814 ForceSendFields []string `json:"-"`
815
816
817
818
819
820
821
822 NullFields []string `json:"-"`
823 }
824
825 func (s *EnterpriseCrmEventbusProtoBaseAlertConfigThresholdValue) MarshalJSON() ([]byte, error) {
826 type NoMethod EnterpriseCrmEventbusProtoBaseAlertConfigThresholdValue
827 raw := NoMethod(*s)
828 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
829 }
830
831 type EnterpriseCrmEventbusProtoBaseFunction struct {
832
833
834
835
836
837
838
839
840
841
842 FunctionName string `json:"functionName,omitempty"`
843
844
845
846
847
848
849
850 ForceSendFields []string `json:"-"`
851
852
853
854
855
856
857
858 NullFields []string `json:"-"`
859 }
860
861 func (s *EnterpriseCrmEventbusProtoBaseFunction) MarshalJSON() ([]byte, error) {
862 type NoMethod EnterpriseCrmEventbusProtoBaseFunction
863 raw := NoMethod(*s)
864 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
865 }
866
867 type EnterpriseCrmEventbusProtoBaseValue struct {
868
869
870 BaseFunction *EnterpriseCrmEventbusProtoFunction `json:"baseFunction,omitempty"`
871
872
873 LiteralValue *EnterpriseCrmEventbusProtoParameterValueType `json:"literalValue,omitempty"`
874
875
876 ReferenceValue string `json:"referenceValue,omitempty"`
877
878
879
880
881
882
883
884 ForceSendFields []string `json:"-"`
885
886
887
888
889
890
891
892 NullFields []string `json:"-"`
893 }
894
895 func (s *EnterpriseCrmEventbusProtoBaseValue) MarshalJSON() ([]byte, error) {
896 type NoMethod EnterpriseCrmEventbusProtoBaseValue
897 raw := NoMethod(*s)
898 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
899 }
900
901 type EnterpriseCrmEventbusProtoBooleanArrayFunction struct {
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916 FunctionName string `json:"functionName,omitempty"`
917
918
919
920
921
922
923
924 ForceSendFields []string `json:"-"`
925
926
927
928
929
930
931
932 NullFields []string `json:"-"`
933 }
934
935 func (s *EnterpriseCrmEventbusProtoBooleanArrayFunction) MarshalJSON() ([]byte, error) {
936 type NoMethod EnterpriseCrmEventbusProtoBooleanArrayFunction
937 raw := NoMethod(*s)
938 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
939 }
940
941 type EnterpriseCrmEventbusProtoBooleanFunction struct {
942
943
944
945
946
947
948
949
950
951
952
953
954 FunctionName string `json:"functionName,omitempty"`
955
956
957
958
959
960
961
962 ForceSendFields []string `json:"-"`
963
964
965
966
967
968
969
970 NullFields []string `json:"-"`
971 }
972
973 func (s *EnterpriseCrmEventbusProtoBooleanFunction) MarshalJSON() ([]byte, error) {
974 type NoMethod EnterpriseCrmEventbusProtoBooleanFunction
975 raw := NoMethod(*s)
976 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
977 }
978
979 type EnterpriseCrmEventbusProtoBooleanParameterArray struct {
980 BooleanValues []bool `json:"booleanValues,omitempty"`
981
982
983
984
985
986
987
988 ForceSendFields []string `json:"-"`
989
990
991
992
993
994
995
996 NullFields []string `json:"-"`
997 }
998
999 func (s *EnterpriseCrmEventbusProtoBooleanParameterArray) MarshalJSON() ([]byte, error) {
1000 type NoMethod EnterpriseCrmEventbusProtoBooleanParameterArray
1001 raw := NoMethod(*s)
1002 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1003 }
1004
1005 type EnterpriseCrmEventbusProtoBuganizerNotification struct {
1006
1007 AssigneeEmailAddress string `json:"assigneeEmailAddress,omitempty"`
1008
1009
1010
1011 ComponentId int64 `json:"componentId,omitempty,string"`
1012
1013
1014 TemplateId int64 `json:"templateId,omitempty,string"`
1015
1016
1017 Title string `json:"title,omitempty"`
1018
1019
1020
1021
1022
1023
1024
1025
1026 ForceSendFields []string `json:"-"`
1027
1028
1029
1030
1031
1032
1033
1034
1035 NullFields []string `json:"-"`
1036 }
1037
1038 func (s *EnterpriseCrmEventbusProtoBuganizerNotification) MarshalJSON() ([]byte, error) {
1039 type NoMethod EnterpriseCrmEventbusProtoBuganizerNotification
1040 raw := NoMethod(*s)
1041 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1042 }
1043
1044
1045
1046 type EnterpriseCrmEventbusProtoCloudSchedulerConfig struct {
1047
1048 CronTab string `json:"cronTab,omitempty"`
1049
1050
1051
1052 ErrorMessage string `json:"errorMessage,omitempty"`
1053
1054
1055
1056 Location string `json:"location,omitempty"`
1057
1058
1059
1060 ServiceAccountEmail string `json:"serviceAccountEmail,omitempty"`
1061
1062
1063
1064
1065
1066
1067
1068 ForceSendFields []string `json:"-"`
1069
1070
1071
1072
1073
1074
1075
1076 NullFields []string `json:"-"`
1077 }
1078
1079 func (s *EnterpriseCrmEventbusProtoCloudSchedulerConfig) MarshalJSON() ([]byte, error) {
1080 type NoMethod EnterpriseCrmEventbusProtoCloudSchedulerConfig
1081 raw := NoMethod(*s)
1082 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1083 }
1084
1085
1086
1087 type EnterpriseCrmEventbusProtoCombinedCondition struct {
1088
1089 Conditions []*EnterpriseCrmEventbusProtoCondition `json:"conditions,omitempty"`
1090
1091
1092
1093
1094
1095
1096
1097 ForceSendFields []string `json:"-"`
1098
1099
1100
1101
1102
1103
1104
1105 NullFields []string `json:"-"`
1106 }
1107
1108 func (s *EnterpriseCrmEventbusProtoCombinedCondition) MarshalJSON() ([]byte, error) {
1109 type NoMethod EnterpriseCrmEventbusProtoCombinedCondition
1110 raw := NoMethod(*s)
1111 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1112 }
1113
1114
1115
1116 type EnterpriseCrmEventbusProtoCondition struct {
1117
1118
1119
1120
1121 EventPropertyKey string `json:"eventPropertyKey,omitempty"`
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137 Operator string `json:"operator,omitempty"`
1138
1139
1140 Value *EnterpriseCrmEventbusProtoValueType `json:"value,omitempty"`
1141
1142
1143
1144
1145
1146
1147
1148 ForceSendFields []string `json:"-"`
1149
1150
1151
1152
1153
1154
1155
1156
1157 NullFields []string `json:"-"`
1158 }
1159
1160 func (s *EnterpriseCrmEventbusProtoCondition) MarshalJSON() ([]byte, error) {
1161 type NoMethod EnterpriseCrmEventbusProtoCondition
1162 raw := NoMethod(*s)
1163 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1164 }
1165
1166
1167
1168 type EnterpriseCrmEventbusProtoConditionResult struct {
1169
1170 CurrentTaskNumber string `json:"currentTaskNumber,omitempty"`
1171
1172
1173 NextTaskNumber string `json:"nextTaskNumber,omitempty"`
1174
1175
1176
1177 Result bool `json:"result,omitempty"`
1178
1179
1180
1181
1182
1183
1184
1185 ForceSendFields []string `json:"-"`
1186
1187
1188
1189
1190
1191
1192
1193
1194 NullFields []string `json:"-"`
1195 }
1196
1197 func (s *EnterpriseCrmEventbusProtoConditionResult) MarshalJSON() ([]byte, error) {
1198 type NoMethod EnterpriseCrmEventbusProtoConditionResult
1199 raw := NoMethod(*s)
1200 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1201 }
1202
1203 type EnterpriseCrmEventbusProtoConnectorsConnection struct {
1204
1205
1206 ConnectionName string `json:"connectionName,omitempty"`
1207
1208
1209
1210
1211 ConnectorVersion string `json:"connectorVersion,omitempty"`
1212
1213
1214
1215
1216 ServiceName string `json:"serviceName,omitempty"`
1217
1218
1219
1220
1221
1222
1223
1224 ForceSendFields []string `json:"-"`
1225
1226
1227
1228
1229
1230
1231
1232
1233 NullFields []string `json:"-"`
1234 }
1235
1236 func (s *EnterpriseCrmEventbusProtoConnectorsConnection) MarshalJSON() ([]byte, error) {
1237 type NoMethod EnterpriseCrmEventbusProtoConnectorsConnection
1238 raw := NoMethod(*s)
1239 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1240 }
1241
1242 type EnterpriseCrmEventbusProtoConnectorsGenericConnectorTaskConfig struct {
1243
1244 Connection *EnterpriseCrmEventbusProtoConnectorsConnection `json:"connection,omitempty"`
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256 Operation string `json:"operation,omitempty"`
1257
1258
1259
1260
1261
1262
1263
1264 ForceSendFields []string `json:"-"`
1265
1266
1267
1268
1269
1270
1271
1272 NullFields []string `json:"-"`
1273 }
1274
1275 func (s *EnterpriseCrmEventbusProtoConnectorsGenericConnectorTaskConfig) MarshalJSON() ([]byte, error) {
1276 type NoMethod EnterpriseCrmEventbusProtoConnectorsGenericConnectorTaskConfig
1277 raw := NoMethod(*s)
1278 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1279 }
1280
1281
1282
1283 type EnterpriseCrmEventbusProtoCoordinate struct {
1284 X int64 `json:"x,omitempty"`
1285
1286 Y int64 `json:"y,omitempty"`
1287
1288
1289
1290
1291
1292
1293
1294 ForceSendFields []string `json:"-"`
1295
1296
1297
1298
1299
1300
1301
1302 NullFields []string `json:"-"`
1303 }
1304
1305 func (s *EnterpriseCrmEventbusProtoCoordinate) MarshalJSON() ([]byte, error) {
1306 type NoMethod EnterpriseCrmEventbusProtoCoordinate
1307 raw := NoMethod(*s)
1308 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1309 }
1310
1311 type EnterpriseCrmEventbusProtoCustomSuspensionRequest struct {
1312
1313
1314 PostToQueueWithTriggerIdRequest *GoogleInternalCloudCrmEventbusV3PostToQueueWithTriggerIdRequest `json:"postToQueueWithTriggerIdRequest,omitempty"`
1315
1316
1317
1318 SuspensionInfoEventParameterKey string `json:"suspensionInfoEventParameterKey,omitempty"`
1319
1320
1321
1322
1323
1324
1325
1326
1327 ForceSendFields []string `json:"-"`
1328
1329
1330
1331
1332
1333
1334
1335
1336 NullFields []string `json:"-"`
1337 }
1338
1339 func (s *EnterpriseCrmEventbusProtoCustomSuspensionRequest) MarshalJSON() ([]byte, error) {
1340 type NoMethod EnterpriseCrmEventbusProtoCustomSuspensionRequest
1341 raw := NoMethod(*s)
1342 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1343 }
1344
1345 type EnterpriseCrmEventbusProtoDoubleArray struct {
1346 Values []float64 `json:"values,omitempty"`
1347
1348
1349
1350
1351
1352
1353
1354 ForceSendFields []string `json:"-"`
1355
1356
1357
1358
1359
1360
1361
1362 NullFields []string `json:"-"`
1363 }
1364
1365 func (s *EnterpriseCrmEventbusProtoDoubleArray) MarshalJSON() ([]byte, error) {
1366 type NoMethod EnterpriseCrmEventbusProtoDoubleArray
1367 raw := NoMethod(*s)
1368 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1369 }
1370
1371 type EnterpriseCrmEventbusProtoDoubleArrayFunction struct {
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390 FunctionName string `json:"functionName,omitempty"`
1391
1392
1393
1394
1395
1396
1397
1398 ForceSendFields []string `json:"-"`
1399
1400
1401
1402
1403
1404
1405
1406 NullFields []string `json:"-"`
1407 }
1408
1409 func (s *EnterpriseCrmEventbusProtoDoubleArrayFunction) MarshalJSON() ([]byte, error) {
1410 type NoMethod EnterpriseCrmEventbusProtoDoubleArrayFunction
1411 raw := NoMethod(*s)
1412 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1413 }
1414
1415 type EnterpriseCrmEventbusProtoDoubleFunction struct {
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434 FunctionName string `json:"functionName,omitempty"`
1435
1436
1437
1438
1439
1440
1441
1442 ForceSendFields []string `json:"-"`
1443
1444
1445
1446
1447
1448
1449
1450 NullFields []string `json:"-"`
1451 }
1452
1453 func (s *EnterpriseCrmEventbusProtoDoubleFunction) MarshalJSON() ([]byte, error) {
1454 type NoMethod EnterpriseCrmEventbusProtoDoubleFunction
1455 raw := NoMethod(*s)
1456 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1457 }
1458
1459 type EnterpriseCrmEventbusProtoDoubleParameterArray struct {
1460 DoubleValues []float64 `json:"doubleValues,omitempty"`
1461
1462
1463
1464
1465
1466
1467
1468 ForceSendFields []string `json:"-"`
1469
1470
1471
1472
1473
1474
1475
1476 NullFields []string `json:"-"`
1477 }
1478
1479 func (s *EnterpriseCrmEventbusProtoDoubleParameterArray) MarshalJSON() ([]byte, error) {
1480 type NoMethod EnterpriseCrmEventbusProtoDoubleParameterArray
1481 raw := NoMethod(*s)
1482 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1483 }
1484
1485
1486
1487 type EnterpriseCrmEventbusProtoErrorDetail struct {
1488
1489
1490 ErrorCode *CrmlogErrorCode `json:"errorCode,omitempty"`
1491
1492
1493
1494 ErrorMessage string `json:"errorMessage,omitempty"`
1495
1496
1497
1498
1499
1500
1501
1502
1503 Severity string `json:"severity,omitempty"`
1504
1505
1506
1507 TaskNumber int64 `json:"taskNumber,omitempty"`
1508
1509
1510
1511
1512
1513
1514
1515 ForceSendFields []string `json:"-"`
1516
1517
1518
1519
1520
1521
1522
1523 NullFields []string `json:"-"`
1524 }
1525
1526 func (s *EnterpriseCrmEventbusProtoErrorDetail) MarshalJSON() ([]byte, error) {
1527 type NoMethod EnterpriseCrmEventbusProtoErrorDetail
1528 raw := NoMethod(*s)
1529 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1530 }
1531
1532
1533
1534
1535
1536 type EnterpriseCrmEventbusProtoEventBusProperties struct {
1537
1538 Properties []*EnterpriseCrmEventbusProtoPropertyEntry `json:"properties,omitempty"`
1539
1540
1541
1542
1543
1544
1545
1546 ForceSendFields []string `json:"-"`
1547
1548
1549
1550
1551
1552
1553
1554 NullFields []string `json:"-"`
1555 }
1556
1557 func (s *EnterpriseCrmEventbusProtoEventBusProperties) MarshalJSON() ([]byte, error) {
1558 type NoMethod EnterpriseCrmEventbusProtoEventBusProperties
1559 raw := NoMethod(*s)
1560 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1561 }
1562
1563
1564
1565
1566
1567 type EnterpriseCrmEventbusProtoEventExecutionDetails struct {
1568 EventAttemptStats []*EnterpriseCrmEventbusProtoEventExecutionDetailsEventAttemptStats `json:"eventAttemptStats,omitempty"`
1569
1570 EventExecutionSnapshot []*EnterpriseCrmEventbusProtoEventExecutionSnapshot `json:"eventExecutionSnapshot,omitempty"`
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586 EventExecutionState string `json:"eventExecutionState,omitempty"`
1587
1588
1589
1590 EventRetriesFromBeginningCount int64 `json:"eventRetriesFromBeginningCount,omitempty"`
1591
1592
1593 LogFilePath string `json:"logFilePath,omitempty"`
1594
1595
1596
1597 NetworkAddress string `json:"networkAddress,omitempty"`
1598
1599
1600
1601 NextExecutionTime int64 `json:"nextExecutionTime,omitempty,string"`
1602
1603
1604
1605
1606 RyeLockUnheldCount int64 `json:"ryeLockUnheldCount,omitempty"`
1607
1608
1609
1610
1611
1612
1613
1614 ForceSendFields []string `json:"-"`
1615
1616
1617
1618
1619
1620
1621
1622
1623 NullFields []string `json:"-"`
1624 }
1625
1626 func (s *EnterpriseCrmEventbusProtoEventExecutionDetails) MarshalJSON() ([]byte, error) {
1627 type NoMethod EnterpriseCrmEventbusProtoEventExecutionDetails
1628 raw := NoMethod(*s)
1629 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1630 }
1631
1632 type EnterpriseCrmEventbusProtoEventExecutionDetailsEventAttemptStats struct {
1633
1634 EndTime int64 `json:"endTime,omitempty,string"`
1635
1636
1637
1638 StartTime int64 `json:"startTime,omitempty,string"`
1639
1640
1641
1642
1643
1644
1645
1646 ForceSendFields []string `json:"-"`
1647
1648
1649
1650
1651
1652
1653
1654 NullFields []string `json:"-"`
1655 }
1656
1657 func (s *EnterpriseCrmEventbusProtoEventExecutionDetailsEventAttemptStats) MarshalJSON() ([]byte, error) {
1658 type NoMethod EnterpriseCrmEventbusProtoEventExecutionDetailsEventAttemptStats
1659 raw := NoMethod(*s)
1660 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1661 }
1662
1663
1664
1665
1666 type EnterpriseCrmEventbusProtoEventExecutionSnapshot struct {
1667
1668
1669 CheckpointTaskNumber string `json:"checkpointTaskNumber,omitempty"`
1670
1671
1672
1673 ConditionResults []*EnterpriseCrmEventbusProtoConditionResult `json:"conditionResults,omitempty"`
1674
1675
1676
1677 DiffParams *EnterpriseCrmEventbusProtoEventParameters `json:"diffParams,omitempty"`
1678
1679
1680
1681 EventExecutionInfoId string `json:"eventExecutionInfoId,omitempty"`
1682
1683
1684
1685 EventExecutionSnapshotId string `json:"eventExecutionSnapshotId,omitempty"`
1686
1687 EventExecutionSnapshotMetadata *EnterpriseCrmEventbusProtoEventExecutionSnapshotEventExecutionSnapshotMetadata `json:"eventExecutionSnapshotMetadata,omitempty"`
1688
1689
1690 EventParams *EnterpriseCrmEventbusProtoEventParameters `json:"eventParams,omitempty"`
1691
1692
1693
1694 ExceedMaxSize bool `json:"exceedMaxSize,omitempty"`
1695
1696
1697 SnapshotTime int64 `json:"snapshotTime,omitempty,string"`
1698
1699
1700
1701 TaskExecutionDetails []*EnterpriseCrmEventbusProtoTaskExecutionDetails `json:"taskExecutionDetails,omitempty"`
1702
1703
1704
1705 TaskName string `json:"taskName,omitempty"`
1706
1707
1708
1709
1710
1711
1712
1713
1714 ForceSendFields []string `json:"-"`
1715
1716
1717
1718
1719
1720
1721
1722
1723 NullFields []string `json:"-"`
1724 }
1725
1726 func (s *EnterpriseCrmEventbusProtoEventExecutionSnapshot) MarshalJSON() ([]byte, error) {
1727 type NoMethod EnterpriseCrmEventbusProtoEventExecutionSnapshot
1728 raw := NoMethod(*s)
1729 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1730 }
1731
1732 type EnterpriseCrmEventbusProtoEventExecutionSnapshotEventExecutionSnapshotMetadata struct {
1733
1734 EventAttemptNum int64 `json:"eventAttemptNum,omitempty"`
1735
1736
1737
1738 TaskAttemptNum int64 `json:"taskAttemptNum,omitempty"`
1739
1740
1741
1742 TaskName string `json:"taskName,omitempty"`
1743
1744
1745
1746 TaskNumber string `json:"taskNumber,omitempty"`
1747
1748
1749
1750
1751
1752
1753
1754 ForceSendFields []string `json:"-"`
1755
1756
1757
1758
1759
1760
1761
1762
1763 NullFields []string `json:"-"`
1764 }
1765
1766 func (s *EnterpriseCrmEventbusProtoEventExecutionSnapshotEventExecutionSnapshotMetadata) MarshalJSON() ([]byte, error) {
1767 type NoMethod EnterpriseCrmEventbusProtoEventExecutionSnapshotEventExecutionSnapshotMetadata
1768 raw := NoMethod(*s)
1769 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1770 }
1771
1772
1773
1774
1775
1776 type EnterpriseCrmEventbusProtoEventParameters struct {
1777
1778
1779
1780 Parameters []*EnterpriseCrmEventbusProtoParameterEntry `json:"parameters,omitempty"`
1781
1782
1783
1784
1785
1786
1787
1788 ForceSendFields []string `json:"-"`
1789
1790
1791
1792
1793
1794
1795
1796 NullFields []string `json:"-"`
1797 }
1798
1799 func (s *EnterpriseCrmEventbusProtoEventParameters) MarshalJSON() ([]byte, error) {
1800 type NoMethod EnterpriseCrmEventbusProtoEventParameters
1801 raw := NoMethod(*s)
1802 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1803 }
1804
1805
1806
1807
1808 type EnterpriseCrmEventbusProtoExecutionTraceInfo struct {
1809
1810
1811 ParentEventExecutionInfoId string `json:"parentEventExecutionInfoId,omitempty"`
1812
1813
1814 TraceId string `json:"traceId,omitempty"`
1815
1816
1817
1818
1819
1820
1821
1822
1823 ForceSendFields []string `json:"-"`
1824
1825
1826
1827
1828
1829
1830
1831
1832 NullFields []string `json:"-"`
1833 }
1834
1835 func (s *EnterpriseCrmEventbusProtoExecutionTraceInfo) MarshalJSON() ([]byte, error) {
1836 type NoMethod EnterpriseCrmEventbusProtoExecutionTraceInfo
1837 raw := NoMethod(*s)
1838 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1839 }
1840
1841
1842
1843 type EnterpriseCrmEventbusProtoExternalTraffic struct {
1844
1845 GcpProjectId string `json:"gcpProjectId,omitempty"`
1846
1847
1848
1849 GcpProjectNumber string `json:"gcpProjectNumber,omitempty"`
1850
1851
1852 Location string `json:"location,omitempty"`
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864 Source string `json:"source,omitempty"`
1865
1866
1867
1868
1869
1870
1871
1872 ForceSendFields []string `json:"-"`
1873
1874
1875
1876
1877
1878
1879
1880 NullFields []string `json:"-"`
1881 }
1882
1883 func (s *EnterpriseCrmEventbusProtoExternalTraffic) MarshalJSON() ([]byte, error) {
1884 type NoMethod EnterpriseCrmEventbusProtoExternalTraffic
1885 raw := NoMethod(*s)
1886 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1887 }
1888
1889
1890
1891
1892
1893 type EnterpriseCrmEventbusProtoFailurePolicy struct {
1894
1895
1896
1897 IntervalInSeconds int64 `json:"intervalInSeconds,omitempty,string"`
1898
1899
1900
1901
1902 MaxNumRetries int64 `json:"maxNumRetries,omitempty"`
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941 RetryStrategy string `json:"retryStrategy,omitempty"`
1942
1943
1944
1945
1946
1947
1948
1949 ForceSendFields []string `json:"-"`
1950
1951
1952
1953
1954
1955
1956
1957
1958 NullFields []string `json:"-"`
1959 }
1960
1961 func (s *EnterpriseCrmEventbusProtoFailurePolicy) MarshalJSON() ([]byte, error) {
1962 type NoMethod EnterpriseCrmEventbusProtoFailurePolicy
1963 raw := NoMethod(*s)
1964 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
1965 }
1966
1967
1968
1969 type EnterpriseCrmEventbusProtoField struct {
1970
1971
1972
1973
1974
1975
1976
1977 Cardinality string `json:"cardinality,omitempty"`
1978
1979
1980
1981
1982
1983 DefaultValue *EnterpriseCrmEventbusProtoParameterValueType `json:"defaultValue,omitempty"`
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008 FieldType string `json:"fieldType,omitempty"`
2009
2010
2011
2012
2013
2014
2015
2016 ProtoDefPath string `json:"protoDefPath,omitempty"`
2017
2018
2019
2020
2021
2022
2023 ReferenceKey string `json:"referenceKey,omitempty"`
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035 TransformExpression *EnterpriseCrmEventbusProtoTransformExpression `json:"transformExpression,omitempty"`
2036
2037
2038
2039
2040
2041
2042
2043 ForceSendFields []string `json:"-"`
2044
2045
2046
2047
2048
2049
2050
2051 NullFields []string `json:"-"`
2052 }
2053
2054 func (s *EnterpriseCrmEventbusProtoField) MarshalJSON() ([]byte, error) {
2055 type NoMethod EnterpriseCrmEventbusProtoField
2056 raw := NoMethod(*s)
2057 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2058 }
2059
2060
2061
2062
2063 type EnterpriseCrmEventbusProtoFieldMappingConfig struct {
2064 MappedFields []*EnterpriseCrmEventbusProtoMappedField `json:"mappedFields,omitempty"`
2065
2066
2067
2068
2069
2070
2071
2072 ForceSendFields []string `json:"-"`
2073
2074
2075
2076
2077
2078
2079
2080 NullFields []string `json:"-"`
2081 }
2082
2083 func (s *EnterpriseCrmEventbusProtoFieldMappingConfig) MarshalJSON() ([]byte, error) {
2084 type NoMethod EnterpriseCrmEventbusProtoFieldMappingConfig
2085 raw := NoMethod(*s)
2086 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2087 }
2088
2089 type EnterpriseCrmEventbusProtoFunction struct {
2090
2091 FunctionType *EnterpriseCrmEventbusProtoFunctionType `json:"functionType,omitempty"`
2092
2093
2094 Parameters []*EnterpriseCrmEventbusProtoTransformExpression `json:"parameters,omitempty"`
2095
2096
2097
2098
2099
2100
2101
2102 ForceSendFields []string `json:"-"`
2103
2104
2105
2106
2107
2108
2109
2110 NullFields []string `json:"-"`
2111 }
2112
2113 func (s *EnterpriseCrmEventbusProtoFunction) MarshalJSON() ([]byte, error) {
2114 type NoMethod EnterpriseCrmEventbusProtoFunction
2115 raw := NoMethod(*s)
2116 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2117 }
2118
2119 type EnterpriseCrmEventbusProtoFunctionType struct {
2120
2121 BaseFunction *EnterpriseCrmEventbusProtoBaseFunction `json:"baseFunction,omitempty"`
2122
2123 BooleanArrayFunction *EnterpriseCrmEventbusProtoBooleanArrayFunction `json:"booleanArrayFunction,omitempty"`
2124
2125 BooleanFunction *EnterpriseCrmEventbusProtoBooleanFunction `json:"booleanFunction,omitempty"`
2126
2127 DoubleArrayFunction *EnterpriseCrmEventbusProtoDoubleArrayFunction `json:"doubleArrayFunction,omitempty"`
2128
2129 DoubleFunction *EnterpriseCrmEventbusProtoDoubleFunction `json:"doubleFunction,omitempty"`
2130
2131 IntArrayFunction *EnterpriseCrmEventbusProtoIntArrayFunction `json:"intArrayFunction,omitempty"`
2132
2133 IntFunction *EnterpriseCrmEventbusProtoIntFunction `json:"intFunction,omitempty"`
2134
2135
2136
2137
2138 JsonFunction *EnterpriseCrmEventbusProtoJsonFunction `json:"jsonFunction,omitempty"`
2139
2140 ProtoArrayFunction *EnterpriseCrmEventbusProtoProtoArrayFunction `json:"protoArrayFunction,omitempty"`
2141
2142 ProtoFunction *EnterpriseCrmEventbusProtoProtoFunction `json:"protoFunction,omitempty"`
2143
2144 StringArrayFunction *EnterpriseCrmEventbusProtoStringArrayFunction `json:"stringArrayFunction,omitempty"`
2145
2146 StringFunction *EnterpriseCrmEventbusProtoStringFunction `json:"stringFunction,omitempty"`
2147
2148
2149
2150
2151
2152
2153
2154 ForceSendFields []string `json:"-"`
2155
2156
2157
2158
2159
2160
2161
2162 NullFields []string `json:"-"`
2163 }
2164
2165 func (s *EnterpriseCrmEventbusProtoFunctionType) MarshalJSON() ([]byte, error) {
2166 type NoMethod EnterpriseCrmEventbusProtoFunctionType
2167 raw := NoMethod(*s)
2168 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2169 }
2170
2171 type EnterpriseCrmEventbusProtoIntArray struct {
2172 Values googleapi.Int64s `json:"values,omitempty"`
2173
2174
2175
2176
2177
2178
2179
2180 ForceSendFields []string `json:"-"`
2181
2182
2183
2184
2185
2186
2187
2188 NullFields []string `json:"-"`
2189 }
2190
2191 func (s *EnterpriseCrmEventbusProtoIntArray) MarshalJSON() ([]byte, error) {
2192 type NoMethod EnterpriseCrmEventbusProtoIntArray
2193 raw := NoMethod(*s)
2194 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2195 }
2196
2197 type EnterpriseCrmEventbusProtoIntArrayFunction struct {
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216 FunctionName string `json:"functionName,omitempty"`
2217
2218
2219
2220
2221
2222
2223
2224 ForceSendFields []string `json:"-"`
2225
2226
2227
2228
2229
2230
2231
2232 NullFields []string `json:"-"`
2233 }
2234
2235 func (s *EnterpriseCrmEventbusProtoIntArrayFunction) MarshalJSON() ([]byte, error) {
2236 type NoMethod EnterpriseCrmEventbusProtoIntArrayFunction
2237 raw := NoMethod(*s)
2238 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2239 }
2240
2241 type EnterpriseCrmEventbusProtoIntFunction struct {
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259 FunctionName string `json:"functionName,omitempty"`
2260
2261
2262
2263
2264
2265
2266
2267 ForceSendFields []string `json:"-"`
2268
2269
2270
2271
2272
2273
2274
2275 NullFields []string `json:"-"`
2276 }
2277
2278 func (s *EnterpriseCrmEventbusProtoIntFunction) MarshalJSON() ([]byte, error) {
2279 type NoMethod EnterpriseCrmEventbusProtoIntFunction
2280 raw := NoMethod(*s)
2281 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2282 }
2283
2284 type EnterpriseCrmEventbusProtoIntParameterArray struct {
2285 IntValues googleapi.Int64s `json:"intValues,omitempty"`
2286
2287
2288
2289
2290
2291
2292
2293 ForceSendFields []string `json:"-"`
2294
2295
2296
2297
2298
2299
2300
2301 NullFields []string `json:"-"`
2302 }
2303
2304 func (s *EnterpriseCrmEventbusProtoIntParameterArray) MarshalJSON() ([]byte, error) {
2305 type NoMethod EnterpriseCrmEventbusProtoIntParameterArray
2306 raw := NoMethod(*s)
2307 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2308 }
2309
2310 type EnterpriseCrmEventbusProtoJsonFunction struct {
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336 FunctionName string `json:"functionName,omitempty"`
2337
2338
2339
2340
2341
2342
2343
2344 ForceSendFields []string `json:"-"`
2345
2346
2347
2348
2349
2350
2351
2352 NullFields []string `json:"-"`
2353 }
2354
2355 func (s *EnterpriseCrmEventbusProtoJsonFunction) MarshalJSON() ([]byte, error) {
2356 type NoMethod EnterpriseCrmEventbusProtoJsonFunction
2357 raw := NoMethod(*s)
2358 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2359 }
2360
2361
2362
2363
2364
2365
2366 type EnterpriseCrmEventbusProtoLogSettings struct {
2367
2368
2369
2370 LogFieldName string `json:"logFieldName,omitempty"`
2371
2372
2373
2374 SanitizeOptions *EnterpriseCrmLoggingGwsSanitizeOptions `json:"sanitizeOptions,omitempty"`
2375
2376
2377
2378
2379
2380
2381
2382
2383 SeedPeriod string `json:"seedPeriod,omitempty"`
2384
2385
2386
2387
2388
2389
2390 SeedScope string `json:"seedScope,omitempty"`
2391
2392
2393
2394 ShorteningLimits *EnterpriseCrmLoggingGwsFieldLimits `json:"shorteningLimits,omitempty"`
2395
2396
2397
2398
2399
2400
2401
2402 ForceSendFields []string `json:"-"`
2403
2404
2405
2406
2407
2408
2409
2410 NullFields []string `json:"-"`
2411 }
2412
2413 func (s *EnterpriseCrmEventbusProtoLogSettings) MarshalJSON() ([]byte, error) {
2414 type NoMethod EnterpriseCrmEventbusProtoLogSettings
2415 raw := NoMethod(*s)
2416 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2417 }
2418
2419 type EnterpriseCrmEventbusProtoLoopMetadata struct {
2420
2421 CurrentIterationCount int64 `json:"currentIterationCount,omitempty,string"`
2422
2423
2424
2425
2426
2427
2428 CurrentIterationDetail string `json:"currentIterationDetail,omitempty"`
2429
2430
2431 ErrorMsg string `json:"errorMsg,omitempty"`
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445 FailureLocation string `json:"failureLocation,omitempty"`
2446
2447
2448
2449
2450
2451
2452
2453
2454 ForceSendFields []string `json:"-"`
2455
2456
2457
2458
2459
2460
2461
2462
2463 NullFields []string `json:"-"`
2464 }
2465
2466 func (s *EnterpriseCrmEventbusProtoLoopMetadata) MarshalJSON() ([]byte, error) {
2467 type NoMethod EnterpriseCrmEventbusProtoLoopMetadata
2468 raw := NoMethod(*s)
2469 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2470 }
2471
2472
2473
2474 type EnterpriseCrmEventbusProtoMappedField struct {
2475
2476 InputField *EnterpriseCrmEventbusProtoField `json:"inputField,omitempty"`
2477
2478
2479 OutputField *EnterpriseCrmEventbusProtoField `json:"outputField,omitempty"`
2480
2481
2482
2483
2484
2485
2486
2487 ForceSendFields []string `json:"-"`
2488
2489
2490
2491
2492
2493
2494
2495 NullFields []string `json:"-"`
2496 }
2497
2498 func (s *EnterpriseCrmEventbusProtoMappedField) MarshalJSON() ([]byte, error) {
2499 type NoMethod EnterpriseCrmEventbusProtoMappedField
2500 raw := NoMethod(*s)
2501 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2502 }
2503
2504
2505
2506 type EnterpriseCrmEventbusProtoNextTask struct {
2507
2508
2509
2510 CombinedConditions []*EnterpriseCrmEventbusProtoCombinedCondition `json:"combinedConditions,omitempty"`
2511
2512
2513
2514 Condition string `json:"condition,omitempty"`
2515
2516
2517
2518 Description string `json:"description,omitempty"`
2519
2520
2521 Label string `json:"label,omitempty"`
2522
2523
2524 TaskConfigId string `json:"taskConfigId,omitempty"`
2525
2526
2527 TaskNumber string `json:"taskNumber,omitempty"`
2528
2529
2530
2531
2532
2533
2534
2535 ForceSendFields []string `json:"-"`
2536
2537
2538
2539
2540
2541
2542
2543
2544 NullFields []string `json:"-"`
2545 }
2546
2547 func (s *EnterpriseCrmEventbusProtoNextTask) MarshalJSON() ([]byte, error) {
2548 type NoMethod EnterpriseCrmEventbusProtoNextTask
2549 raw := NoMethod(*s)
2550 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2551 }
2552
2553
2554
2555
2556 type EnterpriseCrmEventbusProtoNextTeardownTask struct {
2557
2558 Name string `json:"name,omitempty"`
2559
2560
2561
2562
2563
2564
2565
2566 ForceSendFields []string `json:"-"`
2567
2568
2569
2570
2571
2572
2573
2574 NullFields []string `json:"-"`
2575 }
2576
2577 func (s *EnterpriseCrmEventbusProtoNextTeardownTask) MarshalJSON() ([]byte, error) {
2578 type NoMethod EnterpriseCrmEventbusProtoNextTeardownTask
2579 raw := NoMethod(*s)
2580 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2581 }
2582
2583
2584
2585 type EnterpriseCrmEventbusProtoNodeIdentifier struct {
2586
2587 ElementIdentifier string `json:"elementIdentifier,omitempty"`
2588
2589
2590
2591
2592
2593
2594
2595
2596 ElementType string `json:"elementType,omitempty"`
2597
2598
2599
2600
2601
2602
2603
2604 ForceSendFields []string `json:"-"`
2605
2606
2607
2608
2609
2610
2611
2612
2613 NullFields []string `json:"-"`
2614 }
2615
2616 func (s *EnterpriseCrmEventbusProtoNodeIdentifier) MarshalJSON() ([]byte, error) {
2617 type NoMethod EnterpriseCrmEventbusProtoNodeIdentifier
2618 raw := NoMethod(*s)
2619 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2620 }
2621
2622 type EnterpriseCrmEventbusProtoNotification struct {
2623 BuganizerNotification *EnterpriseCrmEventbusProtoBuganizerNotification `json:"buganizerNotification,omitempty"`
2624
2625 EmailAddress *EnterpriseCrmEventbusProtoAddress `json:"emailAddress,omitempty"`
2626
2627 EscalatorQueue string `json:"escalatorQueue,omitempty"`
2628
2629 PubsubTopic string `json:"pubsubTopic,omitempty"`
2630
2631
2632
2633
2634 Request *EnterpriseCrmEventbusProtoCustomSuspensionRequest `json:"request,omitempty"`
2635
2636
2637
2638
2639
2640
2641
2642
2643 ForceSendFields []string `json:"-"`
2644
2645
2646
2647
2648
2649
2650
2651
2652 NullFields []string `json:"-"`
2653 }
2654
2655 func (s *EnterpriseCrmEventbusProtoNotification) MarshalJSON() ([]byte, error) {
2656 type NoMethod EnterpriseCrmEventbusProtoNotification
2657 raw := NoMethod(*s)
2658 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2659 }
2660
2661 type EnterpriseCrmEventbusProtoParamSpecEntryConfig struct {
2662
2663
2664 DescriptivePhrase string `json:"descriptivePhrase,omitempty"`
2665
2666
2667
2668
2669 HelpText string `json:"helpText,omitempty"`
2670
2671
2672 HideDefaultValue bool `json:"hideDefaultValue,omitempty"`
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682 InputDisplayOption string `json:"inputDisplayOption,omitempty"`
2683
2684
2685 IsHidden bool `json:"isHidden,omitempty"`
2686
2687
2688 Label string `json:"label,omitempty"`
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702 ParameterNameOption string `json:"parameterNameOption,omitempty"`
2703
2704
2705
2706 SubSectionLabel string `json:"subSectionLabel,omitempty"`
2707
2708
2709
2710 UiPlaceholderText string `json:"uiPlaceholderText,omitempty"`
2711
2712
2713
2714
2715
2716
2717
2718 ForceSendFields []string `json:"-"`
2719
2720
2721
2722
2723
2724
2725
2726
2727 NullFields []string `json:"-"`
2728 }
2729
2730 func (s *EnterpriseCrmEventbusProtoParamSpecEntryConfig) MarshalJSON() ([]byte, error) {
2731 type NoMethod EnterpriseCrmEventbusProtoParamSpecEntryConfig
2732 raw := NoMethod(*s)
2733 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2734 }
2735
2736 type EnterpriseCrmEventbusProtoParamSpecEntryProtoDefinition struct {
2737
2738
2739
2740 FullName string `json:"fullName,omitempty"`
2741
2742
2743
2744 Path string `json:"path,omitempty"`
2745
2746
2747
2748
2749
2750
2751
2752 ForceSendFields []string `json:"-"`
2753
2754
2755
2756
2757
2758
2759
2760 NullFields []string `json:"-"`
2761 }
2762
2763 func (s *EnterpriseCrmEventbusProtoParamSpecEntryProtoDefinition) MarshalJSON() ([]byte, error) {
2764 type NoMethod EnterpriseCrmEventbusProtoParamSpecEntryProtoDefinition
2765 raw := NoMethod(*s)
2766 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2767 }
2768
2769 type EnterpriseCrmEventbusProtoParamSpecEntryValidationRule struct {
2770 DoubleRange *EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleDoubleRange `json:"doubleRange,omitempty"`
2771
2772 IntRange *EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleIntRange `json:"intRange,omitempty"`
2773
2774 StringRegex *EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleStringRegex `json:"stringRegex,omitempty"`
2775
2776
2777
2778
2779
2780
2781
2782 ForceSendFields []string `json:"-"`
2783
2784
2785
2786
2787
2788
2789
2790 NullFields []string `json:"-"`
2791 }
2792
2793 func (s *EnterpriseCrmEventbusProtoParamSpecEntryValidationRule) MarshalJSON() ([]byte, error) {
2794 type NoMethod EnterpriseCrmEventbusProtoParamSpecEntryValidationRule
2795 raw := NoMethod(*s)
2796 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2797 }
2798
2799
2800
2801 type EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleDoubleRange struct {
2802
2803 Max float64 `json:"max,omitempty"`
2804
2805
2806 Min float64 `json:"min,omitempty"`
2807
2808
2809
2810
2811
2812
2813
2814 ForceSendFields []string `json:"-"`
2815
2816
2817
2818
2819
2820
2821
2822 NullFields []string `json:"-"`
2823 }
2824
2825 func (s *EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleDoubleRange) MarshalJSON() ([]byte, error) {
2826 type NoMethod EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleDoubleRange
2827 raw := NoMethod(*s)
2828 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2829 }
2830
2831 func (s *EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleDoubleRange) UnmarshalJSON(data []byte) error {
2832 type NoMethod EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleDoubleRange
2833 var s1 struct {
2834 Max gensupport.JSONFloat64 `json:"max"`
2835 Min gensupport.JSONFloat64 `json:"min"`
2836 *NoMethod
2837 }
2838 s1.NoMethod = (*NoMethod)(s)
2839 if err := json.Unmarshal(data, &s1); err != nil {
2840 return err
2841 }
2842 s.Max = float64(s1.Max)
2843 s.Min = float64(s1.Min)
2844 return nil
2845 }
2846
2847
2848
2849 type EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleIntRange struct {
2850
2851 Max int64 `json:"max,omitempty,string"`
2852
2853
2854 Min int64 `json:"min,omitempty,string"`
2855
2856
2857
2858
2859
2860
2861
2862 ForceSendFields []string `json:"-"`
2863
2864
2865
2866
2867
2868
2869
2870 NullFields []string `json:"-"`
2871 }
2872
2873 func (s *EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleIntRange) MarshalJSON() ([]byte, error) {
2874 type NoMethod EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleIntRange
2875 raw := NoMethod(*s)
2876 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2877 }
2878
2879
2880
2881 type EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleStringRegex struct {
2882
2883
2884 Exclusive bool `json:"exclusive,omitempty"`
2885
2886
2887 Regex string `json:"regex,omitempty"`
2888
2889
2890
2891
2892
2893
2894
2895 ForceSendFields []string `json:"-"`
2896
2897
2898
2899
2900
2901
2902
2903 NullFields []string `json:"-"`
2904 }
2905
2906 func (s *EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleStringRegex) MarshalJSON() ([]byte, error) {
2907 type NoMethod EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleStringRegex
2908 raw := NoMethod(*s)
2909 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2910 }
2911
2912
2913
2914 type EnterpriseCrmEventbusProtoParameterEntry struct {
2915
2916
2917
2918 Key string `json:"key,omitempty"`
2919
2920
2921
2922 Value *EnterpriseCrmEventbusProtoParameterValueType `json:"value,omitempty"`
2923
2924
2925
2926
2927
2928
2929
2930 ForceSendFields []string `json:"-"`
2931
2932
2933
2934
2935
2936
2937
2938 NullFields []string `json:"-"`
2939 }
2940
2941 func (s *EnterpriseCrmEventbusProtoParameterEntry) MarshalJSON() ([]byte, error) {
2942 type NoMethod EnterpriseCrmEventbusProtoParameterEntry
2943 raw := NoMethod(*s)
2944 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
2945 }
2946
2947
2948
2949
2950 type EnterpriseCrmEventbusProtoParameterMap struct {
2951 Entries []*EnterpriseCrmEventbusProtoParameterMapEntry `json:"entries,omitempty"`
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977 KeyType string `json:"keyType,omitempty"`
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000 ValueType string `json:"valueType,omitempty"`
3001
3002
3003
3004
3005
3006
3007
3008 ForceSendFields []string `json:"-"`
3009
3010
3011
3012
3013
3014
3015
3016 NullFields []string `json:"-"`
3017 }
3018
3019 func (s *EnterpriseCrmEventbusProtoParameterMap) MarshalJSON() ([]byte, error) {
3020 type NoMethod EnterpriseCrmEventbusProtoParameterMap
3021 raw := NoMethod(*s)
3022 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3023 }
3024
3025
3026
3027 type EnterpriseCrmEventbusProtoParameterMapEntry struct {
3028 Key *EnterpriseCrmEventbusProtoParameterMapField `json:"key,omitempty"`
3029
3030 Value *EnterpriseCrmEventbusProtoParameterMapField `json:"value,omitempty"`
3031
3032
3033
3034
3035
3036
3037
3038 ForceSendFields []string `json:"-"`
3039
3040
3041
3042
3043
3044
3045
3046 NullFields []string `json:"-"`
3047 }
3048
3049 func (s *EnterpriseCrmEventbusProtoParameterMapEntry) MarshalJSON() ([]byte, error) {
3050 type NoMethod EnterpriseCrmEventbusProtoParameterMapEntry
3051 raw := NoMethod(*s)
3052 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3053 }
3054
3055
3056
3057 type EnterpriseCrmEventbusProtoParameterMapField struct {
3058
3059 LiteralValue *EnterpriseCrmEventbusProtoParameterValueType `json:"literalValue,omitempty"`
3060
3061
3062 ReferenceKey string `json:"referenceKey,omitempty"`
3063
3064
3065
3066
3067
3068
3069
3070 ForceSendFields []string `json:"-"`
3071
3072
3073
3074
3075
3076
3077
3078 NullFields []string `json:"-"`
3079 }
3080
3081 func (s *EnterpriseCrmEventbusProtoParameterMapField) MarshalJSON() ([]byte, error) {
3082 type NoMethod EnterpriseCrmEventbusProtoParameterMapField
3083 raw := NoMethod(*s)
3084 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3085 }
3086
3087
3088
3089 type EnterpriseCrmEventbusProtoParameterValueType struct {
3090 BooleanArray *EnterpriseCrmEventbusProtoBooleanParameterArray `json:"booleanArray,omitempty"`
3091
3092 BooleanValue bool `json:"booleanValue,omitempty"`
3093
3094 DoubleArray *EnterpriseCrmEventbusProtoDoubleParameterArray `json:"doubleArray,omitempty"`
3095
3096 DoubleValue float64 `json:"doubleValue,omitempty"`
3097
3098 IntArray *EnterpriseCrmEventbusProtoIntParameterArray `json:"intArray,omitempty"`
3099
3100 IntValue int64 `json:"intValue,omitempty,string"`
3101
3102 ProtoArray *EnterpriseCrmEventbusProtoProtoParameterArray `json:"protoArray,omitempty"`
3103
3104 ProtoValue googleapi.RawMessage `json:"protoValue,omitempty"`
3105
3106 SerializedObjectValue *EnterpriseCrmEventbusProtoSerializedObjectParameter `json:"serializedObjectValue,omitempty"`
3107
3108 StringArray *EnterpriseCrmEventbusProtoStringParameterArray `json:"stringArray,omitempty"`
3109
3110 StringValue string `json:"stringValue,omitempty"`
3111
3112
3113
3114
3115
3116
3117
3118 ForceSendFields []string `json:"-"`
3119
3120
3121
3122
3123
3124
3125
3126 NullFields []string `json:"-"`
3127 }
3128
3129 func (s *EnterpriseCrmEventbusProtoParameterValueType) MarshalJSON() ([]byte, error) {
3130 type NoMethod EnterpriseCrmEventbusProtoParameterValueType
3131 raw := NoMethod(*s)
3132 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3133 }
3134
3135 func (s *EnterpriseCrmEventbusProtoParameterValueType) UnmarshalJSON(data []byte) error {
3136 type NoMethod EnterpriseCrmEventbusProtoParameterValueType
3137 var s1 struct {
3138 DoubleValue gensupport.JSONFloat64 `json:"doubleValue"`
3139 *NoMethod
3140 }
3141 s1.NoMethod = (*NoMethod)(s)
3142 if err := json.Unmarshal(data, &s1); err != nil {
3143 return err
3144 }
3145 s.DoubleValue = float64(s1.DoubleValue)
3146 return nil
3147 }
3148
3149
3150
3151 type EnterpriseCrmEventbusProtoPropertyEntry struct {
3152
3153
3154
3155
3156 Key string `json:"key,omitempty"`
3157
3158
3159
3160 Value *EnterpriseCrmEventbusProtoValueType `json:"value,omitempty"`
3161
3162
3163
3164
3165
3166
3167
3168 ForceSendFields []string `json:"-"`
3169
3170
3171
3172
3173
3174
3175
3176 NullFields []string `json:"-"`
3177 }
3178
3179 func (s *EnterpriseCrmEventbusProtoPropertyEntry) MarshalJSON() ([]byte, error) {
3180 type NoMethod EnterpriseCrmEventbusProtoPropertyEntry
3181 raw := NoMethod(*s)
3182 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3183 }
3184
3185 type EnterpriseCrmEventbusProtoProtoArrayFunction struct {
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200 FunctionName string `json:"functionName,omitempty"`
3201
3202
3203
3204
3205
3206
3207
3208 ForceSendFields []string `json:"-"`
3209
3210
3211
3212
3213
3214
3215
3216 NullFields []string `json:"-"`
3217 }
3218
3219 func (s *EnterpriseCrmEventbusProtoProtoArrayFunction) MarshalJSON() ([]byte, error) {
3220 type NoMethod EnterpriseCrmEventbusProtoProtoArrayFunction
3221 raw := NoMethod(*s)
3222 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3223 }
3224
3225 type EnterpriseCrmEventbusProtoProtoFunction struct {
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242 FunctionName string `json:"functionName,omitempty"`
3243
3244
3245
3246
3247
3248
3249
3250 ForceSendFields []string `json:"-"`
3251
3252
3253
3254
3255
3256
3257
3258 NullFields []string `json:"-"`
3259 }
3260
3261 func (s *EnterpriseCrmEventbusProtoProtoFunction) MarshalJSON() ([]byte, error) {
3262 type NoMethod EnterpriseCrmEventbusProtoProtoFunction
3263 raw := NoMethod(*s)
3264 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3265 }
3266
3267 type EnterpriseCrmEventbusProtoProtoParameterArray struct {
3268 ProtoValues []googleapi.RawMessage `json:"protoValues,omitempty"`
3269
3270
3271
3272
3273
3274
3275
3276 ForceSendFields []string `json:"-"`
3277
3278
3279
3280
3281
3282
3283
3284 NullFields []string `json:"-"`
3285 }
3286
3287 func (s *EnterpriseCrmEventbusProtoProtoParameterArray) MarshalJSON() ([]byte, error) {
3288 type NoMethod EnterpriseCrmEventbusProtoProtoParameterArray
3289 raw := NoMethod(*s)
3290 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3291 }
3292
3293 type EnterpriseCrmEventbusProtoScatterResponse struct {
3294
3295 ErrorMsg string `json:"errorMsg,omitempty"`
3296
3297
3298
3299 ExecutionIds []string `json:"executionIds,omitempty"`
3300
3301
3302
3303
3304
3305
3306 IsSuccessful bool `json:"isSuccessful,omitempty"`
3307
3308
3309
3310 ResponseParams []*EnterpriseCrmEventbusProtoParameterEntry `json:"responseParams,omitempty"`
3311
3312
3313 ScatterElement *EnterpriseCrmEventbusProtoParameterValueType `json:"scatterElement,omitempty"`
3314
3315
3316
3317
3318
3319
3320
3321 ForceSendFields []string `json:"-"`
3322
3323
3324
3325
3326
3327
3328
3329 NullFields []string `json:"-"`
3330 }
3331
3332 func (s *EnterpriseCrmEventbusProtoScatterResponse) MarshalJSON() ([]byte, error) {
3333 type NoMethod EnterpriseCrmEventbusProtoScatterResponse
3334 raw := NoMethod(*s)
3335 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3336 }
3337
3338 type EnterpriseCrmEventbusProtoSerializedObjectParameter struct {
3339 ObjectValue string `json:"objectValue,omitempty"`
3340
3341
3342
3343
3344
3345
3346
3347 ForceSendFields []string `json:"-"`
3348
3349
3350
3351
3352
3353
3354
3355 NullFields []string `json:"-"`
3356 }
3357
3358 func (s *EnterpriseCrmEventbusProtoSerializedObjectParameter) MarshalJSON() ([]byte, error) {
3359 type NoMethod EnterpriseCrmEventbusProtoSerializedObjectParameter
3360 raw := NoMethod(*s)
3361 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3362 }
3363
3364 type EnterpriseCrmEventbusProtoStringArray struct {
3365 Values []string `json:"values,omitempty"`
3366
3367
3368
3369
3370
3371
3372
3373 ForceSendFields []string `json:"-"`
3374
3375
3376
3377
3378
3379
3380
3381 NullFields []string `json:"-"`
3382 }
3383
3384 func (s *EnterpriseCrmEventbusProtoStringArray) MarshalJSON() ([]byte, error) {
3385 type NoMethod EnterpriseCrmEventbusProtoStringArray
3386 raw := NoMethod(*s)
3387 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3388 }
3389
3390 type EnterpriseCrmEventbusProtoStringArrayFunction struct {
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405 FunctionName string `json:"functionName,omitempty"`
3406
3407
3408
3409
3410
3411
3412
3413 ForceSendFields []string `json:"-"`
3414
3415
3416
3417
3418
3419
3420
3421 NullFields []string `json:"-"`
3422 }
3423
3424 func (s *EnterpriseCrmEventbusProtoStringArrayFunction) MarshalJSON() ([]byte, error) {
3425 type NoMethod EnterpriseCrmEventbusProtoStringArrayFunction
3426 raw := NoMethod(*s)
3427 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3428 }
3429
3430 type EnterpriseCrmEventbusProtoStringFunction struct {
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449 FunctionName string `json:"functionName,omitempty"`
3450
3451
3452
3453
3454
3455
3456
3457 ForceSendFields []string `json:"-"`
3458
3459
3460
3461
3462
3463
3464
3465 NullFields []string `json:"-"`
3466 }
3467
3468 func (s *EnterpriseCrmEventbusProtoStringFunction) MarshalJSON() ([]byte, error) {
3469 type NoMethod EnterpriseCrmEventbusProtoStringFunction
3470 raw := NoMethod(*s)
3471 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3472 }
3473
3474 type EnterpriseCrmEventbusProtoStringParameterArray struct {
3475 StringValues []string `json:"stringValues,omitempty"`
3476
3477
3478
3479
3480
3481
3482
3483 ForceSendFields []string `json:"-"`
3484
3485
3486
3487
3488
3489
3490
3491 NullFields []string `json:"-"`
3492 }
3493
3494 func (s *EnterpriseCrmEventbusProtoStringParameterArray) MarshalJSON() ([]byte, error) {
3495 type NoMethod EnterpriseCrmEventbusProtoStringParameterArray
3496 raw := NoMethod(*s)
3497 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3498 }
3499
3500
3501
3502 type EnterpriseCrmEventbusProtoSuccessPolicy struct {
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514 FinalState string `json:"finalState,omitempty"`
3515
3516
3517
3518
3519
3520
3521
3522 ForceSendFields []string `json:"-"`
3523
3524
3525
3526
3527
3528
3529
3530 NullFields []string `json:"-"`
3531 }
3532
3533 func (s *EnterpriseCrmEventbusProtoSuccessPolicy) MarshalJSON() ([]byte, error) {
3534 type NoMethod EnterpriseCrmEventbusProtoSuccessPolicy
3535 raw := NoMethod(*s)
3536 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3537 }
3538
3539
3540 type EnterpriseCrmEventbusProtoSuspensionAuthPermissions struct {
3541
3542
3543 GaiaIdentity *EnterpriseCrmEventbusProtoSuspensionAuthPermissionsGaiaIdentity `json:"gaiaIdentity,omitempty"`
3544
3545 GoogleGroup *EnterpriseCrmEventbusProtoSuspensionAuthPermissionsGaiaIdentity `json:"googleGroup,omitempty"`
3546
3547 LoasRole string `json:"loasRole,omitempty"`
3548
3549 MdbGroup string `json:"mdbGroup,omitempty"`
3550
3551
3552
3553
3554
3555
3556
3557 ForceSendFields []string `json:"-"`
3558
3559
3560
3561
3562
3563
3564
3565 NullFields []string `json:"-"`
3566 }
3567
3568 func (s *EnterpriseCrmEventbusProtoSuspensionAuthPermissions) MarshalJSON() ([]byte, error) {
3569 type NoMethod EnterpriseCrmEventbusProtoSuspensionAuthPermissions
3570 raw := NoMethod(*s)
3571 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3572 }
3573
3574 type EnterpriseCrmEventbusProtoSuspensionAuthPermissionsGaiaIdentity struct {
3575 EmailAddress string `json:"emailAddress,omitempty"`
3576
3577 GaiaId int64 `json:"gaiaId,omitempty,string"`
3578
3579
3580
3581
3582
3583
3584
3585 ForceSendFields []string `json:"-"`
3586
3587
3588
3589
3590
3591
3592
3593 NullFields []string `json:"-"`
3594 }
3595
3596 func (s *EnterpriseCrmEventbusProtoSuspensionAuthPermissionsGaiaIdentity) MarshalJSON() ([]byte, error) {
3597 type NoMethod EnterpriseCrmEventbusProtoSuspensionAuthPermissionsGaiaIdentity
3598 raw := NoMethod(*s)
3599 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3600 }
3601
3602 type EnterpriseCrmEventbusProtoSuspensionConfig struct {
3603
3604
3605
3606 CustomMessage string `json:"customMessage,omitempty"`
3607
3608 Notifications []*EnterpriseCrmEventbusProtoNotification `json:"notifications,omitempty"`
3609
3610
3611
3612 SuspensionExpiration *EnterpriseCrmEventbusProtoSuspensionExpiration `json:"suspensionExpiration,omitempty"`
3613
3614
3615 WhoMayResolve []*EnterpriseCrmEventbusProtoSuspensionAuthPermissions `json:"whoMayResolve,omitempty"`
3616
3617
3618
3619
3620
3621
3622
3623 ForceSendFields []string `json:"-"`
3624
3625
3626
3627
3628
3629
3630
3631 NullFields []string `json:"-"`
3632 }
3633
3634 func (s *EnterpriseCrmEventbusProtoSuspensionConfig) MarshalJSON() ([]byte, error) {
3635 type NoMethod EnterpriseCrmEventbusProtoSuspensionConfig
3636 raw := NoMethod(*s)
3637 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3638 }
3639
3640 type EnterpriseCrmEventbusProtoSuspensionExpiration struct {
3641
3642
3643 ExpireAfterMs int64 `json:"expireAfterMs,omitempty"`
3644
3645
3646
3647 LiftWhenExpired bool `json:"liftWhenExpired,omitempty"`
3648
3649
3650
3651
3652 RemindAfterMs int64 `json:"remindAfterMs,omitempty"`
3653
3654
3655
3656
3657
3658
3659
3660 ForceSendFields []string `json:"-"`
3661
3662
3663
3664
3665
3666
3667
3668 NullFields []string `json:"-"`
3669 }
3670
3671 func (s *EnterpriseCrmEventbusProtoSuspensionExpiration) MarshalJSON() ([]byte, error) {
3672 type NoMethod EnterpriseCrmEventbusProtoSuspensionExpiration
3673 raw := NoMethod(*s)
3674 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3675 }
3676
3677 type EnterpriseCrmEventbusProtoSuspensionResolutionInfo struct {
3678 Audit *EnterpriseCrmEventbusProtoSuspensionResolutionInfoAudit `json:"audit,omitempty"`
3679
3680
3681 CreatedTimestamp string `json:"createdTimestamp,omitempty"`
3682
3683
3684 EventExecutionInfoId string `json:"eventExecutionInfoId,omitempty"`
3685
3686
3687
3688 ExternalTraffic *EnterpriseCrmEventbusProtoExternalTraffic `json:"externalTraffic,omitempty"`
3689
3690
3691 LastModifiedTimestamp string `json:"lastModifiedTimestamp,omitempty"`
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701 Product string `json:"product,omitempty"`
3702
3703
3704
3705
3706
3707 Status string `json:"status,omitempty"`
3708
3709 SuspensionConfig *EnterpriseCrmEventbusProtoSuspensionConfig `json:"suspensionConfig,omitempty"`
3710
3711
3712 SuspensionId string `json:"suspensionId,omitempty"`
3713
3714
3715 TaskNumber string `json:"taskNumber,omitempty"`
3716
3717
3718 WorkflowName string `json:"workflowName,omitempty"`
3719
3720
3721
3722
3723
3724
3725
3726 ForceSendFields []string `json:"-"`
3727
3728
3729
3730
3731
3732
3733
3734 NullFields []string `json:"-"`
3735 }
3736
3737 func (s *EnterpriseCrmEventbusProtoSuspensionResolutionInfo) MarshalJSON() ([]byte, error) {
3738 type NoMethod EnterpriseCrmEventbusProtoSuspensionResolutionInfo
3739 raw := NoMethod(*s)
3740 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3741 }
3742
3743 type EnterpriseCrmEventbusProtoSuspensionResolutionInfoAudit struct {
3744 ResolvedBy string `json:"resolvedBy,omitempty"`
3745
3746 ResolvedByCpi string `json:"resolvedByCpi,omitempty"`
3747
3748 Timestamp string `json:"timestamp,omitempty"`
3749
3750
3751
3752
3753
3754
3755
3756 ForceSendFields []string `json:"-"`
3757
3758
3759
3760
3761
3762
3763
3764 NullFields []string `json:"-"`
3765 }
3766
3767 func (s *EnterpriseCrmEventbusProtoSuspensionResolutionInfoAudit) MarshalJSON() ([]byte, error) {
3768 type NoMethod EnterpriseCrmEventbusProtoSuspensionResolutionInfoAudit
3769 raw := NoMethod(*s)
3770 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3771 }
3772
3773
3774
3775
3776
3777 type EnterpriseCrmEventbusProtoTaskAlertConfig struct {
3778
3779
3780
3781
3782 AggregationPeriod string `json:"aggregationPeriod,omitempty"`
3783
3784
3785
3786 AlertDisabled bool `json:"alertDisabled,omitempty"`
3787
3788
3789
3790
3791 AlertName string `json:"alertName,omitempty"`
3792
3793
3794
3795 ClientId string `json:"clientId,omitempty"`
3796
3797
3798
3799
3800
3801 DurationThresholdMs int64 `json:"durationThresholdMs,omitempty,string"`
3802
3803 ErrorEnumList *EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList `json:"errorEnumList,omitempty"`
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822 MetricType string `json:"metricType,omitempty"`
3823
3824
3825
3826 NumAggregationPeriods int64 `json:"numAggregationPeriods,omitempty"`
3827
3828
3829 OnlyFinalAttempt bool `json:"onlyFinalAttempt,omitempty"`
3830
3831
3832
3833 PlaybookUrl string `json:"playbookUrl,omitempty"`
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847 ThresholdType string `json:"thresholdType,omitempty"`
3848
3849
3850
3851 ThresholdValue *EnterpriseCrmEventbusProtoBaseAlertConfigThresholdValue `json:"thresholdValue,omitempty"`
3852
3853 WarningEnumList *EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList `json:"warningEnumList,omitempty"`
3854
3855
3856
3857
3858
3859
3860
3861 ForceSendFields []string `json:"-"`
3862
3863
3864
3865
3866
3867
3868
3869
3870 NullFields []string `json:"-"`
3871 }
3872
3873 func (s *EnterpriseCrmEventbusProtoTaskAlertConfig) MarshalJSON() ([]byte, error) {
3874 type NoMethod EnterpriseCrmEventbusProtoTaskAlertConfig
3875 raw := NoMethod(*s)
3876 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3877 }
3878
3879
3880
3881 type EnterpriseCrmEventbusProtoTaskExecutionDetails struct {
3882 TaskAttemptStats []*EnterpriseCrmEventbusProtoTaskExecutionDetailsTaskAttemptStats `json:"taskAttemptStats,omitempty"`
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909 TaskExecutionState string `json:"taskExecutionState,omitempty"`
3910
3911
3912 TaskNumber string `json:"taskNumber,omitempty"`
3913
3914
3915
3916
3917
3918
3919
3920 ForceSendFields []string `json:"-"`
3921
3922
3923
3924
3925
3926
3927
3928
3929 NullFields []string `json:"-"`
3930 }
3931
3932 func (s *EnterpriseCrmEventbusProtoTaskExecutionDetails) MarshalJSON() ([]byte, error) {
3933 type NoMethod EnterpriseCrmEventbusProtoTaskExecutionDetails
3934 raw := NoMethod(*s)
3935 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3936 }
3937
3938 type EnterpriseCrmEventbusProtoTaskExecutionDetailsTaskAttemptStats struct {
3939
3940 EndTime int64 `json:"endTime,omitempty,string"`
3941
3942
3943
3944 StartTime int64 `json:"startTime,omitempty,string"`
3945
3946
3947
3948
3949
3950
3951
3952 ForceSendFields []string `json:"-"`
3953
3954
3955
3956
3957
3958
3959
3960 NullFields []string `json:"-"`
3961 }
3962
3963 func (s *EnterpriseCrmEventbusProtoTaskExecutionDetailsTaskAttemptStats) MarshalJSON() ([]byte, error) {
3964 type NoMethod EnterpriseCrmEventbusProtoTaskExecutionDetailsTaskAttemptStats
3965 raw := NoMethod(*s)
3966 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
3967 }
3968
3969
3970
3971 type EnterpriseCrmEventbusProtoTaskMetadata struct {
3972
3973
3974 ActiveTaskName string `json:"activeTaskName,omitempty"`
3975
3976 Admins []*EnterpriseCrmEventbusProtoTaskMetadataAdmin `json:"admins,omitempty"`
3977
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989
3990
3991
3992 Category string `json:"category,omitempty"`
3993
3994
3995 CodeSearchLink string `json:"codeSearchLink,omitempty"`
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012 DefaultJsonValidationOption string `json:"defaultJsonValidationOption,omitempty"`
4013
4014
4015
4016
4017 DefaultSpec string `json:"defaultSpec,omitempty"`
4018
4019
4020
4021 Description string `json:"description,omitempty"`
4022
4023
4024
4025
4026 DescriptiveName string `json:"descriptiveName,omitempty"`
4027
4028
4029
4030 DocMarkdown string `json:"docMarkdown,omitempty"`
4031
4032
4033
4034
4035
4036 ExternalCategory string `json:"externalCategory,omitempty"`
4037
4038
4039
4040 ExternalCategorySequence int64 `json:"externalCategorySequence,omitempty"`
4041
4042
4043
4044 ExternalDocHtml string `json:"externalDocHtml,omitempty"`
4045
4046
4047
4048 ExternalDocLink string `json:"externalDocLink,omitempty"`
4049
4050
4051 ExternalDocMarkdown string `json:"externalDocMarkdown,omitempty"`
4052
4053
4054 G3DocLink string `json:"g3DocLink,omitempty"`
4055
4056
4057
4058
4059
4060 IconLink string `json:"iconLink,omitempty"`
4061
4062
4063
4064 IsDeprecated bool `json:"isDeprecated,omitempty"`
4065
4066
4067
4068
4069 Name string `json:"name,omitempty"`
4070
4071
4072
4073
4074 StandaloneExternalDocHtml string `json:"standaloneExternalDocHtml,omitempty"`
4075
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086 Status string `json:"status,omitempty"`
4087
4088
4089
4090
4091
4092
4093
4094
4095
4096
4097
4098
4099
4100 System string `json:"system,omitempty"`
4101
4102
4103
4104
4105
4106 Tags []string `json:"tags,omitempty"`
4107
4108
4109
4110
4111
4112
4113
4114 ForceSendFields []string `json:"-"`
4115
4116
4117
4118
4119
4120
4121
4122
4123 NullFields []string `json:"-"`
4124 }
4125
4126 func (s *EnterpriseCrmEventbusProtoTaskMetadata) MarshalJSON() ([]byte, error) {
4127 type NoMethod EnterpriseCrmEventbusProtoTaskMetadata
4128 raw := NoMethod(*s)
4129 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4130 }
4131
4132
4133
4134
4135
4136 type EnterpriseCrmEventbusProtoTaskMetadataAdmin struct {
4137 GoogleGroupEmail string `json:"googleGroupEmail,omitempty"`
4138
4139 UserEmail string `json:"userEmail,omitempty"`
4140
4141
4142
4143
4144
4145
4146
4147 ForceSendFields []string `json:"-"`
4148
4149
4150
4151
4152
4153
4154
4155
4156 NullFields []string `json:"-"`
4157 }
4158
4159 func (s *EnterpriseCrmEventbusProtoTaskMetadataAdmin) MarshalJSON() ([]byte, error) {
4160 type NoMethod EnterpriseCrmEventbusProtoTaskMetadataAdmin
4161 raw := NoMethod(*s)
4162 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4163 }
4164
4165
4166
4167
4168
4169
4170 type EnterpriseCrmEventbusProtoTaskUiConfig struct {
4171
4172 TaskUiModuleConfigs []*EnterpriseCrmEventbusProtoTaskUiModuleConfig `json:"taskUiModuleConfigs,omitempty"`
4173
4174
4175
4176
4177
4178
4179
4180 ForceSendFields []string `json:"-"`
4181
4182
4183
4184
4185
4186
4187
4188
4189 NullFields []string `json:"-"`
4190 }
4191
4192 func (s *EnterpriseCrmEventbusProtoTaskUiConfig) MarshalJSON() ([]byte, error) {
4193 type NoMethod EnterpriseCrmEventbusProtoTaskUiConfig
4194 raw := NoMethod(*s)
4195 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4196 }
4197
4198
4199
4200 type EnterpriseCrmEventbusProtoTaskUiModuleConfig struct {
4201
4202
4203
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234 ModuleId string `json:"moduleId,omitempty"`
4235
4236
4237
4238
4239
4240
4241
4242 ForceSendFields []string `json:"-"`
4243
4244
4245
4246
4247
4248
4249
4250 NullFields []string `json:"-"`
4251 }
4252
4253 func (s *EnterpriseCrmEventbusProtoTaskUiModuleConfig) MarshalJSON() ([]byte, error) {
4254 type NoMethod EnterpriseCrmEventbusProtoTaskUiModuleConfig
4255 raw := NoMethod(*s)
4256 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4257 }
4258
4259 type EnterpriseCrmEventbusProtoTeardown struct {
4260
4261 TeardownTaskConfigs []*EnterpriseCrmEventbusProtoTeardownTaskConfig `json:"teardownTaskConfigs,omitempty"`
4262
4263
4264
4265
4266
4267
4268
4269 ForceSendFields []string `json:"-"`
4270
4271
4272
4273
4274
4275
4276
4277
4278 NullFields []string `json:"-"`
4279 }
4280
4281 func (s *EnterpriseCrmEventbusProtoTeardown) MarshalJSON() ([]byte, error) {
4282 type NoMethod EnterpriseCrmEventbusProtoTeardown
4283 raw := NoMethod(*s)
4284 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4285 }
4286
4287 type EnterpriseCrmEventbusProtoTeardownTaskConfig struct {
4288
4289 CreatorEmail string `json:"creatorEmail,omitempty"`
4290
4291
4292
4293
4294 Name string `json:"name,omitempty"`
4295
4296 NextTeardownTask *EnterpriseCrmEventbusProtoNextTeardownTask `json:"nextTeardownTask,omitempty"`
4297
4298
4299 Parameters *EnterpriseCrmEventbusProtoEventParameters `json:"parameters,omitempty"`
4300
4301 Properties *EnterpriseCrmEventbusProtoEventBusProperties `json:"properties,omitempty"`
4302
4303
4304
4305 TeardownTaskImplementationClassName string `json:"teardownTaskImplementationClassName,omitempty"`
4306
4307
4308
4309
4310
4311
4312
4313 ForceSendFields []string `json:"-"`
4314
4315
4316
4317
4318
4319
4320
4321 NullFields []string `json:"-"`
4322 }
4323
4324 func (s *EnterpriseCrmEventbusProtoTeardownTaskConfig) MarshalJSON() ([]byte, error) {
4325 type NoMethod EnterpriseCrmEventbusProtoTeardownTaskConfig
4326 raw := NoMethod(*s)
4327 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4328 }
4329
4330 type EnterpriseCrmEventbusProtoToken struct {
4331 Name string `json:"name,omitempty"`
4332
4333 Value string `json:"value,omitempty"`
4334
4335
4336
4337
4338
4339
4340
4341 ForceSendFields []string `json:"-"`
4342
4343
4344
4345
4346
4347
4348
4349 NullFields []string `json:"-"`
4350 }
4351
4352 func (s *EnterpriseCrmEventbusProtoToken) MarshalJSON() ([]byte, error) {
4353 type NoMethod EnterpriseCrmEventbusProtoToken
4354 raw := NoMethod(*s)
4355 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4356 }
4357
4358 type EnterpriseCrmEventbusProtoTransformExpression struct {
4359
4360 InitialValue *EnterpriseCrmEventbusProtoBaseValue `json:"initialValue,omitempty"`
4361
4362
4363 TransformationFunctions []*EnterpriseCrmEventbusProtoFunction `json:"transformationFunctions,omitempty"`
4364
4365
4366
4367
4368
4369
4370
4371 ForceSendFields []string `json:"-"`
4372
4373
4374
4375
4376
4377
4378
4379 NullFields []string `json:"-"`
4380 }
4381
4382 func (s *EnterpriseCrmEventbusProtoTransformExpression) MarshalJSON() ([]byte, error) {
4383 type NoMethod EnterpriseCrmEventbusProtoTransformExpression
4384 raw := NoMethod(*s)
4385 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4386 }
4387
4388 type EnterpriseCrmEventbusProtoTriggerCriteria struct {
4389
4390
4391
4392
4393 Condition string `json:"condition,omitempty"`
4394
4395
4396
4397 Parameters *EnterpriseCrmEventbusProtoEventParameters `json:"parameters,omitempty"`
4398
4399
4400
4401 TriggerCriteriaTaskImplementationClassName string `json:"triggerCriteriaTaskImplementationClassName,omitempty"`
4402
4403
4404
4405
4406
4407
4408
4409 ForceSendFields []string `json:"-"`
4410
4411
4412
4413
4414
4415
4416
4417 NullFields []string `json:"-"`
4418 }
4419
4420 func (s *EnterpriseCrmEventbusProtoTriggerCriteria) MarshalJSON() ([]byte, error) {
4421 type NoMethod EnterpriseCrmEventbusProtoTriggerCriteria
4422 raw := NoMethod(*s)
4423 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4424 }
4425
4426
4427
4428
4429 type EnterpriseCrmEventbusProtoValueType struct {
4430 BooleanValue bool `json:"booleanValue,omitempty"`
4431
4432 DoubleArray *EnterpriseCrmEventbusProtoDoubleArray `json:"doubleArray,omitempty"`
4433
4434 DoubleValue float64 `json:"doubleValue,omitempty"`
4435
4436 IntArray *EnterpriseCrmEventbusProtoIntArray `json:"intArray,omitempty"`
4437
4438 IntValue int64 `json:"intValue,omitempty,string"`
4439
4440 ProtoValue googleapi.RawMessage `json:"protoValue,omitempty"`
4441
4442 StringArray *EnterpriseCrmEventbusProtoStringArray `json:"stringArray,omitempty"`
4443
4444 StringValue string `json:"stringValue,omitempty"`
4445
4446
4447
4448
4449
4450
4451
4452 ForceSendFields []string `json:"-"`
4453
4454
4455
4456
4457
4458
4459
4460 NullFields []string `json:"-"`
4461 }
4462
4463 func (s *EnterpriseCrmEventbusProtoValueType) MarshalJSON() ([]byte, error) {
4464 type NoMethod EnterpriseCrmEventbusProtoValueType
4465 raw := NoMethod(*s)
4466 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4467 }
4468
4469 func (s *EnterpriseCrmEventbusProtoValueType) UnmarshalJSON(data []byte) error {
4470 type NoMethod EnterpriseCrmEventbusProtoValueType
4471 var s1 struct {
4472 DoubleValue gensupport.JSONFloat64 `json:"doubleValue"`
4473 *NoMethod
4474 }
4475 s1.NoMethod = (*NoMethod)(s)
4476 if err := json.Unmarshal(data, &s1); err != nil {
4477 return err
4478 }
4479 s.DoubleValue = float64(s1.DoubleValue)
4480 return nil
4481 }
4482
4483
4484
4485
4486
4487 type EnterpriseCrmEventbusProtoWorkflowAlertConfig struct {
4488
4489
4490 AggregationPeriod string `json:"aggregationPeriod,omitempty"`
4491
4492
4493
4494 AlertDisabled bool `json:"alertDisabled,omitempty"`
4495
4496
4497
4498
4499 AlertName string `json:"alertName,omitempty"`
4500
4501
4502 ClientId string `json:"clientId,omitempty"`
4503
4504
4505
4506
4507
4508 DurationThresholdMs int64 `json:"durationThresholdMs,omitempty,string"`
4509
4510 ErrorEnumList *EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList `json:"errorEnumList,omitempty"`
4511
4512
4513
4514
4515
4516
4517
4518
4519
4520
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541 MetricType string `json:"metricType,omitempty"`
4542
4543
4544
4545 NumAggregationPeriods int64 `json:"numAggregationPeriods,omitempty"`
4546
4547
4548
4549 OnlyFinalAttempt bool `json:"onlyFinalAttempt,omitempty"`
4550
4551
4552
4553 PlaybookUrl string `json:"playbookUrl,omitempty"`
4554
4555
4556
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568 ThresholdType string `json:"thresholdType,omitempty"`
4569
4570
4571
4572 ThresholdValue *EnterpriseCrmEventbusProtoBaseAlertConfigThresholdValue `json:"thresholdValue,omitempty"`
4573
4574 WarningEnumList *EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList `json:"warningEnumList,omitempty"`
4575
4576
4577
4578
4579
4580
4581
4582 ForceSendFields []string `json:"-"`
4583
4584
4585
4586
4587
4588
4589
4590
4591 NullFields []string `json:"-"`
4592 }
4593
4594 func (s *EnterpriseCrmEventbusProtoWorkflowAlertConfig) MarshalJSON() ([]byte, error) {
4595 type NoMethod EnterpriseCrmEventbusProtoWorkflowAlertConfig
4596 raw := NoMethod(*s)
4597 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4598 }
4599
4600
4601
4602 type EnterpriseCrmEventbusStats struct {
4603
4604 Dimensions *EnterpriseCrmEventbusStatsDimensions `json:"dimensions,omitempty"`
4605
4606
4607 DurationInSeconds float64 `json:"durationInSeconds,omitempty"`
4608
4609
4610 ErrorRate float64 `json:"errorRate,omitempty"`
4611
4612
4613 Qps float64 `json:"qps,omitempty"`
4614
4615
4616 WarningRate float64 `json:"warningRate,omitempty"`
4617
4618
4619
4620
4621
4622
4623
4624 ForceSendFields []string `json:"-"`
4625
4626
4627
4628
4629
4630
4631
4632 NullFields []string `json:"-"`
4633 }
4634
4635 func (s *EnterpriseCrmEventbusStats) MarshalJSON() ([]byte, error) {
4636 type NoMethod EnterpriseCrmEventbusStats
4637 raw := NoMethod(*s)
4638 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4639 }
4640
4641 func (s *EnterpriseCrmEventbusStats) UnmarshalJSON(data []byte) error {
4642 type NoMethod EnterpriseCrmEventbusStats
4643 var s1 struct {
4644 DurationInSeconds gensupport.JSONFloat64 `json:"durationInSeconds"`
4645 ErrorRate gensupport.JSONFloat64 `json:"errorRate"`
4646 Qps gensupport.JSONFloat64 `json:"qps"`
4647 WarningRate gensupport.JSONFloat64 `json:"warningRate"`
4648 *NoMethod
4649 }
4650 s1.NoMethod = (*NoMethod)(s)
4651 if err := json.Unmarshal(data, &s1); err != nil {
4652 return err
4653 }
4654 s.DurationInSeconds = float64(s1.DurationInSeconds)
4655 s.ErrorRate = float64(s1.ErrorRate)
4656 s.Qps = float64(s1.Qps)
4657 s.WarningRate = float64(s1.WarningRate)
4658 return nil
4659 }
4660
4661 type EnterpriseCrmEventbusStatsDimensions struct {
4662 ClientId string `json:"clientId,omitempty"`
4663
4664
4665
4666
4667
4668
4669
4670 EnumFilterType string `json:"enumFilterType,omitempty"`
4671
4672 ErrorEnumString string `json:"errorEnumString,omitempty"`
4673
4674
4675
4676
4677
4678
4679
4680 RetryAttempt string `json:"retryAttempt,omitempty"`
4681
4682 TaskName string `json:"taskName,omitempty"`
4683
4684 TaskNumber string `json:"taskNumber,omitempty"`
4685
4686
4687
4688 TriggerId string `json:"triggerId,omitempty"`
4689
4690 WarningEnumString string `json:"warningEnumString,omitempty"`
4691
4692 WorkflowId string `json:"workflowId,omitempty"`
4693
4694 WorkflowName string `json:"workflowName,omitempty"`
4695
4696
4697
4698
4699
4700
4701
4702 ForceSendFields []string `json:"-"`
4703
4704
4705
4706
4707
4708
4709
4710 NullFields []string `json:"-"`
4711 }
4712
4713 func (s *EnterpriseCrmEventbusStatsDimensions) MarshalJSON() ([]byte, error) {
4714 type NoMethod EnterpriseCrmEventbusStatsDimensions
4715 raw := NoMethod(*s)
4716 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4717 }
4718
4719 type EnterpriseCrmFrontendsEventbusProtoBooleanParameterArray struct {
4720 BooleanValues []bool `json:"booleanValues,omitempty"`
4721
4722
4723
4724
4725
4726
4727
4728 ForceSendFields []string `json:"-"`
4729
4730
4731
4732
4733
4734
4735
4736 NullFields []string `json:"-"`
4737 }
4738
4739 func (s *EnterpriseCrmFrontendsEventbusProtoBooleanParameterArray) MarshalJSON() ([]byte, error) {
4740 type NoMethod EnterpriseCrmFrontendsEventbusProtoBooleanParameterArray
4741 raw := NoMethod(*s)
4742 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4743 }
4744
4745 type EnterpriseCrmFrontendsEventbusProtoDoubleParameterArray struct {
4746 DoubleValues []float64 `json:"doubleValues,omitempty"`
4747
4748
4749
4750
4751
4752
4753
4754 ForceSendFields []string `json:"-"`
4755
4756
4757
4758
4759
4760
4761
4762 NullFields []string `json:"-"`
4763 }
4764
4765 func (s *EnterpriseCrmFrontendsEventbusProtoDoubleParameterArray) MarshalJSON() ([]byte, error) {
4766 type NoMethod EnterpriseCrmFrontendsEventbusProtoDoubleParameterArray
4767 raw := NoMethod(*s)
4768 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4769 }
4770
4771
4772
4773
4774
4775 type EnterpriseCrmFrontendsEventbusProtoEventExecutionDetails struct {
4776 EventAttemptStats []*EnterpriseCrmEventbusProtoEventExecutionDetailsEventAttemptStats `json:"eventAttemptStats,omitempty"`
4777
4778
4779
4780
4781 EventExecutionSnapshot []*EnterpriseCrmFrontendsEventbusProtoEventExecutionSnapshot `json:"eventExecutionSnapshot,omitempty"`
4782
4783
4784
4785
4786
4787
4788
4789
4790
4791
4792
4793
4794
4795
4796
4797
4798
4799 EventExecutionState string `json:"eventExecutionState,omitempty"`
4800
4801
4802
4803 EventRetriesFromBeginningCount int64 `json:"eventRetriesFromBeginningCount,omitempty"`
4804
4805
4806 LogFilePath string `json:"logFilePath,omitempty"`
4807
4808
4809
4810 NetworkAddress string `json:"networkAddress,omitempty"`
4811
4812
4813
4814 NextExecutionTime int64 `json:"nextExecutionTime,omitempty,string"`
4815
4816
4817
4818
4819 RyeLockUnheldCount int64 `json:"ryeLockUnheldCount,omitempty"`
4820
4821
4822
4823
4824
4825
4826
4827 ForceSendFields []string `json:"-"`
4828
4829
4830
4831
4832
4833
4834
4835
4836 NullFields []string `json:"-"`
4837 }
4838
4839 func (s *EnterpriseCrmFrontendsEventbusProtoEventExecutionDetails) MarshalJSON() ([]byte, error) {
4840 type NoMethod EnterpriseCrmFrontendsEventbusProtoEventExecutionDetails
4841 raw := NoMethod(*s)
4842 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4843 }
4844
4845
4846
4847 type EnterpriseCrmFrontendsEventbusProtoEventExecutionInfo struct {
4848
4849 ClientId string `json:"clientId,omitempty"`
4850
4851
4852 CreateTime int64 `json:"createTime,omitempty,string"`
4853
4854
4855 ErrorCode *CrmlogErrorCode `json:"errorCode,omitempty"`
4856
4857
4858
4859
4860 Errors []*EnterpriseCrmEventbusProtoErrorDetail `json:"errors,omitempty"`
4861
4862
4863 EventExecutionDetails *EnterpriseCrmFrontendsEventbusProtoEventExecutionDetails `json:"eventExecutionDetails,omitempty"`
4864
4865
4866 EventExecutionInfoId string `json:"eventExecutionInfoId,omitempty"`
4867
4868
4869
4870 ExecutionTraceInfo *EnterpriseCrmEventbusProtoExecutionTraceInfo `json:"executionTraceInfo,omitempty"`
4871
4872
4873 LastModifiedTime int64 `json:"lastModifiedTime,omitempty,string"`
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884 PostMethod string `json:"postMethod,omitempty"`
4885
4886
4887
4888
4889
4890
4891
4892
4893
4894 Product string `json:"product,omitempty"`
4895
4896
4897 RequestId string `json:"requestId,omitempty"`
4898
4899
4900 RequestParams *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"requestParams,omitempty"`
4901
4902
4903 ResponseParams *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"responseParams,omitempty"`
4904
4905
4906 SnapshotNumber int64 `json:"snapshotNumber,omitempty,string"`
4907
4908
4909
4910 Tenant string `json:"tenant,omitempty"`
4911
4912
4913
4914
4915
4916 TriggerId string `json:"triggerId,omitempty"`
4917
4918
4919 WorkflowId string `json:"workflowId,omitempty"`
4920
4921
4922 WorkflowName string `json:"workflowName,omitempty"`
4923
4924
4925
4926
4927 WorkflowRetryBackoffIntervalSeconds int64 `json:"workflowRetryBackoffIntervalSeconds,omitempty,string"`
4928
4929
4930
4931
4932
4933
4934
4935 ForceSendFields []string `json:"-"`
4936
4937
4938
4939
4940
4941
4942
4943 NullFields []string `json:"-"`
4944 }
4945
4946 func (s *EnterpriseCrmFrontendsEventbusProtoEventExecutionInfo) MarshalJSON() ([]byte, error) {
4947 type NoMethod EnterpriseCrmFrontendsEventbusProtoEventExecutionInfo
4948 raw := NoMethod(*s)
4949 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
4950 }
4951
4952 type EnterpriseCrmFrontendsEventbusProtoEventExecutionSnapshot struct {
4953
4954
4955 CheckpointTaskNumber string `json:"checkpointTaskNumber,omitempty"`
4956
4957
4958
4959 ConditionResults []*EnterpriseCrmEventbusProtoConditionResult `json:"conditionResults,omitempty"`
4960
4961
4962
4963 DiffParams *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"diffParams,omitempty"`
4964
4965
4966
4967 EventExecutionInfoId string `json:"eventExecutionInfoId,omitempty"`
4968
4969
4970
4971 EventExecutionSnapshotId string `json:"eventExecutionSnapshotId,omitempty"`
4972
4973 EventExecutionSnapshotMetadata *EnterpriseCrmEventbusProtoEventExecutionSnapshotEventExecutionSnapshotMetadata `json:"eventExecutionSnapshotMetadata,omitempty"`
4974
4975
4976 EventParams *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"eventParams,omitempty"`
4977
4978
4979 SnapshotTime int64 `json:"snapshotTime,omitempty,string"`
4980
4981
4982
4983 TaskExecutionDetails []*EnterpriseCrmEventbusProtoTaskExecutionDetails `json:"taskExecutionDetails,omitempty"`
4984
4985
4986
4987 TaskName string `json:"taskName,omitempty"`
4988
4989
4990
4991
4992
4993
4994
4995
4996 ForceSendFields []string `json:"-"`
4997
4998
4999
5000
5001
5002
5003
5004
5005 NullFields []string `json:"-"`
5006 }
5007
5008 func (s *EnterpriseCrmFrontendsEventbusProtoEventExecutionSnapshot) MarshalJSON() ([]byte, error) {
5009 type NoMethod EnterpriseCrmFrontendsEventbusProtoEventExecutionSnapshot
5010 raw := NoMethod(*s)
5011 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5012 }
5013
5014
5015
5016
5017
5018 type EnterpriseCrmFrontendsEventbusProtoEventParameters struct {
5019
5020
5021
5022 Parameters []*EnterpriseCrmFrontendsEventbusProtoParameterEntry `json:"parameters,omitempty"`
5023
5024
5025
5026
5027
5028
5029
5030 ForceSendFields []string `json:"-"`
5031
5032
5033
5034
5035
5036
5037
5038 NullFields []string `json:"-"`
5039 }
5040
5041 func (s *EnterpriseCrmFrontendsEventbusProtoEventParameters) MarshalJSON() ([]byte, error) {
5042 type NoMethod EnterpriseCrmFrontendsEventbusProtoEventParameters
5043 raw := NoMethod(*s)
5044 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5045 }
5046
5047 type EnterpriseCrmFrontendsEventbusProtoIntParameterArray struct {
5048 IntValues googleapi.Int64s `json:"intValues,omitempty"`
5049
5050
5051
5052
5053
5054
5055
5056 ForceSendFields []string `json:"-"`
5057
5058
5059
5060
5061
5062
5063
5064 NullFields []string `json:"-"`
5065 }
5066
5067 func (s *EnterpriseCrmFrontendsEventbusProtoIntParameterArray) MarshalJSON() ([]byte, error) {
5068 type NoMethod EnterpriseCrmFrontendsEventbusProtoIntParameterArray
5069 raw := NoMethod(*s)
5070 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5071 }
5072
5073
5074
5075 type EnterpriseCrmFrontendsEventbusProtoParamSpecEntry struct {
5076
5077
5078
5079 ClassName string `json:"className,omitempty"`
5080
5081
5082
5083
5084
5085 CollectionElementClassName string `json:"collectionElementClassName,omitempty"`
5086
5087
5088 Config *EnterpriseCrmEventbusProtoParamSpecEntryConfig `json:"config,omitempty"`
5089
5090
5091
5092
5093
5094
5095
5096
5097
5098
5099
5100
5101
5102
5103
5104
5105
5106
5107
5108
5109
5110
5111
5112
5113 DataType string `json:"dataType,omitempty"`
5114
5115
5116
5117
5118 DefaultValue *EnterpriseCrmFrontendsEventbusProtoParameterValueType `json:"defaultValue,omitempty"`
5119
5120
5121
5122 IsDeprecated bool `json:"isDeprecated,omitempty"`
5123
5124 IsOutput bool `json:"isOutput,omitempty"`
5125
5126
5127
5128 JsonSchema string `json:"jsonSchema,omitempty"`
5129
5130
5131
5132
5133 Key string `json:"key,omitempty"`
5134
5135
5136 ProtoDef *EnterpriseCrmEventbusProtoParamSpecEntryProtoDefinition `json:"protoDef,omitempty"`
5137
5138
5139
5140 Required bool `json:"required,omitempty"`
5141
5142
5143
5144 ValidationRule *EnterpriseCrmEventbusProtoParamSpecEntryValidationRule `json:"validationRule,omitempty"`
5145
5146
5147
5148
5149
5150
5151
5152 ForceSendFields []string `json:"-"`
5153
5154
5155
5156
5157
5158
5159
5160 NullFields []string `json:"-"`
5161 }
5162
5163 func (s *EnterpriseCrmFrontendsEventbusProtoParamSpecEntry) MarshalJSON() ([]byte, error) {
5164 type NoMethod EnterpriseCrmFrontendsEventbusProtoParamSpecEntry
5165 raw := NoMethod(*s)
5166 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5167 }
5168
5169 type EnterpriseCrmFrontendsEventbusProtoParamSpecsMessage struct {
5170 Parameters []*EnterpriseCrmFrontendsEventbusProtoParamSpecEntry `json:"parameters,omitempty"`
5171
5172
5173
5174
5175
5176
5177
5178 ForceSendFields []string `json:"-"`
5179
5180
5181
5182
5183
5184
5185
5186 NullFields []string `json:"-"`
5187 }
5188
5189 func (s *EnterpriseCrmFrontendsEventbusProtoParamSpecsMessage) MarshalJSON() ([]byte, error) {
5190 type NoMethod EnterpriseCrmFrontendsEventbusProtoParamSpecsMessage
5191 raw := NoMethod(*s)
5192 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5193 }
5194
5195
5196
5197 type EnterpriseCrmFrontendsEventbusProtoParameterEntry struct {
5198
5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
5212
5213
5214
5215
5216
5217
5218
5219
5220
5221 DataType string `json:"dataType,omitempty"`
5222
5223
5224
5225
5226 Key string `json:"key,omitempty"`
5227
5228
5229
5230 Value *EnterpriseCrmFrontendsEventbusProtoParameterValueType `json:"value,omitempty"`
5231
5232
5233
5234
5235
5236
5237
5238 ForceSendFields []string `json:"-"`
5239
5240
5241
5242
5243
5244
5245
5246 NullFields []string `json:"-"`
5247 }
5248
5249 func (s *EnterpriseCrmFrontendsEventbusProtoParameterEntry) MarshalJSON() ([]byte, error) {
5250 type NoMethod EnterpriseCrmFrontendsEventbusProtoParameterEntry
5251 raw := NoMethod(*s)
5252 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5253 }
5254
5255
5256
5257
5258 type EnterpriseCrmFrontendsEventbusProtoParameterMap struct {
5259 Entries []*EnterpriseCrmFrontendsEventbusProtoParameterMapEntry `json:"entries,omitempty"`
5260
5261
5262
5263
5264
5265
5266
5267
5268
5269
5270
5271
5272
5273
5274
5275
5276
5277
5278
5279
5280
5281
5282
5283
5284
5285 KeyType string `json:"keyType,omitempty"`
5286
5287
5288
5289
5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305
5306
5307
5308 ValueType string `json:"valueType,omitempty"`
5309
5310
5311
5312
5313
5314
5315
5316 ForceSendFields []string `json:"-"`
5317
5318
5319
5320
5321
5322
5323
5324 NullFields []string `json:"-"`
5325 }
5326
5327 func (s *EnterpriseCrmFrontendsEventbusProtoParameterMap) MarshalJSON() ([]byte, error) {
5328 type NoMethod EnterpriseCrmFrontendsEventbusProtoParameterMap
5329 raw := NoMethod(*s)
5330 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5331 }
5332
5333
5334
5335 type EnterpriseCrmFrontendsEventbusProtoParameterMapEntry struct {
5336 Key *EnterpriseCrmFrontendsEventbusProtoParameterMapField `json:"key,omitempty"`
5337
5338 Value *EnterpriseCrmFrontendsEventbusProtoParameterMapField `json:"value,omitempty"`
5339
5340
5341
5342
5343
5344
5345
5346 ForceSendFields []string `json:"-"`
5347
5348
5349
5350
5351
5352
5353
5354 NullFields []string `json:"-"`
5355 }
5356
5357 func (s *EnterpriseCrmFrontendsEventbusProtoParameterMapEntry) MarshalJSON() ([]byte, error) {
5358 type NoMethod EnterpriseCrmFrontendsEventbusProtoParameterMapEntry
5359 raw := NoMethod(*s)
5360 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5361 }
5362
5363
5364
5365 type EnterpriseCrmFrontendsEventbusProtoParameterMapField struct {
5366
5367 LiteralValue *EnterpriseCrmFrontendsEventbusProtoParameterValueType `json:"literalValue,omitempty"`
5368
5369
5370 ReferenceKey string `json:"referenceKey,omitempty"`
5371
5372
5373
5374
5375
5376
5377
5378 ForceSendFields []string `json:"-"`
5379
5380
5381
5382
5383
5384
5385
5386 NullFields []string `json:"-"`
5387 }
5388
5389 func (s *EnterpriseCrmFrontendsEventbusProtoParameterMapField) MarshalJSON() ([]byte, error) {
5390 type NoMethod EnterpriseCrmFrontendsEventbusProtoParameterMapField
5391 raw := NoMethod(*s)
5392 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5393 }
5394
5395
5396
5397 type EnterpriseCrmFrontendsEventbusProtoParameterValueType struct {
5398 BooleanArray *EnterpriseCrmFrontendsEventbusProtoBooleanParameterArray `json:"booleanArray,omitempty"`
5399
5400 BooleanValue bool `json:"booleanValue,omitempty"`
5401
5402 DoubleArray *EnterpriseCrmFrontendsEventbusProtoDoubleParameterArray `json:"doubleArray,omitempty"`
5403
5404 DoubleValue float64 `json:"doubleValue,omitempty"`
5405
5406 IntArray *EnterpriseCrmFrontendsEventbusProtoIntParameterArray `json:"intArray,omitempty"`
5407
5408 IntValue int64 `json:"intValue,omitempty,string"`
5409
5410 JsonValue string `json:"jsonValue,omitempty"`
5411
5412 ProtoArray *EnterpriseCrmFrontendsEventbusProtoProtoParameterArray `json:"protoArray,omitempty"`
5413
5414 ProtoValue googleapi.RawMessage `json:"protoValue,omitempty"`
5415
5416 SerializedObjectValue *EnterpriseCrmFrontendsEventbusProtoSerializedObjectParameter `json:"serializedObjectValue,omitempty"`
5417
5418 StringArray *EnterpriseCrmFrontendsEventbusProtoStringParameterArray `json:"stringArray,omitempty"`
5419
5420 StringValue string `json:"stringValue,omitempty"`
5421
5422
5423
5424
5425
5426
5427
5428 ForceSendFields []string `json:"-"`
5429
5430
5431
5432
5433
5434
5435
5436 NullFields []string `json:"-"`
5437 }
5438
5439 func (s *EnterpriseCrmFrontendsEventbusProtoParameterValueType) MarshalJSON() ([]byte, error) {
5440 type NoMethod EnterpriseCrmFrontendsEventbusProtoParameterValueType
5441 raw := NoMethod(*s)
5442 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5443 }
5444
5445 func (s *EnterpriseCrmFrontendsEventbusProtoParameterValueType) UnmarshalJSON(data []byte) error {
5446 type NoMethod EnterpriseCrmFrontendsEventbusProtoParameterValueType
5447 var s1 struct {
5448 DoubleValue gensupport.JSONFloat64 `json:"doubleValue"`
5449 *NoMethod
5450 }
5451 s1.NoMethod = (*NoMethod)(s)
5452 if err := json.Unmarshal(data, &s1); err != nil {
5453 return err
5454 }
5455 s.DoubleValue = float64(s1.DoubleValue)
5456 return nil
5457 }
5458
5459 type EnterpriseCrmFrontendsEventbusProtoProtoParameterArray struct {
5460 ProtoValues []googleapi.RawMessage `json:"protoValues,omitempty"`
5461
5462
5463
5464
5465
5466
5467
5468 ForceSendFields []string `json:"-"`
5469
5470
5471
5472
5473
5474
5475
5476 NullFields []string `json:"-"`
5477 }
5478
5479 func (s *EnterpriseCrmFrontendsEventbusProtoProtoParameterArray) MarshalJSON() ([]byte, error) {
5480 type NoMethod EnterpriseCrmFrontendsEventbusProtoProtoParameterArray
5481 raw := NoMethod(*s)
5482 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5483 }
5484
5485
5486
5487 type EnterpriseCrmFrontendsEventbusProtoRollbackStrategy struct {
5488
5489
5490 Parameters *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"parameters,omitempty"`
5491
5492
5493
5494 RollbackTaskImplementationClassName string `json:"rollbackTaskImplementationClassName,omitempty"`
5495
5496
5497
5498
5499
5500 TaskNumbersToRollback []string `json:"taskNumbersToRollback,omitempty"`
5501
5502
5503
5504
5505
5506
5507
5508 ForceSendFields []string `json:"-"`
5509
5510
5511
5512
5513
5514
5515
5516 NullFields []string `json:"-"`
5517 }
5518
5519 func (s *EnterpriseCrmFrontendsEventbusProtoRollbackStrategy) MarshalJSON() ([]byte, error) {
5520 type NoMethod EnterpriseCrmFrontendsEventbusProtoRollbackStrategy
5521 raw := NoMethod(*s)
5522 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5523 }
5524
5525 type EnterpriseCrmFrontendsEventbusProtoSerializedObjectParameter struct {
5526 ObjectValue string `json:"objectValue,omitempty"`
5527
5528
5529
5530
5531
5532
5533
5534 ForceSendFields []string `json:"-"`
5535
5536
5537
5538
5539
5540
5541
5542 NullFields []string `json:"-"`
5543 }
5544
5545 func (s *EnterpriseCrmFrontendsEventbusProtoSerializedObjectParameter) MarshalJSON() ([]byte, error) {
5546 type NoMethod EnterpriseCrmFrontendsEventbusProtoSerializedObjectParameter
5547 raw := NoMethod(*s)
5548 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5549 }
5550
5551 type EnterpriseCrmFrontendsEventbusProtoStringParameterArray struct {
5552 StringValues []string `json:"stringValues,omitempty"`
5553
5554
5555
5556
5557
5558
5559
5560 ForceSendFields []string `json:"-"`
5561
5562
5563
5564
5565
5566
5567
5568 NullFields []string `json:"-"`
5569 }
5570
5571 func (s *EnterpriseCrmFrontendsEventbusProtoStringParameterArray) MarshalJSON() ([]byte, error) {
5572 type NoMethod EnterpriseCrmFrontendsEventbusProtoStringParameterArray
5573 raw := NoMethod(*s)
5574 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5575 }
5576
5577
5578
5579
5580 type EnterpriseCrmFrontendsEventbusProtoTaskConfig struct {
5581
5582
5583 AlertConfigs []*EnterpriseCrmEventbusProtoTaskAlertConfig `json:"alertConfigs,omitempty"`
5584
5585
5586 CreateTime string `json:"createTime,omitempty"`
5587
5588
5589
5590 CreatorEmail string `json:"creatorEmail,omitempty"`
5591
5592
5593
5594 Description string `json:"description,omitempty"`
5595
5596
5597
5598
5599
5600
5601
5602
5603 DisableStrictTypeValidation bool `json:"disableStrictTypeValidation,omitempty"`
5604
5605
5606
5607
5608
5609 FailurePolicy *EnterpriseCrmEventbusProtoFailurePolicy `json:"failurePolicy,omitempty"`
5610
5611
5612 IncomingEdgeCount int64 `json:"incomingEdgeCount,omitempty"`
5613
5614
5615
5616
5617
5618
5619
5620
5621
5622
5623
5624
5625
5626
5627
5628 JsonValidationOption string `json:"jsonValidationOption,omitempty"`
5629
5630
5631
5632 Label string `json:"label,omitempty"`
5633
5634
5635 LastModifiedTime string `json:"lastModifiedTime,omitempty"`
5636
5637
5638
5639
5640
5641 NextTasks []*EnterpriseCrmEventbusProtoNextTask `json:"nextTasks,omitempty"`
5642
5643
5644
5645
5646
5647
5648
5649
5650
5651
5652 NextTasksExecutionPolicy string `json:"nextTasksExecutionPolicy,omitempty"`
5653
5654
5655 Parameters map[string]EnterpriseCrmFrontendsEventbusProtoParameterEntry `json:"parameters,omitempty"`
5656
5657
5658
5659 Position *EnterpriseCrmEventbusProtoCoordinate `json:"position,omitempty"`
5660
5661
5662
5663
5664
5665 Precondition string `json:"precondition,omitempty"`
5666
5667
5668
5669 PreconditionLabel string `json:"preconditionLabel,omitempty"`
5670
5671
5672
5673
5674 RollbackStrategy *EnterpriseCrmFrontendsEventbusProtoRollbackStrategy `json:"rollbackStrategy,omitempty"`
5675
5676
5677
5678 SuccessPolicy *EnterpriseCrmEventbusProtoSuccessPolicy `json:"successPolicy,omitempty"`
5679
5680
5681
5682
5683
5684 SynchronousCallFailurePolicy *EnterpriseCrmEventbusProtoFailurePolicy `json:"synchronousCallFailurePolicy,omitempty"`
5685
5686
5687
5688 TaskEntity *EnterpriseCrmFrontendsEventbusProtoTaskEntity `json:"taskEntity,omitempty"`
5689
5690
5691
5692
5693
5694
5695
5696
5697
5698
5699
5700
5701
5702
5703
5704
5705 TaskExecutionStrategy string `json:"taskExecutionStrategy,omitempty"`
5706
5707
5708 TaskName string `json:"taskName,omitempty"`
5709
5710
5711
5712
5713
5714
5715 TaskNumber string `json:"taskNumber,omitempty"`
5716
5717
5718
5719
5720
5721
5722 TaskSpec string `json:"taskSpec,omitempty"`
5723
5724
5725
5726 TaskTemplateName string `json:"taskTemplateName,omitempty"`
5727
5728
5729
5730
5731
5732
5733
5734
5735 TaskType string `json:"taskType,omitempty"`
5736
5737
5738
5739
5740
5741
5742
5743 ForceSendFields []string `json:"-"`
5744
5745
5746
5747
5748
5749
5750
5751 NullFields []string `json:"-"`
5752 }
5753
5754 func (s *EnterpriseCrmFrontendsEventbusProtoTaskConfig) MarshalJSON() ([]byte, error) {
5755 type NoMethod EnterpriseCrmFrontendsEventbusProtoTaskConfig
5756 raw := NoMethod(*s)
5757 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5758 }
5759
5760
5761
5762 type EnterpriseCrmFrontendsEventbusProtoTaskEntity struct {
5763
5764 DisabledForVpcSc bool `json:"disabledForVpcSc,omitempty"`
5765
5766
5767 Metadata *EnterpriseCrmEventbusProtoTaskMetadata `json:"metadata,omitempty"`
5768
5769
5770
5771 ParamSpecs *EnterpriseCrmFrontendsEventbusProtoParamSpecsMessage `json:"paramSpecs,omitempty"`
5772
5773
5774 Stats *EnterpriseCrmEventbusStats `json:"stats,omitempty"`
5775
5776
5777
5778
5779
5780
5781
5782
5783 TaskType string `json:"taskType,omitempty"`
5784
5785
5786
5787 UiConfig *EnterpriseCrmEventbusProtoTaskUiConfig `json:"uiConfig,omitempty"`
5788
5789
5790
5791
5792
5793
5794
5795 ForceSendFields []string `json:"-"`
5796
5797
5798
5799
5800
5801
5802
5803
5804 NullFields []string `json:"-"`
5805 }
5806
5807 func (s *EnterpriseCrmFrontendsEventbusProtoTaskEntity) MarshalJSON() ([]byte, error) {
5808 type NoMethod EnterpriseCrmFrontendsEventbusProtoTaskEntity
5809 raw := NoMethod(*s)
5810 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5811 }
5812
5813
5814
5815 type EnterpriseCrmFrontendsEventbusProtoTriggerConfig struct {
5816
5817
5818
5819
5820
5821 AlertConfig []*EnterpriseCrmEventbusProtoWorkflowAlertConfig `json:"alertConfig,omitempty"`
5822
5823 CloudSchedulerConfig *EnterpriseCrmEventbusProtoCloudSchedulerConfig `json:"cloudSchedulerConfig,omitempty"`
5824
5825
5826
5827 Description string `json:"description,omitempty"`
5828
5829
5830
5831
5832
5833
5834
5835 EnabledClients []string `json:"enabledClients,omitempty"`
5836
5837
5838 Label string `json:"label,omitempty"`
5839
5840
5841
5842
5843
5844
5845
5846
5847
5848 NextTasksExecutionPolicy string `json:"nextTasksExecutionPolicy,omitempty"`
5849
5850
5851
5852
5853
5854
5855 PauseWorkflowExecutions bool `json:"pauseWorkflowExecutions,omitempty"`
5856
5857
5858
5859 Position *EnterpriseCrmEventbusProtoCoordinate `json:"position,omitempty"`
5860
5861
5862
5863
5864 Properties map[string]string `json:"properties,omitempty"`
5865
5866
5867
5868
5869
5870
5871 StartTasks []*EnterpriseCrmEventbusProtoNextTask `json:"startTasks,omitempty"`
5872
5873
5874
5875
5876
5877 TriggerCriteria *EnterpriseCrmEventbusProtoTriggerCriteria `json:"triggerCriteria,omitempty"`
5878
5879
5880 TriggerId string `json:"triggerId,omitempty"`
5881
5882
5883
5884 TriggerNumber string `json:"triggerNumber,omitempty"`
5885
5886
5887
5888
5889
5890
5891
5892
5893
5894
5895
5896
5897
5898
5899
5900 TriggerType string `json:"triggerType,omitempty"`
5901
5902
5903
5904
5905
5906
5907
5908 ForceSendFields []string `json:"-"`
5909
5910
5911
5912
5913
5914
5915
5916 NullFields []string `json:"-"`
5917 }
5918
5919 func (s *EnterpriseCrmFrontendsEventbusProtoTriggerConfig) MarshalJSON() ([]byte, error) {
5920 type NoMethod EnterpriseCrmFrontendsEventbusProtoTriggerConfig
5921 raw := NoMethod(*s)
5922 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
5923 }
5924
5925 type EnterpriseCrmFrontendsEventbusProtoWorkflowParameterEntry struct {
5926
5927 Attributes *EnterpriseCrmEventbusProtoAttributes `json:"attributes,omitempty"`
5928
5929
5930
5931 Children []*EnterpriseCrmFrontendsEventbusProtoWorkflowParameterEntry `json:"children,omitempty"`
5932
5933
5934
5935
5936
5937
5938
5939
5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956 DataType string `json:"dataType,omitempty"`
5957
5958
5959
5960
5961 DefaultValue *EnterpriseCrmFrontendsEventbusProtoParameterValueType `json:"defaultValue,omitempty"`
5962
5963
5964
5965
5966
5967
5968
5969
5970
5971
5972
5973
5974
5975 InOutType string `json:"inOutType,omitempty"`
5976
5977
5978
5979 IsTransient bool `json:"isTransient,omitempty"`
5980
5981
5982
5983 JsonSchema string `json:"jsonSchema,omitempty"`
5984
5985
5986
5987
5988 Key string `json:"key,omitempty"`
5989
5990
5991
5992
5993 Name string `json:"name,omitempty"`
5994
5995
5996
5997
5998 ProducedBy *EnterpriseCrmEventbusProtoNodeIdentifier `json:"producedBy,omitempty"`
5999
6000 Producer string `json:"producer,omitempty"`
6001
6002
6003
6004 ProtoDefName string `json:"protoDefName,omitempty"`
6005
6006
6007
6008
6009
6010 ProtoDefPath string `json:"protoDefPath,omitempty"`
6011
6012
6013
6014
6015
6016
6017
6018 ForceSendFields []string `json:"-"`
6019
6020
6021
6022
6023
6024
6025
6026 NullFields []string `json:"-"`
6027 }
6028
6029 func (s *EnterpriseCrmFrontendsEventbusProtoWorkflowParameterEntry) MarshalJSON() ([]byte, error) {
6030 type NoMethod EnterpriseCrmFrontendsEventbusProtoWorkflowParameterEntry
6031 raw := NoMethod(*s)
6032 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6033 }
6034
6035
6036
6037
6038
6039
6040
6041
6042
6043
6044 type EnterpriseCrmFrontendsEventbusProtoWorkflowParameters struct {
6045
6046
6047
6048 Parameters []*EnterpriseCrmFrontendsEventbusProtoWorkflowParameterEntry `json:"parameters,omitempty"`
6049
6050
6051
6052
6053
6054
6055
6056 ForceSendFields []string `json:"-"`
6057
6058
6059
6060
6061
6062
6063
6064 NullFields []string `json:"-"`
6065 }
6066
6067 func (s *EnterpriseCrmFrontendsEventbusProtoWorkflowParameters) MarshalJSON() ([]byte, error) {
6068 type NoMethod EnterpriseCrmFrontendsEventbusProtoWorkflowParameters
6069 raw := NoMethod(*s)
6070 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6071 }
6072
6073
6074
6075
6076 type EnterpriseCrmLoggingGwsFieldLimits struct {
6077
6078
6079
6080
6081 LogAction string `json:"logAction,omitempty"`
6082
6083
6084
6085
6086
6087
6088
6089
6090
6091 LogType []string `json:"logType,omitempty"`
6092
6093
6094
6095 MaxArraySize int64 `json:"maxArraySize,omitempty"`
6096
6097
6098
6099 MaxStringLength int64 `json:"maxStringLength,omitempty"`
6100
6101
6102
6103
6104
6105
6106
6107
6108
6109
6110
6111
6112
6113 ShortenerType string `json:"shortenerType,omitempty"`
6114
6115
6116
6117
6118
6119
6120
6121 ForceSendFields []string `json:"-"`
6122
6123
6124
6125
6126
6127
6128
6129 NullFields []string `json:"-"`
6130 }
6131
6132 func (s *EnterpriseCrmLoggingGwsFieldLimits) MarshalJSON() ([]byte, error) {
6133 type NoMethod EnterpriseCrmLoggingGwsFieldLimits
6134 raw := NoMethod(*s)
6135 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6136 }
6137
6138
6139
6140
6141
6142
6143
6144 type EnterpriseCrmLoggingGwsSanitizeOptions struct {
6145
6146
6147
6148
6149 IsAlreadySanitized bool `json:"isAlreadySanitized,omitempty"`
6150
6151
6152
6153
6154
6155
6156
6157
6158
6159 LogType []string `json:"logType,omitempty"`
6160
6161
6162
6163
6164
6165
6166
6167 Privacy string `json:"privacy,omitempty"`
6168
6169
6170
6171
6172
6173
6174
6175
6176
6177
6178
6179
6180
6181
6182
6183 SanitizeType string `json:"sanitizeType,omitempty"`
6184
6185
6186
6187
6188
6189
6190
6191 ForceSendFields []string `json:"-"`
6192
6193
6194
6195
6196
6197
6198
6199
6200 NullFields []string `json:"-"`
6201 }
6202
6203 func (s *EnterpriseCrmLoggingGwsSanitizeOptions) MarshalJSON() ([]byte, error) {
6204 type NoMethod EnterpriseCrmLoggingGwsSanitizeOptions
6205 raw := NoMethod(*s)
6206 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6207 }
6208
6209
6210
6211 type GoogleCloudConnectorsV1AuthConfig struct {
6212
6213 AdditionalVariables []*GoogleCloudConnectorsV1ConfigVariable `json:"additionalVariables,omitempty"`
6214
6215
6216
6217
6218
6219
6220
6221
6222
6223
6224
6225
6226 AuthType string `json:"authType,omitempty"`
6227
6228
6229 Oauth2ClientCredentials *GoogleCloudConnectorsV1AuthConfigOauth2ClientCredentials `json:"oauth2ClientCredentials,omitempty"`
6230
6231
6232 Oauth2JwtBearer *GoogleCloudConnectorsV1AuthConfigOauth2JwtBearer `json:"oauth2JwtBearer,omitempty"`
6233
6234
6235 SshPublicKey *GoogleCloudConnectorsV1AuthConfigSshPublicKey `json:"sshPublicKey,omitempty"`
6236
6237
6238 UserPassword *GoogleCloudConnectorsV1AuthConfigUserPassword `json:"userPassword,omitempty"`
6239
6240
6241
6242
6243
6244
6245
6246 ForceSendFields []string `json:"-"`
6247
6248
6249
6250
6251
6252
6253
6254
6255 NullFields []string `json:"-"`
6256 }
6257
6258 func (s *GoogleCloudConnectorsV1AuthConfig) MarshalJSON() ([]byte, error) {
6259 type NoMethod GoogleCloudConnectorsV1AuthConfig
6260 raw := NoMethod(*s)
6261 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6262 }
6263
6264
6265
6266
6267 type GoogleCloudConnectorsV1AuthConfigOauth2ClientCredentials struct {
6268
6269 ClientId string `json:"clientId,omitempty"`
6270
6271
6272 ClientSecret *GoogleCloudConnectorsV1Secret `json:"clientSecret,omitempty"`
6273
6274
6275
6276
6277
6278
6279
6280 ForceSendFields []string `json:"-"`
6281
6282
6283
6284
6285
6286
6287
6288 NullFields []string `json:"-"`
6289 }
6290
6291 func (s *GoogleCloudConnectorsV1AuthConfigOauth2ClientCredentials) MarshalJSON() ([]byte, error) {
6292 type NoMethod GoogleCloudConnectorsV1AuthConfigOauth2ClientCredentials
6293 raw := NoMethod(*s)
6294 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6295 }
6296
6297
6298
6299
6300
6301 type GoogleCloudConnectorsV1AuthConfigOauth2JwtBearer struct {
6302
6303
6304
6305
6306 ClientKey *GoogleCloudConnectorsV1Secret `json:"clientKey,omitempty"`
6307
6308
6309 JwtClaims *GoogleCloudConnectorsV1AuthConfigOauth2JwtBearerJwtClaims `json:"jwtClaims,omitempty"`
6310
6311
6312
6313
6314
6315
6316
6317 ForceSendFields []string `json:"-"`
6318
6319
6320
6321
6322
6323
6324
6325 NullFields []string `json:"-"`
6326 }
6327
6328 func (s *GoogleCloudConnectorsV1AuthConfigOauth2JwtBearer) MarshalJSON() ([]byte, error) {
6329 type NoMethod GoogleCloudConnectorsV1AuthConfigOauth2JwtBearer
6330 raw := NoMethod(*s)
6331 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6332 }
6333
6334
6335
6336 type GoogleCloudConnectorsV1AuthConfigOauth2JwtBearerJwtClaims struct {
6337
6338 Audience string `json:"audience,omitempty"`
6339
6340
6341 Issuer string `json:"issuer,omitempty"`
6342
6343
6344 Subject string `json:"subject,omitempty"`
6345
6346
6347
6348
6349
6350
6351
6352 ForceSendFields []string `json:"-"`
6353
6354
6355
6356
6357
6358
6359
6360 NullFields []string `json:"-"`
6361 }
6362
6363 func (s *GoogleCloudConnectorsV1AuthConfigOauth2JwtBearerJwtClaims) MarshalJSON() ([]byte, error) {
6364 type NoMethod GoogleCloudConnectorsV1AuthConfigOauth2JwtBearerJwtClaims
6365 raw := NoMethod(*s)
6366 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6367 }
6368
6369
6370
6371 type GoogleCloudConnectorsV1AuthConfigSshPublicKey struct {
6372
6373 CertType string `json:"certType,omitempty"`
6374
6375
6376
6377 SshClientCert *GoogleCloudConnectorsV1Secret `json:"sshClientCert,omitempty"`
6378
6379
6380
6381 SshClientCertPass *GoogleCloudConnectorsV1Secret `json:"sshClientCertPass,omitempty"`
6382
6383
6384 Username string `json:"username,omitempty"`
6385
6386
6387
6388
6389
6390
6391
6392 ForceSendFields []string `json:"-"`
6393
6394
6395
6396
6397
6398
6399
6400 NullFields []string `json:"-"`
6401 }
6402
6403 func (s *GoogleCloudConnectorsV1AuthConfigSshPublicKey) MarshalJSON() ([]byte, error) {
6404 type NoMethod GoogleCloudConnectorsV1AuthConfigSshPublicKey
6405 raw := NoMethod(*s)
6406 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6407 }
6408
6409
6410
6411 type GoogleCloudConnectorsV1AuthConfigUserPassword struct {
6412
6413 Password *GoogleCloudConnectorsV1Secret `json:"password,omitempty"`
6414
6415
6416 Username string `json:"username,omitempty"`
6417
6418
6419
6420
6421
6422
6423
6424 ForceSendFields []string `json:"-"`
6425
6426
6427
6428
6429
6430
6431
6432 NullFields []string `json:"-"`
6433 }
6434
6435 func (s *GoogleCloudConnectorsV1AuthConfigUserPassword) MarshalJSON() ([]byte, error) {
6436 type NoMethod GoogleCloudConnectorsV1AuthConfigUserPassword
6437 raw := NoMethod(*s)
6438 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6439 }
6440
6441
6442
6443 type GoogleCloudConnectorsV1ConfigVariable struct {
6444
6445 BoolValue bool `json:"boolValue,omitempty"`
6446
6447
6448 IntValue int64 `json:"intValue,omitempty,string"`
6449
6450
6451 Key string `json:"key,omitempty"`
6452
6453
6454 SecretValue *GoogleCloudConnectorsV1Secret `json:"secretValue,omitempty"`
6455
6456
6457 StringValue string `json:"stringValue,omitempty"`
6458
6459
6460
6461
6462
6463
6464
6465 ForceSendFields []string `json:"-"`
6466
6467
6468
6469
6470
6471
6472
6473 NullFields []string `json:"-"`
6474 }
6475
6476 func (s *GoogleCloudConnectorsV1ConfigVariable) MarshalJSON() ([]byte, error) {
6477 type NoMethod GoogleCloudConnectorsV1ConfigVariable
6478 raw := NoMethod(*s)
6479 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6480 }
6481
6482
6483
6484 type GoogleCloudConnectorsV1Connection struct {
6485
6486
6487 AuthConfig *GoogleCloudConnectorsV1AuthConfig `json:"authConfig,omitempty"`
6488
6489
6490
6491 ConfigVariables []*GoogleCloudConnectorsV1ConfigVariable `json:"configVariables,omitempty"`
6492
6493
6494
6495
6496
6497 ConnectorVersion string `json:"connectorVersion,omitempty"`
6498
6499
6500 CreateTime string `json:"createTime,omitempty"`
6501
6502
6503 Description string `json:"description,omitempty"`
6504
6505
6506
6507
6508 DestinationConfigs []*GoogleCloudConnectorsV1DestinationConfig `json:"destinationConfigs,omitempty"`
6509
6510
6511
6512 EnvoyImageLocation string `json:"envoyImageLocation,omitempty"`
6513
6514
6515
6516 ImageLocation string `json:"imageLocation,omitempty"`
6517
6518
6519
6520
6521 Labels map[string]string `json:"labels,omitempty"`
6522
6523
6524
6525 LockConfig *GoogleCloudConnectorsV1LockConfig `json:"lockConfig,omitempty"`
6526
6527
6528
6529 Name string `json:"name,omitempty"`
6530
6531
6532 NodeConfig *GoogleCloudConnectorsV1NodeConfig `json:"nodeConfig,omitempty"`
6533
6534
6535
6536 ServiceAccount string `json:"serviceAccount,omitempty"`
6537
6538
6539
6540
6541
6542
6543 ServiceDirectory string `json:"serviceDirectory,omitempty"`
6544
6545
6546 Status *GoogleCloudConnectorsV1ConnectionStatus `json:"status,omitempty"`
6547
6548
6549
6550 Suspended bool `json:"suspended,omitempty"`
6551
6552
6553 UpdateTime string `json:"updateTime,omitempty"`
6554
6555
6556
6557
6558
6559
6560
6561 ForceSendFields []string `json:"-"`
6562
6563
6564
6565
6566
6567
6568
6569 NullFields []string `json:"-"`
6570 }
6571
6572 func (s *GoogleCloudConnectorsV1Connection) MarshalJSON() ([]byte, error) {
6573 type NoMethod GoogleCloudConnectorsV1Connection
6574 raw := NoMethod(*s)
6575 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6576 }
6577
6578
6579
6580 type GoogleCloudConnectorsV1ConnectionStatus struct {
6581
6582 Description string `json:"description,omitempty"`
6583
6584
6585
6586
6587
6588
6589
6590
6591
6592
6593
6594 State string `json:"state,omitempty"`
6595
6596
6597 Status string `json:"status,omitempty"`
6598
6599
6600
6601
6602
6603
6604
6605 ForceSendFields []string `json:"-"`
6606
6607
6608
6609
6610
6611
6612
6613 NullFields []string `json:"-"`
6614 }
6615
6616 func (s *GoogleCloudConnectorsV1ConnectionStatus) MarshalJSON() ([]byte, error) {
6617 type NoMethod GoogleCloudConnectorsV1ConnectionStatus
6618 raw := NoMethod(*s)
6619 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6620 }
6621
6622 type GoogleCloudConnectorsV1Destination struct {
6623
6624 Host string `json:"host,omitempty"`
6625
6626
6627
6628 Port int64 `json:"port,omitempty"`
6629
6630
6631
6632 ServiceAttachment string `json:"serviceAttachment,omitempty"`
6633
6634
6635
6636
6637
6638
6639
6640 ForceSendFields []string `json:"-"`
6641
6642
6643
6644
6645
6646
6647
6648 NullFields []string `json:"-"`
6649 }
6650
6651 func (s *GoogleCloudConnectorsV1Destination) MarshalJSON() ([]byte, error) {
6652 type NoMethod GoogleCloudConnectorsV1Destination
6653 raw := NoMethod(*s)
6654 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6655 }
6656
6657
6658
6659 type GoogleCloudConnectorsV1DestinationConfig struct {
6660
6661 Destinations []*GoogleCloudConnectorsV1Destination `json:"destinations,omitempty"`
6662
6663
6664
6665 Key string `json:"key,omitempty"`
6666
6667
6668
6669
6670
6671
6672
6673 ForceSendFields []string `json:"-"`
6674
6675
6676
6677
6678
6679
6680
6681 NullFields []string `json:"-"`
6682 }
6683
6684 func (s *GoogleCloudConnectorsV1DestinationConfig) MarshalJSON() ([]byte, error) {
6685 type NoMethod GoogleCloudConnectorsV1DestinationConfig
6686 raw := NoMethod(*s)
6687 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6688 }
6689
6690
6691
6692 type GoogleCloudConnectorsV1LockConfig struct {
6693
6694 Locked bool `json:"locked,omitempty"`
6695
6696
6697 Reason string `json:"reason,omitempty"`
6698
6699
6700
6701
6702
6703
6704
6705 ForceSendFields []string `json:"-"`
6706
6707
6708
6709
6710
6711
6712
6713 NullFields []string `json:"-"`
6714 }
6715
6716 func (s *GoogleCloudConnectorsV1LockConfig) MarshalJSON() ([]byte, error) {
6717 type NoMethod GoogleCloudConnectorsV1LockConfig
6718 raw := NoMethod(*s)
6719 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6720 }
6721
6722
6723
6724 type GoogleCloudConnectorsV1NodeConfig struct {
6725
6726 MaxNodeCount int64 `json:"maxNodeCount,omitempty"`
6727
6728
6729 MinNodeCount int64 `json:"minNodeCount,omitempty"`
6730
6731
6732
6733
6734
6735
6736
6737 ForceSendFields []string `json:"-"`
6738
6739
6740
6741
6742
6743
6744
6745 NullFields []string `json:"-"`
6746 }
6747
6748 func (s *GoogleCloudConnectorsV1NodeConfig) MarshalJSON() ([]byte, error) {
6749 type NoMethod GoogleCloudConnectorsV1NodeConfig
6750 raw := NoMethod(*s)
6751 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6752 }
6753
6754
6755
6756 type GoogleCloudConnectorsV1Secret struct {
6757
6758
6759 SecretVersion string `json:"secretVersion,omitempty"`
6760
6761
6762
6763
6764
6765
6766
6767 ForceSendFields []string `json:"-"`
6768
6769
6770
6771
6772
6773
6774
6775 NullFields []string `json:"-"`
6776 }
6777
6778 func (s *GoogleCloudConnectorsV1Secret) MarshalJSON() ([]byte, error) {
6779 type NoMethod GoogleCloudConnectorsV1Secret
6780 raw := NoMethod(*s)
6781 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6782 }
6783
6784
6785
6786
6787 type GoogleCloudIntegrationsV1alphaAccessToken struct {
6788
6789
6790 AccessToken string `json:"accessToken,omitempty"`
6791
6792
6793
6794 AccessTokenExpireTime string `json:"accessTokenExpireTime,omitempty"`
6795
6796
6797
6798 RefreshToken string `json:"refreshToken,omitempty"`
6799
6800
6801
6802 RefreshTokenExpireTime string `json:"refreshTokenExpireTime,omitempty"`
6803
6804
6805
6806 TokenType string `json:"tokenType,omitempty"`
6807
6808
6809
6810
6811
6812
6813
6814 ForceSendFields []string `json:"-"`
6815
6816
6817
6818
6819
6820
6821
6822 NullFields []string `json:"-"`
6823 }
6824
6825 func (s *GoogleCloudIntegrationsV1alphaAccessToken) MarshalJSON() ([]byte, error) {
6826 type NoMethod GoogleCloudIntegrationsV1alphaAccessToken
6827 raw := NoMethod(*s)
6828 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6829 }
6830
6831
6832
6833 type GoogleCloudIntegrationsV1alphaArchiveBundleRequest struct {
6834 }
6835
6836
6837
6838 type GoogleCloudIntegrationsV1alphaArchiveBundleResponse struct {
6839
6840
6841 googleapi.ServerResponse `json:"-"`
6842 }
6843
6844
6845
6846 type GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionRequest struct {
6847 }
6848
6849
6850
6851 type GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionResponse struct {
6852
6853
6854 googleapi.ServerResponse `json:"-"`
6855 }
6856
6857
6858
6859 type GoogleCloudIntegrationsV1alphaAttemptStats struct {
6860
6861 EndTime string `json:"endTime,omitempty"`
6862
6863
6864
6865 StartTime string `json:"startTime,omitempty"`
6866
6867
6868
6869
6870
6871
6872
6873 ForceSendFields []string `json:"-"`
6874
6875
6876
6877
6878
6879
6880
6881 NullFields []string `json:"-"`
6882 }
6883
6884 func (s *GoogleCloudIntegrationsV1alphaAttemptStats) MarshalJSON() ([]byte, error) {
6885 type NoMethod GoogleCloudIntegrationsV1alphaAttemptStats
6886 raw := NoMethod(*s)
6887 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
6888 }
6889
6890
6891
6892 type GoogleCloudIntegrationsV1alphaAuthConfig struct {
6893
6894 CertificateId string `json:"certificateId,omitempty"`
6895
6896
6897
6898 CreateTime string `json:"createTime,omitempty"`
6899
6900
6901
6902 CreatorEmail string `json:"creatorEmail,omitempty"`
6903
6904
6905
6906
6907
6908
6909
6910
6911
6912
6913
6914
6915
6916
6917
6918
6919
6920
6921
6922
6923 CredentialType string `json:"credentialType,omitempty"`
6924
6925
6926 DecryptedCredential *GoogleCloudIntegrationsV1alphaCredential `json:"decryptedCredential,omitempty"`
6927
6928
6929 Description string `json:"description,omitempty"`
6930
6931
6932 DisplayName string `json:"displayName,omitempty"`
6933
6934
6935
6936 EncryptedCredential string `json:"encryptedCredential,omitempty"`
6937
6938
6939
6940
6941 ExpiryNotificationDuration []string `json:"expiryNotificationDuration,omitempty"`
6942
6943
6944
6945 LastModifierEmail string `json:"lastModifierEmail,omitempty"`
6946
6947
6948
6949 Name string `json:"name,omitempty"`
6950
6951
6952
6953
6954 OverrideValidTime string `json:"overrideValidTime,omitempty"`
6955
6956
6957 Reason string `json:"reason,omitempty"`
6958
6959
6960
6961
6962
6963
6964
6965
6966
6967
6968
6969
6970 State string `json:"state,omitempty"`
6971
6972
6973
6974 UpdateTime string `json:"updateTime,omitempty"`
6975
6976
6977
6978 ValidTime string `json:"validTime,omitempty"`
6979
6980
6981
6982
6983
6984
6985
6986 Visibility string `json:"visibility,omitempty"`
6987
6988
6989
6990 googleapi.ServerResponse `json:"-"`
6991
6992
6993
6994
6995
6996
6997
6998 ForceSendFields []string `json:"-"`
6999
7000
7001
7002
7003
7004
7005
7006 NullFields []string `json:"-"`
7007 }
7008
7009 func (s *GoogleCloudIntegrationsV1alphaAuthConfig) MarshalJSON() ([]byte, error) {
7010 type NoMethod GoogleCloudIntegrationsV1alphaAuthConfig
7011 raw := NoMethod(*s)
7012 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7013 }
7014
7015
7016
7017
7018 type GoogleCloudIntegrationsV1alphaAuthToken struct {
7019
7020 Token string `json:"token,omitempty"`
7021
7022
7023 Type string `json:"type,omitempty"`
7024
7025
7026
7027
7028
7029
7030
7031 ForceSendFields []string `json:"-"`
7032
7033
7034
7035
7036
7037
7038
7039 NullFields []string `json:"-"`
7040 }
7041
7042 func (s *GoogleCloudIntegrationsV1alphaAuthToken) MarshalJSON() ([]byte, error) {
7043 type NoMethod GoogleCloudIntegrationsV1alphaAuthToken
7044 raw := NoMethod(*s)
7045 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7046 }
7047
7048
7049
7050 type GoogleCloudIntegrationsV1alphaBooleanParameterArray struct {
7051
7052 BooleanValues []bool `json:"booleanValues,omitempty"`
7053
7054
7055
7056
7057
7058
7059
7060 ForceSendFields []string `json:"-"`
7061
7062
7063
7064
7065
7066
7067
7068 NullFields []string `json:"-"`
7069 }
7070
7071 func (s *GoogleCloudIntegrationsV1alphaBooleanParameterArray) MarshalJSON() ([]byte, error) {
7072 type NoMethod GoogleCloudIntegrationsV1alphaBooleanParameterArray
7073 raw := NoMethod(*s)
7074 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7075 }
7076
7077
7078
7079 type GoogleCloudIntegrationsV1alphaCancelExecutionRequest struct {
7080 }
7081
7082
7083
7084 type GoogleCloudIntegrationsV1alphaCancelExecutionResponse struct {
7085
7086 IsCanceled bool `json:"isCanceled,omitempty"`
7087
7088
7089
7090 googleapi.ServerResponse `json:"-"`
7091
7092
7093
7094
7095
7096
7097
7098 ForceSendFields []string `json:"-"`
7099
7100
7101
7102
7103
7104
7105
7106 NullFields []string `json:"-"`
7107 }
7108
7109 func (s *GoogleCloudIntegrationsV1alphaCancelExecutionResponse) MarshalJSON() ([]byte, error) {
7110 type NoMethod GoogleCloudIntegrationsV1alphaCancelExecutionResponse
7111 raw := NoMethod(*s)
7112 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7113 }
7114
7115
7116 type GoogleCloudIntegrationsV1alphaCertificate struct {
7117
7118
7119
7120
7121
7122
7123 CertificateStatus string `json:"certificateStatus,omitempty"`
7124
7125
7126
7127 CredentialId string `json:"credentialId,omitempty"`
7128
7129
7130 Description string `json:"description,omitempty"`
7131
7132
7133 DisplayName string `json:"displayName,omitempty"`
7134
7135
7136 Name string `json:"name,omitempty"`
7137
7138
7139
7140 RawCertificate *GoogleCloudIntegrationsV1alphaClientCertificate `json:"rawCertificate,omitempty"`
7141
7142
7143
7144 RequestorId string `json:"requestorId,omitempty"`
7145
7146
7147
7148 ValidEndTime string `json:"validEndTime,omitempty"`
7149
7150
7151
7152 ValidStartTime string `json:"validStartTime,omitempty"`
7153
7154
7155
7156 googleapi.ServerResponse `json:"-"`
7157
7158
7159
7160
7161
7162
7163
7164 ForceSendFields []string `json:"-"`
7165
7166
7167
7168
7169
7170
7171
7172
7173 NullFields []string `json:"-"`
7174 }
7175
7176 func (s *GoogleCloudIntegrationsV1alphaCertificate) MarshalJSON() ([]byte, error) {
7177 type NoMethod GoogleCloudIntegrationsV1alphaCertificate
7178 raw := NoMethod(*s)
7179 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7180 }
7181
7182
7183
7184 type GoogleCloudIntegrationsV1alphaClientCertificate struct {
7185
7186
7187
7188
7189
7190
7191
7192
7193
7194
7195
7196
7197
7198
7199
7200
7201 EncryptedPrivateKey string `json:"encryptedPrivateKey,omitempty"`
7202
7203
7204
7205
7206 Passphrase string `json:"passphrase,omitempty"`
7207
7208
7209
7210
7211
7212
7213
7214
7215
7216
7217
7218
7219
7220
7221
7222
7223
7224 SslCertificate string `json:"sslCertificate,omitempty"`
7225
7226
7227
7228
7229
7230
7231
7232 ForceSendFields []string `json:"-"`
7233
7234
7235
7236
7237
7238
7239
7240
7241 NullFields []string `json:"-"`
7242 }
7243
7244 func (s *GoogleCloudIntegrationsV1alphaClientCertificate) MarshalJSON() ([]byte, error) {
7245 type NoMethod GoogleCloudIntegrationsV1alphaClientCertificate
7246 raw := NoMethod(*s)
7247 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7248 }
7249
7250
7251
7252 type GoogleCloudIntegrationsV1alphaClientConfig struct {
7253
7254
7255
7256
7257
7258
7259
7260
7261
7262 BillingType string `json:"billingType,omitempty"`
7263
7264
7265
7266
7267
7268
7269
7270
7271
7272 ClientState string `json:"clientState,omitempty"`
7273
7274
7275
7276 CloudKmsConfig *GoogleCloudIntegrationsV1alphaCloudKmsConfig `json:"cloudKmsConfig,omitempty"`
7277
7278
7279
7280 CloudLoggingConfig *GoogleCloudIntegrationsV1alphaCloudLoggingConfig `json:"cloudLoggingConfig,omitempty"`
7281
7282
7283 CreateTime string `json:"createTime,omitempty"`
7284
7285
7286 Description string `json:"description,omitempty"`
7287
7288
7289 Id string `json:"id,omitempty"`
7290
7291
7292 P4ServiceAccount string `json:"p4ServiceAccount,omitempty"`
7293
7294
7295 ProjectId string `json:"projectId,omitempty"`
7296
7297
7298 Region string `json:"region,omitempty"`
7299
7300
7301
7302
7303
7304
7305
7306 ForceSendFields []string `json:"-"`
7307
7308
7309
7310
7311
7312
7313
7314 NullFields []string `json:"-"`
7315 }
7316
7317 func (s *GoogleCloudIntegrationsV1alphaClientConfig) MarshalJSON() ([]byte, error) {
7318 type NoMethod GoogleCloudIntegrationsV1alphaClientConfig
7319 raw := NoMethod(*s)
7320 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7321 }
7322
7323
7324
7325 type GoogleCloudIntegrationsV1alphaCloudKmsConfig struct {
7326
7327
7328
7329 Key string `json:"key,omitempty"`
7330
7331
7332
7333
7334
7335
7336 KeyVersion string `json:"keyVersion,omitempty"`
7337
7338
7339
7340 KmsLocation string `json:"kmsLocation,omitempty"`
7341
7342
7343
7344
7345
7346 KmsRing string `json:"kmsRing,omitempty"`
7347
7348
7349
7350
7351
7352
7353
7354 ForceSendFields []string `json:"-"`
7355
7356
7357
7358
7359
7360
7361
7362 NullFields []string `json:"-"`
7363 }
7364
7365 func (s *GoogleCloudIntegrationsV1alphaCloudKmsConfig) MarshalJSON() ([]byte, error) {
7366 type NoMethod GoogleCloudIntegrationsV1alphaCloudKmsConfig
7367 raw := NoMethod(*s)
7368 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7369 }
7370
7371
7372
7373 type GoogleCloudIntegrationsV1alphaCloudLoggingConfig struct {
7374
7375 Bucket string `json:"bucket,omitempty"`
7376
7377
7378
7379 EnableCloudLogging bool `json:"enableCloudLogging,omitempty"`
7380
7381
7382
7383
7384
7385
7386
7387 ForceSendFields []string `json:"-"`
7388
7389
7390
7391
7392
7393
7394
7395 NullFields []string `json:"-"`
7396 }
7397
7398 func (s *GoogleCloudIntegrationsV1alphaCloudLoggingConfig) MarshalJSON() ([]byte, error) {
7399 type NoMethod GoogleCloudIntegrationsV1alphaCloudLoggingConfig
7400 raw := NoMethod(*s)
7401 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7402 }
7403
7404
7405
7406 type GoogleCloudIntegrationsV1alphaCloudSchedulerConfig struct {
7407
7408 CronTab string `json:"cronTab,omitempty"`
7409
7410
7411
7412 ErrorMessage string `json:"errorMessage,omitempty"`
7413
7414
7415
7416 Location string `json:"location,omitempty"`
7417
7418
7419
7420 ServiceAccountEmail string `json:"serviceAccountEmail,omitempty"`
7421
7422
7423
7424
7425
7426
7427
7428 ForceSendFields []string `json:"-"`
7429
7430
7431
7432
7433
7434
7435
7436 NullFields []string `json:"-"`
7437 }
7438
7439 func (s *GoogleCloudIntegrationsV1alphaCloudSchedulerConfig) MarshalJSON() ([]byte, error) {
7440 type NoMethod GoogleCloudIntegrationsV1alphaCloudSchedulerConfig
7441 raw := NoMethod(*s)
7442 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7443 }
7444
7445
7446
7447 type GoogleCloudIntegrationsV1alphaConnectionSchemaMetadata struct {
7448
7449 Actions []string `json:"actions,omitempty"`
7450
7451
7452 Entities []string `json:"entities,omitempty"`
7453
7454
7455
7456 googleapi.ServerResponse `json:"-"`
7457
7458
7459
7460
7461
7462
7463
7464 ForceSendFields []string `json:"-"`
7465
7466
7467
7468
7469
7470
7471
7472 NullFields []string `json:"-"`
7473 }
7474
7475 func (s *GoogleCloudIntegrationsV1alphaConnectionSchemaMetadata) MarshalJSON() ([]byte, error) {
7476 type NoMethod GoogleCloudIntegrationsV1alphaConnectionSchemaMetadata
7477 raw := NoMethod(*s)
7478 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7479 }
7480
7481
7482
7483 type GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectRequest struct {
7484
7485 AppsScriptProject string `json:"appsScriptProject,omitempty"`
7486
7487
7488
7489 AuthConfigId string `json:"authConfigId,omitempty"`
7490
7491
7492
7493
7494
7495
7496
7497 ForceSendFields []string `json:"-"`
7498
7499
7500
7501
7502
7503
7504
7505
7506 NullFields []string `json:"-"`
7507 }
7508
7509 func (s *GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectRequest) MarshalJSON() ([]byte, error) {
7510 type NoMethod GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectRequest
7511 raw := NoMethod(*s)
7512 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7513 }
7514
7515
7516
7517 type GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectResponse struct {
7518
7519 ProjectId string `json:"projectId,omitempty"`
7520
7521
7522
7523 googleapi.ServerResponse `json:"-"`
7524
7525
7526
7527
7528
7529
7530
7531 ForceSendFields []string `json:"-"`
7532
7533
7534
7535
7536
7537
7538
7539 NullFields []string `json:"-"`
7540 }
7541
7542 func (s *GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectResponse) MarshalJSON() ([]byte, error) {
7543 type NoMethod GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectResponse
7544 raw := NoMethod(*s)
7545 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7546 }
7547
7548
7549
7550
7551 type GoogleCloudIntegrationsV1alphaCreateBundleRequest struct {
7552
7553 BundleId string `json:"bundleId,omitempty"`
7554
7555
7556
7557 Integrations []string `json:"integrations,omitempty"`
7558
7559
7560
7561
7562
7563
7564 SecondaryCustomerOrgId string `json:"secondaryCustomerOrgId,omitempty"`
7565
7566
7567
7568
7569
7570
7571
7572 ForceSendFields []string `json:"-"`
7573
7574
7575
7576
7577
7578
7579
7580 NullFields []string `json:"-"`
7581 }
7582
7583 func (s *GoogleCloudIntegrationsV1alphaCreateBundleRequest) MarshalJSON() ([]byte, error) {
7584 type NoMethod GoogleCloudIntegrationsV1alphaCreateBundleRequest
7585 raw := NoMethod(*s)
7586 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7587 }
7588
7589
7590
7591 type GoogleCloudIntegrationsV1alphaCreateBundleResponse struct {
7592
7593 Config *GoogleCloudIntegrationsV1alphaIntegrationBundleConfig `json:"config,omitempty"`
7594
7595
7596 TriggerId string `json:"triggerId,omitempty"`
7597
7598
7599
7600 googleapi.ServerResponse `json:"-"`
7601
7602
7603
7604
7605
7606
7607
7608 ForceSendFields []string `json:"-"`
7609
7610
7611
7612
7613
7614
7615
7616 NullFields []string `json:"-"`
7617 }
7618
7619 func (s *GoogleCloudIntegrationsV1alphaCreateBundleResponse) MarshalJSON() ([]byte, error) {
7620 type NoMethod GoogleCloudIntegrationsV1alphaCreateBundleResponse
7621 raw := NoMethod(*s)
7622 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7623 }
7624
7625
7626
7627 type GoogleCloudIntegrationsV1alphaCreateCloudFunctionRequest struct {
7628
7629 FunctionName string `json:"functionName,omitempty"`
7630
7631
7632 FunctionRegion string `json:"functionRegion,omitempty"`
7633
7634
7635
7636 ProjectId string `json:"projectId,omitempty"`
7637
7638
7639
7640
7641
7642
7643
7644 ForceSendFields []string `json:"-"`
7645
7646
7647
7648
7649
7650
7651
7652 NullFields []string `json:"-"`
7653 }
7654
7655 func (s *GoogleCloudIntegrationsV1alphaCreateCloudFunctionRequest) MarshalJSON() ([]byte, error) {
7656 type NoMethod GoogleCloudIntegrationsV1alphaCreateCloudFunctionRequest
7657 raw := NoMethod(*s)
7658 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7659 }
7660
7661
7662
7663 type GoogleCloudIntegrationsV1alphaCreateCloudFunctionResponse struct {
7664
7665 TriggerUrl string `json:"triggerUrl,omitempty"`
7666
7667
7668
7669 googleapi.ServerResponse `json:"-"`
7670
7671
7672
7673
7674
7675
7676
7677 ForceSendFields []string `json:"-"`
7678
7679
7680
7681
7682
7683
7684
7685 NullFields []string `json:"-"`
7686 }
7687
7688 func (s *GoogleCloudIntegrationsV1alphaCreateCloudFunctionResponse) MarshalJSON() ([]byte, error) {
7689 type NoMethod GoogleCloudIntegrationsV1alphaCreateCloudFunctionResponse
7690 raw := NoMethod(*s)
7691 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7692 }
7693
7694
7695
7696 type GoogleCloudIntegrationsV1alphaCredential struct {
7697
7698 AuthToken *GoogleCloudIntegrationsV1alphaAuthToken `json:"authToken,omitempty"`
7699
7700
7701
7702
7703
7704
7705
7706
7707
7708
7709
7710
7711
7712
7713
7714
7715
7716
7717
7718
7719 CredentialType string `json:"credentialType,omitempty"`
7720
7721
7722 Jwt *GoogleCloudIntegrationsV1alphaJwt `json:"jwt,omitempty"`
7723
7724
7725
7726
7727 Oauth2AuthorizationCode *GoogleCloudIntegrationsV1alphaOAuth2AuthorizationCode `json:"oauth2AuthorizationCode,omitempty"`
7728
7729
7730
7731 Oauth2ClientCredentials *GoogleCloudIntegrationsV1alphaOAuth2ClientCredentials `json:"oauth2ClientCredentials,omitempty"`
7732
7733
7734 Oauth2ResourceOwnerCredentials *GoogleCloudIntegrationsV1alphaOAuth2ResourceOwnerCredentials `json:"oauth2ResourceOwnerCredentials,omitempty"`
7735
7736
7737 OidcToken *GoogleCloudIntegrationsV1alphaOidcToken `json:"oidcToken,omitempty"`
7738
7739
7740 ServiceAccountCredentials *GoogleCloudIntegrationsV1alphaServiceAccountCredentials `json:"serviceAccountCredentials,omitempty"`
7741
7742
7743 UsernameAndPassword *GoogleCloudIntegrationsV1alphaUsernameAndPassword `json:"usernameAndPassword,omitempty"`
7744
7745
7746
7747
7748
7749
7750
7751 ForceSendFields []string `json:"-"`
7752
7753
7754
7755
7756
7757
7758
7759 NullFields []string `json:"-"`
7760 }
7761
7762 func (s *GoogleCloudIntegrationsV1alphaCredential) MarshalJSON() ([]byte, error) {
7763 type NoMethod GoogleCloudIntegrationsV1alphaCredential
7764 raw := NoMethod(*s)
7765 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7766 }
7767
7768
7769
7770 type GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionRequest struct {
7771 }
7772
7773
7774
7775 type GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionResponse struct {
7776
7777
7778 googleapi.ServerResponse `json:"-"`
7779 }
7780
7781
7782
7783 type GoogleCloudIntegrationsV1alphaDeprovisionClientRequest struct {
7784 }
7785
7786
7787
7788 type GoogleCloudIntegrationsV1alphaDoubleParameterArray struct {
7789
7790 DoubleValues []float64 `json:"doubleValues,omitempty"`
7791
7792
7793
7794
7795
7796
7797
7798 ForceSendFields []string `json:"-"`
7799
7800
7801
7802
7803
7804
7805
7806 NullFields []string `json:"-"`
7807 }
7808
7809 func (s *GoogleCloudIntegrationsV1alphaDoubleParameterArray) MarshalJSON() ([]byte, error) {
7810 type NoMethod GoogleCloudIntegrationsV1alphaDoubleParameterArray
7811 raw := NoMethod(*s)
7812 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7813 }
7814
7815
7816
7817 type GoogleCloudIntegrationsV1alphaDownloadExecutionResponse struct {
7818
7819 Content string `json:"content,omitempty"`
7820
7821
7822
7823 googleapi.ServerResponse `json:"-"`
7824
7825
7826
7827
7828
7829
7830
7831 ForceSendFields []string `json:"-"`
7832
7833
7834
7835
7836
7837
7838
7839 NullFields []string `json:"-"`
7840 }
7841
7842 func (s *GoogleCloudIntegrationsV1alphaDownloadExecutionResponse) MarshalJSON() ([]byte, error) {
7843 type NoMethod GoogleCloudIntegrationsV1alphaDownloadExecutionResponse
7844 raw := NoMethod(*s)
7845 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7846 }
7847
7848
7849
7850 type GoogleCloudIntegrationsV1alphaDownloadIntegrationVersionResponse struct {
7851
7852 Content string `json:"content,omitempty"`
7853
7854
7855
7856 googleapi.ServerResponse `json:"-"`
7857
7858
7859
7860
7861
7862
7863
7864 ForceSendFields []string `json:"-"`
7865
7866
7867
7868
7869
7870
7871
7872 NullFields []string `json:"-"`
7873 }
7874
7875 func (s *GoogleCloudIntegrationsV1alphaDownloadIntegrationVersionResponse) MarshalJSON() ([]byte, error) {
7876 type NoMethod GoogleCloudIntegrationsV1alphaDownloadIntegrationVersionResponse
7877 raw := NoMethod(*s)
7878 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7879 }
7880
7881
7882
7883
7884 type GoogleCloudIntegrationsV1alphaEnumerateConnectorPlatformRegionsResponse struct {
7885
7886 Regions []string `json:"regions,omitempty"`
7887
7888
7889
7890 googleapi.ServerResponse `json:"-"`
7891
7892
7893
7894
7895
7896
7897
7898 ForceSendFields []string `json:"-"`
7899
7900
7901
7902
7903
7904
7905
7906 NullFields []string `json:"-"`
7907 }
7908
7909 func (s *GoogleCloudIntegrationsV1alphaEnumerateConnectorPlatformRegionsResponse) MarshalJSON() ([]byte, error) {
7910 type NoMethod GoogleCloudIntegrationsV1alphaEnumerateConnectorPlatformRegionsResponse
7911 raw := NoMethod(*s)
7912 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7913 }
7914
7915
7916
7917
7918 type GoogleCloudIntegrationsV1alphaEventParameter struct {
7919
7920
7921
7922 Key string `json:"key,omitempty"`
7923
7924
7925
7926 Value *GoogleCloudIntegrationsV1alphaValueType `json:"value,omitempty"`
7927
7928
7929
7930
7931
7932
7933
7934 ForceSendFields []string `json:"-"`
7935
7936
7937
7938
7939
7940
7941
7942 NullFields []string `json:"-"`
7943 }
7944
7945 func (s *GoogleCloudIntegrationsV1alphaEventParameter) MarshalJSON() ([]byte, error) {
7946 type NoMethod GoogleCloudIntegrationsV1alphaEventParameter
7947 raw := NoMethod(*s)
7948 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
7949 }
7950
7951
7952
7953 type GoogleCloudIntegrationsV1alphaExecuteIntegrationsRequest struct {
7954
7955
7956
7957
7958
7959
7960 DoNotPropagateError bool `json:"doNotPropagateError,omitempty"`
7961
7962
7963 ExecutionId string `json:"executionId,omitempty"`
7964
7965
7966
7967 InputParameters map[string]GoogleCloudIntegrationsV1alphaValueType `json:"inputParameters,omitempty"`
7968
7969
7970
7971
7972 ParameterEntries []*EnterpriseCrmFrontendsEventbusProtoParameterEntry `json:"parameterEntries,omitempty"`
7973
7974
7975
7976 Parameters *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"parameters,omitempty"`
7977
7978
7979
7980
7981 RequestId string `json:"requestId,omitempty"`
7982
7983
7984
7985
7986
7987 TriggerId string `json:"triggerId,omitempty"`
7988
7989
7990
7991
7992
7993
7994
7995 ForceSendFields []string `json:"-"`
7996
7997
7998
7999
8000
8001
8002
8003
8004 NullFields []string `json:"-"`
8005 }
8006
8007 func (s *GoogleCloudIntegrationsV1alphaExecuteIntegrationsRequest) MarshalJSON() ([]byte, error) {
8008 type NoMethod GoogleCloudIntegrationsV1alphaExecuteIntegrationsRequest
8009 raw := NoMethod(*s)
8010 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8011 }
8012
8013
8014
8015 type GoogleCloudIntegrationsV1alphaExecuteIntegrationsResponse struct {
8016
8017 EventParameters *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"eventParameters,omitempty"`
8018
8019
8020
8021 ExecutionFailed bool `json:"executionFailed,omitempty"`
8022
8023
8024
8025 ExecutionId string `json:"executionId,omitempty"`
8026
8027
8028
8029
8030
8031 OutputParameters googleapi.RawMessage `json:"outputParameters,omitempty"`
8032
8033
8034
8035
8036 ParameterEntries []*EnterpriseCrmFrontendsEventbusProtoParameterEntry `json:"parameterEntries,omitempty"`
8037
8038
8039
8040 googleapi.ServerResponse `json:"-"`
8041
8042
8043
8044
8045
8046
8047
8048 ForceSendFields []string `json:"-"`
8049
8050
8051
8052
8053
8054
8055
8056
8057 NullFields []string `json:"-"`
8058 }
8059
8060 func (s *GoogleCloudIntegrationsV1alphaExecuteIntegrationsResponse) MarshalJSON() ([]byte, error) {
8061 type NoMethod GoogleCloudIntegrationsV1alphaExecuteIntegrationsResponse
8062 raw := NoMethod(*s)
8063 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8064 }
8065
8066
8067
8068 type GoogleCloudIntegrationsV1alphaExecution struct {
8069
8070 CreateTime string `json:"createTime,omitempty"`
8071
8072
8073
8074 DirectSubExecutions []*GoogleCloudIntegrationsV1alphaExecution `json:"directSubExecutions,omitempty"`
8075
8076
8077 EventExecutionDetails *EnterpriseCrmEventbusProtoEventExecutionDetails `json:"eventExecutionDetails,omitempty"`
8078
8079
8080 ExecutionDetails *GoogleCloudIntegrationsV1alphaExecutionDetails `json:"executionDetails,omitempty"`
8081
8082
8083
8084
8085
8086
8087
8088
8089 ExecutionMethod string `json:"executionMethod,omitempty"`
8090
8091
8092 Name string `json:"name,omitempty"`
8093
8094
8095 RequestParameters map[string]GoogleCloudIntegrationsV1alphaValueType `json:"requestParameters,omitempty"`
8096
8097
8098 RequestParams []*EnterpriseCrmFrontendsEventbusProtoParameterEntry `json:"requestParams,omitempty"`
8099
8100
8101
8102 ResponseParameters map[string]GoogleCloudIntegrationsV1alphaValueType `json:"responseParameters,omitempty"`
8103
8104
8105 ResponseParams []*EnterpriseCrmFrontendsEventbusProtoParameterEntry `json:"responseParams,omitempty"`
8106
8107
8108
8109
8110
8111 TriggerId string `json:"triggerId,omitempty"`
8112
8113
8114 UpdateTime string `json:"updateTime,omitempty"`
8115
8116
8117
8118 googleapi.ServerResponse `json:"-"`
8119
8120
8121
8122
8123
8124
8125
8126 ForceSendFields []string `json:"-"`
8127
8128
8129
8130
8131
8132
8133
8134 NullFields []string `json:"-"`
8135 }
8136
8137 func (s *GoogleCloudIntegrationsV1alphaExecution) MarshalJSON() ([]byte, error) {
8138 type NoMethod GoogleCloudIntegrationsV1alphaExecution
8139 raw := NoMethod(*s)
8140 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8141 }
8142
8143
8144
8145
8146 type GoogleCloudIntegrationsV1alphaExecutionDetails struct {
8147
8148 AttemptStats []*GoogleCloudIntegrationsV1alphaAttemptStats `json:"attemptStats,omitempty"`
8149
8150
8151 ExecutionSnapshots []*GoogleCloudIntegrationsV1alphaExecutionSnapshot `json:"executionSnapshots,omitempty"`
8152
8153
8154
8155
8156
8157
8158
8159
8160
8161
8162
8163
8164
8165
8166
8167
8168 State string `json:"state,omitempty"`
8169
8170
8171
8172
8173
8174
8175
8176 ForceSendFields []string `json:"-"`
8177
8178
8179
8180
8181
8182
8183
8184 NullFields []string `json:"-"`
8185 }
8186
8187 func (s *GoogleCloudIntegrationsV1alphaExecutionDetails) MarshalJSON() ([]byte, error) {
8188 type NoMethod GoogleCloudIntegrationsV1alphaExecutionDetails
8189 raw := NoMethod(*s)
8190 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8191 }
8192
8193
8194
8195 type GoogleCloudIntegrationsV1alphaExecutionSnapshot struct {
8196
8197
8198 CheckpointTaskNumber string `json:"checkpointTaskNumber,omitempty"`
8199
8200
8201 ExecutionSnapshotMetadata *GoogleCloudIntegrationsV1alphaExecutionSnapshotExecutionSnapshotMetadata `json:"executionSnapshotMetadata,omitempty"`
8202
8203
8204 Params map[string]GoogleCloudIntegrationsV1alphaValueType `json:"params,omitempty"`
8205
8206
8207
8208 TaskExecutionDetails []*GoogleCloudIntegrationsV1alphaTaskExecutionDetails `json:"taskExecutionDetails,omitempty"`
8209
8210
8211
8212
8213
8214
8215
8216
8217 ForceSendFields []string `json:"-"`
8218
8219
8220
8221
8222
8223
8224
8225
8226 NullFields []string `json:"-"`
8227 }
8228
8229 func (s *GoogleCloudIntegrationsV1alphaExecutionSnapshot) MarshalJSON() ([]byte, error) {
8230 type NoMethod GoogleCloudIntegrationsV1alphaExecutionSnapshot
8231 raw := NoMethod(*s)
8232 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8233 }
8234
8235
8236
8237 type GoogleCloudIntegrationsV1alphaExecutionSnapshotExecutionSnapshotMetadata struct {
8238
8239
8240 ExecutionAttempt int64 `json:"executionAttempt,omitempty"`
8241
8242
8243 Task string `json:"task,omitempty"`
8244
8245
8246 TaskAttempt int64 `json:"taskAttempt,omitempty"`
8247
8248
8249 TaskNumber string `json:"taskNumber,omitempty"`
8250
8251
8252
8253
8254
8255
8256
8257 ForceSendFields []string `json:"-"`
8258
8259
8260
8261
8262
8263
8264
8265
8266 NullFields []string `json:"-"`
8267 }
8268
8269 func (s *GoogleCloudIntegrationsV1alphaExecutionSnapshotExecutionSnapshotMetadata) MarshalJSON() ([]byte, error) {
8270 type NoMethod GoogleCloudIntegrationsV1alphaExecutionSnapshotExecutionSnapshotMetadata
8271 raw := NoMethod(*s)
8272 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8273 }
8274
8275
8276
8277
8278
8279 type GoogleCloudIntegrationsV1alphaFailurePolicy struct {
8280
8281
8282
8283 IntervalTime string `json:"intervalTime,omitempty"`
8284
8285
8286
8287
8288 MaxRetries int64 `json:"maxRetries,omitempty"`
8289
8290
8291
8292
8293
8294
8295
8296
8297
8298
8299
8300
8301
8302
8303
8304
8305
8306
8307
8308
8309
8310
8311
8312
8313
8314
8315
8316
8317
8318
8319
8320
8321
8322
8323
8324
8325
8326 RetryStrategy string `json:"retryStrategy,omitempty"`
8327
8328
8329
8330
8331
8332
8333
8334 ForceSendFields []string `json:"-"`
8335
8336
8337
8338
8339
8340
8341
8342 NullFields []string `json:"-"`
8343 }
8344
8345 func (s *GoogleCloudIntegrationsV1alphaFailurePolicy) MarshalJSON() ([]byte, error) {
8346 type NoMethod GoogleCloudIntegrationsV1alphaFailurePolicy
8347 raw := NoMethod(*s)
8348 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8349 }
8350
8351
8352
8353 type GoogleCloudIntegrationsV1alphaGenerateTokenResponse struct {
8354
8355
8356 Message string `json:"message,omitempty"`
8357
8358
8359
8360 googleapi.ServerResponse `json:"-"`
8361
8362
8363
8364
8365
8366
8367
8368 ForceSendFields []string `json:"-"`
8369
8370
8371
8372
8373
8374
8375
8376 NullFields []string `json:"-"`
8377 }
8378
8379 func (s *GoogleCloudIntegrationsV1alphaGenerateTokenResponse) MarshalJSON() ([]byte, error) {
8380 type NoMethod GoogleCloudIntegrationsV1alphaGenerateTokenResponse
8381 raw := NoMethod(*s)
8382 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8383 }
8384
8385
8386
8387 type GoogleCloudIntegrationsV1alphaGetBundleResponse struct {
8388
8389 Config *GoogleCloudIntegrationsV1alphaIntegrationBundleConfig `json:"config,omitempty"`
8390
8391
8392
8393 googleapi.ServerResponse `json:"-"`
8394
8395
8396
8397
8398
8399
8400
8401 ForceSendFields []string `json:"-"`
8402
8403
8404
8405
8406
8407
8408
8409 NullFields []string `json:"-"`
8410 }
8411
8412 func (s *GoogleCloudIntegrationsV1alphaGetBundleResponse) MarshalJSON() ([]byte, error) {
8413 type NoMethod GoogleCloudIntegrationsV1alphaGetBundleResponse
8414 raw := NoMethod(*s)
8415 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8416 }
8417
8418
8419
8420 type GoogleCloudIntegrationsV1alphaGetClientMetadataResponse struct {
8421
8422
8423 Properties *GoogleCloudIntegrationsV1alphaProjectProperties `json:"properties,omitempty"`
8424
8425
8426
8427 googleapi.ServerResponse `json:"-"`
8428
8429
8430
8431
8432
8433
8434
8435 ForceSendFields []string `json:"-"`
8436
8437
8438
8439
8440
8441
8442
8443 NullFields []string `json:"-"`
8444 }
8445
8446 func (s *GoogleCloudIntegrationsV1alphaGetClientMetadataResponse) MarshalJSON() ([]byte, error) {
8447 type NoMethod GoogleCloudIntegrationsV1alphaGetClientMetadataResponse
8448 raw := NoMethod(*s)
8449 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8450 }
8451
8452
8453
8454 type GoogleCloudIntegrationsV1alphaGetClientResponse struct {
8455
8456
8457 Client *GoogleCloudIntegrationsV1alphaClientConfig `json:"client,omitempty"`
8458
8459
8460
8461 googleapi.ServerResponse `json:"-"`
8462
8463
8464
8465
8466
8467
8468
8469 ForceSendFields []string `json:"-"`
8470
8471
8472
8473
8474
8475
8476
8477 NullFields []string `json:"-"`
8478 }
8479
8480 func (s *GoogleCloudIntegrationsV1alphaGetClientResponse) MarshalJSON() ([]byte, error) {
8481 type NoMethod GoogleCloudIntegrationsV1alphaGetClientResponse
8482 raw := NoMethod(*s)
8483 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8484 }
8485
8486
8487
8488 type GoogleCloudIntegrationsV1alphaIntParameterArray struct {
8489
8490 IntValues googleapi.Int64s `json:"intValues,omitempty"`
8491
8492
8493
8494
8495
8496
8497
8498 ForceSendFields []string `json:"-"`
8499
8500
8501
8502
8503
8504
8505
8506 NullFields []string `json:"-"`
8507 }
8508
8509 func (s *GoogleCloudIntegrationsV1alphaIntParameterArray) MarshalJSON() ([]byte, error) {
8510 type NoMethod GoogleCloudIntegrationsV1alphaIntParameterArray
8511 raw := NoMethod(*s)
8512 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8513 }
8514
8515
8516
8517 type GoogleCloudIntegrationsV1alphaIntegration struct {
8518
8519 Active bool `json:"active,omitempty"`
8520
8521
8522 Description string `json:"description,omitempty"`
8523
8524
8525 Name string `json:"name,omitempty"`
8526
8527
8528 UpdateTime string `json:"updateTime,omitempty"`
8529
8530
8531
8532
8533
8534
8535
8536 ForceSendFields []string `json:"-"`
8537
8538
8539
8540
8541
8542
8543
8544 NullFields []string `json:"-"`
8545 }
8546
8547 func (s *GoogleCloudIntegrationsV1alphaIntegration) MarshalJSON() ([]byte, error) {
8548 type NoMethod GoogleCloudIntegrationsV1alphaIntegration
8549 raw := NoMethod(*s)
8550 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8551 }
8552
8553
8554
8555
8556 type GoogleCloudIntegrationsV1alphaIntegrationAlertConfig struct {
8557
8558
8559
8560
8561
8562 AggregationPeriod string `json:"aggregationPeriod,omitempty"`
8563
8564
8565
8566 AlertThreshold int64 `json:"alertThreshold,omitempty"`
8567
8568
8569
8570 DisableAlert bool `json:"disableAlert,omitempty"`
8571
8572
8573
8574
8575 DisplayName string `json:"displayName,omitempty"`
8576
8577
8578
8579
8580
8581 DurationThreshold string `json:"durationThreshold,omitempty"`
8582
8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
8593
8594
8595
8596
8597
8598
8599
8600
8601
8602
8603
8604
8605
8606
8607
8608
8609
8610
8611
8612
8613
8614 MetricType string `json:"metricType,omitempty"`
8615
8616
8617
8618 OnlyFinalAttempt bool `json:"onlyFinalAttempt,omitempty"`
8619
8620
8621
8622
8623
8624
8625
8626
8627
8628
8629
8630
8631
8632
8633 ThresholdType string `json:"thresholdType,omitempty"`
8634
8635
8636
8637 ThresholdValue *GoogleCloudIntegrationsV1alphaIntegrationAlertConfigThresholdValue `json:"thresholdValue,omitempty"`
8638
8639
8640
8641
8642
8643
8644
8645 ForceSendFields []string `json:"-"`
8646
8647
8648
8649
8650
8651
8652
8653
8654 NullFields []string `json:"-"`
8655 }
8656
8657 func (s *GoogleCloudIntegrationsV1alphaIntegrationAlertConfig) MarshalJSON() ([]byte, error) {
8658 type NoMethod GoogleCloudIntegrationsV1alphaIntegrationAlertConfig
8659 raw := NoMethod(*s)
8660 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8661 }
8662
8663
8664
8665
8666
8667
8668
8669
8670
8671
8672
8673
8674 type GoogleCloudIntegrationsV1alphaIntegrationAlertConfigThresholdValue struct {
8675
8676 Absolute int64 `json:"absolute,omitempty,string"`
8677
8678
8679 Percentage int64 `json:"percentage,omitempty"`
8680
8681
8682
8683
8684
8685
8686
8687 ForceSendFields []string `json:"-"`
8688
8689
8690
8691
8692
8693
8694
8695 NullFields []string `json:"-"`
8696 }
8697
8698 func (s *GoogleCloudIntegrationsV1alphaIntegrationAlertConfigThresholdValue) MarshalJSON() ([]byte, error) {
8699 type NoMethod GoogleCloudIntegrationsV1alphaIntegrationAlertConfigThresholdValue
8700 raw := NoMethod(*s)
8701 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8702 }
8703
8704
8705
8706
8707
8708 type GoogleCloudIntegrationsV1alphaIntegrationBundleConfig struct {
8709
8710
8711 Integrations []string `json:"integrations,omitempty"`
8712
8713
8714
8715 ServiceAccount string `json:"serviceAccount,omitempty"`
8716
8717
8718
8719
8720
8721
8722
8723 ForceSendFields []string `json:"-"`
8724
8725
8726
8727
8728
8729
8730
8731 NullFields []string `json:"-"`
8732 }
8733
8734 func (s *GoogleCloudIntegrationsV1alphaIntegrationBundleConfig) MarshalJSON() ([]byte, error) {
8735 type NoMethod GoogleCloudIntegrationsV1alphaIntegrationBundleConfig
8736 raw := NoMethod(*s)
8737 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8738 }
8739
8740
8741
8742
8743
8744
8745
8746 type GoogleCloudIntegrationsV1alphaIntegrationParameter struct {
8747
8748
8749
8750
8751
8752
8753
8754
8755
8756
8757
8758
8759
8760
8761
8762 DataType string `json:"dataType,omitempty"`
8763
8764
8765
8766
8767 DefaultValue *GoogleCloudIntegrationsV1alphaValueType `json:"defaultValue,omitempty"`
8768
8769
8770
8771
8772 DisplayName string `json:"displayName,omitempty"`
8773
8774
8775
8776
8777
8778
8779
8780
8781
8782
8783
8784
8785
8786
8787 InputOutputType string `json:"inputOutputType,omitempty"`
8788
8789
8790 IsTransient bool `json:"isTransient,omitempty"`
8791
8792
8793
8794 JsonSchema string `json:"jsonSchema,omitempty"`
8795
8796
8797
8798
8799 Key string `json:"key,omitempty"`
8800
8801
8802
8803
8804 Producer string `json:"producer,omitempty"`
8805
8806
8807 Searchable bool `json:"searchable,omitempty"`
8808
8809
8810
8811
8812
8813
8814
8815 ForceSendFields []string `json:"-"`
8816
8817
8818
8819
8820
8821
8822
8823 NullFields []string `json:"-"`
8824 }
8825
8826 func (s *GoogleCloudIntegrationsV1alphaIntegrationParameter) MarshalJSON() ([]byte, error) {
8827 type NoMethod GoogleCloudIntegrationsV1alphaIntegrationParameter
8828 raw := NoMethod(*s)
8829 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8830 }
8831
8832
8833
8834 type GoogleCloudIntegrationsV1alphaIntegrationVersion struct {
8835
8836 CreateTime string `json:"createTime,omitempty"`
8837
8838
8839
8840
8841
8842
8843
8844
8845
8846
8847
8848 DatabasePersistencePolicy string `json:"databasePersistencePolicy,omitempty"`
8849
8850
8851 Description string `json:"description,omitempty"`
8852
8853
8854
8855
8856
8857
8858 IntegrationParameters []*GoogleCloudIntegrationsV1alphaIntegrationParameter `json:"integrationParameters,omitempty"`
8859
8860
8861
8862
8863
8864
8865
8866 IntegrationParametersInternal *EnterpriseCrmFrontendsEventbusProtoWorkflowParameters `json:"integrationParametersInternal,omitempty"`
8867
8868
8869
8870
8871 LastModifierEmail string `json:"lastModifierEmail,omitempty"`
8872
8873
8874
8875
8876 LockHolder string `json:"lockHolder,omitempty"`
8877
8878
8879 Name string `json:"name,omitempty"`
8880
8881
8882
8883
8884
8885
8886
8887
8888
8889
8890
8891
8892
8893 Origin string `json:"origin,omitempty"`
8894
8895
8896
8897 ParentTemplateId string `json:"parentTemplateId,omitempty"`
8898
8899
8900
8901
8902
8903
8904 SnapshotNumber int64 `json:"snapshotNumber,omitempty,string"`
8905
8906
8907
8908
8909
8910
8911
8912
8913
8914 State string `json:"state,omitempty"`
8915
8916
8917
8918
8919
8920
8921
8922
8923
8924
8925 Status string `json:"status,omitempty"`
8926
8927
8928
8929
8930 TaskConfigs []*GoogleCloudIntegrationsV1alphaTaskConfig `json:"taskConfigs,omitempty"`
8931
8932
8933
8934
8935 TaskConfigsInternal []*EnterpriseCrmFrontendsEventbusProtoTaskConfig `json:"taskConfigsInternal,omitempty"`
8936
8937
8938
8939
8940
8941 Teardown *EnterpriseCrmEventbusProtoTeardown `json:"teardown,omitempty"`
8942
8943
8944 TriggerConfigs []*GoogleCloudIntegrationsV1alphaTriggerConfig `json:"triggerConfigs,omitempty"`
8945
8946
8947 TriggerConfigsInternal []*EnterpriseCrmFrontendsEventbusProtoTriggerConfig `json:"triggerConfigsInternal,omitempty"`
8948
8949
8950 UpdateTime string `json:"updateTime,omitempty"`
8951
8952
8953
8954
8955 UserLabel string `json:"userLabel,omitempty"`
8956
8957
8958
8959 googleapi.ServerResponse `json:"-"`
8960
8961
8962
8963
8964
8965
8966
8967 ForceSendFields []string `json:"-"`
8968
8969
8970
8971
8972
8973
8974
8975 NullFields []string `json:"-"`
8976 }
8977
8978 func (s *GoogleCloudIntegrationsV1alphaIntegrationVersion) MarshalJSON() ([]byte, error) {
8979 type NoMethod GoogleCloudIntegrationsV1alphaIntegrationVersion
8980 raw := NoMethod(*s)
8981 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
8982 }
8983
8984
8985
8986
8987
8988 type GoogleCloudIntegrationsV1alphaJwt struct {
8989
8990 Jwt string `json:"jwt,omitempty"`
8991
8992
8993
8994 JwtHeader string `json:"jwtHeader,omitempty"`
8995
8996
8997
8998
8999
9000 JwtPayload string `json:"jwtPayload,omitempty"`
9001
9002
9003 Secret string `json:"secret,omitempty"`
9004
9005
9006
9007
9008
9009
9010
9011 ForceSendFields []string `json:"-"`
9012
9013
9014
9015
9016
9017
9018
9019 NullFields []string `json:"-"`
9020 }
9021
9022 func (s *GoogleCloudIntegrationsV1alphaJwt) MarshalJSON() ([]byte, error) {
9023 type NoMethod GoogleCloudIntegrationsV1alphaJwt
9024 raw := NoMethod(*s)
9025 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9026 }
9027
9028
9029
9030 type GoogleCloudIntegrationsV1alphaLiftSuspensionRequest struct {
9031
9032
9033
9034
9035
9036
9037
9038 SuspensionResult string `json:"suspensionResult,omitempty"`
9039
9040
9041
9042
9043
9044
9045
9046 ForceSendFields []string `json:"-"`
9047
9048
9049
9050
9051
9052
9053
9054
9055 NullFields []string `json:"-"`
9056 }
9057
9058 func (s *GoogleCloudIntegrationsV1alphaLiftSuspensionRequest) MarshalJSON() ([]byte, error) {
9059 type NoMethod GoogleCloudIntegrationsV1alphaLiftSuspensionRequest
9060 raw := NoMethod(*s)
9061 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9062 }
9063
9064
9065
9066 type GoogleCloudIntegrationsV1alphaLiftSuspensionResponse struct {
9067
9068 EventExecutionInfoId string `json:"eventExecutionInfoId,omitempty"`
9069
9070
9071
9072 googleapi.ServerResponse `json:"-"`
9073
9074
9075
9076
9077
9078
9079
9080
9081 ForceSendFields []string `json:"-"`
9082
9083
9084
9085
9086
9087
9088
9089
9090 NullFields []string `json:"-"`
9091 }
9092
9093 func (s *GoogleCloudIntegrationsV1alphaLiftSuspensionResponse) MarshalJSON() ([]byte, error) {
9094 type NoMethod GoogleCloudIntegrationsV1alphaLiftSuspensionResponse
9095 raw := NoMethod(*s)
9096 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9097 }
9098
9099
9100
9101 type GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectRequest struct {
9102
9103 ScriptId string `json:"scriptId,omitempty"`
9104
9105
9106
9107
9108
9109
9110
9111 ForceSendFields []string `json:"-"`
9112
9113
9114
9115
9116
9117
9118
9119 NullFields []string `json:"-"`
9120 }
9121
9122 func (s *GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectRequest) MarshalJSON() ([]byte, error) {
9123 type NoMethod GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectRequest
9124 raw := NoMethod(*s)
9125 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9126 }
9127
9128
9129
9130 type GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectResponse struct {
9131
9132 ScriptId string `json:"scriptId,omitempty"`
9133
9134
9135
9136 googleapi.ServerResponse `json:"-"`
9137
9138
9139
9140
9141
9142
9143
9144 ForceSendFields []string `json:"-"`
9145
9146
9147
9148
9149
9150
9151
9152 NullFields []string `json:"-"`
9153 }
9154
9155 func (s *GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectResponse) MarshalJSON() ([]byte, error) {
9156 type NoMethod GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectResponse
9157 raw := NoMethod(*s)
9158 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9159 }
9160
9161
9162
9163 type GoogleCloudIntegrationsV1alphaListAuthConfigsResponse struct {
9164
9165 AuthConfigs []*GoogleCloudIntegrationsV1alphaAuthConfig `json:"authConfigs,omitempty"`
9166
9167
9168 NextPageToken string `json:"nextPageToken,omitempty"`
9169
9170
9171
9172 googleapi.ServerResponse `json:"-"`
9173
9174
9175
9176
9177
9178
9179
9180 ForceSendFields []string `json:"-"`
9181
9182
9183
9184
9185
9186
9187
9188 NullFields []string `json:"-"`
9189 }
9190
9191 func (s *GoogleCloudIntegrationsV1alphaListAuthConfigsResponse) MarshalJSON() ([]byte, error) {
9192 type NoMethod GoogleCloudIntegrationsV1alphaListAuthConfigsResponse
9193 raw := NoMethod(*s)
9194 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9195 }
9196
9197
9198
9199 type GoogleCloudIntegrationsV1alphaListCertificatesResponse struct {
9200
9201 Certificates []*GoogleCloudIntegrationsV1alphaCertificate `json:"certificates,omitempty"`
9202
9203
9204 NextPageToken string `json:"nextPageToken,omitempty"`
9205
9206
9207
9208 googleapi.ServerResponse `json:"-"`
9209
9210
9211
9212
9213
9214
9215
9216 ForceSendFields []string `json:"-"`
9217
9218
9219
9220
9221
9222
9223
9224 NullFields []string `json:"-"`
9225 }
9226
9227 func (s *GoogleCloudIntegrationsV1alphaListCertificatesResponse) MarshalJSON() ([]byte, error) {
9228 type NoMethod GoogleCloudIntegrationsV1alphaListCertificatesResponse
9229 raw := NoMethod(*s)
9230 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9231 }
9232
9233
9234
9235 type GoogleCloudIntegrationsV1alphaListConnectionsResponse struct {
9236
9237 Connections []*GoogleCloudConnectorsV1Connection `json:"connections,omitempty"`
9238
9239
9240 NextPageToken string `json:"nextPageToken,omitempty"`
9241
9242
9243
9244 googleapi.ServerResponse `json:"-"`
9245
9246
9247
9248
9249
9250
9251
9252 ForceSendFields []string `json:"-"`
9253
9254
9255
9256
9257
9258
9259
9260 NullFields []string `json:"-"`
9261 }
9262
9263 func (s *GoogleCloudIntegrationsV1alphaListConnectionsResponse) MarshalJSON() ([]byte, error) {
9264 type NoMethod GoogleCloudIntegrationsV1alphaListConnectionsResponse
9265 raw := NoMethod(*s)
9266 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9267 }
9268
9269
9270
9271 type GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse struct {
9272
9273
9274 ExecutionSnapshots []*EnterpriseCrmEventbusProtoEventExecutionSnapshot `json:"executionSnapshots,omitempty"`
9275
9276
9277 NextPageToken string `json:"nextPageToken,omitempty"`
9278
9279
9280
9281 googleapi.ServerResponse `json:"-"`
9282
9283
9284
9285
9286
9287
9288
9289 ForceSendFields []string `json:"-"`
9290
9291
9292
9293
9294
9295
9296
9297
9298 NullFields []string `json:"-"`
9299 }
9300
9301 func (s *GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse) MarshalJSON() ([]byte, error) {
9302 type NoMethod GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse
9303 raw := NoMethod(*s)
9304 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9305 }
9306
9307
9308
9309 type GoogleCloudIntegrationsV1alphaListExecutionsResponse struct {
9310
9311
9312 ExecutionInfos []*EnterpriseCrmFrontendsEventbusProtoEventExecutionInfo `json:"executionInfos,omitempty"`
9313
9314
9315 Executions []*GoogleCloudIntegrationsV1alphaExecution `json:"executions,omitempty"`
9316
9317
9318 NextPageToken string `json:"nextPageToken,omitempty"`
9319
9320
9321
9322 googleapi.ServerResponse `json:"-"`
9323
9324
9325
9326
9327
9328
9329
9330 ForceSendFields []string `json:"-"`
9331
9332
9333
9334
9335
9336
9337
9338
9339 NullFields []string `json:"-"`
9340 }
9341
9342 func (s *GoogleCloudIntegrationsV1alphaListExecutionsResponse) MarshalJSON() ([]byte, error) {
9343 type NoMethod GoogleCloudIntegrationsV1alphaListExecutionsResponse
9344 raw := NoMethod(*s)
9345 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9346 }
9347
9348
9349
9350 type GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse struct {
9351
9352 IntegrationVersions []*GoogleCloudIntegrationsV1alphaIntegrationVersion `json:"integrationVersions,omitempty"`
9353
9354
9355
9356
9357 NextPageToken string `json:"nextPageToken,omitempty"`
9358
9359
9360
9361 NoPermission bool `json:"noPermission,omitempty"`
9362
9363
9364
9365 googleapi.ServerResponse `json:"-"`
9366
9367
9368
9369
9370
9371
9372
9373 ForceSendFields []string `json:"-"`
9374
9375
9376
9377
9378
9379
9380
9381
9382 NullFields []string `json:"-"`
9383 }
9384
9385 func (s *GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse) MarshalJSON() ([]byte, error) {
9386 type NoMethod GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse
9387 raw := NoMethod(*s)
9388 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9389 }
9390
9391
9392
9393 type GoogleCloudIntegrationsV1alphaListIntegrationsResponse struct {
9394
9395 Integrations []*GoogleCloudIntegrationsV1alphaIntegration `json:"integrations,omitempty"`
9396
9397
9398 NextPageToken string `json:"nextPageToken,omitempty"`
9399
9400
9401
9402 googleapi.ServerResponse `json:"-"`
9403
9404
9405
9406
9407
9408
9409
9410 ForceSendFields []string `json:"-"`
9411
9412
9413
9414
9415
9416
9417
9418 NullFields []string `json:"-"`
9419 }
9420
9421 func (s *GoogleCloudIntegrationsV1alphaListIntegrationsResponse) MarshalJSON() ([]byte, error) {
9422 type NoMethod GoogleCloudIntegrationsV1alphaListIntegrationsResponse
9423 raw := NoMethod(*s)
9424 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9425 }
9426
9427
9428
9429 type GoogleCloudIntegrationsV1alphaListRuntimeActionSchemasResponse struct {
9430
9431 NextPageToken string `json:"nextPageToken,omitempty"`
9432
9433
9434 RuntimeActionSchemas []*GoogleCloudIntegrationsV1alphaRuntimeActionSchema `json:"runtimeActionSchemas,omitempty"`
9435
9436
9437
9438 googleapi.ServerResponse `json:"-"`
9439
9440
9441
9442
9443
9444
9445
9446 ForceSendFields []string `json:"-"`
9447
9448
9449
9450
9451
9452
9453
9454 NullFields []string `json:"-"`
9455 }
9456
9457 func (s *GoogleCloudIntegrationsV1alphaListRuntimeActionSchemasResponse) MarshalJSON() ([]byte, error) {
9458 type NoMethod GoogleCloudIntegrationsV1alphaListRuntimeActionSchemasResponse
9459 raw := NoMethod(*s)
9460 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9461 }
9462
9463
9464
9465 type GoogleCloudIntegrationsV1alphaListRuntimeEntitySchemasResponse struct {
9466
9467 NextPageToken string `json:"nextPageToken,omitempty"`
9468
9469
9470 RuntimeEntitySchemas []*GoogleCloudIntegrationsV1alphaRuntimeEntitySchema `json:"runtimeEntitySchemas,omitempty"`
9471
9472
9473
9474 googleapi.ServerResponse `json:"-"`
9475
9476
9477
9478
9479
9480
9481
9482 ForceSendFields []string `json:"-"`
9483
9484
9485
9486
9487
9488
9489
9490 NullFields []string `json:"-"`
9491 }
9492
9493 func (s *GoogleCloudIntegrationsV1alphaListRuntimeEntitySchemasResponse) MarshalJSON() ([]byte, error) {
9494 type NoMethod GoogleCloudIntegrationsV1alphaListRuntimeEntitySchemasResponse
9495 raw := NoMethod(*s)
9496 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9497 }
9498
9499
9500
9501 type GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse struct {
9502
9503 NextPageToken string `json:"nextPageToken,omitempty"`
9504
9505
9506 SfdcChannels []*GoogleCloudIntegrationsV1alphaSfdcChannel `json:"sfdcChannels,omitempty"`
9507
9508
9509
9510 googleapi.ServerResponse `json:"-"`
9511
9512
9513
9514
9515
9516
9517
9518 ForceSendFields []string `json:"-"`
9519
9520
9521
9522
9523
9524
9525
9526 NullFields []string `json:"-"`
9527 }
9528
9529 func (s *GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse) MarshalJSON() ([]byte, error) {
9530 type NoMethod GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse
9531 raw := NoMethod(*s)
9532 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9533 }
9534
9535
9536
9537 type GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse struct {
9538
9539 NextPageToken string `json:"nextPageToken,omitempty"`
9540
9541
9542 SfdcInstances []*GoogleCloudIntegrationsV1alphaSfdcInstance `json:"sfdcInstances,omitempty"`
9543
9544
9545
9546 googleapi.ServerResponse `json:"-"`
9547
9548
9549
9550
9551
9552
9553
9554 ForceSendFields []string `json:"-"`
9555
9556
9557
9558
9559
9560
9561
9562 NullFields []string `json:"-"`
9563 }
9564
9565 func (s *GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse) MarshalJSON() ([]byte, error) {
9566 type NoMethod GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse
9567 raw := NoMethod(*s)
9568 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9569 }
9570
9571
9572
9573 type GoogleCloudIntegrationsV1alphaListSuspensionsResponse struct {
9574
9575 NextPageToken string `json:"nextPageToken,omitempty"`
9576
9577
9578
9579 Suspensions []*GoogleCloudIntegrationsV1alphaSuspension `json:"suspensions,omitempty"`
9580
9581
9582
9583 googleapi.ServerResponse `json:"-"`
9584
9585
9586
9587
9588
9589
9590
9591 ForceSendFields []string `json:"-"`
9592
9593
9594
9595
9596
9597
9598
9599 NullFields []string `json:"-"`
9600 }
9601
9602 func (s *GoogleCloudIntegrationsV1alphaListSuspensionsResponse) MarshalJSON() ([]byte, error) {
9603 type NoMethod GoogleCloudIntegrationsV1alphaListSuspensionsResponse
9604 raw := NoMethod(*s)
9605 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9606 }
9607
9608
9609
9610 type GoogleCloudIntegrationsV1alphaListTaskEntitiesResponse struct {
9611
9612 TaskEntities []*EnterpriseCrmFrontendsEventbusProtoTaskEntity `json:"taskEntities,omitempty"`
9613
9614
9615
9616 googleapi.ServerResponse `json:"-"`
9617
9618
9619
9620
9621
9622
9623
9624 ForceSendFields []string `json:"-"`
9625
9626
9627
9628
9629
9630
9631
9632 NullFields []string `json:"-"`
9633 }
9634
9635 func (s *GoogleCloudIntegrationsV1alphaListTaskEntitiesResponse) MarshalJSON() ([]byte, error) {
9636 type NoMethod GoogleCloudIntegrationsV1alphaListTaskEntitiesResponse
9637 raw := NoMethod(*s)
9638 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9639 }
9640
9641
9642
9643 type GoogleCloudIntegrationsV1alphaNextTask struct {
9644
9645
9646 Condition string `json:"condition,omitempty"`
9647
9648
9649
9650 Description string `json:"description,omitempty"`
9651
9652
9653
9654 DisplayName string `json:"displayName,omitempty"`
9655
9656
9657 TaskConfigId string `json:"taskConfigId,omitempty"`
9658
9659
9660 TaskId string `json:"taskId,omitempty"`
9661
9662
9663
9664
9665
9666
9667
9668 ForceSendFields []string `json:"-"`
9669
9670
9671
9672
9673
9674
9675
9676 NullFields []string `json:"-"`
9677 }
9678
9679 func (s *GoogleCloudIntegrationsV1alphaNextTask) MarshalJSON() ([]byte, error) {
9680 type NoMethod GoogleCloudIntegrationsV1alphaNextTask
9681 raw := NoMethod(*s)
9682 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9683 }
9684
9685
9686
9687
9688
9689
9690
9691
9692 type GoogleCloudIntegrationsV1alphaOAuth2AuthorizationCode struct {
9693
9694 AccessToken *GoogleCloudIntegrationsV1alphaAccessToken `json:"accessToken,omitempty"`
9695
9696
9697
9698
9699
9700 ApplyReauthPolicy bool `json:"applyReauthPolicy,omitempty"`
9701
9702
9703
9704 AuthCode string `json:"authCode,omitempty"`
9705
9706
9707 AuthEndpoint string `json:"authEndpoint,omitempty"`
9708
9709
9710
9711 AuthParams *GoogleCloudIntegrationsV1alphaParameterMap `json:"authParams,omitempty"`
9712
9713
9714 ClientId string `json:"clientId,omitempty"`
9715
9716
9717 ClientSecret string `json:"clientSecret,omitempty"`
9718
9719
9720
9721
9722
9723
9724
9725
9726
9727
9728
9729 RequestType string `json:"requestType,omitempty"`
9730
9731
9732 Scope string `json:"scope,omitempty"`
9733
9734
9735 TokenEndpoint string `json:"tokenEndpoint,omitempty"`
9736
9737
9738 TokenParams *GoogleCloudIntegrationsV1alphaParameterMap `json:"tokenParams,omitempty"`
9739
9740
9741
9742
9743
9744
9745
9746 ForceSendFields []string `json:"-"`
9747
9748
9749
9750
9751
9752
9753
9754 NullFields []string `json:"-"`
9755 }
9756
9757 func (s *GoogleCloudIntegrationsV1alphaOAuth2AuthorizationCode) MarshalJSON() ([]byte, error) {
9758 type NoMethod GoogleCloudIntegrationsV1alphaOAuth2AuthorizationCode
9759 raw := NoMethod(*s)
9760 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9761 }
9762
9763
9764
9765
9766
9767 type GoogleCloudIntegrationsV1alphaOAuth2ClientCredentials struct {
9768
9769 AccessToken *GoogleCloudIntegrationsV1alphaAccessToken `json:"accessToken,omitempty"`
9770
9771
9772 ClientId string `json:"clientId,omitempty"`
9773
9774
9775 ClientSecret string `json:"clientSecret,omitempty"`
9776
9777
9778
9779
9780
9781
9782
9783
9784
9785
9786
9787 RequestType string `json:"requestType,omitempty"`
9788
9789
9790 Scope string `json:"scope,omitempty"`
9791
9792
9793
9794 TokenEndpoint string `json:"tokenEndpoint,omitempty"`
9795
9796
9797 TokenParams *GoogleCloudIntegrationsV1alphaParameterMap `json:"tokenParams,omitempty"`
9798
9799
9800
9801
9802
9803
9804
9805 ForceSendFields []string `json:"-"`
9806
9807
9808
9809
9810
9811
9812
9813 NullFields []string `json:"-"`
9814 }
9815
9816 func (s *GoogleCloudIntegrationsV1alphaOAuth2ClientCredentials) MarshalJSON() ([]byte, error) {
9817 type NoMethod GoogleCloudIntegrationsV1alphaOAuth2ClientCredentials
9818 raw := NoMethod(*s)
9819 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9820 }
9821
9822
9823
9824
9825
9826
9827
9828 type GoogleCloudIntegrationsV1alphaOAuth2ResourceOwnerCredentials struct {
9829
9830 AccessToken *GoogleCloudIntegrationsV1alphaAccessToken `json:"accessToken,omitempty"`
9831
9832
9833 ClientId string `json:"clientId,omitempty"`
9834
9835
9836 ClientSecret string `json:"clientSecret,omitempty"`
9837
9838
9839 Password string `json:"password,omitempty"`
9840
9841
9842
9843
9844
9845
9846
9847
9848
9849
9850
9851 RequestType string `json:"requestType,omitempty"`
9852
9853
9854 Scope string `json:"scope,omitempty"`
9855
9856
9857
9858 TokenEndpoint string `json:"tokenEndpoint,omitempty"`
9859
9860
9861 TokenParams *GoogleCloudIntegrationsV1alphaParameterMap `json:"tokenParams,omitempty"`
9862
9863
9864 Username string `json:"username,omitempty"`
9865
9866
9867
9868
9869
9870
9871
9872 ForceSendFields []string `json:"-"`
9873
9874
9875
9876
9877
9878
9879
9880 NullFields []string `json:"-"`
9881 }
9882
9883 func (s *GoogleCloudIntegrationsV1alphaOAuth2ResourceOwnerCredentials) MarshalJSON() ([]byte, error) {
9884 type NoMethod GoogleCloudIntegrationsV1alphaOAuth2ResourceOwnerCredentials
9885 raw := NoMethod(*s)
9886 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9887 }
9888
9889
9890 type GoogleCloudIntegrationsV1alphaOidcToken struct {
9891
9892
9893
9894 Audience string `json:"audience,omitempty"`
9895
9896
9897
9898 ServiceAccountEmail string `json:"serviceAccountEmail,omitempty"`
9899
9900
9901 Token string `json:"token,omitempty"`
9902
9903
9904
9905 TokenExpireTime string `json:"tokenExpireTime,omitempty"`
9906
9907
9908
9909
9910
9911
9912
9913 ForceSendFields []string `json:"-"`
9914
9915
9916
9917
9918
9919
9920
9921 NullFields []string `json:"-"`
9922 }
9923
9924 func (s *GoogleCloudIntegrationsV1alphaOidcToken) MarshalJSON() ([]byte, error) {
9925 type NoMethod GoogleCloudIntegrationsV1alphaOidcToken
9926 raw := NoMethod(*s)
9927 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9928 }
9929
9930
9931
9932
9933 type GoogleCloudIntegrationsV1alphaParameterMap struct {
9934
9935 Entries []*GoogleCloudIntegrationsV1alphaParameterMapEntry `json:"entries,omitempty"`
9936
9937
9938
9939
9940
9941
9942
9943
9944
9945
9946
9947
9948
9949
9950
9951
9952
9953 KeyType string `json:"keyType,omitempty"`
9954
9955
9956
9957
9958
9959
9960
9961
9962
9963
9964
9965
9966
9967
9968
9969
9970
9971 ValueType string `json:"valueType,omitempty"`
9972
9973
9974
9975
9976
9977
9978
9979 ForceSendFields []string `json:"-"`
9980
9981
9982
9983
9984
9985
9986
9987 NullFields []string `json:"-"`
9988 }
9989
9990 func (s *GoogleCloudIntegrationsV1alphaParameterMap) MarshalJSON() ([]byte, error) {
9991 type NoMethod GoogleCloudIntegrationsV1alphaParameterMap
9992 raw := NoMethod(*s)
9993 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
9994 }
9995
9996
9997
9998 type GoogleCloudIntegrationsV1alphaParameterMapEntry struct {
9999
10000 Key *GoogleCloudIntegrationsV1alphaParameterMapField `json:"key,omitempty"`
10001
10002
10003 Value *GoogleCloudIntegrationsV1alphaParameterMapField `json:"value,omitempty"`
10004
10005
10006
10007
10008
10009
10010
10011 ForceSendFields []string `json:"-"`
10012
10013
10014
10015
10016
10017
10018
10019 NullFields []string `json:"-"`
10020 }
10021
10022 func (s *GoogleCloudIntegrationsV1alphaParameterMapEntry) MarshalJSON() ([]byte, error) {
10023 type NoMethod GoogleCloudIntegrationsV1alphaParameterMapEntry
10024 raw := NoMethod(*s)
10025 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10026 }
10027
10028
10029
10030 type GoogleCloudIntegrationsV1alphaParameterMapField struct {
10031
10032 LiteralValue *GoogleCloudIntegrationsV1alphaValueType `json:"literalValue,omitempty"`
10033
10034
10035 ReferenceKey string `json:"referenceKey,omitempty"`
10036
10037
10038
10039
10040
10041
10042
10043 ForceSendFields []string `json:"-"`
10044
10045
10046
10047
10048
10049
10050
10051 NullFields []string `json:"-"`
10052 }
10053
10054 func (s *GoogleCloudIntegrationsV1alphaParameterMapField) MarshalJSON() ([]byte, error) {
10055 type NoMethod GoogleCloudIntegrationsV1alphaParameterMapField
10056 raw := NoMethod(*s)
10057 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10058 }
10059
10060
10061
10062 type GoogleCloudIntegrationsV1alphaProjectProperties struct {
10063
10064
10065
10066
10067
10068
10069
10070
10071
10072
10073
10074 IpEnablementState string `json:"ipEnablementState,omitempty"`
10075
10076
10077
10078 ProvisionedRegions []string `json:"provisionedRegions,omitempty"`
10079
10080
10081
10082
10083
10084
10085
10086 ForceSendFields []string `json:"-"`
10087
10088
10089
10090
10091
10092
10093
10094
10095 NullFields []string `json:"-"`
10096 }
10097
10098 func (s *GoogleCloudIntegrationsV1alphaProjectProperties) MarshalJSON() ([]byte, error) {
10099 type NoMethod GoogleCloudIntegrationsV1alphaProjectProperties
10100 raw := NoMethod(*s)
10101 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10102 }
10103
10104
10105
10106 type GoogleCloudIntegrationsV1alphaProvisionClientRequest struct {
10107
10108
10109 CloudKmsConfig *GoogleCloudIntegrationsV1alphaCloudKmsConfig `json:"cloudKmsConfig,omitempty"`
10110
10111
10112
10113 CreateSampleWorkflows bool `json:"createSampleWorkflows,omitempty"`
10114
10115
10116
10117
10118
10119
10120
10121 ForceSendFields []string `json:"-"`
10122
10123
10124
10125
10126
10127
10128
10129
10130 NullFields []string `json:"-"`
10131 }
10132
10133 func (s *GoogleCloudIntegrationsV1alphaProvisionClientRequest) MarshalJSON() ([]byte, error) {
10134 type NoMethod GoogleCloudIntegrationsV1alphaProvisionClientRequest
10135 raw := NoMethod(*s)
10136 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10137 }
10138
10139
10140
10141 type GoogleCloudIntegrationsV1alphaPublishIntegrationVersionRequest struct {
10142 }
10143
10144
10145
10146 type GoogleCloudIntegrationsV1alphaPublishIntegrationVersionResponse struct {
10147
10148
10149 googleapi.ServerResponse `json:"-"`
10150 }
10151
10152
10153
10154 type GoogleCloudIntegrationsV1alphaResolveSuspensionRequest struct {
10155
10156
10157 Suspension *GoogleCloudIntegrationsV1alphaSuspension `json:"suspension,omitempty"`
10158
10159
10160
10161
10162
10163
10164
10165 ForceSendFields []string `json:"-"`
10166
10167
10168
10169
10170
10171
10172
10173 NullFields []string `json:"-"`
10174 }
10175
10176 func (s *GoogleCloudIntegrationsV1alphaResolveSuspensionRequest) MarshalJSON() ([]byte, error) {
10177 type NoMethod GoogleCloudIntegrationsV1alphaResolveSuspensionRequest
10178 raw := NoMethod(*s)
10179 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10180 }
10181
10182
10183
10184 type GoogleCloudIntegrationsV1alphaResolveSuspensionResponse struct {
10185
10186
10187 googleapi.ServerResponse `json:"-"`
10188 }
10189
10190
10191
10192 type GoogleCloudIntegrationsV1alphaRuntimeActionSchema struct {
10193
10194 Action string `json:"action,omitempty"`
10195
10196
10197 InputSchema string `json:"inputSchema,omitempty"`
10198
10199
10200 OutputSchema string `json:"outputSchema,omitempty"`
10201
10202
10203
10204
10205
10206
10207
10208 ForceSendFields []string `json:"-"`
10209
10210
10211
10212
10213
10214
10215
10216 NullFields []string `json:"-"`
10217 }
10218
10219 func (s *GoogleCloudIntegrationsV1alphaRuntimeActionSchema) MarshalJSON() ([]byte, error) {
10220 type NoMethod GoogleCloudIntegrationsV1alphaRuntimeActionSchema
10221 raw := NoMethod(*s)
10222 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10223 }
10224
10225
10226
10227 type GoogleCloudIntegrationsV1alphaRuntimeEntitySchema struct {
10228
10229
10230 ArrayFieldSchema string `json:"arrayFieldSchema,omitempty"`
10231
10232
10233 Entity string `json:"entity,omitempty"`
10234
10235
10236 FieldSchema string `json:"fieldSchema,omitempty"`
10237
10238
10239
10240
10241
10242
10243
10244 ForceSendFields []string `json:"-"`
10245
10246
10247
10248
10249
10250
10251
10252
10253 NullFields []string `json:"-"`
10254 }
10255
10256 func (s *GoogleCloudIntegrationsV1alphaRuntimeEntitySchema) MarshalJSON() ([]byte, error) {
10257 type NoMethod GoogleCloudIntegrationsV1alphaRuntimeEntitySchema
10258 raw := NoMethod(*s)
10259 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10260 }
10261
10262
10263
10264 type GoogleCloudIntegrationsV1alphaScheduleIntegrationsRequest struct {
10265
10266
10267 InputParameters map[string]GoogleCloudIntegrationsV1alphaValueType `json:"inputParameters,omitempty"`
10268
10269
10270
10271
10272 ParameterEntries []*EnterpriseCrmFrontendsEventbusProtoParameterEntry `json:"parameterEntries,omitempty"`
10273
10274
10275 Parameters *EnterpriseCrmEventbusProtoEventParameters `json:"parameters,omitempty"`
10276
10277
10278
10279
10280 RequestId string `json:"requestId,omitempty"`
10281
10282
10283
10284
10285 ScheduleTime string `json:"scheduleTime,omitempty"`
10286
10287
10288
10289 TriggerId string `json:"triggerId,omitempty"`
10290
10291
10292
10293
10294
10295
10296
10297 ForceSendFields []string `json:"-"`
10298
10299
10300
10301
10302
10303
10304
10305
10306 NullFields []string `json:"-"`
10307 }
10308
10309 func (s *GoogleCloudIntegrationsV1alphaScheduleIntegrationsRequest) MarshalJSON() ([]byte, error) {
10310 type NoMethod GoogleCloudIntegrationsV1alphaScheduleIntegrationsRequest
10311 raw := NoMethod(*s)
10312 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10313 }
10314
10315
10316
10317 type GoogleCloudIntegrationsV1alphaScheduleIntegrationsResponse struct {
10318
10319
10320 ExecutionInfoIds []string `json:"executionInfoIds,omitempty"`
10321
10322
10323
10324 googleapi.ServerResponse `json:"-"`
10325
10326
10327
10328
10329
10330
10331
10332 ForceSendFields []string `json:"-"`
10333
10334
10335
10336
10337
10338
10339
10340
10341 NullFields []string `json:"-"`
10342 }
10343
10344 func (s *GoogleCloudIntegrationsV1alphaScheduleIntegrationsResponse) MarshalJSON() ([]byte, error) {
10345 type NoMethod GoogleCloudIntegrationsV1alphaScheduleIntegrationsResponse
10346 raw := NoMethod(*s)
10347 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10348 }
10349
10350
10351
10352
10353 type GoogleCloudIntegrationsV1alphaServiceAccountCredentials struct {
10354
10355 Scope string `json:"scope,omitempty"`
10356
10357
10358
10359 ServiceAccount string `json:"serviceAccount,omitempty"`
10360
10361
10362
10363
10364
10365
10366
10367 ForceSendFields []string `json:"-"`
10368
10369
10370
10371
10372
10373
10374
10375 NullFields []string `json:"-"`
10376 }
10377
10378 func (s *GoogleCloudIntegrationsV1alphaServiceAccountCredentials) MarshalJSON() ([]byte, error) {
10379 type NoMethod GoogleCloudIntegrationsV1alphaServiceAccountCredentials
10380 raw := NoMethod(*s)
10381 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10382 }
10383
10384
10385
10386 type GoogleCloudIntegrationsV1alphaSfdcChannel struct {
10387
10388
10389 ChannelTopic string `json:"channelTopic,omitempty"`
10390
10391
10392 CreateTime string `json:"createTime,omitempty"`
10393
10394
10395
10396 DeleteTime string `json:"deleteTime,omitempty"`
10397
10398
10399 Description string `json:"description,omitempty"`
10400
10401
10402
10403 DisplayName string `json:"displayName,omitempty"`
10404
10405
10406
10407
10408
10409 IsActive bool `json:"isActive,omitempty"`
10410
10411
10412 LastReplayId string `json:"lastReplayId,omitempty"`
10413
10414
10415
10416
10417 Name string `json:"name,omitempty"`
10418
10419
10420 UpdateTime string `json:"updateTime,omitempty"`
10421
10422
10423
10424 googleapi.ServerResponse `json:"-"`
10425
10426
10427
10428
10429
10430
10431
10432 ForceSendFields []string `json:"-"`
10433
10434
10435
10436
10437
10438
10439
10440 NullFields []string `json:"-"`
10441 }
10442
10443 func (s *GoogleCloudIntegrationsV1alphaSfdcChannel) MarshalJSON() ([]byte, error) {
10444 type NoMethod GoogleCloudIntegrationsV1alphaSfdcChannel
10445 raw := NoMethod(*s)
10446 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10447 }
10448
10449
10450
10451 type GoogleCloudIntegrationsV1alphaSfdcInstance struct {
10452
10453
10454 AuthConfigId []string `json:"authConfigId,omitempty"`
10455
10456
10457 CreateTime string `json:"createTime,omitempty"`
10458
10459
10460
10461 DeleteTime string `json:"deleteTime,omitempty"`
10462
10463
10464 Description string `json:"description,omitempty"`
10465
10466
10467
10468 DisplayName string `json:"displayName,omitempty"`
10469
10470
10471
10472 Name string `json:"name,omitempty"`
10473
10474
10475
10476 ServiceAuthority string `json:"serviceAuthority,omitempty"`
10477
10478
10479 SfdcOrgId string `json:"sfdcOrgId,omitempty"`
10480
10481
10482 UpdateTime string `json:"updateTime,omitempty"`
10483
10484
10485
10486 googleapi.ServerResponse `json:"-"`
10487
10488
10489
10490
10491
10492
10493
10494 ForceSendFields []string `json:"-"`
10495
10496
10497
10498
10499
10500
10501
10502 NullFields []string `json:"-"`
10503 }
10504
10505 func (s *GoogleCloudIntegrationsV1alphaSfdcInstance) MarshalJSON() ([]byte, error) {
10506 type NoMethod GoogleCloudIntegrationsV1alphaSfdcInstance
10507 raw := NoMethod(*s)
10508 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10509 }
10510
10511
10512
10513 type GoogleCloudIntegrationsV1alphaStringParameterArray struct {
10514
10515 StringValues []string `json:"stringValues,omitempty"`
10516
10517
10518
10519
10520
10521
10522
10523 ForceSendFields []string `json:"-"`
10524
10525
10526
10527
10528
10529
10530
10531 NullFields []string `json:"-"`
10532 }
10533
10534 func (s *GoogleCloudIntegrationsV1alphaStringParameterArray) MarshalJSON() ([]byte, error) {
10535 type NoMethod GoogleCloudIntegrationsV1alphaStringParameterArray
10536 raw := NoMethod(*s)
10537 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10538 }
10539
10540
10541
10542 type GoogleCloudIntegrationsV1alphaSuccessPolicy struct {
10543
10544
10545
10546
10547
10548
10549
10550
10551
10552
10553
10554 FinalState string `json:"finalState,omitempty"`
10555
10556
10557
10558
10559
10560
10561
10562 ForceSendFields []string `json:"-"`
10563
10564
10565
10566
10567
10568
10569
10570 NullFields []string `json:"-"`
10571 }
10572
10573 func (s *GoogleCloudIntegrationsV1alphaSuccessPolicy) MarshalJSON() ([]byte, error) {
10574 type NoMethod GoogleCloudIntegrationsV1alphaSuccessPolicy
10575 raw := NoMethod(*s)
10576 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10577 }
10578
10579
10580
10581 type GoogleCloudIntegrationsV1alphaSuspension struct {
10582
10583
10584 ApprovalConfig *GoogleCloudIntegrationsV1alphaSuspensionApprovalConfig `json:"approvalConfig,omitempty"`
10585
10586
10587 Audit *GoogleCloudIntegrationsV1alphaSuspensionAudit `json:"audit,omitempty"`
10588
10589
10590 CreateTime string `json:"createTime,omitempty"`
10591
10592
10593 EventExecutionInfoId string `json:"eventExecutionInfoId,omitempty"`
10594
10595
10596 Integration string `json:"integration,omitempty"`
10597
10598
10599 LastModifyTime string `json:"lastModifyTime,omitempty"`
10600
10601
10602 Name string `json:"name,omitempty"`
10603
10604
10605
10606
10607
10608
10609
10610
10611
10612 State string `json:"state,omitempty"`
10613
10614
10615
10616 SuspensionConfig *EnterpriseCrmEventbusProtoSuspensionConfig `json:"suspensionConfig,omitempty"`
10617
10618
10619 TaskId string `json:"taskId,omitempty"`
10620
10621
10622
10623
10624
10625
10626
10627 ForceSendFields []string `json:"-"`
10628
10629
10630
10631
10632
10633
10634
10635
10636 NullFields []string `json:"-"`
10637 }
10638
10639 func (s *GoogleCloudIntegrationsV1alphaSuspension) MarshalJSON() ([]byte, error) {
10640 type NoMethod GoogleCloudIntegrationsV1alphaSuspension
10641 raw := NoMethod(*s)
10642 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10643 }
10644
10645
10646
10647 type GoogleCloudIntegrationsV1alphaSuspensionApprovalConfig struct {
10648
10649 CustomMessage string `json:"customMessage,omitempty"`
10650
10651
10652 EmailAddresses []string `json:"emailAddresses,omitempty"`
10653
10654
10655
10656 Expiration *GoogleCloudIntegrationsV1alphaSuspensionApprovalExpiration `json:"expiration,omitempty"`
10657
10658
10659
10660
10661
10662
10663
10664 ForceSendFields []string `json:"-"`
10665
10666
10667
10668
10669
10670
10671
10672 NullFields []string `json:"-"`
10673 }
10674
10675 func (s *GoogleCloudIntegrationsV1alphaSuspensionApprovalConfig) MarshalJSON() ([]byte, error) {
10676 type NoMethod GoogleCloudIntegrationsV1alphaSuspensionApprovalConfig
10677 raw := NoMethod(*s)
10678 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10679 }
10680
10681
10682
10683 type GoogleCloudIntegrationsV1alphaSuspensionApprovalExpiration struct {
10684
10685
10686 ExpireTime string `json:"expireTime,omitempty"`
10687
10688
10689
10690 LiftWhenExpired bool `json:"liftWhenExpired,omitempty"`
10691
10692
10693
10694
10695 RemindTime string `json:"remindTime,omitempty"`
10696
10697
10698
10699
10700
10701
10702
10703 ForceSendFields []string `json:"-"`
10704
10705
10706
10707
10708
10709
10710
10711 NullFields []string `json:"-"`
10712 }
10713
10714 func (s *GoogleCloudIntegrationsV1alphaSuspensionApprovalExpiration) MarshalJSON() ([]byte, error) {
10715 type NoMethod GoogleCloudIntegrationsV1alphaSuspensionApprovalExpiration
10716 raw := NoMethod(*s)
10717 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10718 }
10719
10720
10721
10722 type GoogleCloudIntegrationsV1alphaSuspensionAudit struct {
10723
10724 ResolveTime string `json:"resolveTime,omitempty"`
10725
10726
10727 Resolver string `json:"resolver,omitempty"`
10728
10729
10730
10731
10732
10733
10734
10735 ForceSendFields []string `json:"-"`
10736
10737
10738
10739
10740
10741
10742
10743 NullFields []string `json:"-"`
10744 }
10745
10746 func (s *GoogleCloudIntegrationsV1alphaSuspensionAudit) MarshalJSON() ([]byte, error) {
10747 type NoMethod GoogleCloudIntegrationsV1alphaSuspensionAudit
10748 raw := NoMethod(*s)
10749 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10750 }
10751
10752
10753
10754 type GoogleCloudIntegrationsV1alphaTakeoverEditLockRequest struct {
10755 }
10756
10757
10758
10759 type GoogleCloudIntegrationsV1alphaTakeoverEditLockResponse struct {
10760
10761
10762 IntegrationVersion *GoogleCloudIntegrationsV1alphaIntegrationVersion `json:"integrationVersion,omitempty"`
10763
10764
10765
10766 googleapi.ServerResponse `json:"-"`
10767
10768
10769
10770
10771
10772
10773
10774 ForceSendFields []string `json:"-"`
10775
10776
10777
10778
10779
10780
10781
10782
10783 NullFields []string `json:"-"`
10784 }
10785
10786 func (s *GoogleCloudIntegrationsV1alphaTakeoverEditLockResponse) MarshalJSON() ([]byte, error) {
10787 type NoMethod GoogleCloudIntegrationsV1alphaTakeoverEditLockResponse
10788 raw := NoMethod(*s)
10789 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10790 }
10791
10792
10793
10794
10795 type GoogleCloudIntegrationsV1alphaTaskConfig struct {
10796
10797
10798 Description string `json:"description,omitempty"`
10799
10800
10801
10802 DisplayName string `json:"displayName,omitempty"`
10803
10804
10805
10806
10807
10808 FailurePolicy *GoogleCloudIntegrationsV1alphaFailurePolicy `json:"failurePolicy,omitempty"`
10809
10810
10811
10812
10813
10814
10815
10816
10817
10818
10819
10820
10821
10822
10823
10824 JsonValidationOption string `json:"jsonValidationOption,omitempty"`
10825
10826
10827
10828
10829
10830 NextTasks []*GoogleCloudIntegrationsV1alphaNextTask `json:"nextTasks,omitempty"`
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
10841 NextTasksExecutionPolicy string `json:"nextTasksExecutionPolicy,omitempty"`
10842
10843
10844
10845 Parameters map[string]GoogleCloudIntegrationsV1alphaEventParameter `json:"parameters,omitempty"`
10846
10847
10848
10849 SuccessPolicy *GoogleCloudIntegrationsV1alphaSuccessPolicy `json:"successPolicy,omitempty"`
10850
10851
10852
10853
10854
10855 SynchronousCallFailurePolicy *GoogleCloudIntegrationsV1alphaFailurePolicy `json:"synchronousCallFailurePolicy,omitempty"`
10856
10857
10858 Task string `json:"task,omitempty"`
10859
10860
10861
10862
10863
10864
10865
10866
10867
10868
10869
10870
10871
10872
10873
10874
10875
10876
10877 TaskExecutionStrategy string `json:"taskExecutionStrategy,omitempty"`
10878
10879
10880
10881
10882
10883 TaskId string `json:"taskId,omitempty"`
10884
10885
10886
10887 TaskTemplate string `json:"taskTemplate,omitempty"`
10888
10889
10890
10891
10892
10893
10894
10895 ForceSendFields []string `json:"-"`
10896
10897
10898
10899
10900
10901
10902
10903 NullFields []string `json:"-"`
10904 }
10905
10906 func (s *GoogleCloudIntegrationsV1alphaTaskConfig) MarshalJSON() ([]byte, error) {
10907 type NoMethod GoogleCloudIntegrationsV1alphaTaskConfig
10908 raw := NoMethod(*s)
10909 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10910 }
10911
10912
10913
10914 type GoogleCloudIntegrationsV1alphaTaskExecutionDetails struct {
10915
10916 TaskAttemptStats []*GoogleCloudIntegrationsV1alphaAttemptStats `json:"taskAttemptStats,omitempty"`
10917
10918
10919
10920
10921
10922
10923
10924
10925
10926
10927
10928
10929
10930
10931
10932
10933
10934
10935
10936
10937
10938
10939
10940
10941
10942
10943
10944
10945 TaskExecutionState string `json:"taskExecutionState,omitempty"`
10946
10947
10948 TaskNumber string `json:"taskNumber,omitempty"`
10949
10950
10951
10952
10953
10954
10955
10956 ForceSendFields []string `json:"-"`
10957
10958
10959
10960
10961
10962
10963
10964
10965 NullFields []string `json:"-"`
10966 }
10967
10968 func (s *GoogleCloudIntegrationsV1alphaTaskExecutionDetails) MarshalJSON() ([]byte, error) {
10969 type NoMethod GoogleCloudIntegrationsV1alphaTaskExecutionDetails
10970 raw := NoMethod(*s)
10971 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
10972 }
10973
10974
10975
10976 type GoogleCloudIntegrationsV1alphaTestIntegrationsRequest struct {
10977
10978
10979 ClientId string `json:"clientId,omitempty"`
10980
10981
10982 DeadlineSecondsTime string `json:"deadlineSecondsTime,omitempty"`
10983
10984
10985
10986 InputParameters map[string]GoogleCloudIntegrationsV1alphaValueType `json:"inputParameters,omitempty"`
10987
10988
10989
10990 IntegrationVersion *GoogleCloudIntegrationsV1alphaIntegrationVersion `json:"integrationVersion,omitempty"`
10991
10992
10993
10994 Parameters *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"parameters,omitempty"`
10995
10996
10997
10998
10999
11000
11001 TestMode bool `json:"testMode,omitempty"`
11002
11003
11004
11005
11006
11007 TriggerId string `json:"triggerId,omitempty"`
11008
11009
11010
11011
11012
11013
11014
11015 ForceSendFields []string `json:"-"`
11016
11017
11018
11019
11020
11021
11022
11023 NullFields []string `json:"-"`
11024 }
11025
11026 func (s *GoogleCloudIntegrationsV1alphaTestIntegrationsRequest) MarshalJSON() ([]byte, error) {
11027 type NoMethod GoogleCloudIntegrationsV1alphaTestIntegrationsRequest
11028 raw := NoMethod(*s)
11029 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11030 }
11031
11032
11033
11034 type GoogleCloudIntegrationsV1alphaTestIntegrationsResponse struct {
11035
11036 EventParameters *EnterpriseCrmFrontendsEventbusProtoEventParameters `json:"eventParameters,omitempty"`
11037
11038
11039
11040 ExecutionFailed bool `json:"executionFailed,omitempty"`
11041
11042
11043
11044 ExecutionId string `json:"executionId,omitempty"`
11045
11046
11047
11048
11049 ParameterEntries []*EnterpriseCrmFrontendsEventbusProtoParameterEntry `json:"parameterEntries,omitempty"`
11050
11051
11052
11053
11054 Parameters map[string]GoogleCloudIntegrationsV1alphaValueType `json:"parameters,omitempty"`
11055
11056
11057
11058 googleapi.ServerResponse `json:"-"`
11059
11060
11061
11062
11063
11064
11065
11066 ForceSendFields []string `json:"-"`
11067
11068
11069
11070
11071
11072
11073
11074
11075 NullFields []string `json:"-"`
11076 }
11077
11078 func (s *GoogleCloudIntegrationsV1alphaTestIntegrationsResponse) MarshalJSON() ([]byte, error) {
11079 type NoMethod GoogleCloudIntegrationsV1alphaTestIntegrationsResponse
11080 raw := NoMethod(*s)
11081 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11082 }
11083
11084
11085
11086 type GoogleCloudIntegrationsV1alphaTriggerConfig struct {
11087
11088
11089
11090
11091
11092 AlertConfig []*GoogleCloudIntegrationsV1alphaIntegrationAlertConfig `json:"alertConfig,omitempty"`
11093
11094
11095
11096 CloudSchedulerConfig *GoogleCloudIntegrationsV1alphaCloudSchedulerConfig `json:"cloudSchedulerConfig,omitempty"`
11097
11098
11099
11100 Description string `json:"description,omitempty"`
11101
11102
11103 Label string `json:"label,omitempty"`
11104
11105
11106
11107
11108
11109
11110
11111
11112
11113
11114 NextTasksExecutionPolicy string `json:"nextTasksExecutionPolicy,omitempty"`
11115
11116
11117
11118
11119
11120 Properties map[string]string `json:"properties,omitempty"`
11121
11122
11123
11124
11125
11126
11127 StartTasks []*GoogleCloudIntegrationsV1alphaNextTask `json:"startTasks,omitempty"`
11128
11129
11130 TriggerId string `json:"triggerId,omitempty"`
11131
11132
11133
11134 TriggerNumber string `json:"triggerNumber,omitempty"`
11135
11136
11137
11138
11139
11140
11141
11142
11143
11144
11145
11146 TriggerType string `json:"triggerType,omitempty"`
11147
11148
11149
11150
11151
11152
11153
11154 ForceSendFields []string `json:"-"`
11155
11156
11157
11158
11159
11160
11161
11162 NullFields []string `json:"-"`
11163 }
11164
11165 func (s *GoogleCloudIntegrationsV1alphaTriggerConfig) MarshalJSON() ([]byte, error) {
11166 type NoMethod GoogleCloudIntegrationsV1alphaTriggerConfig
11167 raw := NoMethod(*s)
11168 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11169 }
11170
11171
11172
11173 type GoogleCloudIntegrationsV1alphaUnpublishIntegrationVersionRequest struct {
11174 }
11175
11176
11177
11178 type GoogleCloudIntegrationsV1alphaUpdateBundleRequest struct {
11179
11180 Config *GoogleCloudIntegrationsV1alphaIntegrationBundleConfig `json:"config,omitempty"`
11181
11182
11183
11184
11185
11186
11187
11188 ForceSendFields []string `json:"-"`
11189
11190
11191
11192
11193
11194
11195
11196 NullFields []string `json:"-"`
11197 }
11198
11199 func (s *GoogleCloudIntegrationsV1alphaUpdateBundleRequest) MarshalJSON() ([]byte, error) {
11200 type NoMethod GoogleCloudIntegrationsV1alphaUpdateBundleRequest
11201 raw := NoMethod(*s)
11202 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11203 }
11204
11205
11206
11207 type GoogleCloudIntegrationsV1alphaUpdateBundleResponse struct {
11208
11209 Config *GoogleCloudIntegrationsV1alphaIntegrationBundleConfig `json:"config,omitempty"`
11210
11211
11212
11213 googleapi.ServerResponse `json:"-"`
11214
11215
11216
11217
11218
11219
11220
11221 ForceSendFields []string `json:"-"`
11222
11223
11224
11225
11226
11227
11228
11229 NullFields []string `json:"-"`
11230 }
11231
11232 func (s *GoogleCloudIntegrationsV1alphaUpdateBundleResponse) MarshalJSON() ([]byte, error) {
11233 type NoMethod GoogleCloudIntegrationsV1alphaUpdateBundleResponse
11234 raw := NoMethod(*s)
11235 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11236 }
11237
11238
11239
11240 type GoogleCloudIntegrationsV1alphaUploadIntegrationVersionRequest struct {
11241
11242 Content string `json:"content,omitempty"`
11243
11244
11245
11246
11247
11248
11249
11250 FileFormat string `json:"fileFormat,omitempty"`
11251
11252
11253
11254
11255
11256
11257
11258 ForceSendFields []string `json:"-"`
11259
11260
11261
11262
11263
11264
11265
11266 NullFields []string `json:"-"`
11267 }
11268
11269 func (s *GoogleCloudIntegrationsV1alphaUploadIntegrationVersionRequest) MarshalJSON() ([]byte, error) {
11270 type NoMethod GoogleCloudIntegrationsV1alphaUploadIntegrationVersionRequest
11271 raw := NoMethod(*s)
11272 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11273 }
11274
11275
11276
11277 type GoogleCloudIntegrationsV1alphaUploadIntegrationVersionResponse struct {
11278
11279 IntegrationVersion *GoogleCloudIntegrationsV1alphaIntegrationVersion `json:"integrationVersion,omitempty"`
11280
11281
11282
11283 googleapi.ServerResponse `json:"-"`
11284
11285
11286
11287
11288
11289
11290
11291 ForceSendFields []string `json:"-"`
11292
11293
11294
11295
11296
11297
11298
11299
11300 NullFields []string `json:"-"`
11301 }
11302
11303 func (s *GoogleCloudIntegrationsV1alphaUploadIntegrationVersionResponse) MarshalJSON() ([]byte, error) {
11304 type NoMethod GoogleCloudIntegrationsV1alphaUploadIntegrationVersionResponse
11305 raw := NoMethod(*s)
11306 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11307 }
11308
11309
11310
11311 type GoogleCloudIntegrationsV1alphaUsernameAndPassword struct {
11312
11313 Password string `json:"password,omitempty"`
11314
11315
11316 Username string `json:"username,omitempty"`
11317
11318
11319
11320
11321
11322
11323
11324 ForceSendFields []string `json:"-"`
11325
11326
11327
11328
11329
11330
11331
11332 NullFields []string `json:"-"`
11333 }
11334
11335 func (s *GoogleCloudIntegrationsV1alphaUsernameAndPassword) MarshalJSON() ([]byte, error) {
11336 type NoMethod GoogleCloudIntegrationsV1alphaUsernameAndPassword
11337 raw := NoMethod(*s)
11338 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11339 }
11340
11341
11342
11343 type GoogleCloudIntegrationsV1alphaValidateIntegrationVersionRequest struct {
11344 }
11345
11346
11347
11348 type GoogleCloudIntegrationsV1alphaValidateIntegrationVersionResponse struct {
11349
11350
11351 googleapi.ServerResponse `json:"-"`
11352 }
11353
11354
11355 type GoogleCloudIntegrationsV1alphaValueType struct {
11356
11357 BooleanArray *GoogleCloudIntegrationsV1alphaBooleanParameterArray `json:"booleanArray,omitempty"`
11358
11359
11360 BooleanValue bool `json:"booleanValue,omitempty"`
11361
11362
11363 DoubleArray *GoogleCloudIntegrationsV1alphaDoubleParameterArray `json:"doubleArray,omitempty"`
11364
11365
11366 DoubleValue float64 `json:"doubleValue,omitempty"`
11367
11368
11369 IntArray *GoogleCloudIntegrationsV1alphaIntParameterArray `json:"intArray,omitempty"`
11370
11371
11372 IntValue int64 `json:"intValue,omitempty,string"`
11373
11374
11375 JsonValue string `json:"jsonValue,omitempty"`
11376
11377
11378 StringArray *GoogleCloudIntegrationsV1alphaStringParameterArray `json:"stringArray,omitempty"`
11379
11380
11381 StringValue string `json:"stringValue,omitempty"`
11382
11383
11384
11385
11386
11387
11388
11389 ForceSendFields []string `json:"-"`
11390
11391
11392
11393
11394
11395
11396
11397 NullFields []string `json:"-"`
11398 }
11399
11400 func (s *GoogleCloudIntegrationsV1alphaValueType) MarshalJSON() ([]byte, error) {
11401 type NoMethod GoogleCloudIntegrationsV1alphaValueType
11402 raw := NoMethod(*s)
11403 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11404 }
11405
11406 func (s *GoogleCloudIntegrationsV1alphaValueType) UnmarshalJSON(data []byte) error {
11407 type NoMethod GoogleCloudIntegrationsV1alphaValueType
11408 var s1 struct {
11409 DoubleValue gensupport.JSONFloat64 `json:"doubleValue"`
11410 *NoMethod
11411 }
11412 s1.NoMethod = (*NoMethod)(s)
11413 if err := json.Unmarshal(data, &s1); err != nil {
11414 return err
11415 }
11416 s.DoubleValue = float64(s1.DoubleValue)
11417 return nil
11418 }
11419
11420
11421
11422
11423 type GoogleInternalCloudCrmEventbusV3PostToQueueWithTriggerIdRequest struct {
11424
11425
11426
11427
11428
11429
11430 ClientId string `json:"clientId,omitempty"`
11431
11432
11433
11434
11435
11436
11437
11438 IgnoreErrorIfNoActiveWorkflow bool `json:"ignoreErrorIfNoActiveWorkflow,omitempty"`
11439
11440
11441
11442 Parameters *EnterpriseCrmEventbusProtoEventParameters `json:"parameters,omitempty"`
11443
11444
11445
11446
11447
11448
11449
11450
11451
11452
11453
11454
11455
11456
11457
11458
11459
11460
11461
11462
11463
11464
11465 Priority string `json:"priority,omitempty"`
11466
11467
11468
11469
11470
11471 RequestId string `json:"requestId,omitempty"`
11472
11473
11474
11475 ScheduledTime int64 `json:"scheduledTime,omitempty,string"`
11476
11477
11478
11479 TestMode bool `json:"testMode,omitempty"`
11480
11481
11482
11483 TriggerId string `json:"triggerId,omitempty"`
11484
11485
11486
11487
11488
11489 WorkflowName string `json:"workflowName,omitempty"`
11490
11491
11492
11493
11494
11495
11496
11497 ForceSendFields []string `json:"-"`
11498
11499
11500
11501
11502
11503
11504
11505 NullFields []string `json:"-"`
11506 }
11507
11508 func (s *GoogleInternalCloudCrmEventbusV3PostToQueueWithTriggerIdRequest) MarshalJSON() ([]byte, error) {
11509 type NoMethod GoogleInternalCloudCrmEventbusV3PostToQueueWithTriggerIdRequest
11510 raw := NoMethod(*s)
11511 return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
11512 }
11513
11514
11515
11516
11517
11518
11519 type GoogleProtobufEmpty struct {
11520
11521
11522 googleapi.ServerResponse `json:"-"`
11523 }
11524
11525
11526
11527 type CallbackGenerateTokenCall struct {
11528 s *Service
11529 urlParams_ gensupport.URLParams
11530 ifNoneMatch_ string
11531 ctx_ context.Context
11532 header_ http.Header
11533 }
11534
11535
11536
11537
11538
11539 func (r *CallbackService) GenerateToken() *CallbackGenerateTokenCall {
11540 c := &CallbackGenerateTokenCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11541 return c
11542 }
11543
11544
11545
11546 func (c *CallbackGenerateTokenCall) Code(code string) *CallbackGenerateTokenCall {
11547 c.urlParams_.Set("code", code)
11548 return c
11549 }
11550
11551
11552
11553 func (c *CallbackGenerateTokenCall) GcpProjectId(gcpProjectId string) *CallbackGenerateTokenCall {
11554 c.urlParams_.Set("gcpProjectId", gcpProjectId)
11555 return c
11556 }
11557
11558
11559
11560
11561
11562
11563
11564
11565
11566
11567 func (c *CallbackGenerateTokenCall) Product(product string) *CallbackGenerateTokenCall {
11568 c.urlParams_.Set("product", product)
11569 return c
11570 }
11571
11572
11573
11574 func (c *CallbackGenerateTokenCall) RedirectUri(redirectUri string) *CallbackGenerateTokenCall {
11575 c.urlParams_.Set("redirectUri", redirectUri)
11576 return c
11577 }
11578
11579
11580
11581 func (c *CallbackGenerateTokenCall) State(state string) *CallbackGenerateTokenCall {
11582 c.urlParams_.Set("state", state)
11583 return c
11584 }
11585
11586
11587
11588
11589 func (c *CallbackGenerateTokenCall) Fields(s ...googleapi.Field) *CallbackGenerateTokenCall {
11590 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11591 return c
11592 }
11593
11594
11595
11596
11597
11598
11599 func (c *CallbackGenerateTokenCall) IfNoneMatch(entityTag string) *CallbackGenerateTokenCall {
11600 c.ifNoneMatch_ = entityTag
11601 return c
11602 }
11603
11604
11605
11606
11607 func (c *CallbackGenerateTokenCall) Context(ctx context.Context) *CallbackGenerateTokenCall {
11608 c.ctx_ = ctx
11609 return c
11610 }
11611
11612
11613
11614 func (c *CallbackGenerateTokenCall) Header() http.Header {
11615 if c.header_ == nil {
11616 c.header_ = make(http.Header)
11617 }
11618 return c.header_
11619 }
11620
11621 func (c *CallbackGenerateTokenCall) doRequest(alt string) (*http.Response, error) {
11622 reqHeaders := make(http.Header)
11623 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
11624 for k, v := range c.header_ {
11625 reqHeaders[k] = v
11626 }
11627 reqHeaders.Set("User-Agent", c.s.userAgent())
11628 if c.ifNoneMatch_ != "" {
11629 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11630 }
11631 var body io.Reader = nil
11632 c.urlParams_.Set("alt", alt)
11633 c.urlParams_.Set("prettyPrint", "false")
11634 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/callback:generateToken")
11635 urls += "?" + c.urlParams_.Encode()
11636 req, err := http.NewRequest("GET", urls, body)
11637 if err != nil {
11638 return nil, err
11639 }
11640 req.Header = reqHeaders
11641 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11642 }
11643
11644
11645
11646
11647
11648
11649
11650
11651
11652
11653 func (c *CallbackGenerateTokenCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaGenerateTokenResponse, error) {
11654 gensupport.SetOptions(c.urlParams_, opts...)
11655 res, err := c.doRequest("json")
11656 if res != nil && res.StatusCode == http.StatusNotModified {
11657 if res.Body != nil {
11658 res.Body.Close()
11659 }
11660 return nil, gensupport.WrapError(&googleapi.Error{
11661 Code: res.StatusCode,
11662 Header: res.Header,
11663 })
11664 }
11665 if err != nil {
11666 return nil, err
11667 }
11668 defer googleapi.CloseBody(res)
11669 if err := googleapi.CheckResponse(res); err != nil {
11670 return nil, gensupport.WrapError(err)
11671 }
11672 ret := &GoogleCloudIntegrationsV1alphaGenerateTokenResponse{
11673 ServerResponse: googleapi.ServerResponse{
11674 Header: res.Header,
11675 HTTPStatusCode: res.StatusCode,
11676 },
11677 }
11678 target := &ret
11679 if err := gensupport.DecodeResponse(target, res); err != nil {
11680 return nil, err
11681 }
11682 return ret, nil
11683
11684
11685
11686
11687
11688
11689
11690
11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705
11706
11707
11708
11709
11710
11711
11712
11713
11714
11715
11716
11717
11718
11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737 }
11738
11739
11740
11741 type ConnectorPlatformRegionsEnumerateCall struct {
11742 s *Service
11743 urlParams_ gensupport.URLParams
11744 ifNoneMatch_ string
11745 ctx_ context.Context
11746 header_ http.Header
11747 }
11748
11749
11750
11751 func (r *ConnectorPlatformRegionsService) Enumerate() *ConnectorPlatformRegionsEnumerateCall {
11752 c := &ConnectorPlatformRegionsEnumerateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11753 return c
11754 }
11755
11756
11757
11758
11759 func (c *ConnectorPlatformRegionsEnumerateCall) Fields(s ...googleapi.Field) *ConnectorPlatformRegionsEnumerateCall {
11760 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11761 return c
11762 }
11763
11764
11765
11766
11767
11768
11769 func (c *ConnectorPlatformRegionsEnumerateCall) IfNoneMatch(entityTag string) *ConnectorPlatformRegionsEnumerateCall {
11770 c.ifNoneMatch_ = entityTag
11771 return c
11772 }
11773
11774
11775
11776
11777 func (c *ConnectorPlatformRegionsEnumerateCall) Context(ctx context.Context) *ConnectorPlatformRegionsEnumerateCall {
11778 c.ctx_ = ctx
11779 return c
11780 }
11781
11782
11783
11784 func (c *ConnectorPlatformRegionsEnumerateCall) Header() http.Header {
11785 if c.header_ == nil {
11786 c.header_ = make(http.Header)
11787 }
11788 return c.header_
11789 }
11790
11791 func (c *ConnectorPlatformRegionsEnumerateCall) doRequest(alt string) (*http.Response, error) {
11792 reqHeaders := make(http.Header)
11793 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
11794 for k, v := range c.header_ {
11795 reqHeaders[k] = v
11796 }
11797 reqHeaders.Set("User-Agent", c.s.userAgent())
11798 if c.ifNoneMatch_ != "" {
11799 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11800 }
11801 var body io.Reader = nil
11802 c.urlParams_.Set("alt", alt)
11803 c.urlParams_.Set("prettyPrint", "false")
11804 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/connectorPlatformRegions:enumerate")
11805 urls += "?" + c.urlParams_.Encode()
11806 req, err := http.NewRequest("GET", urls, body)
11807 if err != nil {
11808 return nil, err
11809 }
11810 req.Header = reqHeaders
11811 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11812 }
11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823
11824 func (c *ConnectorPlatformRegionsEnumerateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaEnumerateConnectorPlatformRegionsResponse, error) {
11825 gensupport.SetOptions(c.urlParams_, opts...)
11826 res, err := c.doRequest("json")
11827 if res != nil && res.StatusCode == http.StatusNotModified {
11828 if res.Body != nil {
11829 res.Body.Close()
11830 }
11831 return nil, gensupport.WrapError(&googleapi.Error{
11832 Code: res.StatusCode,
11833 Header: res.Header,
11834 })
11835 }
11836 if err != nil {
11837 return nil, err
11838 }
11839 defer googleapi.CloseBody(res)
11840 if err := googleapi.CheckResponse(res); err != nil {
11841 return nil, gensupport.WrapError(err)
11842 }
11843 ret := &GoogleCloudIntegrationsV1alphaEnumerateConnectorPlatformRegionsResponse{
11844 ServerResponse: googleapi.ServerResponse{
11845 Header: res.Header,
11846 HTTPStatusCode: res.StatusCode,
11847 },
11848 }
11849 target := &ret
11850 if err := gensupport.DecodeResponse(target, res); err != nil {
11851 return nil, err
11852 }
11853 return ret, nil
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
11865
11866
11867
11868
11869
11870 }
11871
11872
11873
11874 type ProjectsGetClientmetadataCall struct {
11875 s *Service
11876 parent string
11877 urlParams_ gensupport.URLParams
11878 ifNoneMatch_ string
11879 ctx_ context.Context
11880 header_ http.Header
11881 }
11882
11883
11884
11885
11886 func (r *ProjectsService) GetClientmetadata(parent string) *ProjectsGetClientmetadataCall {
11887 c := &ProjectsGetClientmetadataCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11888 c.parent = parent
11889 return c
11890 }
11891
11892
11893
11894
11895 func (c *ProjectsGetClientmetadataCall) Fields(s ...googleapi.Field) *ProjectsGetClientmetadataCall {
11896 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11897 return c
11898 }
11899
11900
11901
11902
11903
11904
11905 func (c *ProjectsGetClientmetadataCall) IfNoneMatch(entityTag string) *ProjectsGetClientmetadataCall {
11906 c.ifNoneMatch_ = entityTag
11907 return c
11908 }
11909
11910
11911
11912
11913 func (c *ProjectsGetClientmetadataCall) Context(ctx context.Context) *ProjectsGetClientmetadataCall {
11914 c.ctx_ = ctx
11915 return c
11916 }
11917
11918
11919
11920 func (c *ProjectsGetClientmetadataCall) Header() http.Header {
11921 if c.header_ == nil {
11922 c.header_ = make(http.Header)
11923 }
11924 return c.header_
11925 }
11926
11927 func (c *ProjectsGetClientmetadataCall) doRequest(alt string) (*http.Response, error) {
11928 reqHeaders := make(http.Header)
11929 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
11930 for k, v := range c.header_ {
11931 reqHeaders[k] = v
11932 }
11933 reqHeaders.Set("User-Agent", c.s.userAgent())
11934 if c.ifNoneMatch_ != "" {
11935 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11936 }
11937 var body io.Reader = nil
11938 c.urlParams_.Set("alt", alt)
11939 c.urlParams_.Set("prettyPrint", "false")
11940 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/clientmetadata")
11941 urls += "?" + c.urlParams_.Encode()
11942 req, err := http.NewRequest("GET", urls, body)
11943 if err != nil {
11944 return nil, err
11945 }
11946 req.Header = reqHeaders
11947 googleapi.Expand(req.URL, map[string]string{
11948 "parent": c.parent,
11949 })
11950 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11951 }
11952
11953
11954
11955
11956
11957
11958
11959
11960
11961
11962
11963 func (c *ProjectsGetClientmetadataCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaGetClientMetadataResponse, error) {
11964 gensupport.SetOptions(c.urlParams_, opts...)
11965 res, err := c.doRequest("json")
11966 if res != nil && res.StatusCode == http.StatusNotModified {
11967 if res.Body != nil {
11968 res.Body.Close()
11969 }
11970 return nil, gensupport.WrapError(&googleapi.Error{
11971 Code: res.StatusCode,
11972 Header: res.Header,
11973 })
11974 }
11975 if err != nil {
11976 return nil, err
11977 }
11978 defer googleapi.CloseBody(res)
11979 if err := googleapi.CheckResponse(res); err != nil {
11980 return nil, gensupport.WrapError(err)
11981 }
11982 ret := &GoogleCloudIntegrationsV1alphaGetClientMetadataResponse{
11983 ServerResponse: googleapi.ServerResponse{
11984 Header: res.Header,
11985 HTTPStatusCode: res.StatusCode,
11986 },
11987 }
11988 target := &ret
11989 if err := gensupport.DecodeResponse(target, res); err != nil {
11990 return nil, err
11991 }
11992 return ret, nil
11993
11994
11995
11996
11997
11998
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019 }
12020
12021
12022
12023 type ProjectsLocationsGetClientsCall struct {
12024 s *Service
12025 parent string
12026 urlParams_ gensupport.URLParams
12027 ifNoneMatch_ string
12028 ctx_ context.Context
12029 header_ http.Header
12030 }
12031
12032
12033
12034
12035
12036 func (r *ProjectsLocationsService) GetClients(parent string) *ProjectsLocationsGetClientsCall {
12037 c := &ProjectsLocationsGetClientsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12038 c.parent = parent
12039 return c
12040 }
12041
12042
12043
12044
12045 func (c *ProjectsLocationsGetClientsCall) Fields(s ...googleapi.Field) *ProjectsLocationsGetClientsCall {
12046 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12047 return c
12048 }
12049
12050
12051
12052
12053
12054
12055 func (c *ProjectsLocationsGetClientsCall) IfNoneMatch(entityTag string) *ProjectsLocationsGetClientsCall {
12056 c.ifNoneMatch_ = entityTag
12057 return c
12058 }
12059
12060
12061
12062
12063 func (c *ProjectsLocationsGetClientsCall) Context(ctx context.Context) *ProjectsLocationsGetClientsCall {
12064 c.ctx_ = ctx
12065 return c
12066 }
12067
12068
12069
12070 func (c *ProjectsLocationsGetClientsCall) Header() http.Header {
12071 if c.header_ == nil {
12072 c.header_ = make(http.Header)
12073 }
12074 return c.header_
12075 }
12076
12077 func (c *ProjectsLocationsGetClientsCall) doRequest(alt string) (*http.Response, error) {
12078 reqHeaders := make(http.Header)
12079 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
12080 for k, v := range c.header_ {
12081 reqHeaders[k] = v
12082 }
12083 reqHeaders.Set("User-Agent", c.s.userAgent())
12084 if c.ifNoneMatch_ != "" {
12085 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12086 }
12087 var body io.Reader = nil
12088 c.urlParams_.Set("alt", alt)
12089 c.urlParams_.Set("prettyPrint", "false")
12090 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/clients")
12091 urls += "?" + c.urlParams_.Encode()
12092 req, err := http.NewRequest("GET", urls, body)
12093 if err != nil {
12094 return nil, err
12095 }
12096 req.Header = reqHeaders
12097 googleapi.Expand(req.URL, map[string]string{
12098 "parent": c.parent,
12099 })
12100 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12101 }
12102
12103
12104
12105
12106
12107
12108
12109
12110
12111
12112
12113
12114 func (c *ProjectsLocationsGetClientsCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaGetClientResponse, error) {
12115 gensupport.SetOptions(c.urlParams_, opts...)
12116 res, err := c.doRequest("json")
12117 if res != nil && res.StatusCode == http.StatusNotModified {
12118 if res.Body != nil {
12119 res.Body.Close()
12120 }
12121 return nil, gensupport.WrapError(&googleapi.Error{
12122 Code: res.StatusCode,
12123 Header: res.Header,
12124 })
12125 }
12126 if err != nil {
12127 return nil, err
12128 }
12129 defer googleapi.CloseBody(res)
12130 if err := googleapi.CheckResponse(res); err != nil {
12131 return nil, gensupport.WrapError(err)
12132 }
12133 ret := &GoogleCloudIntegrationsV1alphaGetClientResponse{
12134 ServerResponse: googleapi.ServerResponse{
12135 Header: res.Header,
12136 HTTPStatusCode: res.StatusCode,
12137 },
12138 }
12139 target := &ret
12140 if err := gensupport.DecodeResponse(target, res); err != nil {
12141 return nil, err
12142 }
12143 return ret, nil
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155
12156
12157
12158
12159
12160
12161
12162
12163
12164
12165
12166
12167
12168
12169
12170 }
12171
12172
12173
12174 type ProjectsLocationsListTaskEntitiesCall struct {
12175 s *Service
12176 parent string
12177 urlParams_ gensupport.URLParams
12178 ifNoneMatch_ string
12179 ctx_ context.Context
12180 header_ http.Header
12181 }
12182
12183
12184
12185
12186
12187
12188 func (r *ProjectsLocationsService) ListTaskEntities(parent string) *ProjectsLocationsListTaskEntitiesCall {
12189 c := &ProjectsLocationsListTaskEntitiesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12190 c.parent = parent
12191 return c
12192 }
12193
12194
12195
12196
12197 func (c *ProjectsLocationsListTaskEntitiesCall) Fields(s ...googleapi.Field) *ProjectsLocationsListTaskEntitiesCall {
12198 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12199 return c
12200 }
12201
12202
12203
12204
12205
12206
12207 func (c *ProjectsLocationsListTaskEntitiesCall) IfNoneMatch(entityTag string) *ProjectsLocationsListTaskEntitiesCall {
12208 c.ifNoneMatch_ = entityTag
12209 return c
12210 }
12211
12212
12213
12214
12215 func (c *ProjectsLocationsListTaskEntitiesCall) Context(ctx context.Context) *ProjectsLocationsListTaskEntitiesCall {
12216 c.ctx_ = ctx
12217 return c
12218 }
12219
12220
12221
12222 func (c *ProjectsLocationsListTaskEntitiesCall) Header() http.Header {
12223 if c.header_ == nil {
12224 c.header_ = make(http.Header)
12225 }
12226 return c.header_
12227 }
12228
12229 func (c *ProjectsLocationsListTaskEntitiesCall) doRequest(alt string) (*http.Response, error) {
12230 reqHeaders := make(http.Header)
12231 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
12232 for k, v := range c.header_ {
12233 reqHeaders[k] = v
12234 }
12235 reqHeaders.Set("User-Agent", c.s.userAgent())
12236 if c.ifNoneMatch_ != "" {
12237 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12238 }
12239 var body io.Reader = nil
12240 c.urlParams_.Set("alt", alt)
12241 c.urlParams_.Set("prettyPrint", "false")
12242 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}:listTaskEntities")
12243 urls += "?" + c.urlParams_.Encode()
12244 req, err := http.NewRequest("GET", urls, body)
12245 if err != nil {
12246 return nil, err
12247 }
12248 req.Header = reqHeaders
12249 googleapi.Expand(req.URL, map[string]string{
12250 "parent": c.parent,
12251 })
12252 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12253 }
12254
12255
12256
12257
12258
12259
12260
12261
12262
12263
12264
12265 func (c *ProjectsLocationsListTaskEntitiesCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListTaskEntitiesResponse, error) {
12266 gensupport.SetOptions(c.urlParams_, opts...)
12267 res, err := c.doRequest("json")
12268 if res != nil && res.StatusCode == http.StatusNotModified {
12269 if res.Body != nil {
12270 res.Body.Close()
12271 }
12272 return nil, gensupport.WrapError(&googleapi.Error{
12273 Code: res.StatusCode,
12274 Header: res.Header,
12275 })
12276 }
12277 if err != nil {
12278 return nil, err
12279 }
12280 defer googleapi.CloseBody(res)
12281 if err := googleapi.CheckResponse(res); err != nil {
12282 return nil, gensupport.WrapError(err)
12283 }
12284 ret := &GoogleCloudIntegrationsV1alphaListTaskEntitiesResponse{
12285 ServerResponse: googleapi.ServerResponse{
12286 Header: res.Header,
12287 HTTPStatusCode: res.StatusCode,
12288 },
12289 }
12290 target := &ret
12291 if err := gensupport.DecodeResponse(target, res); err != nil {
12292 return nil, err
12293 }
12294 return ret, nil
12295
12296
12297
12298
12299
12300
12301
12302
12303
12304
12305
12306
12307
12308
12309
12310
12311
12312
12313
12314
12315
12316
12317
12318
12319
12320
12321 }
12322
12323
12324
12325 type ProjectsLocationsAppsScriptProjectsCreateCall struct {
12326 s *Service
12327 parent string
12328 googlecloudintegrationsv1alphacreateappsscriptprojectrequest *GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectRequest
12329 urlParams_ gensupport.URLParams
12330 ctx_ context.Context
12331 header_ http.Header
12332 }
12333
12334
12335
12336
12337 func (r *ProjectsLocationsAppsScriptProjectsService) Create(parent string, googlecloudintegrationsv1alphacreateappsscriptprojectrequest *GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectRequest) *ProjectsLocationsAppsScriptProjectsCreateCall {
12338 c := &ProjectsLocationsAppsScriptProjectsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12339 c.parent = parent
12340 c.googlecloudintegrationsv1alphacreateappsscriptprojectrequest = googlecloudintegrationsv1alphacreateappsscriptprojectrequest
12341 return c
12342 }
12343
12344
12345
12346
12347 func (c *ProjectsLocationsAppsScriptProjectsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppsScriptProjectsCreateCall {
12348 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12349 return c
12350 }
12351
12352
12353
12354
12355 func (c *ProjectsLocationsAppsScriptProjectsCreateCall) Context(ctx context.Context) *ProjectsLocationsAppsScriptProjectsCreateCall {
12356 c.ctx_ = ctx
12357 return c
12358 }
12359
12360
12361
12362 func (c *ProjectsLocationsAppsScriptProjectsCreateCall) Header() http.Header {
12363 if c.header_ == nil {
12364 c.header_ = make(http.Header)
12365 }
12366 return c.header_
12367 }
12368
12369 func (c *ProjectsLocationsAppsScriptProjectsCreateCall) doRequest(alt string) (*http.Response, error) {
12370 reqHeaders := make(http.Header)
12371 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
12372 for k, v := range c.header_ {
12373 reqHeaders[k] = v
12374 }
12375 reqHeaders.Set("User-Agent", c.s.userAgent())
12376 var body io.Reader = nil
12377 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacreateappsscriptprojectrequest)
12378 if err != nil {
12379 return nil, err
12380 }
12381 reqHeaders.Set("Content-Type", "application/json")
12382 c.urlParams_.Set("alt", alt)
12383 c.urlParams_.Set("prettyPrint", "false")
12384 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/appsScriptProjects")
12385 urls += "?" + c.urlParams_.Encode()
12386 req, err := http.NewRequest("POST", urls, body)
12387 if err != nil {
12388 return nil, err
12389 }
12390 req.Header = reqHeaders
12391 googleapi.Expand(req.URL, map[string]string{
12392 "parent": c.parent,
12393 })
12394 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12395 }
12396
12397
12398
12399
12400
12401
12402
12403
12404
12405
12406
12407 func (c *ProjectsLocationsAppsScriptProjectsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectResponse, error) {
12408 gensupport.SetOptions(c.urlParams_, opts...)
12409 res, err := c.doRequest("json")
12410 if res != nil && res.StatusCode == http.StatusNotModified {
12411 if res.Body != nil {
12412 res.Body.Close()
12413 }
12414 return nil, gensupport.WrapError(&googleapi.Error{
12415 Code: res.StatusCode,
12416 Header: res.Header,
12417 })
12418 }
12419 if err != nil {
12420 return nil, err
12421 }
12422 defer googleapi.CloseBody(res)
12423 if err := googleapi.CheckResponse(res); err != nil {
12424 return nil, gensupport.WrapError(err)
12425 }
12426 ret := &GoogleCloudIntegrationsV1alphaCreateAppsScriptProjectResponse{
12427 ServerResponse: googleapi.ServerResponse{
12428 Header: res.Header,
12429 HTTPStatusCode: res.StatusCode,
12430 },
12431 }
12432 target := &ret
12433 if err := gensupport.DecodeResponse(target, res); err != nil {
12434 return nil, err
12435 }
12436 return ret, nil
12437
12438
12439
12440
12441
12442
12443
12444
12445
12446
12447
12448
12449
12450
12451
12452
12453
12454
12455
12456
12457
12458
12459
12460
12461
12462
12463
12464
12465
12466 }
12467
12468
12469
12470 type ProjectsLocationsAppsScriptProjectsLinkCall struct {
12471 s *Service
12472 parent string
12473 googlecloudintegrationsv1alphalinkappsscriptprojectrequest *GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectRequest
12474 urlParams_ gensupport.URLParams
12475 ctx_ context.Context
12476 header_ http.Header
12477 }
12478
12479
12480
12481
12482 func (r *ProjectsLocationsAppsScriptProjectsService) Link(parent string, googlecloudintegrationsv1alphalinkappsscriptprojectrequest *GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectRequest) *ProjectsLocationsAppsScriptProjectsLinkCall {
12483 c := &ProjectsLocationsAppsScriptProjectsLinkCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12484 c.parent = parent
12485 c.googlecloudintegrationsv1alphalinkappsscriptprojectrequest = googlecloudintegrationsv1alphalinkappsscriptprojectrequest
12486 return c
12487 }
12488
12489
12490
12491
12492 func (c *ProjectsLocationsAppsScriptProjectsLinkCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppsScriptProjectsLinkCall {
12493 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12494 return c
12495 }
12496
12497
12498
12499
12500 func (c *ProjectsLocationsAppsScriptProjectsLinkCall) Context(ctx context.Context) *ProjectsLocationsAppsScriptProjectsLinkCall {
12501 c.ctx_ = ctx
12502 return c
12503 }
12504
12505
12506
12507 func (c *ProjectsLocationsAppsScriptProjectsLinkCall) Header() http.Header {
12508 if c.header_ == nil {
12509 c.header_ = make(http.Header)
12510 }
12511 return c.header_
12512 }
12513
12514 func (c *ProjectsLocationsAppsScriptProjectsLinkCall) doRequest(alt string) (*http.Response, error) {
12515 reqHeaders := make(http.Header)
12516 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
12517 for k, v := range c.header_ {
12518 reqHeaders[k] = v
12519 }
12520 reqHeaders.Set("User-Agent", c.s.userAgent())
12521 var body io.Reader = nil
12522 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphalinkappsscriptprojectrequest)
12523 if err != nil {
12524 return nil, err
12525 }
12526 reqHeaders.Set("Content-Type", "application/json")
12527 c.urlParams_.Set("alt", alt)
12528 c.urlParams_.Set("prettyPrint", "false")
12529 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/appsScriptProjects:link")
12530 urls += "?" + c.urlParams_.Encode()
12531 req, err := http.NewRequest("POST", urls, body)
12532 if err != nil {
12533 return nil, err
12534 }
12535 req.Header = reqHeaders
12536 googleapi.Expand(req.URL, map[string]string{
12537 "parent": c.parent,
12538 })
12539 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12540 }
12541
12542
12543
12544
12545
12546
12547
12548
12549
12550
12551
12552 func (c *ProjectsLocationsAppsScriptProjectsLinkCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectResponse, error) {
12553 gensupport.SetOptions(c.urlParams_, opts...)
12554 res, err := c.doRequest("json")
12555 if res != nil && res.StatusCode == http.StatusNotModified {
12556 if res.Body != nil {
12557 res.Body.Close()
12558 }
12559 return nil, gensupport.WrapError(&googleapi.Error{
12560 Code: res.StatusCode,
12561 Header: res.Header,
12562 })
12563 }
12564 if err != nil {
12565 return nil, err
12566 }
12567 defer googleapi.CloseBody(res)
12568 if err := googleapi.CheckResponse(res); err != nil {
12569 return nil, gensupport.WrapError(err)
12570 }
12571 ret := &GoogleCloudIntegrationsV1alphaLinkAppsScriptProjectResponse{
12572 ServerResponse: googleapi.ServerResponse{
12573 Header: res.Header,
12574 HTTPStatusCode: res.StatusCode,
12575 },
12576 }
12577 target := &ret
12578 if err := gensupport.DecodeResponse(target, res); err != nil {
12579 return nil, err
12580 }
12581 return ret, nil
12582
12583
12584
12585
12586
12587
12588
12589
12590
12591
12592
12593
12594
12595
12596
12597
12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611 }
12612
12613
12614
12615 type ProjectsLocationsAuthConfigsCreateCall struct {
12616 s *Service
12617 parent string
12618 googlecloudintegrationsv1alphaauthconfig *GoogleCloudIntegrationsV1alphaAuthConfig
12619 urlParams_ gensupport.URLParams
12620 ctx_ context.Context
12621 header_ http.Header
12622 }
12623
12624
12625
12626
12627
12628
12629
12630
12631 func (r *ProjectsLocationsAuthConfigsService) Create(parent string, googlecloudintegrationsv1alphaauthconfig *GoogleCloudIntegrationsV1alphaAuthConfig) *ProjectsLocationsAuthConfigsCreateCall {
12632 c := &ProjectsLocationsAuthConfigsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12633 c.parent = parent
12634 c.googlecloudintegrationsv1alphaauthconfig = googlecloudintegrationsv1alphaauthconfig
12635 return c
12636 }
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646
12647
12648
12649
12650
12651
12652
12653
12654
12655 func (c *ProjectsLocationsAuthConfigsCreateCall) ClientCertificateEncryptedPrivateKey(clientCertificateEncryptedPrivateKey string) *ProjectsLocationsAuthConfigsCreateCall {
12656 c.urlParams_.Set("clientCertificate.encryptedPrivateKey", clientCertificateEncryptedPrivateKey)
12657 return c
12658 }
12659
12660
12661
12662
12663
12664
12665 func (c *ProjectsLocationsAuthConfigsCreateCall) ClientCertificatePassphrase(clientCertificatePassphrase string) *ProjectsLocationsAuthConfigsCreateCall {
12666 c.urlParams_.Set("clientCertificate.passphrase", clientCertificatePassphrase)
12667 return c
12668 }
12669
12670
12671
12672
12673
12674
12675
12676
12677
12678
12679
12680
12681
12682
12683
12684
12685
12686
12687 func (c *ProjectsLocationsAuthConfigsCreateCall) ClientCertificateSslCertificate(clientCertificateSslCertificate string) *ProjectsLocationsAuthConfigsCreateCall {
12688 c.urlParams_.Set("clientCertificate.sslCertificate", clientCertificateSslCertificate)
12689 return c
12690 }
12691
12692
12693
12694
12695 func (c *ProjectsLocationsAuthConfigsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsAuthConfigsCreateCall {
12696 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12697 return c
12698 }
12699
12700
12701
12702
12703 func (c *ProjectsLocationsAuthConfigsCreateCall) Context(ctx context.Context) *ProjectsLocationsAuthConfigsCreateCall {
12704 c.ctx_ = ctx
12705 return c
12706 }
12707
12708
12709
12710 func (c *ProjectsLocationsAuthConfigsCreateCall) Header() http.Header {
12711 if c.header_ == nil {
12712 c.header_ = make(http.Header)
12713 }
12714 return c.header_
12715 }
12716
12717 func (c *ProjectsLocationsAuthConfigsCreateCall) doRequest(alt string) (*http.Response, error) {
12718 reqHeaders := make(http.Header)
12719 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
12720 for k, v := range c.header_ {
12721 reqHeaders[k] = v
12722 }
12723 reqHeaders.Set("User-Agent", c.s.userAgent())
12724 var body io.Reader = nil
12725 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaauthconfig)
12726 if err != nil {
12727 return nil, err
12728 }
12729 reqHeaders.Set("Content-Type", "application/json")
12730 c.urlParams_.Set("alt", alt)
12731 c.urlParams_.Set("prettyPrint", "false")
12732 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/authConfigs")
12733 urls += "?" + c.urlParams_.Encode()
12734 req, err := http.NewRequest("POST", urls, body)
12735 if err != nil {
12736 return nil, err
12737 }
12738 req.Header = reqHeaders
12739 googleapi.Expand(req.URL, map[string]string{
12740 "parent": c.parent,
12741 })
12742 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12743 }
12744
12745
12746
12747
12748
12749
12750
12751
12752
12753
12754 func (c *ProjectsLocationsAuthConfigsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaAuthConfig, error) {
12755 gensupport.SetOptions(c.urlParams_, opts...)
12756 res, err := c.doRequest("json")
12757 if res != nil && res.StatusCode == http.StatusNotModified {
12758 if res.Body != nil {
12759 res.Body.Close()
12760 }
12761 return nil, gensupport.WrapError(&googleapi.Error{
12762 Code: res.StatusCode,
12763 Header: res.Header,
12764 })
12765 }
12766 if err != nil {
12767 return nil, err
12768 }
12769 defer googleapi.CloseBody(res)
12770 if err := googleapi.CheckResponse(res); err != nil {
12771 return nil, gensupport.WrapError(err)
12772 }
12773 ret := &GoogleCloudIntegrationsV1alphaAuthConfig{
12774 ServerResponse: googleapi.ServerResponse{
12775 Header: res.Header,
12776 HTTPStatusCode: res.StatusCode,
12777 },
12778 }
12779 target := &ret
12780 if err := gensupport.DecodeResponse(target, res); err != nil {
12781 return nil, err
12782 }
12783 return ret, nil
12784
12785
12786
12787
12788
12789
12790
12791
12792
12793
12794
12795
12796
12797
12798
12799
12800
12801
12802
12803
12804
12805
12806
12807
12808
12809
12810
12811
12812
12813
12814
12815
12816
12817
12818
12819
12820
12821
12822
12823
12824
12825
12826
12827
12828 }
12829
12830
12831
12832 type ProjectsLocationsAuthConfigsDeleteCall struct {
12833 s *Service
12834 name string
12835 urlParams_ gensupport.URLParams
12836 ctx_ context.Context
12837 header_ http.Header
12838 }
12839
12840
12841
12842
12843 func (r *ProjectsLocationsAuthConfigsService) Delete(name string) *ProjectsLocationsAuthConfigsDeleteCall {
12844 c := &ProjectsLocationsAuthConfigsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12845 c.name = name
12846 return c
12847 }
12848
12849
12850
12851
12852 func (c *ProjectsLocationsAuthConfigsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsAuthConfigsDeleteCall {
12853 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12854 return c
12855 }
12856
12857
12858
12859
12860 func (c *ProjectsLocationsAuthConfigsDeleteCall) Context(ctx context.Context) *ProjectsLocationsAuthConfigsDeleteCall {
12861 c.ctx_ = ctx
12862 return c
12863 }
12864
12865
12866
12867 func (c *ProjectsLocationsAuthConfigsDeleteCall) Header() http.Header {
12868 if c.header_ == nil {
12869 c.header_ = make(http.Header)
12870 }
12871 return c.header_
12872 }
12873
12874 func (c *ProjectsLocationsAuthConfigsDeleteCall) doRequest(alt string) (*http.Response, error) {
12875 reqHeaders := make(http.Header)
12876 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
12877 for k, v := range c.header_ {
12878 reqHeaders[k] = v
12879 }
12880 reqHeaders.Set("User-Agent", c.s.userAgent())
12881 var body io.Reader = nil
12882 c.urlParams_.Set("alt", alt)
12883 c.urlParams_.Set("prettyPrint", "false")
12884 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
12885 urls += "?" + c.urlParams_.Encode()
12886 req, err := http.NewRequest("DELETE", urls, body)
12887 if err != nil {
12888 return nil, err
12889 }
12890 req.Header = reqHeaders
12891 googleapi.Expand(req.URL, map[string]string{
12892 "name": c.name,
12893 })
12894 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12895 }
12896
12897
12898
12899
12900
12901
12902
12903
12904 func (c *ProjectsLocationsAuthConfigsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
12905 gensupport.SetOptions(c.urlParams_, opts...)
12906 res, err := c.doRequest("json")
12907 if res != nil && res.StatusCode == http.StatusNotModified {
12908 if res.Body != nil {
12909 res.Body.Close()
12910 }
12911 return nil, gensupport.WrapError(&googleapi.Error{
12912 Code: res.StatusCode,
12913 Header: res.Header,
12914 })
12915 }
12916 if err != nil {
12917 return nil, err
12918 }
12919 defer googleapi.CloseBody(res)
12920 if err := googleapi.CheckResponse(res); err != nil {
12921 return nil, gensupport.WrapError(err)
12922 }
12923 ret := &GoogleProtobufEmpty{
12924 ServerResponse: googleapi.ServerResponse{
12925 Header: res.Header,
12926 HTTPStatusCode: res.StatusCode,
12927 },
12928 }
12929 target := &ret
12930 if err := gensupport.DecodeResponse(target, res); err != nil {
12931 return nil, err
12932 }
12933 return ret, nil
12934
12935
12936
12937
12938
12939
12940
12941
12942
12943
12944
12945
12946
12947
12948
12949
12950
12951
12952
12953
12954
12955
12956
12957
12958
12959
12960 }
12961
12962
12963
12964 type ProjectsLocationsAuthConfigsGetCall struct {
12965 s *Service
12966 name string
12967 urlParams_ gensupport.URLParams
12968 ifNoneMatch_ string
12969 ctx_ context.Context
12970 header_ http.Header
12971 }
12972
12973
12974
12975
12976
12977
12978 func (r *ProjectsLocationsAuthConfigsService) Get(name string) *ProjectsLocationsAuthConfigsGetCall {
12979 c := &ProjectsLocationsAuthConfigsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12980 c.name = name
12981 return c
12982 }
12983
12984
12985
12986
12987 func (c *ProjectsLocationsAuthConfigsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsAuthConfigsGetCall {
12988 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12989 return c
12990 }
12991
12992
12993
12994
12995
12996
12997 func (c *ProjectsLocationsAuthConfigsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsAuthConfigsGetCall {
12998 c.ifNoneMatch_ = entityTag
12999 return c
13000 }
13001
13002
13003
13004
13005 func (c *ProjectsLocationsAuthConfigsGetCall) Context(ctx context.Context) *ProjectsLocationsAuthConfigsGetCall {
13006 c.ctx_ = ctx
13007 return c
13008 }
13009
13010
13011
13012 func (c *ProjectsLocationsAuthConfigsGetCall) Header() http.Header {
13013 if c.header_ == nil {
13014 c.header_ = make(http.Header)
13015 }
13016 return c.header_
13017 }
13018
13019 func (c *ProjectsLocationsAuthConfigsGetCall) doRequest(alt string) (*http.Response, error) {
13020 reqHeaders := make(http.Header)
13021 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
13022 for k, v := range c.header_ {
13023 reqHeaders[k] = v
13024 }
13025 reqHeaders.Set("User-Agent", c.s.userAgent())
13026 if c.ifNoneMatch_ != "" {
13027 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13028 }
13029 var body io.Reader = nil
13030 c.urlParams_.Set("alt", alt)
13031 c.urlParams_.Set("prettyPrint", "false")
13032 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
13033 urls += "?" + c.urlParams_.Encode()
13034 req, err := http.NewRequest("GET", urls, body)
13035 if err != nil {
13036 return nil, err
13037 }
13038 req.Header = reqHeaders
13039 googleapi.Expand(req.URL, map[string]string{
13040 "name": c.name,
13041 })
13042 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13043 }
13044
13045
13046
13047
13048
13049
13050
13051
13052
13053
13054 func (c *ProjectsLocationsAuthConfigsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaAuthConfig, error) {
13055 gensupport.SetOptions(c.urlParams_, opts...)
13056 res, err := c.doRequest("json")
13057 if res != nil && res.StatusCode == http.StatusNotModified {
13058 if res.Body != nil {
13059 res.Body.Close()
13060 }
13061 return nil, gensupport.WrapError(&googleapi.Error{
13062 Code: res.StatusCode,
13063 Header: res.Header,
13064 })
13065 }
13066 if err != nil {
13067 return nil, err
13068 }
13069 defer googleapi.CloseBody(res)
13070 if err := googleapi.CheckResponse(res); err != nil {
13071 return nil, gensupport.WrapError(err)
13072 }
13073 ret := &GoogleCloudIntegrationsV1alphaAuthConfig{
13074 ServerResponse: googleapi.ServerResponse{
13075 Header: res.Header,
13076 HTTPStatusCode: res.StatusCode,
13077 },
13078 }
13079 target := &ret
13080 if err := gensupport.DecodeResponse(target, res); err != nil {
13081 return nil, err
13082 }
13083 return ret, nil
13084
13085
13086
13087
13088
13089
13090
13091
13092
13093
13094
13095
13096
13097
13098
13099
13100
13101
13102
13103
13104
13105
13106
13107
13108
13109
13110 }
13111
13112
13113
13114 type ProjectsLocationsAuthConfigsListCall struct {
13115 s *Service
13116 parent string
13117 urlParams_ gensupport.URLParams
13118 ifNoneMatch_ string
13119 ctx_ context.Context
13120 header_ http.Header
13121 }
13122
13123
13124
13125
13126
13127 func (r *ProjectsLocationsAuthConfigsService) List(parent string) *ProjectsLocationsAuthConfigsListCall {
13128 c := &ProjectsLocationsAuthConfigsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13129 c.parent = parent
13130 return c
13131 }
13132
13133
13134
13135
13136 func (c *ProjectsLocationsAuthConfigsListCall) Filter(filter string) *ProjectsLocationsAuthConfigsListCall {
13137 c.urlParams_.Set("filter", filter)
13138 return c
13139 }
13140
13141
13142
13143 func (c *ProjectsLocationsAuthConfigsListCall) PageSize(pageSize int64) *ProjectsLocationsAuthConfigsListCall {
13144 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
13145 return c
13146 }
13147
13148
13149
13150 func (c *ProjectsLocationsAuthConfigsListCall) PageToken(pageToken string) *ProjectsLocationsAuthConfigsListCall {
13151 c.urlParams_.Set("pageToken", pageToken)
13152 return c
13153 }
13154
13155
13156
13157
13158 func (c *ProjectsLocationsAuthConfigsListCall) ReadMask(readMask string) *ProjectsLocationsAuthConfigsListCall {
13159 c.urlParams_.Set("readMask", readMask)
13160 return c
13161 }
13162
13163
13164
13165
13166 func (c *ProjectsLocationsAuthConfigsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsAuthConfigsListCall {
13167 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13168 return c
13169 }
13170
13171
13172
13173
13174
13175
13176 func (c *ProjectsLocationsAuthConfigsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsAuthConfigsListCall {
13177 c.ifNoneMatch_ = entityTag
13178 return c
13179 }
13180
13181
13182
13183
13184 func (c *ProjectsLocationsAuthConfigsListCall) Context(ctx context.Context) *ProjectsLocationsAuthConfigsListCall {
13185 c.ctx_ = ctx
13186 return c
13187 }
13188
13189
13190
13191 func (c *ProjectsLocationsAuthConfigsListCall) Header() http.Header {
13192 if c.header_ == nil {
13193 c.header_ = make(http.Header)
13194 }
13195 return c.header_
13196 }
13197
13198 func (c *ProjectsLocationsAuthConfigsListCall) doRequest(alt string) (*http.Response, error) {
13199 reqHeaders := make(http.Header)
13200 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
13201 for k, v := range c.header_ {
13202 reqHeaders[k] = v
13203 }
13204 reqHeaders.Set("User-Agent", c.s.userAgent())
13205 if c.ifNoneMatch_ != "" {
13206 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13207 }
13208 var body io.Reader = nil
13209 c.urlParams_.Set("alt", alt)
13210 c.urlParams_.Set("prettyPrint", "false")
13211 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/authConfigs")
13212 urls += "?" + c.urlParams_.Encode()
13213 req, err := http.NewRequest("GET", urls, body)
13214 if err != nil {
13215 return nil, err
13216 }
13217 req.Header = reqHeaders
13218 googleapi.Expand(req.URL, map[string]string{
13219 "parent": c.parent,
13220 })
13221 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13222 }
13223
13224
13225
13226
13227
13228
13229
13230
13231
13232
13233 func (c *ProjectsLocationsAuthConfigsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListAuthConfigsResponse, error) {
13234 gensupport.SetOptions(c.urlParams_, opts...)
13235 res, err := c.doRequest("json")
13236 if res != nil && res.StatusCode == http.StatusNotModified {
13237 if res.Body != nil {
13238 res.Body.Close()
13239 }
13240 return nil, gensupport.WrapError(&googleapi.Error{
13241 Code: res.StatusCode,
13242 Header: res.Header,
13243 })
13244 }
13245 if err != nil {
13246 return nil, err
13247 }
13248 defer googleapi.CloseBody(res)
13249 if err := googleapi.CheckResponse(res); err != nil {
13250 return nil, gensupport.WrapError(err)
13251 }
13252 ret := &GoogleCloudIntegrationsV1alphaListAuthConfigsResponse{
13253 ServerResponse: googleapi.ServerResponse{
13254 Header: res.Header,
13255 HTTPStatusCode: res.StatusCode,
13256 },
13257 }
13258 target := &ret
13259 if err := gensupport.DecodeResponse(target, res); err != nil {
13260 return nil, err
13261 }
13262 return ret, nil
13263
13264
13265
13266
13267
13268
13269
13270
13271
13272
13273
13274
13275
13276
13277
13278
13279
13280
13281
13282
13283
13284
13285
13286
13287
13288
13289
13290
13291
13292
13293
13294
13295
13296
13297
13298
13299
13300
13301
13302
13303
13304
13305
13306
13307
13308
13309
13310
13311 }
13312
13313
13314
13315
13316 func (c *ProjectsLocationsAuthConfigsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListAuthConfigsResponse) error) error {
13317 c.ctx_ = ctx
13318 defer c.PageToken(c.urlParams_.Get("pageToken"))
13319 for {
13320 x, err := c.Do()
13321 if err != nil {
13322 return err
13323 }
13324 if err := f(x); err != nil {
13325 return err
13326 }
13327 if x.NextPageToken == "" {
13328 return nil
13329 }
13330 c.PageToken(x.NextPageToken)
13331 }
13332 }
13333
13334
13335
13336 type ProjectsLocationsAuthConfigsPatchCall struct {
13337 s *Service
13338 name string
13339 googlecloudintegrationsv1alphaauthconfig *GoogleCloudIntegrationsV1alphaAuthConfig
13340 urlParams_ gensupport.URLParams
13341 ctx_ context.Context
13342 header_ http.Header
13343 }
13344
13345
13346
13347
13348
13349
13350
13351
13352
13353 func (r *ProjectsLocationsAuthConfigsService) Patch(name string, googlecloudintegrationsv1alphaauthconfig *GoogleCloudIntegrationsV1alphaAuthConfig) *ProjectsLocationsAuthConfigsPatchCall {
13354 c := &ProjectsLocationsAuthConfigsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13355 c.name = name
13356 c.googlecloudintegrationsv1alphaauthconfig = googlecloudintegrationsv1alphaauthconfig
13357 return c
13358 }
13359
13360
13361
13362
13363
13364
13365
13366
13367
13368
13369
13370
13371
13372
13373
13374
13375
13376
13377 func (c *ProjectsLocationsAuthConfigsPatchCall) ClientCertificateEncryptedPrivateKey(clientCertificateEncryptedPrivateKey string) *ProjectsLocationsAuthConfigsPatchCall {
13378 c.urlParams_.Set("clientCertificate.encryptedPrivateKey", clientCertificateEncryptedPrivateKey)
13379 return c
13380 }
13381
13382
13383
13384
13385
13386
13387 func (c *ProjectsLocationsAuthConfigsPatchCall) ClientCertificatePassphrase(clientCertificatePassphrase string) *ProjectsLocationsAuthConfigsPatchCall {
13388 c.urlParams_.Set("clientCertificate.passphrase", clientCertificatePassphrase)
13389 return c
13390 }
13391
13392
13393
13394
13395
13396
13397
13398
13399
13400
13401
13402
13403
13404
13405
13406
13407
13408
13409 func (c *ProjectsLocationsAuthConfigsPatchCall) ClientCertificateSslCertificate(clientCertificateSslCertificate string) *ProjectsLocationsAuthConfigsPatchCall {
13410 c.urlParams_.Set("clientCertificate.sslCertificate", clientCertificateSslCertificate)
13411 return c
13412 }
13413
13414
13415
13416
13417 func (c *ProjectsLocationsAuthConfigsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsAuthConfigsPatchCall {
13418 c.urlParams_.Set("updateMask", updateMask)
13419 return c
13420 }
13421
13422
13423
13424
13425 func (c *ProjectsLocationsAuthConfigsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsAuthConfigsPatchCall {
13426 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13427 return c
13428 }
13429
13430
13431
13432
13433 func (c *ProjectsLocationsAuthConfigsPatchCall) Context(ctx context.Context) *ProjectsLocationsAuthConfigsPatchCall {
13434 c.ctx_ = ctx
13435 return c
13436 }
13437
13438
13439
13440 func (c *ProjectsLocationsAuthConfigsPatchCall) Header() http.Header {
13441 if c.header_ == nil {
13442 c.header_ = make(http.Header)
13443 }
13444 return c.header_
13445 }
13446
13447 func (c *ProjectsLocationsAuthConfigsPatchCall) doRequest(alt string) (*http.Response, error) {
13448 reqHeaders := make(http.Header)
13449 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
13450 for k, v := range c.header_ {
13451 reqHeaders[k] = v
13452 }
13453 reqHeaders.Set("User-Agent", c.s.userAgent())
13454 var body io.Reader = nil
13455 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaauthconfig)
13456 if err != nil {
13457 return nil, err
13458 }
13459 reqHeaders.Set("Content-Type", "application/json")
13460 c.urlParams_.Set("alt", alt)
13461 c.urlParams_.Set("prettyPrint", "false")
13462 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
13463 urls += "?" + c.urlParams_.Encode()
13464 req, err := http.NewRequest("PATCH", urls, body)
13465 if err != nil {
13466 return nil, err
13467 }
13468 req.Header = reqHeaders
13469 googleapi.Expand(req.URL, map[string]string{
13470 "name": c.name,
13471 })
13472 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13473 }
13474
13475
13476
13477
13478
13479
13480
13481
13482
13483
13484 func (c *ProjectsLocationsAuthConfigsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaAuthConfig, error) {
13485 gensupport.SetOptions(c.urlParams_, opts...)
13486 res, err := c.doRequest("json")
13487 if res != nil && res.StatusCode == http.StatusNotModified {
13488 if res.Body != nil {
13489 res.Body.Close()
13490 }
13491 return nil, gensupport.WrapError(&googleapi.Error{
13492 Code: res.StatusCode,
13493 Header: res.Header,
13494 })
13495 }
13496 if err != nil {
13497 return nil, err
13498 }
13499 defer googleapi.CloseBody(res)
13500 if err := googleapi.CheckResponse(res); err != nil {
13501 return nil, gensupport.WrapError(err)
13502 }
13503 ret := &GoogleCloudIntegrationsV1alphaAuthConfig{
13504 ServerResponse: googleapi.ServerResponse{
13505 Header: res.Header,
13506 HTTPStatusCode: res.StatusCode,
13507 },
13508 }
13509 target := &ret
13510 if err := gensupport.DecodeResponse(target, res); err != nil {
13511 return nil, err
13512 }
13513 return ret, nil
13514
13515
13516
13517
13518
13519
13520
13521
13522
13523
13524
13525
13526
13527
13528
13529
13530
13531
13532
13533
13534
13535
13536
13537
13538
13539
13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
13550
13551
13552
13553
13554
13555
13556
13557
13558
13559
13560
13561
13562
13563
13564 }
13565
13566
13567
13568 type ProjectsLocationsCertificatesCreateCall struct {
13569 s *Service
13570 parent string
13571 googlecloudintegrationsv1alphacertificate *GoogleCloudIntegrationsV1alphaCertificate
13572 urlParams_ gensupport.URLParams
13573 ctx_ context.Context
13574 header_ http.Header
13575 }
13576
13577
13578
13579
13580
13581
13582 func (r *ProjectsLocationsCertificatesService) Create(parent string, googlecloudintegrationsv1alphacertificate *GoogleCloudIntegrationsV1alphaCertificate) *ProjectsLocationsCertificatesCreateCall {
13583 c := &ProjectsLocationsCertificatesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13584 c.parent = parent
13585 c.googlecloudintegrationsv1alphacertificate = googlecloudintegrationsv1alphacertificate
13586 return c
13587 }
13588
13589
13590
13591
13592 func (c *ProjectsLocationsCertificatesCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsCertificatesCreateCall {
13593 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13594 return c
13595 }
13596
13597
13598
13599
13600 func (c *ProjectsLocationsCertificatesCreateCall) Context(ctx context.Context) *ProjectsLocationsCertificatesCreateCall {
13601 c.ctx_ = ctx
13602 return c
13603 }
13604
13605
13606
13607 func (c *ProjectsLocationsCertificatesCreateCall) Header() http.Header {
13608 if c.header_ == nil {
13609 c.header_ = make(http.Header)
13610 }
13611 return c.header_
13612 }
13613
13614 func (c *ProjectsLocationsCertificatesCreateCall) doRequest(alt string) (*http.Response, error) {
13615 reqHeaders := make(http.Header)
13616 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
13617 for k, v := range c.header_ {
13618 reqHeaders[k] = v
13619 }
13620 reqHeaders.Set("User-Agent", c.s.userAgent())
13621 var body io.Reader = nil
13622 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacertificate)
13623 if err != nil {
13624 return nil, err
13625 }
13626 reqHeaders.Set("Content-Type", "application/json")
13627 c.urlParams_.Set("alt", alt)
13628 c.urlParams_.Set("prettyPrint", "false")
13629 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/certificates")
13630 urls += "?" + c.urlParams_.Encode()
13631 req, err := http.NewRequest("POST", urls, body)
13632 if err != nil {
13633 return nil, err
13634 }
13635 req.Header = reqHeaders
13636 googleapi.Expand(req.URL, map[string]string{
13637 "parent": c.parent,
13638 })
13639 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13640 }
13641
13642
13643
13644
13645
13646
13647
13648
13649
13650
13651 func (c *ProjectsLocationsCertificatesCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCertificate, error) {
13652 gensupport.SetOptions(c.urlParams_, opts...)
13653 res, err := c.doRequest("json")
13654 if res != nil && res.StatusCode == http.StatusNotModified {
13655 if res.Body != nil {
13656 res.Body.Close()
13657 }
13658 return nil, gensupport.WrapError(&googleapi.Error{
13659 Code: res.StatusCode,
13660 Header: res.Header,
13661 })
13662 }
13663 if err != nil {
13664 return nil, err
13665 }
13666 defer googleapi.CloseBody(res)
13667 if err := googleapi.CheckResponse(res); err != nil {
13668 return nil, gensupport.WrapError(err)
13669 }
13670 ret := &GoogleCloudIntegrationsV1alphaCertificate{
13671 ServerResponse: googleapi.ServerResponse{
13672 Header: res.Header,
13673 HTTPStatusCode: res.StatusCode,
13674 },
13675 }
13676 target := &ret
13677 if err := gensupport.DecodeResponse(target, res); err != nil {
13678 return nil, err
13679 }
13680 return ret, nil
13681
13682
13683
13684
13685
13686
13687
13688
13689
13690
13691
13692
13693
13694
13695
13696
13697
13698
13699
13700
13701
13702
13703
13704
13705
13706
13707
13708
13709
13710 }
13711
13712
13713
13714 type ProjectsLocationsCertificatesDeleteCall struct {
13715 s *Service
13716 name string
13717 urlParams_ gensupport.URLParams
13718 ctx_ context.Context
13719 header_ http.Header
13720 }
13721
13722
13723
13724
13725 func (r *ProjectsLocationsCertificatesService) Delete(name string) *ProjectsLocationsCertificatesDeleteCall {
13726 c := &ProjectsLocationsCertificatesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13727 c.name = name
13728 return c
13729 }
13730
13731
13732
13733
13734 func (c *ProjectsLocationsCertificatesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsCertificatesDeleteCall {
13735 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13736 return c
13737 }
13738
13739
13740
13741
13742 func (c *ProjectsLocationsCertificatesDeleteCall) Context(ctx context.Context) *ProjectsLocationsCertificatesDeleteCall {
13743 c.ctx_ = ctx
13744 return c
13745 }
13746
13747
13748
13749 func (c *ProjectsLocationsCertificatesDeleteCall) Header() http.Header {
13750 if c.header_ == nil {
13751 c.header_ = make(http.Header)
13752 }
13753 return c.header_
13754 }
13755
13756 func (c *ProjectsLocationsCertificatesDeleteCall) doRequest(alt string) (*http.Response, error) {
13757 reqHeaders := make(http.Header)
13758 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
13759 for k, v := range c.header_ {
13760 reqHeaders[k] = v
13761 }
13762 reqHeaders.Set("User-Agent", c.s.userAgent())
13763 var body io.Reader = nil
13764 c.urlParams_.Set("alt", alt)
13765 c.urlParams_.Set("prettyPrint", "false")
13766 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
13767 urls += "?" + c.urlParams_.Encode()
13768 req, err := http.NewRequest("DELETE", urls, body)
13769 if err != nil {
13770 return nil, err
13771 }
13772 req.Header = reqHeaders
13773 googleapi.Expand(req.URL, map[string]string{
13774 "name": c.name,
13775 })
13776 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13777 }
13778
13779
13780
13781
13782
13783
13784
13785
13786 func (c *ProjectsLocationsCertificatesDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
13787 gensupport.SetOptions(c.urlParams_, opts...)
13788 res, err := c.doRequest("json")
13789 if res != nil && res.StatusCode == http.StatusNotModified {
13790 if res.Body != nil {
13791 res.Body.Close()
13792 }
13793 return nil, gensupport.WrapError(&googleapi.Error{
13794 Code: res.StatusCode,
13795 Header: res.Header,
13796 })
13797 }
13798 if err != nil {
13799 return nil, err
13800 }
13801 defer googleapi.CloseBody(res)
13802 if err := googleapi.CheckResponse(res); err != nil {
13803 return nil, gensupport.WrapError(err)
13804 }
13805 ret := &GoogleProtobufEmpty{
13806 ServerResponse: googleapi.ServerResponse{
13807 Header: res.Header,
13808 HTTPStatusCode: res.StatusCode,
13809 },
13810 }
13811 target := &ret
13812 if err := gensupport.DecodeResponse(target, res); err != nil {
13813 return nil, err
13814 }
13815 return ret, nil
13816
13817
13818
13819
13820
13821
13822
13823
13824
13825
13826
13827
13828
13829
13830
13831
13832
13833
13834
13835
13836
13837
13838
13839
13840
13841
13842 }
13843
13844
13845
13846 type ProjectsLocationsCertificatesGetCall struct {
13847 s *Service
13848 name string
13849 urlParams_ gensupport.URLParams
13850 ifNoneMatch_ string
13851 ctx_ context.Context
13852 header_ http.Header
13853 }
13854
13855
13856
13857
13858
13859 func (r *ProjectsLocationsCertificatesService) Get(name string) *ProjectsLocationsCertificatesGetCall {
13860 c := &ProjectsLocationsCertificatesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13861 c.name = name
13862 return c
13863 }
13864
13865
13866
13867
13868 func (c *ProjectsLocationsCertificatesGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsCertificatesGetCall {
13869 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13870 return c
13871 }
13872
13873
13874
13875
13876
13877
13878 func (c *ProjectsLocationsCertificatesGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsCertificatesGetCall {
13879 c.ifNoneMatch_ = entityTag
13880 return c
13881 }
13882
13883
13884
13885
13886 func (c *ProjectsLocationsCertificatesGetCall) Context(ctx context.Context) *ProjectsLocationsCertificatesGetCall {
13887 c.ctx_ = ctx
13888 return c
13889 }
13890
13891
13892
13893 func (c *ProjectsLocationsCertificatesGetCall) Header() http.Header {
13894 if c.header_ == nil {
13895 c.header_ = make(http.Header)
13896 }
13897 return c.header_
13898 }
13899
13900 func (c *ProjectsLocationsCertificatesGetCall) doRequest(alt string) (*http.Response, error) {
13901 reqHeaders := make(http.Header)
13902 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
13903 for k, v := range c.header_ {
13904 reqHeaders[k] = v
13905 }
13906 reqHeaders.Set("User-Agent", c.s.userAgent())
13907 if c.ifNoneMatch_ != "" {
13908 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13909 }
13910 var body io.Reader = nil
13911 c.urlParams_.Set("alt", alt)
13912 c.urlParams_.Set("prettyPrint", "false")
13913 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
13914 urls += "?" + c.urlParams_.Encode()
13915 req, err := http.NewRequest("GET", urls, body)
13916 if err != nil {
13917 return nil, err
13918 }
13919 req.Header = reqHeaders
13920 googleapi.Expand(req.URL, map[string]string{
13921 "name": c.name,
13922 })
13923 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13924 }
13925
13926
13927
13928
13929
13930
13931
13932
13933
13934
13935 func (c *ProjectsLocationsCertificatesGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCertificate, error) {
13936 gensupport.SetOptions(c.urlParams_, opts...)
13937 res, err := c.doRequest("json")
13938 if res != nil && res.StatusCode == http.StatusNotModified {
13939 if res.Body != nil {
13940 res.Body.Close()
13941 }
13942 return nil, gensupport.WrapError(&googleapi.Error{
13943 Code: res.StatusCode,
13944 Header: res.Header,
13945 })
13946 }
13947 if err != nil {
13948 return nil, err
13949 }
13950 defer googleapi.CloseBody(res)
13951 if err := googleapi.CheckResponse(res); err != nil {
13952 return nil, gensupport.WrapError(err)
13953 }
13954 ret := &GoogleCloudIntegrationsV1alphaCertificate{
13955 ServerResponse: googleapi.ServerResponse{
13956 Header: res.Header,
13957 HTTPStatusCode: res.StatusCode,
13958 },
13959 }
13960 target := &ret
13961 if err := gensupport.DecodeResponse(target, res); err != nil {
13962 return nil, err
13963 }
13964 return ret, nil
13965
13966
13967
13968
13969
13970
13971
13972
13973
13974
13975
13976
13977
13978
13979
13980
13981
13982
13983
13984
13985
13986
13987
13988
13989
13990
13991 }
13992
13993
13994
13995 type ProjectsLocationsCertificatesListCall struct {
13996 s *Service
13997 parent string
13998 urlParams_ gensupport.URLParams
13999 ifNoneMatch_ string
14000 ctx_ context.Context
14001 header_ http.Header
14002 }
14003
14004
14005
14006
14007
14008 func (r *ProjectsLocationsCertificatesService) List(parent string) *ProjectsLocationsCertificatesListCall {
14009 c := &ProjectsLocationsCertificatesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14010 c.parent = parent
14011 return c
14012 }
14013
14014
14015
14016
14017 func (c *ProjectsLocationsCertificatesListCall) Filter(filter string) *ProjectsLocationsCertificatesListCall {
14018 c.urlParams_.Set("filter", filter)
14019 return c
14020 }
14021
14022
14023
14024 func (c *ProjectsLocationsCertificatesListCall) PageSize(pageSize int64) *ProjectsLocationsCertificatesListCall {
14025 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
14026 return c
14027 }
14028
14029
14030
14031 func (c *ProjectsLocationsCertificatesListCall) PageToken(pageToken string) *ProjectsLocationsCertificatesListCall {
14032 c.urlParams_.Set("pageToken", pageToken)
14033 return c
14034 }
14035
14036
14037
14038
14039 func (c *ProjectsLocationsCertificatesListCall) ReadMask(readMask string) *ProjectsLocationsCertificatesListCall {
14040 c.urlParams_.Set("readMask", readMask)
14041 return c
14042 }
14043
14044
14045
14046
14047 func (c *ProjectsLocationsCertificatesListCall) Fields(s ...googleapi.Field) *ProjectsLocationsCertificatesListCall {
14048 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14049 return c
14050 }
14051
14052
14053
14054
14055
14056
14057 func (c *ProjectsLocationsCertificatesListCall) IfNoneMatch(entityTag string) *ProjectsLocationsCertificatesListCall {
14058 c.ifNoneMatch_ = entityTag
14059 return c
14060 }
14061
14062
14063
14064
14065 func (c *ProjectsLocationsCertificatesListCall) Context(ctx context.Context) *ProjectsLocationsCertificatesListCall {
14066 c.ctx_ = ctx
14067 return c
14068 }
14069
14070
14071
14072 func (c *ProjectsLocationsCertificatesListCall) Header() http.Header {
14073 if c.header_ == nil {
14074 c.header_ = make(http.Header)
14075 }
14076 return c.header_
14077 }
14078
14079 func (c *ProjectsLocationsCertificatesListCall) doRequest(alt string) (*http.Response, error) {
14080 reqHeaders := make(http.Header)
14081 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
14082 for k, v := range c.header_ {
14083 reqHeaders[k] = v
14084 }
14085 reqHeaders.Set("User-Agent", c.s.userAgent())
14086 if c.ifNoneMatch_ != "" {
14087 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14088 }
14089 var body io.Reader = nil
14090 c.urlParams_.Set("alt", alt)
14091 c.urlParams_.Set("prettyPrint", "false")
14092 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/certificates")
14093 urls += "?" + c.urlParams_.Encode()
14094 req, err := http.NewRequest("GET", urls, body)
14095 if err != nil {
14096 return nil, err
14097 }
14098 req.Header = reqHeaders
14099 googleapi.Expand(req.URL, map[string]string{
14100 "parent": c.parent,
14101 })
14102 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14103 }
14104
14105
14106
14107
14108
14109
14110
14111
14112
14113
14114
14115 func (c *ProjectsLocationsCertificatesListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListCertificatesResponse, error) {
14116 gensupport.SetOptions(c.urlParams_, opts...)
14117 res, err := c.doRequest("json")
14118 if res != nil && res.StatusCode == http.StatusNotModified {
14119 if res.Body != nil {
14120 res.Body.Close()
14121 }
14122 return nil, gensupport.WrapError(&googleapi.Error{
14123 Code: res.StatusCode,
14124 Header: res.Header,
14125 })
14126 }
14127 if err != nil {
14128 return nil, err
14129 }
14130 defer googleapi.CloseBody(res)
14131 if err := googleapi.CheckResponse(res); err != nil {
14132 return nil, gensupport.WrapError(err)
14133 }
14134 ret := &GoogleCloudIntegrationsV1alphaListCertificatesResponse{
14135 ServerResponse: googleapi.ServerResponse{
14136 Header: res.Header,
14137 HTTPStatusCode: res.StatusCode,
14138 },
14139 }
14140 target := &ret
14141 if err := gensupport.DecodeResponse(target, res); err != nil {
14142 return nil, err
14143 }
14144 return ret, nil
14145
14146
14147
14148
14149
14150
14151
14152
14153
14154
14155
14156
14157
14158
14159
14160
14161
14162
14163
14164
14165
14166
14167
14168
14169
14170
14171
14172
14173
14174
14175
14176
14177
14178
14179
14180
14181
14182
14183
14184
14185
14186
14187
14188
14189
14190
14191
14192
14193 }
14194
14195
14196
14197
14198 func (c *ProjectsLocationsCertificatesListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListCertificatesResponse) error) error {
14199 c.ctx_ = ctx
14200 defer c.PageToken(c.urlParams_.Get("pageToken"))
14201 for {
14202 x, err := c.Do()
14203 if err != nil {
14204 return err
14205 }
14206 if err := f(x); err != nil {
14207 return err
14208 }
14209 if x.NextPageToken == "" {
14210 return nil
14211 }
14212 c.PageToken(x.NextPageToken)
14213 }
14214 }
14215
14216
14217
14218 type ProjectsLocationsCertificatesPatchCall struct {
14219 s *Service
14220 name string
14221 googlecloudintegrationsv1alphacertificate *GoogleCloudIntegrationsV1alphaCertificate
14222 urlParams_ gensupport.URLParams
14223 ctx_ context.Context
14224 header_ http.Header
14225 }
14226
14227
14228
14229
14230
14231
14232
14233 func (r *ProjectsLocationsCertificatesService) Patch(name string, googlecloudintegrationsv1alphacertificate *GoogleCloudIntegrationsV1alphaCertificate) *ProjectsLocationsCertificatesPatchCall {
14234 c := &ProjectsLocationsCertificatesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14235 c.name = name
14236 c.googlecloudintegrationsv1alphacertificate = googlecloudintegrationsv1alphacertificate
14237 return c
14238 }
14239
14240
14241
14242
14243 func (c *ProjectsLocationsCertificatesPatchCall) UpdateMask(updateMask string) *ProjectsLocationsCertificatesPatchCall {
14244 c.urlParams_.Set("updateMask", updateMask)
14245 return c
14246 }
14247
14248
14249
14250
14251 func (c *ProjectsLocationsCertificatesPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsCertificatesPatchCall {
14252 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14253 return c
14254 }
14255
14256
14257
14258
14259 func (c *ProjectsLocationsCertificatesPatchCall) Context(ctx context.Context) *ProjectsLocationsCertificatesPatchCall {
14260 c.ctx_ = ctx
14261 return c
14262 }
14263
14264
14265
14266 func (c *ProjectsLocationsCertificatesPatchCall) Header() http.Header {
14267 if c.header_ == nil {
14268 c.header_ = make(http.Header)
14269 }
14270 return c.header_
14271 }
14272
14273 func (c *ProjectsLocationsCertificatesPatchCall) doRequest(alt string) (*http.Response, error) {
14274 reqHeaders := make(http.Header)
14275 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
14276 for k, v := range c.header_ {
14277 reqHeaders[k] = v
14278 }
14279 reqHeaders.Set("User-Agent", c.s.userAgent())
14280 var body io.Reader = nil
14281 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacertificate)
14282 if err != nil {
14283 return nil, err
14284 }
14285 reqHeaders.Set("Content-Type", "application/json")
14286 c.urlParams_.Set("alt", alt)
14287 c.urlParams_.Set("prettyPrint", "false")
14288 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
14289 urls += "?" + c.urlParams_.Encode()
14290 req, err := http.NewRequest("PATCH", urls, body)
14291 if err != nil {
14292 return nil, err
14293 }
14294 req.Header = reqHeaders
14295 googleapi.Expand(req.URL, map[string]string{
14296 "name": c.name,
14297 })
14298 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14299 }
14300
14301
14302
14303
14304
14305
14306
14307
14308
14309
14310 func (c *ProjectsLocationsCertificatesPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCertificate, error) {
14311 gensupport.SetOptions(c.urlParams_, opts...)
14312 res, err := c.doRequest("json")
14313 if res != nil && res.StatusCode == http.StatusNotModified {
14314 if res.Body != nil {
14315 res.Body.Close()
14316 }
14317 return nil, gensupport.WrapError(&googleapi.Error{
14318 Code: res.StatusCode,
14319 Header: res.Header,
14320 })
14321 }
14322 if err != nil {
14323 return nil, err
14324 }
14325 defer googleapi.CloseBody(res)
14326 if err := googleapi.CheckResponse(res); err != nil {
14327 return nil, gensupport.WrapError(err)
14328 }
14329 ret := &GoogleCloudIntegrationsV1alphaCertificate{
14330 ServerResponse: googleapi.ServerResponse{
14331 Header: res.Header,
14332 HTTPStatusCode: res.StatusCode,
14333 },
14334 }
14335 target := &ret
14336 if err := gensupport.DecodeResponse(target, res); err != nil {
14337 return nil, err
14338 }
14339 return ret, nil
14340
14341
14342
14343
14344
14345
14346
14347
14348
14349
14350
14351
14352
14353
14354
14355
14356
14357
14358
14359
14360
14361
14362
14363
14364
14365
14366
14367
14368
14369
14370
14371
14372
14373
14374
14375 }
14376
14377
14378
14379 type ProjectsLocationsClientsDeprovisionCall struct {
14380 s *Service
14381 parent string
14382 googlecloudintegrationsv1alphadeprovisionclientrequest *GoogleCloudIntegrationsV1alphaDeprovisionClientRequest
14383 urlParams_ gensupport.URLParams
14384 ctx_ context.Context
14385 header_ http.Header
14386 }
14387
14388
14389
14390
14391
14392
14393 func (r *ProjectsLocationsClientsService) Deprovision(parent string, googlecloudintegrationsv1alphadeprovisionclientrequest *GoogleCloudIntegrationsV1alphaDeprovisionClientRequest) *ProjectsLocationsClientsDeprovisionCall {
14394 c := &ProjectsLocationsClientsDeprovisionCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14395 c.parent = parent
14396 c.googlecloudintegrationsv1alphadeprovisionclientrequest = googlecloudintegrationsv1alphadeprovisionclientrequest
14397 return c
14398 }
14399
14400
14401
14402
14403 func (c *ProjectsLocationsClientsDeprovisionCall) Fields(s ...googleapi.Field) *ProjectsLocationsClientsDeprovisionCall {
14404 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14405 return c
14406 }
14407
14408
14409
14410
14411 func (c *ProjectsLocationsClientsDeprovisionCall) Context(ctx context.Context) *ProjectsLocationsClientsDeprovisionCall {
14412 c.ctx_ = ctx
14413 return c
14414 }
14415
14416
14417
14418 func (c *ProjectsLocationsClientsDeprovisionCall) Header() http.Header {
14419 if c.header_ == nil {
14420 c.header_ = make(http.Header)
14421 }
14422 return c.header_
14423 }
14424
14425 func (c *ProjectsLocationsClientsDeprovisionCall) doRequest(alt string) (*http.Response, error) {
14426 reqHeaders := make(http.Header)
14427 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
14428 for k, v := range c.header_ {
14429 reqHeaders[k] = v
14430 }
14431 reqHeaders.Set("User-Agent", c.s.userAgent())
14432 var body io.Reader = nil
14433 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphadeprovisionclientrequest)
14434 if err != nil {
14435 return nil, err
14436 }
14437 reqHeaders.Set("Content-Type", "application/json")
14438 c.urlParams_.Set("alt", alt)
14439 c.urlParams_.Set("prettyPrint", "false")
14440 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/clients:deprovision")
14441 urls += "?" + c.urlParams_.Encode()
14442 req, err := http.NewRequest("POST", urls, body)
14443 if err != nil {
14444 return nil, err
14445 }
14446 req.Header = reqHeaders
14447 googleapi.Expand(req.URL, map[string]string{
14448 "parent": c.parent,
14449 })
14450 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14451 }
14452
14453
14454
14455
14456
14457
14458
14459
14460 func (c *ProjectsLocationsClientsDeprovisionCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
14461 gensupport.SetOptions(c.urlParams_, opts...)
14462 res, err := c.doRequest("json")
14463 if res != nil && res.StatusCode == http.StatusNotModified {
14464 if res.Body != nil {
14465 res.Body.Close()
14466 }
14467 return nil, gensupport.WrapError(&googleapi.Error{
14468 Code: res.StatusCode,
14469 Header: res.Header,
14470 })
14471 }
14472 if err != nil {
14473 return nil, err
14474 }
14475 defer googleapi.CloseBody(res)
14476 if err := googleapi.CheckResponse(res); err != nil {
14477 return nil, gensupport.WrapError(err)
14478 }
14479 ret := &GoogleProtobufEmpty{
14480 ServerResponse: googleapi.ServerResponse{
14481 Header: res.Header,
14482 HTTPStatusCode: res.StatusCode,
14483 },
14484 }
14485 target := &ret
14486 if err := gensupport.DecodeResponse(target, res); err != nil {
14487 return nil, err
14488 }
14489 return ret, nil
14490
14491
14492
14493
14494
14495
14496
14497
14498
14499
14500
14501
14502
14503
14504
14505
14506
14507
14508
14509
14510
14511
14512
14513
14514
14515
14516
14517
14518
14519 }
14520
14521
14522
14523 type ProjectsLocationsClientsProvisionCall struct {
14524 s *Service
14525 parent string
14526 googlecloudintegrationsv1alphaprovisionclientrequest *GoogleCloudIntegrationsV1alphaProvisionClientRequest
14527 urlParams_ gensupport.URLParams
14528 ctx_ context.Context
14529 header_ http.Header
14530 }
14531
14532
14533
14534
14535
14536
14537 func (r *ProjectsLocationsClientsService) Provision(parent string, googlecloudintegrationsv1alphaprovisionclientrequest *GoogleCloudIntegrationsV1alphaProvisionClientRequest) *ProjectsLocationsClientsProvisionCall {
14538 c := &ProjectsLocationsClientsProvisionCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14539 c.parent = parent
14540 c.googlecloudintegrationsv1alphaprovisionclientrequest = googlecloudintegrationsv1alphaprovisionclientrequest
14541 return c
14542 }
14543
14544
14545
14546
14547 func (c *ProjectsLocationsClientsProvisionCall) Fields(s ...googleapi.Field) *ProjectsLocationsClientsProvisionCall {
14548 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14549 return c
14550 }
14551
14552
14553
14554
14555 func (c *ProjectsLocationsClientsProvisionCall) Context(ctx context.Context) *ProjectsLocationsClientsProvisionCall {
14556 c.ctx_ = ctx
14557 return c
14558 }
14559
14560
14561
14562 func (c *ProjectsLocationsClientsProvisionCall) Header() http.Header {
14563 if c.header_ == nil {
14564 c.header_ = make(http.Header)
14565 }
14566 return c.header_
14567 }
14568
14569 func (c *ProjectsLocationsClientsProvisionCall) doRequest(alt string) (*http.Response, error) {
14570 reqHeaders := make(http.Header)
14571 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
14572 for k, v := range c.header_ {
14573 reqHeaders[k] = v
14574 }
14575 reqHeaders.Set("User-Agent", c.s.userAgent())
14576 var body io.Reader = nil
14577 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaprovisionclientrequest)
14578 if err != nil {
14579 return nil, err
14580 }
14581 reqHeaders.Set("Content-Type", "application/json")
14582 c.urlParams_.Set("alt", alt)
14583 c.urlParams_.Set("prettyPrint", "false")
14584 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/clients:provision")
14585 urls += "?" + c.urlParams_.Encode()
14586 req, err := http.NewRequest("POST", urls, body)
14587 if err != nil {
14588 return nil, err
14589 }
14590 req.Header = reqHeaders
14591 googleapi.Expand(req.URL, map[string]string{
14592 "parent": c.parent,
14593 })
14594 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14595 }
14596
14597
14598
14599
14600
14601
14602
14603
14604 func (c *ProjectsLocationsClientsProvisionCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
14605 gensupport.SetOptions(c.urlParams_, opts...)
14606 res, err := c.doRequest("json")
14607 if res != nil && res.StatusCode == http.StatusNotModified {
14608 if res.Body != nil {
14609 res.Body.Close()
14610 }
14611 return nil, gensupport.WrapError(&googleapi.Error{
14612 Code: res.StatusCode,
14613 Header: res.Header,
14614 })
14615 }
14616 if err != nil {
14617 return nil, err
14618 }
14619 defer googleapi.CloseBody(res)
14620 if err := googleapi.CheckResponse(res); err != nil {
14621 return nil, gensupport.WrapError(err)
14622 }
14623 ret := &GoogleProtobufEmpty{
14624 ServerResponse: googleapi.ServerResponse{
14625 Header: res.Header,
14626 HTTPStatusCode: res.StatusCode,
14627 },
14628 }
14629 target := &ret
14630 if err := gensupport.DecodeResponse(target, res); err != nil {
14631 return nil, err
14632 }
14633 return ret, nil
14634
14635
14636
14637
14638
14639
14640
14641
14642
14643
14644
14645
14646
14647
14648
14649
14650
14651
14652
14653
14654
14655
14656
14657
14658
14659
14660
14661
14662
14663 }
14664
14665
14666
14667 type ProjectsLocationsCloudFunctionsCreateCall struct {
14668 s *Service
14669 parent string
14670 googlecloudintegrationsv1alphacreatecloudfunctionrequest *GoogleCloudIntegrationsV1alphaCreateCloudFunctionRequest
14671 urlParams_ gensupport.URLParams
14672 ctx_ context.Context
14673 header_ http.Header
14674 }
14675
14676
14677
14678
14679 func (r *ProjectsLocationsCloudFunctionsService) Create(parent string, googlecloudintegrationsv1alphacreatecloudfunctionrequest *GoogleCloudIntegrationsV1alphaCreateCloudFunctionRequest) *ProjectsLocationsCloudFunctionsCreateCall {
14680 c := &ProjectsLocationsCloudFunctionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14681 c.parent = parent
14682 c.googlecloudintegrationsv1alphacreatecloudfunctionrequest = googlecloudintegrationsv1alphacreatecloudfunctionrequest
14683 return c
14684 }
14685
14686
14687
14688
14689 func (c *ProjectsLocationsCloudFunctionsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsCloudFunctionsCreateCall {
14690 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14691 return c
14692 }
14693
14694
14695
14696
14697 func (c *ProjectsLocationsCloudFunctionsCreateCall) Context(ctx context.Context) *ProjectsLocationsCloudFunctionsCreateCall {
14698 c.ctx_ = ctx
14699 return c
14700 }
14701
14702
14703
14704 func (c *ProjectsLocationsCloudFunctionsCreateCall) Header() http.Header {
14705 if c.header_ == nil {
14706 c.header_ = make(http.Header)
14707 }
14708 return c.header_
14709 }
14710
14711 func (c *ProjectsLocationsCloudFunctionsCreateCall) doRequest(alt string) (*http.Response, error) {
14712 reqHeaders := make(http.Header)
14713 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
14714 for k, v := range c.header_ {
14715 reqHeaders[k] = v
14716 }
14717 reqHeaders.Set("User-Agent", c.s.userAgent())
14718 var body io.Reader = nil
14719 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacreatecloudfunctionrequest)
14720 if err != nil {
14721 return nil, err
14722 }
14723 reqHeaders.Set("Content-Type", "application/json")
14724 c.urlParams_.Set("alt", alt)
14725 c.urlParams_.Set("prettyPrint", "false")
14726 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/cloudFunctions")
14727 urls += "?" + c.urlParams_.Encode()
14728 req, err := http.NewRequest("POST", urls, body)
14729 if err != nil {
14730 return nil, err
14731 }
14732 req.Header = reqHeaders
14733 googleapi.Expand(req.URL, map[string]string{
14734 "parent": c.parent,
14735 })
14736 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14737 }
14738
14739
14740
14741
14742
14743
14744
14745
14746
14747
14748
14749 func (c *ProjectsLocationsCloudFunctionsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCreateCloudFunctionResponse, error) {
14750 gensupport.SetOptions(c.urlParams_, opts...)
14751 res, err := c.doRequest("json")
14752 if res != nil && res.StatusCode == http.StatusNotModified {
14753 if res.Body != nil {
14754 res.Body.Close()
14755 }
14756 return nil, gensupport.WrapError(&googleapi.Error{
14757 Code: res.StatusCode,
14758 Header: res.Header,
14759 })
14760 }
14761 if err != nil {
14762 return nil, err
14763 }
14764 defer googleapi.CloseBody(res)
14765 if err := googleapi.CheckResponse(res); err != nil {
14766 return nil, gensupport.WrapError(err)
14767 }
14768 ret := &GoogleCloudIntegrationsV1alphaCreateCloudFunctionResponse{
14769 ServerResponse: googleapi.ServerResponse{
14770 Header: res.Header,
14771 HTTPStatusCode: res.StatusCode,
14772 },
14773 }
14774 target := &ret
14775 if err := gensupport.DecodeResponse(target, res); err != nil {
14776 return nil, err
14777 }
14778 return ret, nil
14779
14780
14781
14782
14783
14784
14785
14786
14787
14788
14789
14790
14791
14792
14793
14794
14795
14796
14797
14798
14799
14800
14801
14802
14803
14804
14805
14806
14807
14808 }
14809
14810
14811
14812 type ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall struct {
14813 s *Service
14814 name string
14815 urlParams_ gensupport.URLParams
14816 ifNoneMatch_ string
14817 ctx_ context.Context
14818 header_ http.Header
14819 }
14820
14821
14822
14823
14824
14825
14826
14827 func (r *ProjectsLocationsConnectionsService) GetConnectionSchemaMetadata(name string) *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall {
14828 c := &ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14829 c.name = name
14830 return c
14831 }
14832
14833
14834
14835
14836 func (c *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall {
14837 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14838 return c
14839 }
14840
14841
14842
14843
14844
14845
14846 func (c *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall {
14847 c.ifNoneMatch_ = entityTag
14848 return c
14849 }
14850
14851
14852
14853
14854 func (c *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall) Context(ctx context.Context) *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall {
14855 c.ctx_ = ctx
14856 return c
14857 }
14858
14859
14860
14861 func (c *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall) Header() http.Header {
14862 if c.header_ == nil {
14863 c.header_ = make(http.Header)
14864 }
14865 return c.header_
14866 }
14867
14868 func (c *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall) doRequest(alt string) (*http.Response, error) {
14869 reqHeaders := make(http.Header)
14870 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
14871 for k, v := range c.header_ {
14872 reqHeaders[k] = v
14873 }
14874 reqHeaders.Set("User-Agent", c.s.userAgent())
14875 if c.ifNoneMatch_ != "" {
14876 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14877 }
14878 var body io.Reader = nil
14879 c.urlParams_.Set("alt", alt)
14880 c.urlParams_.Set("prettyPrint", "false")
14881 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
14882 urls += "?" + c.urlParams_.Encode()
14883 req, err := http.NewRequest("GET", urls, body)
14884 if err != nil {
14885 return nil, err
14886 }
14887 req.Header = reqHeaders
14888 googleapi.Expand(req.URL, map[string]string{
14889 "name": c.name,
14890 })
14891 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14892 }
14893
14894
14895
14896
14897
14898
14899
14900
14901
14902
14903
14904 func (c *ProjectsLocationsConnectionsGetConnectionSchemaMetadataCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaConnectionSchemaMetadata, error) {
14905 gensupport.SetOptions(c.urlParams_, opts...)
14906 res, err := c.doRequest("json")
14907 if res != nil && res.StatusCode == http.StatusNotModified {
14908 if res.Body != nil {
14909 res.Body.Close()
14910 }
14911 return nil, gensupport.WrapError(&googleapi.Error{
14912 Code: res.StatusCode,
14913 Header: res.Header,
14914 })
14915 }
14916 if err != nil {
14917 return nil, err
14918 }
14919 defer googleapi.CloseBody(res)
14920 if err := googleapi.CheckResponse(res); err != nil {
14921 return nil, gensupport.WrapError(err)
14922 }
14923 ret := &GoogleCloudIntegrationsV1alphaConnectionSchemaMetadata{
14924 ServerResponse: googleapi.ServerResponse{
14925 Header: res.Header,
14926 HTTPStatusCode: res.StatusCode,
14927 },
14928 }
14929 target := &ret
14930 if err := gensupport.DecodeResponse(target, res); err != nil {
14931 return nil, err
14932 }
14933 return ret, nil
14934
14935
14936
14937
14938
14939
14940
14941
14942
14943
14944
14945
14946
14947
14948
14949
14950
14951
14952
14953
14954
14955
14956
14957
14958
14959
14960 }
14961
14962
14963
14964 type ProjectsLocationsConnectionsListCall struct {
14965 s *Service
14966 parent string
14967 urlParams_ gensupport.URLParams
14968 ifNoneMatch_ string
14969 ctx_ context.Context
14970 header_ http.Header
14971 }
14972
14973
14974
14975
14976
14977 func (r *ProjectsLocationsConnectionsService) List(parent string) *ProjectsLocationsConnectionsListCall {
14978 c := &ProjectsLocationsConnectionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14979 c.parent = parent
14980 return c
14981 }
14982
14983
14984 func (c *ProjectsLocationsConnectionsListCall) Filter(filter string) *ProjectsLocationsConnectionsListCall {
14985 c.urlParams_.Set("filter", filter)
14986 return c
14987 }
14988
14989
14990 func (c *ProjectsLocationsConnectionsListCall) OrderBy(orderBy string) *ProjectsLocationsConnectionsListCall {
14991 c.urlParams_.Set("orderBy", orderBy)
14992 return c
14993 }
14994
14995
14996 func (c *ProjectsLocationsConnectionsListCall) PageSize(pageSize int64) *ProjectsLocationsConnectionsListCall {
14997 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
14998 return c
14999 }
15000
15001
15002 func (c *ProjectsLocationsConnectionsListCall) PageToken(pageToken string) *ProjectsLocationsConnectionsListCall {
15003 c.urlParams_.Set("pageToken", pageToken)
15004 return c
15005 }
15006
15007
15008
15009
15010 func (c *ProjectsLocationsConnectionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsListCall {
15011 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15012 return c
15013 }
15014
15015
15016
15017
15018
15019
15020 func (c *ProjectsLocationsConnectionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectionsListCall {
15021 c.ifNoneMatch_ = entityTag
15022 return c
15023 }
15024
15025
15026
15027
15028 func (c *ProjectsLocationsConnectionsListCall) Context(ctx context.Context) *ProjectsLocationsConnectionsListCall {
15029 c.ctx_ = ctx
15030 return c
15031 }
15032
15033
15034
15035 func (c *ProjectsLocationsConnectionsListCall) Header() http.Header {
15036 if c.header_ == nil {
15037 c.header_ = make(http.Header)
15038 }
15039 return c.header_
15040 }
15041
15042 func (c *ProjectsLocationsConnectionsListCall) doRequest(alt string) (*http.Response, error) {
15043 reqHeaders := make(http.Header)
15044 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
15045 for k, v := range c.header_ {
15046 reqHeaders[k] = v
15047 }
15048 reqHeaders.Set("User-Agent", c.s.userAgent())
15049 if c.ifNoneMatch_ != "" {
15050 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15051 }
15052 var body io.Reader = nil
15053 c.urlParams_.Set("alt", alt)
15054 c.urlParams_.Set("prettyPrint", "false")
15055 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/connections")
15056 urls += "?" + c.urlParams_.Encode()
15057 req, err := http.NewRequest("GET", urls, body)
15058 if err != nil {
15059 return nil, err
15060 }
15061 req.Header = reqHeaders
15062 googleapi.Expand(req.URL, map[string]string{
15063 "parent": c.parent,
15064 })
15065 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15066 }
15067
15068
15069
15070
15071
15072
15073
15074
15075
15076
15077 func (c *ProjectsLocationsConnectionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListConnectionsResponse, error) {
15078 gensupport.SetOptions(c.urlParams_, opts...)
15079 res, err := c.doRequest("json")
15080 if res != nil && res.StatusCode == http.StatusNotModified {
15081 if res.Body != nil {
15082 res.Body.Close()
15083 }
15084 return nil, gensupport.WrapError(&googleapi.Error{
15085 Code: res.StatusCode,
15086 Header: res.Header,
15087 })
15088 }
15089 if err != nil {
15090 return nil, err
15091 }
15092 defer googleapi.CloseBody(res)
15093 if err := googleapi.CheckResponse(res); err != nil {
15094 return nil, gensupport.WrapError(err)
15095 }
15096 ret := &GoogleCloudIntegrationsV1alphaListConnectionsResponse{
15097 ServerResponse: googleapi.ServerResponse{
15098 Header: res.Header,
15099 HTTPStatusCode: res.StatusCode,
15100 },
15101 }
15102 target := &ret
15103 if err := gensupport.DecodeResponse(target, res); err != nil {
15104 return nil, err
15105 }
15106 return ret, nil
15107
15108
15109
15110
15111
15112
15113
15114
15115
15116
15117
15118
15119
15120
15121
15122
15123
15124
15125
15126
15127
15128
15129
15130
15131
15132
15133
15134
15135
15136
15137
15138
15139
15140
15141
15142
15143
15144
15145
15146
15147
15148
15149
15150
15151
15152
15153
15154 }
15155
15156
15157
15158
15159 func (c *ProjectsLocationsConnectionsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListConnectionsResponse) error) error {
15160 c.ctx_ = ctx
15161 defer c.PageToken(c.urlParams_.Get("pageToken"))
15162 for {
15163 x, err := c.Do()
15164 if err != nil {
15165 return err
15166 }
15167 if err := f(x); err != nil {
15168 return err
15169 }
15170 if x.NextPageToken == "" {
15171 return nil
15172 }
15173 c.PageToken(x.NextPageToken)
15174 }
15175 }
15176
15177
15178
15179 type ProjectsLocationsConnectionsRuntimeActionSchemasListCall struct {
15180 s *Service
15181 parent string
15182 urlParams_ gensupport.URLParams
15183 ifNoneMatch_ string
15184 ctx_ context.Context
15185 header_ http.Header
15186 }
15187
15188
15189
15190
15191
15192
15193 func (r *ProjectsLocationsConnectionsRuntimeActionSchemasService) List(parent string) *ProjectsLocationsConnectionsRuntimeActionSchemasListCall {
15194 c := &ProjectsLocationsConnectionsRuntimeActionSchemasListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15195 c.parent = parent
15196 return c
15197 }
15198
15199
15200
15201 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) Filter(filter string) *ProjectsLocationsConnectionsRuntimeActionSchemasListCall {
15202 c.urlParams_.Set("filter", filter)
15203 return c
15204 }
15205
15206
15207 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) PageSize(pageSize int64) *ProjectsLocationsConnectionsRuntimeActionSchemasListCall {
15208 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
15209 return c
15210 }
15211
15212
15213 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) PageToken(pageToken string) *ProjectsLocationsConnectionsRuntimeActionSchemasListCall {
15214 c.urlParams_.Set("pageToken", pageToken)
15215 return c
15216 }
15217
15218
15219
15220
15221 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsRuntimeActionSchemasListCall {
15222 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15223 return c
15224 }
15225
15226
15227
15228
15229
15230
15231 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectionsRuntimeActionSchemasListCall {
15232 c.ifNoneMatch_ = entityTag
15233 return c
15234 }
15235
15236
15237
15238
15239 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) Context(ctx context.Context) *ProjectsLocationsConnectionsRuntimeActionSchemasListCall {
15240 c.ctx_ = ctx
15241 return c
15242 }
15243
15244
15245
15246 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) Header() http.Header {
15247 if c.header_ == nil {
15248 c.header_ = make(http.Header)
15249 }
15250 return c.header_
15251 }
15252
15253 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) doRequest(alt string) (*http.Response, error) {
15254 reqHeaders := make(http.Header)
15255 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
15256 for k, v := range c.header_ {
15257 reqHeaders[k] = v
15258 }
15259 reqHeaders.Set("User-Agent", c.s.userAgent())
15260 if c.ifNoneMatch_ != "" {
15261 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15262 }
15263 var body io.Reader = nil
15264 c.urlParams_.Set("alt", alt)
15265 c.urlParams_.Set("prettyPrint", "false")
15266 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/runtimeActionSchemas")
15267 urls += "?" + c.urlParams_.Encode()
15268 req, err := http.NewRequest("GET", urls, body)
15269 if err != nil {
15270 return nil, err
15271 }
15272 req.Header = reqHeaders
15273 googleapi.Expand(req.URL, map[string]string{
15274 "parent": c.parent,
15275 })
15276 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15277 }
15278
15279
15280
15281
15282
15283
15284
15285
15286
15287
15288
15289 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListRuntimeActionSchemasResponse, error) {
15290 gensupport.SetOptions(c.urlParams_, opts...)
15291 res, err := c.doRequest("json")
15292 if res != nil && res.StatusCode == http.StatusNotModified {
15293 if res.Body != nil {
15294 res.Body.Close()
15295 }
15296 return nil, gensupport.WrapError(&googleapi.Error{
15297 Code: res.StatusCode,
15298 Header: res.Header,
15299 })
15300 }
15301 if err != nil {
15302 return nil, err
15303 }
15304 defer googleapi.CloseBody(res)
15305 if err := googleapi.CheckResponse(res); err != nil {
15306 return nil, gensupport.WrapError(err)
15307 }
15308 ret := &GoogleCloudIntegrationsV1alphaListRuntimeActionSchemasResponse{
15309 ServerResponse: googleapi.ServerResponse{
15310 Header: res.Header,
15311 HTTPStatusCode: res.StatusCode,
15312 },
15313 }
15314 target := &ret
15315 if err := gensupport.DecodeResponse(target, res); err != nil {
15316 return nil, err
15317 }
15318 return ret, nil
15319
15320
15321
15322
15323
15324
15325
15326
15327
15328
15329
15330
15331
15332
15333
15334
15335
15336
15337
15338
15339
15340
15341
15342
15343
15344
15345
15346
15347
15348
15349
15350
15351
15352
15353
15354
15355
15356
15357
15358
15359
15360
15361 }
15362
15363
15364
15365
15366 func (c *ProjectsLocationsConnectionsRuntimeActionSchemasListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListRuntimeActionSchemasResponse) error) error {
15367 c.ctx_ = ctx
15368 defer c.PageToken(c.urlParams_.Get("pageToken"))
15369 for {
15370 x, err := c.Do()
15371 if err != nil {
15372 return err
15373 }
15374 if err := f(x); err != nil {
15375 return err
15376 }
15377 if x.NextPageToken == "" {
15378 return nil
15379 }
15380 c.PageToken(x.NextPageToken)
15381 }
15382 }
15383
15384
15385
15386 type ProjectsLocationsConnectionsRuntimeEntitySchemasListCall struct {
15387 s *Service
15388 parent string
15389 urlParams_ gensupport.URLParams
15390 ifNoneMatch_ string
15391 ctx_ context.Context
15392 header_ http.Header
15393 }
15394
15395
15396
15397
15398
15399
15400 func (r *ProjectsLocationsConnectionsRuntimeEntitySchemasService) List(parent string) *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall {
15401 c := &ProjectsLocationsConnectionsRuntimeEntitySchemasListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15402 c.parent = parent
15403 return c
15404 }
15405
15406
15407
15408 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) Filter(filter string) *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall {
15409 c.urlParams_.Set("filter", filter)
15410 return c
15411 }
15412
15413
15414 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) PageSize(pageSize int64) *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall {
15415 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
15416 return c
15417 }
15418
15419
15420 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) PageToken(pageToken string) *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall {
15421 c.urlParams_.Set("pageToken", pageToken)
15422 return c
15423 }
15424
15425
15426
15427
15428 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall {
15429 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15430 return c
15431 }
15432
15433
15434
15435
15436
15437
15438 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall {
15439 c.ifNoneMatch_ = entityTag
15440 return c
15441 }
15442
15443
15444
15445
15446 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) Context(ctx context.Context) *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall {
15447 c.ctx_ = ctx
15448 return c
15449 }
15450
15451
15452
15453 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) Header() http.Header {
15454 if c.header_ == nil {
15455 c.header_ = make(http.Header)
15456 }
15457 return c.header_
15458 }
15459
15460 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) doRequest(alt string) (*http.Response, error) {
15461 reqHeaders := make(http.Header)
15462 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
15463 for k, v := range c.header_ {
15464 reqHeaders[k] = v
15465 }
15466 reqHeaders.Set("User-Agent", c.s.userAgent())
15467 if c.ifNoneMatch_ != "" {
15468 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15469 }
15470 var body io.Reader = nil
15471 c.urlParams_.Set("alt", alt)
15472 c.urlParams_.Set("prettyPrint", "false")
15473 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/runtimeEntitySchemas")
15474 urls += "?" + c.urlParams_.Encode()
15475 req, err := http.NewRequest("GET", urls, body)
15476 if err != nil {
15477 return nil, err
15478 }
15479 req.Header = reqHeaders
15480 googleapi.Expand(req.URL, map[string]string{
15481 "parent": c.parent,
15482 })
15483 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15484 }
15485
15486
15487
15488
15489
15490
15491
15492
15493
15494
15495
15496 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListRuntimeEntitySchemasResponse, error) {
15497 gensupport.SetOptions(c.urlParams_, opts...)
15498 res, err := c.doRequest("json")
15499 if res != nil && res.StatusCode == http.StatusNotModified {
15500 if res.Body != nil {
15501 res.Body.Close()
15502 }
15503 return nil, gensupport.WrapError(&googleapi.Error{
15504 Code: res.StatusCode,
15505 Header: res.Header,
15506 })
15507 }
15508 if err != nil {
15509 return nil, err
15510 }
15511 defer googleapi.CloseBody(res)
15512 if err := googleapi.CheckResponse(res); err != nil {
15513 return nil, gensupport.WrapError(err)
15514 }
15515 ret := &GoogleCloudIntegrationsV1alphaListRuntimeEntitySchemasResponse{
15516 ServerResponse: googleapi.ServerResponse{
15517 Header: res.Header,
15518 HTTPStatusCode: res.StatusCode,
15519 },
15520 }
15521 target := &ret
15522 if err := gensupport.DecodeResponse(target, res); err != nil {
15523 return nil, err
15524 }
15525 return ret, nil
15526
15527
15528
15529
15530
15531
15532
15533
15534
15535
15536
15537
15538
15539
15540
15541
15542
15543
15544
15545
15546
15547
15548
15549
15550
15551
15552
15553
15554
15555
15556
15557
15558
15559
15560
15561
15562
15563
15564
15565
15566
15567
15568 }
15569
15570
15571
15572
15573 func (c *ProjectsLocationsConnectionsRuntimeEntitySchemasListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListRuntimeEntitySchemasResponse) error) error {
15574 c.ctx_ = ctx
15575 defer c.PageToken(c.urlParams_.Get("pageToken"))
15576 for {
15577 x, err := c.Do()
15578 if err != nil {
15579 return err
15580 }
15581 if err := f(x); err != nil {
15582 return err
15583 }
15584 if x.NextPageToken == "" {
15585 return nil
15586 }
15587 c.PageToken(x.NextPageToken)
15588 }
15589 }
15590
15591
15592
15593 type ProjectsLocationsIntegrationsDeleteCall struct {
15594 s *Service
15595 name string
15596 urlParams_ gensupport.URLParams
15597 ctx_ context.Context
15598 header_ http.Header
15599 }
15600
15601
15602
15603
15604 func (r *ProjectsLocationsIntegrationsService) Delete(name string) *ProjectsLocationsIntegrationsDeleteCall {
15605 c := &ProjectsLocationsIntegrationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15606 c.name = name
15607 return c
15608 }
15609
15610
15611
15612
15613 func (c *ProjectsLocationsIntegrationsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsDeleteCall {
15614 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15615 return c
15616 }
15617
15618
15619
15620
15621 func (c *ProjectsLocationsIntegrationsDeleteCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsDeleteCall {
15622 c.ctx_ = ctx
15623 return c
15624 }
15625
15626
15627
15628 func (c *ProjectsLocationsIntegrationsDeleteCall) Header() http.Header {
15629 if c.header_ == nil {
15630 c.header_ = make(http.Header)
15631 }
15632 return c.header_
15633 }
15634
15635 func (c *ProjectsLocationsIntegrationsDeleteCall) doRequest(alt string) (*http.Response, error) {
15636 reqHeaders := make(http.Header)
15637 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
15638 for k, v := range c.header_ {
15639 reqHeaders[k] = v
15640 }
15641 reqHeaders.Set("User-Agent", c.s.userAgent())
15642 var body io.Reader = nil
15643 c.urlParams_.Set("alt", alt)
15644 c.urlParams_.Set("prettyPrint", "false")
15645 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
15646 urls += "?" + c.urlParams_.Encode()
15647 req, err := http.NewRequest("DELETE", urls, body)
15648 if err != nil {
15649 return nil, err
15650 }
15651 req.Header = reqHeaders
15652 googleapi.Expand(req.URL, map[string]string{
15653 "name": c.name,
15654 })
15655 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15656 }
15657
15658
15659
15660
15661
15662
15663
15664
15665 func (c *ProjectsLocationsIntegrationsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
15666 gensupport.SetOptions(c.urlParams_, opts...)
15667 res, err := c.doRequest("json")
15668 if res != nil && res.StatusCode == http.StatusNotModified {
15669 if res.Body != nil {
15670 res.Body.Close()
15671 }
15672 return nil, gensupport.WrapError(&googleapi.Error{
15673 Code: res.StatusCode,
15674 Header: res.Header,
15675 })
15676 }
15677 if err != nil {
15678 return nil, err
15679 }
15680 defer googleapi.CloseBody(res)
15681 if err := googleapi.CheckResponse(res); err != nil {
15682 return nil, gensupport.WrapError(err)
15683 }
15684 ret := &GoogleProtobufEmpty{
15685 ServerResponse: googleapi.ServerResponse{
15686 Header: res.Header,
15687 HTTPStatusCode: res.StatusCode,
15688 },
15689 }
15690 target := &ret
15691 if err := gensupport.DecodeResponse(target, res); err != nil {
15692 return nil, err
15693 }
15694 return ret, nil
15695
15696
15697
15698
15699
15700
15701
15702
15703
15704
15705
15706
15707
15708
15709
15710
15711
15712
15713
15714
15715
15716
15717
15718
15719
15720
15721 }
15722
15723
15724
15725 type ProjectsLocationsIntegrationsExecuteCall struct {
15726 s *Service
15727 name string
15728 googlecloudintegrationsv1alphaexecuteintegrationsrequest *GoogleCloudIntegrationsV1alphaExecuteIntegrationsRequest
15729 urlParams_ gensupport.URLParams
15730 ctx_ context.Context
15731 header_ http.Header
15732 }
15733
15734
15735
15736
15737
15738
15739
15740
15741
15742
15743 func (r *ProjectsLocationsIntegrationsService) Execute(name string, googlecloudintegrationsv1alphaexecuteintegrationsrequest *GoogleCloudIntegrationsV1alphaExecuteIntegrationsRequest) *ProjectsLocationsIntegrationsExecuteCall {
15744 c := &ProjectsLocationsIntegrationsExecuteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15745 c.name = name
15746 c.googlecloudintegrationsv1alphaexecuteintegrationsrequest = googlecloudintegrationsv1alphaexecuteintegrationsrequest
15747 return c
15748 }
15749
15750
15751
15752
15753 func (c *ProjectsLocationsIntegrationsExecuteCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsExecuteCall {
15754 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15755 return c
15756 }
15757
15758
15759
15760
15761 func (c *ProjectsLocationsIntegrationsExecuteCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsExecuteCall {
15762 c.ctx_ = ctx
15763 return c
15764 }
15765
15766
15767
15768 func (c *ProjectsLocationsIntegrationsExecuteCall) Header() http.Header {
15769 if c.header_ == nil {
15770 c.header_ = make(http.Header)
15771 }
15772 return c.header_
15773 }
15774
15775 func (c *ProjectsLocationsIntegrationsExecuteCall) doRequest(alt string) (*http.Response, error) {
15776 reqHeaders := make(http.Header)
15777 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
15778 for k, v := range c.header_ {
15779 reqHeaders[k] = v
15780 }
15781 reqHeaders.Set("User-Agent", c.s.userAgent())
15782 var body io.Reader = nil
15783 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaexecuteintegrationsrequest)
15784 if err != nil {
15785 return nil, err
15786 }
15787 reqHeaders.Set("Content-Type", "application/json")
15788 c.urlParams_.Set("alt", alt)
15789 c.urlParams_.Set("prettyPrint", "false")
15790 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:execute")
15791 urls += "?" + c.urlParams_.Encode()
15792 req, err := http.NewRequest("POST", urls, body)
15793 if err != nil {
15794 return nil, err
15795 }
15796 req.Header = reqHeaders
15797 googleapi.Expand(req.URL, map[string]string{
15798 "name": c.name,
15799 })
15800 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15801 }
15802
15803
15804
15805
15806
15807
15808
15809
15810
15811
15812
15813 func (c *ProjectsLocationsIntegrationsExecuteCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaExecuteIntegrationsResponse, error) {
15814 gensupport.SetOptions(c.urlParams_, opts...)
15815 res, err := c.doRequest("json")
15816 if res != nil && res.StatusCode == http.StatusNotModified {
15817 if res.Body != nil {
15818 res.Body.Close()
15819 }
15820 return nil, gensupport.WrapError(&googleapi.Error{
15821 Code: res.StatusCode,
15822 Header: res.Header,
15823 })
15824 }
15825 if err != nil {
15826 return nil, err
15827 }
15828 defer googleapi.CloseBody(res)
15829 if err := googleapi.CheckResponse(res); err != nil {
15830 return nil, gensupport.WrapError(err)
15831 }
15832 ret := &GoogleCloudIntegrationsV1alphaExecuteIntegrationsResponse{
15833 ServerResponse: googleapi.ServerResponse{
15834 Header: res.Header,
15835 HTTPStatusCode: res.StatusCode,
15836 },
15837 }
15838 target := &ret
15839 if err := gensupport.DecodeResponse(target, res); err != nil {
15840 return nil, err
15841 }
15842 return ret, nil
15843
15844
15845
15846
15847
15848
15849
15850
15851
15852
15853
15854
15855
15856
15857
15858
15859
15860
15861
15862
15863
15864
15865
15866
15867
15868
15869
15870
15871
15872 }
15873
15874
15875
15876 type ProjectsLocationsIntegrationsListCall struct {
15877 s *Service
15878 parent string
15879 urlParams_ gensupport.URLParams
15880 ifNoneMatch_ string
15881 ctx_ context.Context
15882 header_ http.Header
15883 }
15884
15885
15886
15887
15888
15889 func (r *ProjectsLocationsIntegrationsService) List(parent string) *ProjectsLocationsIntegrationsListCall {
15890 c := &ProjectsLocationsIntegrationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15891 c.parent = parent
15892 return c
15893 }
15894
15895
15896
15897
15898
15899
15900
15901
15902
15903 func (c *ProjectsLocationsIntegrationsListCall) Filter(filter string) *ProjectsLocationsIntegrationsListCall {
15904 c.urlParams_.Set("filter", filter)
15905 return c
15906 }
15907
15908
15909
15910
15911
15912 func (c *ProjectsLocationsIntegrationsListCall) OrderBy(orderBy string) *ProjectsLocationsIntegrationsListCall {
15913 c.urlParams_.Set("orderBy", orderBy)
15914 return c
15915 }
15916
15917
15918
15919 func (c *ProjectsLocationsIntegrationsListCall) PageSize(pageSize int64) *ProjectsLocationsIntegrationsListCall {
15920 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
15921 return c
15922 }
15923
15924
15925
15926 func (c *ProjectsLocationsIntegrationsListCall) PageToken(pageToken string) *ProjectsLocationsIntegrationsListCall {
15927 c.urlParams_.Set("pageToken", pageToken)
15928 return c
15929 }
15930
15931
15932
15933
15934 func (c *ProjectsLocationsIntegrationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsListCall {
15935 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15936 return c
15937 }
15938
15939
15940
15941
15942
15943
15944 func (c *ProjectsLocationsIntegrationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsListCall {
15945 c.ifNoneMatch_ = entityTag
15946 return c
15947 }
15948
15949
15950
15951
15952 func (c *ProjectsLocationsIntegrationsListCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsListCall {
15953 c.ctx_ = ctx
15954 return c
15955 }
15956
15957
15958
15959 func (c *ProjectsLocationsIntegrationsListCall) Header() http.Header {
15960 if c.header_ == nil {
15961 c.header_ = make(http.Header)
15962 }
15963 return c.header_
15964 }
15965
15966 func (c *ProjectsLocationsIntegrationsListCall) doRequest(alt string) (*http.Response, error) {
15967 reqHeaders := make(http.Header)
15968 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
15969 for k, v := range c.header_ {
15970 reqHeaders[k] = v
15971 }
15972 reqHeaders.Set("User-Agent", c.s.userAgent())
15973 if c.ifNoneMatch_ != "" {
15974 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15975 }
15976 var body io.Reader = nil
15977 c.urlParams_.Set("alt", alt)
15978 c.urlParams_.Set("prettyPrint", "false")
15979 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/integrations")
15980 urls += "?" + c.urlParams_.Encode()
15981 req, err := http.NewRequest("GET", urls, body)
15982 if err != nil {
15983 return nil, err
15984 }
15985 req.Header = reqHeaders
15986 googleapi.Expand(req.URL, map[string]string{
15987 "parent": c.parent,
15988 })
15989 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15990 }
15991
15992
15993
15994
15995
15996
15997
15998
15999
16000
16001
16002 func (c *ProjectsLocationsIntegrationsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListIntegrationsResponse, error) {
16003 gensupport.SetOptions(c.urlParams_, opts...)
16004 res, err := c.doRequest("json")
16005 if res != nil && res.StatusCode == http.StatusNotModified {
16006 if res.Body != nil {
16007 res.Body.Close()
16008 }
16009 return nil, gensupport.WrapError(&googleapi.Error{
16010 Code: res.StatusCode,
16011 Header: res.Header,
16012 })
16013 }
16014 if err != nil {
16015 return nil, err
16016 }
16017 defer googleapi.CloseBody(res)
16018 if err := googleapi.CheckResponse(res); err != nil {
16019 return nil, gensupport.WrapError(err)
16020 }
16021 ret := &GoogleCloudIntegrationsV1alphaListIntegrationsResponse{
16022 ServerResponse: googleapi.ServerResponse{
16023 Header: res.Header,
16024 HTTPStatusCode: res.StatusCode,
16025 },
16026 }
16027 target := &ret
16028 if err := gensupport.DecodeResponse(target, res); err != nil {
16029 return nil, err
16030 }
16031 return ret, nil
16032
16033
16034
16035
16036
16037
16038
16039
16040
16041
16042
16043
16044
16045
16046
16047
16048
16049
16050
16051
16052
16053
16054
16055
16056
16057
16058
16059
16060
16061
16062
16063
16064
16065
16066
16067
16068
16069
16070
16071
16072
16073
16074
16075
16076
16077
16078
16079 }
16080
16081
16082
16083
16084 func (c *ProjectsLocationsIntegrationsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListIntegrationsResponse) error) error {
16085 c.ctx_ = ctx
16086 defer c.PageToken(c.urlParams_.Get("pageToken"))
16087 for {
16088 x, err := c.Do()
16089 if err != nil {
16090 return err
16091 }
16092 if err := f(x); err != nil {
16093 return err
16094 }
16095 if x.NextPageToken == "" {
16096 return nil
16097 }
16098 c.PageToken(x.NextPageToken)
16099 }
16100 }
16101
16102
16103
16104 type ProjectsLocationsIntegrationsScheduleCall struct {
16105 s *Service
16106 name string
16107 googlecloudintegrationsv1alphascheduleintegrationsrequest *GoogleCloudIntegrationsV1alphaScheduleIntegrationsRequest
16108 urlParams_ gensupport.URLParams
16109 ctx_ context.Context
16110 header_ http.Header
16111 }
16112
16113
16114
16115
16116
16117 func (r *ProjectsLocationsIntegrationsService) Schedule(name string, googlecloudintegrationsv1alphascheduleintegrationsrequest *GoogleCloudIntegrationsV1alphaScheduleIntegrationsRequest) *ProjectsLocationsIntegrationsScheduleCall {
16118 c := &ProjectsLocationsIntegrationsScheduleCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16119 c.name = name
16120 c.googlecloudintegrationsv1alphascheduleintegrationsrequest = googlecloudintegrationsv1alphascheduleintegrationsrequest
16121 return c
16122 }
16123
16124
16125
16126
16127 func (c *ProjectsLocationsIntegrationsScheduleCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsScheduleCall {
16128 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16129 return c
16130 }
16131
16132
16133
16134
16135 func (c *ProjectsLocationsIntegrationsScheduleCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsScheduleCall {
16136 c.ctx_ = ctx
16137 return c
16138 }
16139
16140
16141
16142 func (c *ProjectsLocationsIntegrationsScheduleCall) Header() http.Header {
16143 if c.header_ == nil {
16144 c.header_ = make(http.Header)
16145 }
16146 return c.header_
16147 }
16148
16149 func (c *ProjectsLocationsIntegrationsScheduleCall) doRequest(alt string) (*http.Response, error) {
16150 reqHeaders := make(http.Header)
16151 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
16152 for k, v := range c.header_ {
16153 reqHeaders[k] = v
16154 }
16155 reqHeaders.Set("User-Agent", c.s.userAgent())
16156 var body io.Reader = nil
16157 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphascheduleintegrationsrequest)
16158 if err != nil {
16159 return nil, err
16160 }
16161 reqHeaders.Set("Content-Type", "application/json")
16162 c.urlParams_.Set("alt", alt)
16163 c.urlParams_.Set("prettyPrint", "false")
16164 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:schedule")
16165 urls += "?" + c.urlParams_.Encode()
16166 req, err := http.NewRequest("POST", urls, body)
16167 if err != nil {
16168 return nil, err
16169 }
16170 req.Header = reqHeaders
16171 googleapi.Expand(req.URL, map[string]string{
16172 "name": c.name,
16173 })
16174 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16175 }
16176
16177
16178
16179
16180
16181
16182
16183
16184
16185
16186
16187 func (c *ProjectsLocationsIntegrationsScheduleCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaScheduleIntegrationsResponse, error) {
16188 gensupport.SetOptions(c.urlParams_, opts...)
16189 res, err := c.doRequest("json")
16190 if res != nil && res.StatusCode == http.StatusNotModified {
16191 if res.Body != nil {
16192 res.Body.Close()
16193 }
16194 return nil, gensupport.WrapError(&googleapi.Error{
16195 Code: res.StatusCode,
16196 Header: res.Header,
16197 })
16198 }
16199 if err != nil {
16200 return nil, err
16201 }
16202 defer googleapi.CloseBody(res)
16203 if err := googleapi.CheckResponse(res); err != nil {
16204 return nil, gensupport.WrapError(err)
16205 }
16206 ret := &GoogleCloudIntegrationsV1alphaScheduleIntegrationsResponse{
16207 ServerResponse: googleapi.ServerResponse{
16208 Header: res.Header,
16209 HTTPStatusCode: res.StatusCode,
16210 },
16211 }
16212 target := &ret
16213 if err := gensupport.DecodeResponse(target, res); err != nil {
16214 return nil, err
16215 }
16216 return ret, nil
16217
16218
16219
16220
16221
16222
16223
16224
16225
16226
16227
16228
16229
16230
16231
16232
16233
16234
16235
16236
16237
16238
16239
16240
16241
16242
16243
16244
16245
16246 }
16247
16248
16249
16250 type ProjectsLocationsIntegrationsTestCall struct {
16251 s *Service
16252 name string
16253 googlecloudintegrationsv1alphatestintegrationsrequest *GoogleCloudIntegrationsV1alphaTestIntegrationsRequest
16254 urlParams_ gensupport.URLParams
16255 ctx_ context.Context
16256 header_ http.Header
16257 }
16258
16259
16260
16261
16262 func (r *ProjectsLocationsIntegrationsService) Test(name string, googlecloudintegrationsv1alphatestintegrationsrequest *GoogleCloudIntegrationsV1alphaTestIntegrationsRequest) *ProjectsLocationsIntegrationsTestCall {
16263 c := &ProjectsLocationsIntegrationsTestCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16264 c.name = name
16265 c.googlecloudintegrationsv1alphatestintegrationsrequest = googlecloudintegrationsv1alphatestintegrationsrequest
16266 return c
16267 }
16268
16269
16270
16271
16272 func (c *ProjectsLocationsIntegrationsTestCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsTestCall {
16273 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16274 return c
16275 }
16276
16277
16278
16279
16280 func (c *ProjectsLocationsIntegrationsTestCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsTestCall {
16281 c.ctx_ = ctx
16282 return c
16283 }
16284
16285
16286
16287 func (c *ProjectsLocationsIntegrationsTestCall) Header() http.Header {
16288 if c.header_ == nil {
16289 c.header_ = make(http.Header)
16290 }
16291 return c.header_
16292 }
16293
16294 func (c *ProjectsLocationsIntegrationsTestCall) doRequest(alt string) (*http.Response, error) {
16295 reqHeaders := make(http.Header)
16296 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
16297 for k, v := range c.header_ {
16298 reqHeaders[k] = v
16299 }
16300 reqHeaders.Set("User-Agent", c.s.userAgent())
16301 var body io.Reader = nil
16302 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphatestintegrationsrequest)
16303 if err != nil {
16304 return nil, err
16305 }
16306 reqHeaders.Set("Content-Type", "application/json")
16307 c.urlParams_.Set("alt", alt)
16308 c.urlParams_.Set("prettyPrint", "false")
16309 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:test")
16310 urls += "?" + c.urlParams_.Encode()
16311 req, err := http.NewRequest("POST", urls, body)
16312 if err != nil {
16313 return nil, err
16314 }
16315 req.Header = reqHeaders
16316 googleapi.Expand(req.URL, map[string]string{
16317 "name": c.name,
16318 })
16319 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16320 }
16321
16322
16323
16324
16325
16326
16327
16328
16329
16330
16331
16332 func (c *ProjectsLocationsIntegrationsTestCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaTestIntegrationsResponse, error) {
16333 gensupport.SetOptions(c.urlParams_, opts...)
16334 res, err := c.doRequest("json")
16335 if res != nil && res.StatusCode == http.StatusNotModified {
16336 if res.Body != nil {
16337 res.Body.Close()
16338 }
16339 return nil, gensupport.WrapError(&googleapi.Error{
16340 Code: res.StatusCode,
16341 Header: res.Header,
16342 })
16343 }
16344 if err != nil {
16345 return nil, err
16346 }
16347 defer googleapi.CloseBody(res)
16348 if err := googleapi.CheckResponse(res); err != nil {
16349 return nil, gensupport.WrapError(err)
16350 }
16351 ret := &GoogleCloudIntegrationsV1alphaTestIntegrationsResponse{
16352 ServerResponse: googleapi.ServerResponse{
16353 Header: res.Header,
16354 HTTPStatusCode: res.StatusCode,
16355 },
16356 }
16357 target := &ret
16358 if err := gensupport.DecodeResponse(target, res); err != nil {
16359 return nil, err
16360 }
16361 return ret, nil
16362
16363
16364
16365
16366
16367
16368
16369
16370
16371
16372
16373
16374
16375
16376
16377
16378
16379
16380
16381
16382
16383
16384
16385
16386
16387
16388
16389
16390
16391 }
16392
16393
16394
16395 type ProjectsLocationsIntegrationsExecutionsDownloadCall struct {
16396 s *Service
16397 name string
16398 urlParams_ gensupport.URLParams
16399 ifNoneMatch_ string
16400 ctx_ context.Context
16401 header_ http.Header
16402 }
16403
16404
16405
16406
16407
16408
16409 func (r *ProjectsLocationsIntegrationsExecutionsService) Download(name string) *ProjectsLocationsIntegrationsExecutionsDownloadCall {
16410 c := &ProjectsLocationsIntegrationsExecutionsDownloadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16411 c.name = name
16412 return c
16413 }
16414
16415
16416
16417
16418 func (c *ProjectsLocationsIntegrationsExecutionsDownloadCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsExecutionsDownloadCall {
16419 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16420 return c
16421 }
16422
16423
16424
16425
16426
16427
16428 func (c *ProjectsLocationsIntegrationsExecutionsDownloadCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsExecutionsDownloadCall {
16429 c.ifNoneMatch_ = entityTag
16430 return c
16431 }
16432
16433
16434
16435
16436 func (c *ProjectsLocationsIntegrationsExecutionsDownloadCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsExecutionsDownloadCall {
16437 c.ctx_ = ctx
16438 return c
16439 }
16440
16441
16442
16443 func (c *ProjectsLocationsIntegrationsExecutionsDownloadCall) Header() http.Header {
16444 if c.header_ == nil {
16445 c.header_ = make(http.Header)
16446 }
16447 return c.header_
16448 }
16449
16450 func (c *ProjectsLocationsIntegrationsExecutionsDownloadCall) doRequest(alt string) (*http.Response, error) {
16451 reqHeaders := make(http.Header)
16452 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
16453 for k, v := range c.header_ {
16454 reqHeaders[k] = v
16455 }
16456 reqHeaders.Set("User-Agent", c.s.userAgent())
16457 if c.ifNoneMatch_ != "" {
16458 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16459 }
16460 var body io.Reader = nil
16461 c.urlParams_.Set("alt", alt)
16462 c.urlParams_.Set("prettyPrint", "false")
16463 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:download")
16464 urls += "?" + c.urlParams_.Encode()
16465 req, err := http.NewRequest("GET", urls, body)
16466 if err != nil {
16467 return nil, err
16468 }
16469 req.Header = reqHeaders
16470 googleapi.Expand(req.URL, map[string]string{
16471 "name": c.name,
16472 })
16473 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16474 }
16475
16476
16477
16478
16479
16480
16481
16482
16483
16484
16485
16486 func (c *ProjectsLocationsIntegrationsExecutionsDownloadCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaDownloadExecutionResponse, error) {
16487 gensupport.SetOptions(c.urlParams_, opts...)
16488 res, err := c.doRequest("json")
16489 if res != nil && res.StatusCode == http.StatusNotModified {
16490 if res.Body != nil {
16491 res.Body.Close()
16492 }
16493 return nil, gensupport.WrapError(&googleapi.Error{
16494 Code: res.StatusCode,
16495 Header: res.Header,
16496 })
16497 }
16498 if err != nil {
16499 return nil, err
16500 }
16501 defer googleapi.CloseBody(res)
16502 if err := googleapi.CheckResponse(res); err != nil {
16503 return nil, gensupport.WrapError(err)
16504 }
16505 ret := &GoogleCloudIntegrationsV1alphaDownloadExecutionResponse{
16506 ServerResponse: googleapi.ServerResponse{
16507 Header: res.Header,
16508 HTTPStatusCode: res.StatusCode,
16509 },
16510 }
16511 target := &ret
16512 if err := gensupport.DecodeResponse(target, res); err != nil {
16513 return nil, err
16514 }
16515 return ret, nil
16516
16517
16518
16519
16520
16521
16522
16523
16524
16525
16526
16527
16528
16529
16530
16531
16532
16533
16534
16535
16536
16537
16538
16539
16540
16541
16542 }
16543
16544
16545
16546 type ProjectsLocationsIntegrationsExecutionsGetCall struct {
16547 s *Service
16548 name string
16549 urlParams_ gensupport.URLParams
16550 ifNoneMatch_ string
16551 ctx_ context.Context
16552 header_ http.Header
16553 }
16554
16555
16556
16557
16558
16559
16560 func (r *ProjectsLocationsIntegrationsExecutionsService) Get(name string) *ProjectsLocationsIntegrationsExecutionsGetCall {
16561 c := &ProjectsLocationsIntegrationsExecutionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16562 c.name = name
16563 return c
16564 }
16565
16566
16567
16568
16569 func (c *ProjectsLocationsIntegrationsExecutionsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsExecutionsGetCall {
16570 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16571 return c
16572 }
16573
16574
16575
16576
16577
16578
16579 func (c *ProjectsLocationsIntegrationsExecutionsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsExecutionsGetCall {
16580 c.ifNoneMatch_ = entityTag
16581 return c
16582 }
16583
16584
16585
16586
16587 func (c *ProjectsLocationsIntegrationsExecutionsGetCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsExecutionsGetCall {
16588 c.ctx_ = ctx
16589 return c
16590 }
16591
16592
16593
16594 func (c *ProjectsLocationsIntegrationsExecutionsGetCall) Header() http.Header {
16595 if c.header_ == nil {
16596 c.header_ = make(http.Header)
16597 }
16598 return c.header_
16599 }
16600
16601 func (c *ProjectsLocationsIntegrationsExecutionsGetCall) doRequest(alt string) (*http.Response, error) {
16602 reqHeaders := make(http.Header)
16603 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
16604 for k, v := range c.header_ {
16605 reqHeaders[k] = v
16606 }
16607 reqHeaders.Set("User-Agent", c.s.userAgent())
16608 if c.ifNoneMatch_ != "" {
16609 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16610 }
16611 var body io.Reader = nil
16612 c.urlParams_.Set("alt", alt)
16613 c.urlParams_.Set("prettyPrint", "false")
16614 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
16615 urls += "?" + c.urlParams_.Encode()
16616 req, err := http.NewRequest("GET", urls, body)
16617 if err != nil {
16618 return nil, err
16619 }
16620 req.Header = reqHeaders
16621 googleapi.Expand(req.URL, map[string]string{
16622 "name": c.name,
16623 })
16624 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16625 }
16626
16627
16628
16629
16630
16631
16632
16633
16634
16635 func (c *ProjectsLocationsIntegrationsExecutionsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaExecution, error) {
16636 gensupport.SetOptions(c.urlParams_, opts...)
16637 res, err := c.doRequest("json")
16638 if res != nil && res.StatusCode == http.StatusNotModified {
16639 if res.Body != nil {
16640 res.Body.Close()
16641 }
16642 return nil, gensupport.WrapError(&googleapi.Error{
16643 Code: res.StatusCode,
16644 Header: res.Header,
16645 })
16646 }
16647 if err != nil {
16648 return nil, err
16649 }
16650 defer googleapi.CloseBody(res)
16651 if err := googleapi.CheckResponse(res); err != nil {
16652 return nil, gensupport.WrapError(err)
16653 }
16654 ret := &GoogleCloudIntegrationsV1alphaExecution{
16655 ServerResponse: googleapi.ServerResponse{
16656 Header: res.Header,
16657 HTTPStatusCode: res.StatusCode,
16658 },
16659 }
16660 target := &ret
16661 if err := gensupport.DecodeResponse(target, res); err != nil {
16662 return nil, err
16663 }
16664 return ret, nil
16665
16666
16667
16668
16669
16670
16671
16672
16673
16674
16675
16676
16677
16678
16679
16680
16681
16682
16683
16684
16685
16686
16687
16688
16689
16690
16691 }
16692
16693
16694
16695 type ProjectsLocationsIntegrationsExecutionsListCall struct {
16696 s *Service
16697 parent string
16698 urlParams_ gensupport.URLParams
16699 ifNoneMatch_ string
16700 ctx_ context.Context
16701 header_ http.Header
16702 }
16703
16704
16705
16706
16707
16708
16709
16710 func (r *ProjectsLocationsIntegrationsExecutionsService) List(parent string) *ProjectsLocationsIntegrationsExecutionsListCall {
16711 c := &ProjectsLocationsIntegrationsExecutionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16712 c.parent = parent
16713 return c
16714 }
16715
16716
16717
16718
16719
16720
16721
16722
16723 func (c *ProjectsLocationsIntegrationsExecutionsListCall) Filter(filter string) *ProjectsLocationsIntegrationsExecutionsListCall {
16724 c.urlParams_.Set("filter", filter)
16725 return c
16726 }
16727
16728
16729
16730 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsCustomFilter(filterParamsCustomFilter string) *ProjectsLocationsIntegrationsExecutionsListCall {
16731 c.urlParams_.Set("filterParams.customFilter", filterParamsCustomFilter)
16732 return c
16733 }
16734
16735
16736
16737 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsEndTime(filterParamsEndTime int64) *ProjectsLocationsIntegrationsExecutionsListCall {
16738 c.urlParams_.Set("filterParams.endTime", fmt.Sprint(filterParamsEndTime))
16739 return c
16740 }
16741
16742
16743
16744 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsEventStatuses(filterParamsEventStatuses ...string) *ProjectsLocationsIntegrationsExecutionsListCall {
16745 c.urlParams_.SetMulti("filterParams.eventStatuses", append([]string{}, filterParamsEventStatuses...))
16746 return c
16747 }
16748
16749
16750
16751 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsExecutionId(filterParamsExecutionId string) *ProjectsLocationsIntegrationsExecutionsListCall {
16752 c.urlParams_.Set("filterParams.executionId", filterParamsExecutionId)
16753 return c
16754 }
16755
16756
16757
16758
16759 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsParameterKey(filterParamsParameterKey string) *ProjectsLocationsIntegrationsExecutionsListCall {
16760 c.urlParams_.Set("filterParams.parameterKey", filterParamsParameterKey)
16761 return c
16762 }
16763
16764
16765
16766
16767 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsParameterPairKey(filterParamsParameterPairKey string) *ProjectsLocationsIntegrationsExecutionsListCall {
16768 c.urlParams_.Set("filterParams.parameterPairKey", filterParamsParameterPairKey)
16769 return c
16770 }
16771
16772
16773
16774
16775 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsParameterPairValue(filterParamsParameterPairValue string) *ProjectsLocationsIntegrationsExecutionsListCall {
16776 c.urlParams_.Set("filterParams.parameterPairValue", filterParamsParameterPairValue)
16777 return c
16778 }
16779
16780
16781
16782 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsParameterType(filterParamsParameterType string) *ProjectsLocationsIntegrationsExecutionsListCall {
16783 c.urlParams_.Set("filterParams.parameterType", filterParamsParameterType)
16784 return c
16785 }
16786
16787
16788
16789
16790 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsParameterValue(filterParamsParameterValue string) *ProjectsLocationsIntegrationsExecutionsListCall {
16791 c.urlParams_.Set("filterParams.parameterValue", filterParamsParameterValue)
16792 return c
16793 }
16794
16795
16796
16797 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsStartTime(filterParamsStartTime int64) *ProjectsLocationsIntegrationsExecutionsListCall {
16798 c.urlParams_.Set("filterParams.startTime", fmt.Sprint(filterParamsStartTime))
16799 return c
16800 }
16801
16802
16803
16804 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsTaskStatuses(filterParamsTaskStatuses ...string) *ProjectsLocationsIntegrationsExecutionsListCall {
16805 c.urlParams_.SetMulti("filterParams.taskStatuses", append([]string{}, filterParamsTaskStatuses...))
16806 return c
16807 }
16808
16809
16810
16811 func (c *ProjectsLocationsIntegrationsExecutionsListCall) FilterParamsWorkflowName(filterParamsWorkflowName string) *ProjectsLocationsIntegrationsExecutionsListCall {
16812 c.urlParams_.Set("filterParams.workflowName", filterParamsWorkflowName)
16813 return c
16814 }
16815
16816
16817
16818
16819 func (c *ProjectsLocationsIntegrationsExecutionsListCall) OrderBy(orderBy string) *ProjectsLocationsIntegrationsExecutionsListCall {
16820 c.urlParams_.Set("orderBy", orderBy)
16821 return c
16822 }
16823
16824
16825
16826 func (c *ProjectsLocationsIntegrationsExecutionsListCall) PageSize(pageSize int64) *ProjectsLocationsIntegrationsExecutionsListCall {
16827 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
16828 return c
16829 }
16830
16831
16832
16833 func (c *ProjectsLocationsIntegrationsExecutionsListCall) PageToken(pageToken string) *ProjectsLocationsIntegrationsExecutionsListCall {
16834 c.urlParams_.Set("pageToken", pageToken)
16835 return c
16836 }
16837
16838
16839
16840
16841
16842 func (c *ProjectsLocationsIntegrationsExecutionsListCall) ReadMask(readMask string) *ProjectsLocationsIntegrationsExecutionsListCall {
16843 c.urlParams_.Set("readMask", readMask)
16844 return c
16845 }
16846
16847
16848
16849
16850
16851 func (c *ProjectsLocationsIntegrationsExecutionsListCall) RefreshAcl(refreshAcl bool) *ProjectsLocationsIntegrationsExecutionsListCall {
16852 c.urlParams_.Set("refreshAcl", fmt.Sprint(refreshAcl))
16853 return c
16854 }
16855
16856
16857
16858
16859
16860
16861 func (c *ProjectsLocationsIntegrationsExecutionsListCall) TruncateParams(truncateParams bool) *ProjectsLocationsIntegrationsExecutionsListCall {
16862 c.urlParams_.Set("truncateParams", fmt.Sprint(truncateParams))
16863 return c
16864 }
16865
16866
16867
16868
16869 func (c *ProjectsLocationsIntegrationsExecutionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsExecutionsListCall {
16870 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16871 return c
16872 }
16873
16874
16875
16876
16877
16878
16879 func (c *ProjectsLocationsIntegrationsExecutionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsExecutionsListCall {
16880 c.ifNoneMatch_ = entityTag
16881 return c
16882 }
16883
16884
16885
16886
16887 func (c *ProjectsLocationsIntegrationsExecutionsListCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsExecutionsListCall {
16888 c.ctx_ = ctx
16889 return c
16890 }
16891
16892
16893
16894 func (c *ProjectsLocationsIntegrationsExecutionsListCall) Header() http.Header {
16895 if c.header_ == nil {
16896 c.header_ = make(http.Header)
16897 }
16898 return c.header_
16899 }
16900
16901 func (c *ProjectsLocationsIntegrationsExecutionsListCall) doRequest(alt string) (*http.Response, error) {
16902 reqHeaders := make(http.Header)
16903 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
16904 for k, v := range c.header_ {
16905 reqHeaders[k] = v
16906 }
16907 reqHeaders.Set("User-Agent", c.s.userAgent())
16908 if c.ifNoneMatch_ != "" {
16909 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16910 }
16911 var body io.Reader = nil
16912 c.urlParams_.Set("alt", alt)
16913 c.urlParams_.Set("prettyPrint", "false")
16914 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/executions")
16915 urls += "?" + c.urlParams_.Encode()
16916 req, err := http.NewRequest("GET", urls, body)
16917 if err != nil {
16918 return nil, err
16919 }
16920 req.Header = reqHeaders
16921 googleapi.Expand(req.URL, map[string]string{
16922 "parent": c.parent,
16923 })
16924 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16925 }
16926
16927
16928
16929
16930
16931
16932
16933
16934
16935
16936 func (c *ProjectsLocationsIntegrationsExecutionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListExecutionsResponse, error) {
16937 gensupport.SetOptions(c.urlParams_, opts...)
16938 res, err := c.doRequest("json")
16939 if res != nil && res.StatusCode == http.StatusNotModified {
16940 if res.Body != nil {
16941 res.Body.Close()
16942 }
16943 return nil, gensupport.WrapError(&googleapi.Error{
16944 Code: res.StatusCode,
16945 Header: res.Header,
16946 })
16947 }
16948 if err != nil {
16949 return nil, err
16950 }
16951 defer googleapi.CloseBody(res)
16952 if err := googleapi.CheckResponse(res); err != nil {
16953 return nil, gensupport.WrapError(err)
16954 }
16955 ret := &GoogleCloudIntegrationsV1alphaListExecutionsResponse{
16956 ServerResponse: googleapi.ServerResponse{
16957 Header: res.Header,
16958 HTTPStatusCode: res.StatusCode,
16959 },
16960 }
16961 target := &ret
16962 if err := gensupport.DecodeResponse(target, res); err != nil {
16963 return nil, err
16964 }
16965 return ret, nil
16966
16967
16968
16969
16970
16971
16972
16973
16974
16975
16976
16977
16978
16979
16980
16981
16982
16983
16984
16985
16986
16987
16988
16989
16990
16991
16992
16993
16994
16995
16996
16997
16998
16999
17000
17001
17002
17003
17004
17005
17006
17007
17008
17009
17010
17011
17012
17013
17014
17015
17016
17017
17018
17019
17020
17021
17022
17023
17024
17025
17026
17027
17028
17029
17030
17031
17032
17033
17034
17035
17036
17037
17038
17039
17040
17041
17042
17043
17044
17045
17046
17047
17048
17049
17050
17051
17052
17053
17054
17055
17056
17057
17058
17059
17060
17061
17062
17063
17064
17065
17066
17067
17068
17069
17070
17071
17072
17073
17074
17075
17076
17077
17078
17079
17080
17081
17082
17083
17084
17085
17086
17087
17088
17089
17090
17091
17092
17093 }
17094
17095
17096
17097
17098 func (c *ProjectsLocationsIntegrationsExecutionsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListExecutionsResponse) error) error {
17099 c.ctx_ = ctx
17100 defer c.PageToken(c.urlParams_.Get("pageToken"))
17101 for {
17102 x, err := c.Do()
17103 if err != nil {
17104 return err
17105 }
17106 if err := f(x); err != nil {
17107 return err
17108 }
17109 if x.NextPageToken == "" {
17110 return nil
17111 }
17112 c.PageToken(x.NextPageToken)
17113 }
17114 }
17115
17116
17117
17118 type ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall struct {
17119 s *Service
17120 name string
17121 googlecloudintegrationsv1alphaliftsuspensionrequest *GoogleCloudIntegrationsV1alphaLiftSuspensionRequest
17122 urlParams_ gensupport.URLParams
17123 ctx_ context.Context
17124 header_ http.Header
17125 }
17126
17127
17128
17129
17130
17131
17132
17133
17134
17135 func (r *ProjectsLocationsIntegrationsExecutionsSuspensionsService) Lift(name string, googlecloudintegrationsv1alphaliftsuspensionrequest *GoogleCloudIntegrationsV1alphaLiftSuspensionRequest) *ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall {
17136 c := &ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17137 c.name = name
17138 c.googlecloudintegrationsv1alphaliftsuspensionrequest = googlecloudintegrationsv1alphaliftsuspensionrequest
17139 return c
17140 }
17141
17142
17143
17144
17145 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall {
17146 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17147 return c
17148 }
17149
17150
17151
17152
17153 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall {
17154 c.ctx_ = ctx
17155 return c
17156 }
17157
17158
17159
17160 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall) Header() http.Header {
17161 if c.header_ == nil {
17162 c.header_ = make(http.Header)
17163 }
17164 return c.header_
17165 }
17166
17167 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall) doRequest(alt string) (*http.Response, error) {
17168 reqHeaders := make(http.Header)
17169 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
17170 for k, v := range c.header_ {
17171 reqHeaders[k] = v
17172 }
17173 reqHeaders.Set("User-Agent", c.s.userAgent())
17174 var body io.Reader = nil
17175 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaliftsuspensionrequest)
17176 if err != nil {
17177 return nil, err
17178 }
17179 reqHeaders.Set("Content-Type", "application/json")
17180 c.urlParams_.Set("alt", alt)
17181 c.urlParams_.Set("prettyPrint", "false")
17182 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:lift")
17183 urls += "?" + c.urlParams_.Encode()
17184 req, err := http.NewRequest("POST", urls, body)
17185 if err != nil {
17186 return nil, err
17187 }
17188 req.Header = reqHeaders
17189 googleapi.Expand(req.URL, map[string]string{
17190 "name": c.name,
17191 })
17192 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17193 }
17194
17195
17196
17197
17198
17199
17200
17201
17202
17203
17204 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsLiftCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaLiftSuspensionResponse, error) {
17205 gensupport.SetOptions(c.urlParams_, opts...)
17206 res, err := c.doRequest("json")
17207 if res != nil && res.StatusCode == http.StatusNotModified {
17208 if res.Body != nil {
17209 res.Body.Close()
17210 }
17211 return nil, gensupport.WrapError(&googleapi.Error{
17212 Code: res.StatusCode,
17213 Header: res.Header,
17214 })
17215 }
17216 if err != nil {
17217 return nil, err
17218 }
17219 defer googleapi.CloseBody(res)
17220 if err := googleapi.CheckResponse(res); err != nil {
17221 return nil, gensupport.WrapError(err)
17222 }
17223 ret := &GoogleCloudIntegrationsV1alphaLiftSuspensionResponse{
17224 ServerResponse: googleapi.ServerResponse{
17225 Header: res.Header,
17226 HTTPStatusCode: res.StatusCode,
17227 },
17228 }
17229 target := &ret
17230 if err := gensupport.DecodeResponse(target, res); err != nil {
17231 return nil, err
17232 }
17233 return ret, nil
17234
17235
17236
17237
17238
17239
17240
17241
17242
17243
17244
17245
17246
17247
17248
17249
17250
17251
17252
17253
17254
17255
17256
17257
17258
17259
17260
17261
17262
17263 }
17264
17265
17266
17267 type ProjectsLocationsIntegrationsExecutionsSuspensionsListCall struct {
17268 s *Service
17269 parent string
17270 urlParams_ gensupport.URLParams
17271 ifNoneMatch_ string
17272 ctx_ context.Context
17273 header_ http.Header
17274 }
17275
17276
17277
17278
17279
17280
17281
17282
17283 func (r *ProjectsLocationsIntegrationsExecutionsSuspensionsService) List(parent string) *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall {
17284 c := &ProjectsLocationsIntegrationsExecutionsSuspensionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17285 c.parent = parent
17286 return c
17287 }
17288
17289
17290 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) Filter(filter string) *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall {
17291 c.urlParams_.Set("filter", filter)
17292 return c
17293 }
17294
17295
17296
17297 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) OrderBy(orderBy string) *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall {
17298 c.urlParams_.Set("orderBy", orderBy)
17299 return c
17300 }
17301
17302
17303
17304 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) PageSize(pageSize int64) *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall {
17305 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
17306 return c
17307 }
17308
17309
17310
17311 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) PageToken(pageToken string) *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall {
17312 c.urlParams_.Set("pageToken", pageToken)
17313 return c
17314 }
17315
17316
17317
17318
17319 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall {
17320 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17321 return c
17322 }
17323
17324
17325
17326
17327
17328
17329 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall {
17330 c.ifNoneMatch_ = entityTag
17331 return c
17332 }
17333
17334
17335
17336
17337 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall {
17338 c.ctx_ = ctx
17339 return c
17340 }
17341
17342
17343
17344 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) Header() http.Header {
17345 if c.header_ == nil {
17346 c.header_ = make(http.Header)
17347 }
17348 return c.header_
17349 }
17350
17351 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) doRequest(alt string) (*http.Response, error) {
17352 reqHeaders := make(http.Header)
17353 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
17354 for k, v := range c.header_ {
17355 reqHeaders[k] = v
17356 }
17357 reqHeaders.Set("User-Agent", c.s.userAgent())
17358 if c.ifNoneMatch_ != "" {
17359 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17360 }
17361 var body io.Reader = nil
17362 c.urlParams_.Set("alt", alt)
17363 c.urlParams_.Set("prettyPrint", "false")
17364 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/suspensions")
17365 urls += "?" + c.urlParams_.Encode()
17366 req, err := http.NewRequest("GET", urls, body)
17367 if err != nil {
17368 return nil, err
17369 }
17370 req.Header = reqHeaders
17371 googleapi.Expand(req.URL, map[string]string{
17372 "parent": c.parent,
17373 })
17374 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17375 }
17376
17377
17378
17379
17380
17381
17382
17383
17384
17385
17386 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListSuspensionsResponse, error) {
17387 gensupport.SetOptions(c.urlParams_, opts...)
17388 res, err := c.doRequest("json")
17389 if res != nil && res.StatusCode == http.StatusNotModified {
17390 if res.Body != nil {
17391 res.Body.Close()
17392 }
17393 return nil, gensupport.WrapError(&googleapi.Error{
17394 Code: res.StatusCode,
17395 Header: res.Header,
17396 })
17397 }
17398 if err != nil {
17399 return nil, err
17400 }
17401 defer googleapi.CloseBody(res)
17402 if err := googleapi.CheckResponse(res); err != nil {
17403 return nil, gensupport.WrapError(err)
17404 }
17405 ret := &GoogleCloudIntegrationsV1alphaListSuspensionsResponse{
17406 ServerResponse: googleapi.ServerResponse{
17407 Header: res.Header,
17408 HTTPStatusCode: res.StatusCode,
17409 },
17410 }
17411 target := &ret
17412 if err := gensupport.DecodeResponse(target, res); err != nil {
17413 return nil, err
17414 }
17415 return ret, nil
17416
17417
17418
17419
17420
17421
17422
17423
17424
17425
17426
17427
17428
17429
17430
17431
17432
17433
17434
17435
17436
17437
17438
17439
17440
17441
17442
17443
17444
17445
17446
17447
17448
17449
17450
17451
17452
17453
17454
17455
17456
17457
17458
17459
17460
17461
17462
17463 }
17464
17465
17466
17467
17468 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListSuspensionsResponse) error) error {
17469 c.ctx_ = ctx
17470 defer c.PageToken(c.urlParams_.Get("pageToken"))
17471 for {
17472 x, err := c.Do()
17473 if err != nil {
17474 return err
17475 }
17476 if err := f(x); err != nil {
17477 return err
17478 }
17479 if x.NextPageToken == "" {
17480 return nil
17481 }
17482 c.PageToken(x.NextPageToken)
17483 }
17484 }
17485
17486
17487
17488 type ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall struct {
17489 s *Service
17490 name string
17491 googlecloudintegrationsv1alpharesolvesuspensionrequest *GoogleCloudIntegrationsV1alphaResolveSuspensionRequest
17492 urlParams_ gensupport.URLParams
17493 ctx_ context.Context
17494 header_ http.Header
17495 }
17496
17497
17498
17499
17500
17501
17502
17503
17504
17505
17506 func (r *ProjectsLocationsIntegrationsExecutionsSuspensionsService) Resolve(name string, googlecloudintegrationsv1alpharesolvesuspensionrequest *GoogleCloudIntegrationsV1alphaResolveSuspensionRequest) *ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall {
17507 c := &ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17508 c.name = name
17509 c.googlecloudintegrationsv1alpharesolvesuspensionrequest = googlecloudintegrationsv1alpharesolvesuspensionrequest
17510 return c
17511 }
17512
17513
17514
17515
17516 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall {
17517 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17518 return c
17519 }
17520
17521
17522
17523
17524 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall {
17525 c.ctx_ = ctx
17526 return c
17527 }
17528
17529
17530
17531 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall) Header() http.Header {
17532 if c.header_ == nil {
17533 c.header_ = make(http.Header)
17534 }
17535 return c.header_
17536 }
17537
17538 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall) doRequest(alt string) (*http.Response, error) {
17539 reqHeaders := make(http.Header)
17540 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
17541 for k, v := range c.header_ {
17542 reqHeaders[k] = v
17543 }
17544 reqHeaders.Set("User-Agent", c.s.userAgent())
17545 var body io.Reader = nil
17546 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alpharesolvesuspensionrequest)
17547 if err != nil {
17548 return nil, err
17549 }
17550 reqHeaders.Set("Content-Type", "application/json")
17551 c.urlParams_.Set("alt", alt)
17552 c.urlParams_.Set("prettyPrint", "false")
17553 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:resolve")
17554 urls += "?" + c.urlParams_.Encode()
17555 req, err := http.NewRequest("POST", urls, body)
17556 if err != nil {
17557 return nil, err
17558 }
17559 req.Header = reqHeaders
17560 googleapi.Expand(req.URL, map[string]string{
17561 "name": c.name,
17562 })
17563 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17564 }
17565
17566
17567
17568
17569
17570
17571
17572
17573
17574
17575
17576 func (c *ProjectsLocationsIntegrationsExecutionsSuspensionsResolveCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaResolveSuspensionResponse, error) {
17577 gensupport.SetOptions(c.urlParams_, opts...)
17578 res, err := c.doRequest("json")
17579 if res != nil && res.StatusCode == http.StatusNotModified {
17580 if res.Body != nil {
17581 res.Body.Close()
17582 }
17583 return nil, gensupport.WrapError(&googleapi.Error{
17584 Code: res.StatusCode,
17585 Header: res.Header,
17586 })
17587 }
17588 if err != nil {
17589 return nil, err
17590 }
17591 defer googleapi.CloseBody(res)
17592 if err := googleapi.CheckResponse(res); err != nil {
17593 return nil, gensupport.WrapError(err)
17594 }
17595 ret := &GoogleCloudIntegrationsV1alphaResolveSuspensionResponse{
17596 ServerResponse: googleapi.ServerResponse{
17597 Header: res.Header,
17598 HTTPStatusCode: res.StatusCode,
17599 },
17600 }
17601 target := &ret
17602 if err := gensupport.DecodeResponse(target, res); err != nil {
17603 return nil, err
17604 }
17605 return ret, nil
17606
17607
17608
17609
17610
17611
17612
17613
17614
17615
17616
17617
17618
17619
17620
17621
17622
17623
17624
17625
17626
17627
17628
17629
17630
17631
17632
17633
17634
17635 }
17636
17637
17638
17639 type ProjectsLocationsIntegrationsExecutionsnapshotsListCall struct {
17640 s *Service
17641 parent string
17642 urlParams_ gensupport.URLParams
17643 ifNoneMatch_ string
17644 ctx_ context.Context
17645 header_ http.Header
17646 }
17647
17648
17649
17650
17651
17652 func (r *ProjectsLocationsIntegrationsExecutionsnapshotsService) List(parent string) *ProjectsLocationsIntegrationsExecutionsnapshotsListCall {
17653 c := &ProjectsLocationsIntegrationsExecutionsnapshotsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17654 c.parent = parent
17655 return c
17656 }
17657
17658
17659
17660 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) Filter(filter string) *ProjectsLocationsIntegrationsExecutionsnapshotsListCall {
17661 c.urlParams_.Set("filter", filter)
17662 return c
17663 }
17664
17665
17666
17667 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) PageSize(pageSize int64) *ProjectsLocationsIntegrationsExecutionsnapshotsListCall {
17668 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
17669 return c
17670 }
17671
17672
17673
17674 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) PageToken(pageToken string) *ProjectsLocationsIntegrationsExecutionsnapshotsListCall {
17675 c.urlParams_.Set("pageToken", pageToken)
17676 return c
17677 }
17678
17679
17680
17681
17682
17683 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) ReadMask(readMask string) *ProjectsLocationsIntegrationsExecutionsnapshotsListCall {
17684 c.urlParams_.Set("readMask", readMask)
17685 return c
17686 }
17687
17688
17689
17690
17691 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsExecutionsnapshotsListCall {
17692 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17693 return c
17694 }
17695
17696
17697
17698
17699
17700
17701 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsExecutionsnapshotsListCall {
17702 c.ifNoneMatch_ = entityTag
17703 return c
17704 }
17705
17706
17707
17708
17709 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsExecutionsnapshotsListCall {
17710 c.ctx_ = ctx
17711 return c
17712 }
17713
17714
17715
17716 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) Header() http.Header {
17717 if c.header_ == nil {
17718 c.header_ = make(http.Header)
17719 }
17720 return c.header_
17721 }
17722
17723 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) doRequest(alt string) (*http.Response, error) {
17724 reqHeaders := make(http.Header)
17725 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
17726 for k, v := range c.header_ {
17727 reqHeaders[k] = v
17728 }
17729 reqHeaders.Set("User-Agent", c.s.userAgent())
17730 if c.ifNoneMatch_ != "" {
17731 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17732 }
17733 var body io.Reader = nil
17734 c.urlParams_.Set("alt", alt)
17735 c.urlParams_.Set("prettyPrint", "false")
17736 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/executionsnapshots")
17737 urls += "?" + c.urlParams_.Encode()
17738 req, err := http.NewRequest("GET", urls, body)
17739 if err != nil {
17740 return nil, err
17741 }
17742 req.Header = reqHeaders
17743 googleapi.Expand(req.URL, map[string]string{
17744 "parent": c.parent,
17745 })
17746 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17747 }
17748
17749
17750
17751
17752
17753
17754
17755
17756
17757
17758
17759 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse, error) {
17760 gensupport.SetOptions(c.urlParams_, opts...)
17761 res, err := c.doRequest("json")
17762 if res != nil && res.StatusCode == http.StatusNotModified {
17763 if res.Body != nil {
17764 res.Body.Close()
17765 }
17766 return nil, gensupport.WrapError(&googleapi.Error{
17767 Code: res.StatusCode,
17768 Header: res.Header,
17769 })
17770 }
17771 if err != nil {
17772 return nil, err
17773 }
17774 defer googleapi.CloseBody(res)
17775 if err := googleapi.CheckResponse(res); err != nil {
17776 return nil, gensupport.WrapError(err)
17777 }
17778 ret := &GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse{
17779 ServerResponse: googleapi.ServerResponse{
17780 Header: res.Header,
17781 HTTPStatusCode: res.StatusCode,
17782 },
17783 }
17784 target := &ret
17785 if err := gensupport.DecodeResponse(target, res); err != nil {
17786 return nil, err
17787 }
17788 return ret, nil
17789
17790
17791
17792
17793
17794
17795
17796
17797
17798
17799
17800
17801
17802
17803
17804
17805
17806
17807
17808
17809
17810
17811
17812
17813
17814
17815
17816
17817
17818
17819
17820
17821
17822
17823
17824
17825
17826
17827
17828
17829
17830
17831
17832
17833
17834
17835
17836
17837 }
17838
17839
17840
17841
17842 func (c *ProjectsLocationsIntegrationsExecutionsnapshotsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse) error) error {
17843 c.ctx_ = ctx
17844 defer c.PageToken(c.urlParams_.Get("pageToken"))
17845 for {
17846 x, err := c.Do()
17847 if err != nil {
17848 return err
17849 }
17850 if err := f(x); err != nil {
17851 return err
17852 }
17853 if x.NextPageToken == "" {
17854 return nil
17855 }
17856 c.PageToken(x.NextPageToken)
17857 }
17858 }
17859
17860
17861
17862 type ProjectsLocationsIntegrationsVersionsArchiveCall struct {
17863 s *Service
17864 name string
17865 googlecloudintegrationsv1alphaarchiveintegrationversionrequest *GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionRequest
17866 urlParams_ gensupport.URLParams
17867 ctx_ context.Context
17868 header_ http.Header
17869 }
17870
17871
17872
17873
17874
17875
17876
17877
17878
17879
17880
17881
17882
17883
17884
17885 func (r *ProjectsLocationsIntegrationsVersionsService) Archive(name string, googlecloudintegrationsv1alphaarchiveintegrationversionrequest *GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionRequest) *ProjectsLocationsIntegrationsVersionsArchiveCall {
17886 c := &ProjectsLocationsIntegrationsVersionsArchiveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17887 c.name = name
17888 c.googlecloudintegrationsv1alphaarchiveintegrationversionrequest = googlecloudintegrationsv1alphaarchiveintegrationversionrequest
17889 return c
17890 }
17891
17892
17893
17894
17895 func (c *ProjectsLocationsIntegrationsVersionsArchiveCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsArchiveCall {
17896 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17897 return c
17898 }
17899
17900
17901
17902
17903 func (c *ProjectsLocationsIntegrationsVersionsArchiveCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsArchiveCall {
17904 c.ctx_ = ctx
17905 return c
17906 }
17907
17908
17909
17910 func (c *ProjectsLocationsIntegrationsVersionsArchiveCall) Header() http.Header {
17911 if c.header_ == nil {
17912 c.header_ = make(http.Header)
17913 }
17914 return c.header_
17915 }
17916
17917 func (c *ProjectsLocationsIntegrationsVersionsArchiveCall) doRequest(alt string) (*http.Response, error) {
17918 reqHeaders := make(http.Header)
17919 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
17920 for k, v := range c.header_ {
17921 reqHeaders[k] = v
17922 }
17923 reqHeaders.Set("User-Agent", c.s.userAgent())
17924 var body io.Reader = nil
17925 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaarchiveintegrationversionrequest)
17926 if err != nil {
17927 return nil, err
17928 }
17929 reqHeaders.Set("Content-Type", "application/json")
17930 c.urlParams_.Set("alt", alt)
17931 c.urlParams_.Set("prettyPrint", "false")
17932 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:archive")
17933 urls += "?" + c.urlParams_.Encode()
17934 req, err := http.NewRequest("POST", urls, body)
17935 if err != nil {
17936 return nil, err
17937 }
17938 req.Header = reqHeaders
17939 googleapi.Expand(req.URL, map[string]string{
17940 "name": c.name,
17941 })
17942 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17943 }
17944
17945
17946
17947
17948
17949
17950
17951
17952
17953
17954
17955 func (c *ProjectsLocationsIntegrationsVersionsArchiveCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionResponse, error) {
17956 gensupport.SetOptions(c.urlParams_, opts...)
17957 res, err := c.doRequest("json")
17958 if res != nil && res.StatusCode == http.StatusNotModified {
17959 if res.Body != nil {
17960 res.Body.Close()
17961 }
17962 return nil, gensupport.WrapError(&googleapi.Error{
17963 Code: res.StatusCode,
17964 Header: res.Header,
17965 })
17966 }
17967 if err != nil {
17968 return nil, err
17969 }
17970 defer googleapi.CloseBody(res)
17971 if err := googleapi.CheckResponse(res); err != nil {
17972 return nil, gensupport.WrapError(err)
17973 }
17974 ret := &GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionResponse{
17975 ServerResponse: googleapi.ServerResponse{
17976 Header: res.Header,
17977 HTTPStatusCode: res.StatusCode,
17978 },
17979 }
17980 target := &ret
17981 if err := gensupport.DecodeResponse(target, res); err != nil {
17982 return nil, err
17983 }
17984 return ret, nil
17985
17986
17987
17988
17989
17990
17991
17992
17993
17994
17995
17996
17997
17998
17999
18000
18001
18002
18003
18004
18005
18006
18007
18008
18009
18010
18011
18012
18013
18014 }
18015
18016
18017
18018 type ProjectsLocationsIntegrationsVersionsCreateCall struct {
18019 s *Service
18020 parent string
18021 googlecloudintegrationsv1alphaintegrationversion *GoogleCloudIntegrationsV1alphaIntegrationVersion
18022 urlParams_ gensupport.URLParams
18023 ctx_ context.Context
18024 header_ http.Header
18025 }
18026
18027
18028
18029
18030
18031
18032
18033 func (r *ProjectsLocationsIntegrationsVersionsService) Create(parent string, googlecloudintegrationsv1alphaintegrationversion *GoogleCloudIntegrationsV1alphaIntegrationVersion) *ProjectsLocationsIntegrationsVersionsCreateCall {
18034 c := &ProjectsLocationsIntegrationsVersionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18035 c.parent = parent
18036 c.googlecloudintegrationsv1alphaintegrationversion = googlecloudintegrationsv1alphaintegrationversion
18037 return c
18038 }
18039
18040
18041
18042
18043
18044
18045
18046 func (c *ProjectsLocationsIntegrationsVersionsCreateCall) NewIntegration(newIntegration bool) *ProjectsLocationsIntegrationsVersionsCreateCall {
18047 c.urlParams_.Set("newIntegration", fmt.Sprint(newIntegration))
18048 return c
18049 }
18050
18051
18052
18053
18054 func (c *ProjectsLocationsIntegrationsVersionsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsCreateCall {
18055 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18056 return c
18057 }
18058
18059
18060
18061
18062 func (c *ProjectsLocationsIntegrationsVersionsCreateCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsCreateCall {
18063 c.ctx_ = ctx
18064 return c
18065 }
18066
18067
18068
18069 func (c *ProjectsLocationsIntegrationsVersionsCreateCall) Header() http.Header {
18070 if c.header_ == nil {
18071 c.header_ = make(http.Header)
18072 }
18073 return c.header_
18074 }
18075
18076 func (c *ProjectsLocationsIntegrationsVersionsCreateCall) doRequest(alt string) (*http.Response, error) {
18077 reqHeaders := make(http.Header)
18078 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
18079 for k, v := range c.header_ {
18080 reqHeaders[k] = v
18081 }
18082 reqHeaders.Set("User-Agent", c.s.userAgent())
18083 var body io.Reader = nil
18084 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaintegrationversion)
18085 if err != nil {
18086 return nil, err
18087 }
18088 reqHeaders.Set("Content-Type", "application/json")
18089 c.urlParams_.Set("alt", alt)
18090 c.urlParams_.Set("prettyPrint", "false")
18091 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/versions")
18092 urls += "?" + c.urlParams_.Encode()
18093 req, err := http.NewRequest("POST", urls, body)
18094 if err != nil {
18095 return nil, err
18096 }
18097 req.Header = reqHeaders
18098 googleapi.Expand(req.URL, map[string]string{
18099 "parent": c.parent,
18100 })
18101 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18102 }
18103
18104
18105
18106
18107
18108
18109
18110
18111
18112
18113 func (c *ProjectsLocationsIntegrationsVersionsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaIntegrationVersion, error) {
18114 gensupport.SetOptions(c.urlParams_, opts...)
18115 res, err := c.doRequest("json")
18116 if res != nil && res.StatusCode == http.StatusNotModified {
18117 if res.Body != nil {
18118 res.Body.Close()
18119 }
18120 return nil, gensupport.WrapError(&googleapi.Error{
18121 Code: res.StatusCode,
18122 Header: res.Header,
18123 })
18124 }
18125 if err != nil {
18126 return nil, err
18127 }
18128 defer googleapi.CloseBody(res)
18129 if err := googleapi.CheckResponse(res); err != nil {
18130 return nil, gensupport.WrapError(err)
18131 }
18132 ret := &GoogleCloudIntegrationsV1alphaIntegrationVersion{
18133 ServerResponse: googleapi.ServerResponse{
18134 Header: res.Header,
18135 HTTPStatusCode: res.StatusCode,
18136 },
18137 }
18138 target := &ret
18139 if err := gensupport.DecodeResponse(target, res); err != nil {
18140 return nil, err
18141 }
18142 return ret, nil
18143
18144
18145
18146
18147
18148
18149
18150
18151
18152
18153
18154
18155
18156
18157
18158
18159
18160
18161
18162
18163
18164
18165
18166
18167
18168
18169
18170
18171
18172
18173
18174
18175
18176
18177 }
18178
18179
18180
18181 type ProjectsLocationsIntegrationsVersionsDeactivateCall struct {
18182 s *Service
18183 name string
18184 googlecloudintegrationsv1alphadeactivateintegrationversionrequest *GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionRequest
18185 urlParams_ gensupport.URLParams
18186 ctx_ context.Context
18187 header_ http.Header
18188 }
18189
18190
18191
18192
18193
18194
18195
18196
18197
18198
18199 func (r *ProjectsLocationsIntegrationsVersionsService) Deactivate(name string, googlecloudintegrationsv1alphadeactivateintegrationversionrequest *GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionRequest) *ProjectsLocationsIntegrationsVersionsDeactivateCall {
18200 c := &ProjectsLocationsIntegrationsVersionsDeactivateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18201 c.name = name
18202 c.googlecloudintegrationsv1alphadeactivateintegrationversionrequest = googlecloudintegrationsv1alphadeactivateintegrationversionrequest
18203 return c
18204 }
18205
18206
18207
18208
18209 func (c *ProjectsLocationsIntegrationsVersionsDeactivateCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsDeactivateCall {
18210 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18211 return c
18212 }
18213
18214
18215
18216
18217 func (c *ProjectsLocationsIntegrationsVersionsDeactivateCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsDeactivateCall {
18218 c.ctx_ = ctx
18219 return c
18220 }
18221
18222
18223
18224 func (c *ProjectsLocationsIntegrationsVersionsDeactivateCall) Header() http.Header {
18225 if c.header_ == nil {
18226 c.header_ = make(http.Header)
18227 }
18228 return c.header_
18229 }
18230
18231 func (c *ProjectsLocationsIntegrationsVersionsDeactivateCall) doRequest(alt string) (*http.Response, error) {
18232 reqHeaders := make(http.Header)
18233 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
18234 for k, v := range c.header_ {
18235 reqHeaders[k] = v
18236 }
18237 reqHeaders.Set("User-Agent", c.s.userAgent())
18238 var body io.Reader = nil
18239 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphadeactivateintegrationversionrequest)
18240 if err != nil {
18241 return nil, err
18242 }
18243 reqHeaders.Set("Content-Type", "application/json")
18244 c.urlParams_.Set("alt", alt)
18245 c.urlParams_.Set("prettyPrint", "false")
18246 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:deactivate")
18247 urls += "?" + c.urlParams_.Encode()
18248 req, err := http.NewRequest("POST", urls, body)
18249 if err != nil {
18250 return nil, err
18251 }
18252 req.Header = reqHeaders
18253 googleapi.Expand(req.URL, map[string]string{
18254 "name": c.name,
18255 })
18256 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18257 }
18258
18259
18260
18261
18262
18263
18264
18265
18266
18267
18268
18269 func (c *ProjectsLocationsIntegrationsVersionsDeactivateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionResponse, error) {
18270 gensupport.SetOptions(c.urlParams_, opts...)
18271 res, err := c.doRequest("json")
18272 if res != nil && res.StatusCode == http.StatusNotModified {
18273 if res.Body != nil {
18274 res.Body.Close()
18275 }
18276 return nil, gensupport.WrapError(&googleapi.Error{
18277 Code: res.StatusCode,
18278 Header: res.Header,
18279 })
18280 }
18281 if err != nil {
18282 return nil, err
18283 }
18284 defer googleapi.CloseBody(res)
18285 if err := googleapi.CheckResponse(res); err != nil {
18286 return nil, gensupport.WrapError(err)
18287 }
18288 ret := &GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionResponse{
18289 ServerResponse: googleapi.ServerResponse{
18290 Header: res.Header,
18291 HTTPStatusCode: res.StatusCode,
18292 },
18293 }
18294 target := &ret
18295 if err := gensupport.DecodeResponse(target, res); err != nil {
18296 return nil, err
18297 }
18298 return ret, nil
18299
18300
18301
18302
18303
18304
18305
18306
18307
18308
18309
18310
18311
18312
18313
18314
18315
18316
18317
18318
18319
18320
18321
18322
18323
18324
18325
18326
18327
18328 }
18329
18330
18331
18332 type ProjectsLocationsIntegrationsVersionsDeleteCall struct {
18333 s *Service
18334 name string
18335 urlParams_ gensupport.URLParams
18336 ctx_ context.Context
18337 header_ http.Header
18338 }
18339
18340
18341
18342
18343
18344
18345
18346
18347
18348
18349
18350
18351
18352
18353
18354 func (r *ProjectsLocationsIntegrationsVersionsService) Delete(name string) *ProjectsLocationsIntegrationsVersionsDeleteCall {
18355 c := &ProjectsLocationsIntegrationsVersionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18356 c.name = name
18357 return c
18358 }
18359
18360
18361
18362
18363 func (c *ProjectsLocationsIntegrationsVersionsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsDeleteCall {
18364 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18365 return c
18366 }
18367
18368
18369
18370
18371 func (c *ProjectsLocationsIntegrationsVersionsDeleteCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsDeleteCall {
18372 c.ctx_ = ctx
18373 return c
18374 }
18375
18376
18377
18378 func (c *ProjectsLocationsIntegrationsVersionsDeleteCall) Header() http.Header {
18379 if c.header_ == nil {
18380 c.header_ = make(http.Header)
18381 }
18382 return c.header_
18383 }
18384
18385 func (c *ProjectsLocationsIntegrationsVersionsDeleteCall) doRequest(alt string) (*http.Response, error) {
18386 reqHeaders := make(http.Header)
18387 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
18388 for k, v := range c.header_ {
18389 reqHeaders[k] = v
18390 }
18391 reqHeaders.Set("User-Agent", c.s.userAgent())
18392 var body io.Reader = nil
18393 c.urlParams_.Set("alt", alt)
18394 c.urlParams_.Set("prettyPrint", "false")
18395 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
18396 urls += "?" + c.urlParams_.Encode()
18397 req, err := http.NewRequest("DELETE", urls, body)
18398 if err != nil {
18399 return nil, err
18400 }
18401 req.Header = reqHeaders
18402 googleapi.Expand(req.URL, map[string]string{
18403 "name": c.name,
18404 })
18405 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18406 }
18407
18408
18409
18410
18411
18412
18413
18414
18415 func (c *ProjectsLocationsIntegrationsVersionsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
18416 gensupport.SetOptions(c.urlParams_, opts...)
18417 res, err := c.doRequest("json")
18418 if res != nil && res.StatusCode == http.StatusNotModified {
18419 if res.Body != nil {
18420 res.Body.Close()
18421 }
18422 return nil, gensupport.WrapError(&googleapi.Error{
18423 Code: res.StatusCode,
18424 Header: res.Header,
18425 })
18426 }
18427 if err != nil {
18428 return nil, err
18429 }
18430 defer googleapi.CloseBody(res)
18431 if err := googleapi.CheckResponse(res); err != nil {
18432 return nil, gensupport.WrapError(err)
18433 }
18434 ret := &GoogleProtobufEmpty{
18435 ServerResponse: googleapi.ServerResponse{
18436 Header: res.Header,
18437 HTTPStatusCode: res.StatusCode,
18438 },
18439 }
18440 target := &ret
18441 if err := gensupport.DecodeResponse(target, res); err != nil {
18442 return nil, err
18443 }
18444 return ret, nil
18445
18446
18447
18448
18449
18450
18451
18452
18453
18454
18455
18456
18457
18458
18459
18460
18461
18462
18463
18464
18465
18466
18467
18468
18469
18470
18471 }
18472
18473
18474
18475 type ProjectsLocationsIntegrationsVersionsDownloadCall struct {
18476 s *Service
18477 name string
18478 urlParams_ gensupport.URLParams
18479 ifNoneMatch_ string
18480 ctx_ context.Context
18481 header_ http.Header
18482 }
18483
18484
18485
18486
18487
18488
18489
18490
18491 func (r *ProjectsLocationsIntegrationsVersionsService) Download(name string) *ProjectsLocationsIntegrationsVersionsDownloadCall {
18492 c := &ProjectsLocationsIntegrationsVersionsDownloadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18493 c.name = name
18494 return c
18495 }
18496
18497
18498
18499
18500
18501
18502
18503
18504
18505 func (c *ProjectsLocationsIntegrationsVersionsDownloadCall) FileFormat(fileFormat string) *ProjectsLocationsIntegrationsVersionsDownloadCall {
18506 c.urlParams_.Set("fileFormat", fileFormat)
18507 return c
18508 }
18509
18510
18511
18512
18513 func (c *ProjectsLocationsIntegrationsVersionsDownloadCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsDownloadCall {
18514 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18515 return c
18516 }
18517
18518
18519
18520
18521
18522
18523 func (c *ProjectsLocationsIntegrationsVersionsDownloadCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsVersionsDownloadCall {
18524 c.ifNoneMatch_ = entityTag
18525 return c
18526 }
18527
18528
18529
18530
18531 func (c *ProjectsLocationsIntegrationsVersionsDownloadCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsDownloadCall {
18532 c.ctx_ = ctx
18533 return c
18534 }
18535
18536
18537
18538 func (c *ProjectsLocationsIntegrationsVersionsDownloadCall) Header() http.Header {
18539 if c.header_ == nil {
18540 c.header_ = make(http.Header)
18541 }
18542 return c.header_
18543 }
18544
18545 func (c *ProjectsLocationsIntegrationsVersionsDownloadCall) doRequest(alt string) (*http.Response, error) {
18546 reqHeaders := make(http.Header)
18547 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
18548 for k, v := range c.header_ {
18549 reqHeaders[k] = v
18550 }
18551 reqHeaders.Set("User-Agent", c.s.userAgent())
18552 if c.ifNoneMatch_ != "" {
18553 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18554 }
18555 var body io.Reader = nil
18556 c.urlParams_.Set("alt", alt)
18557 c.urlParams_.Set("prettyPrint", "false")
18558 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:download")
18559 urls += "?" + c.urlParams_.Encode()
18560 req, err := http.NewRequest("GET", urls, body)
18561 if err != nil {
18562 return nil, err
18563 }
18564 req.Header = reqHeaders
18565 googleapi.Expand(req.URL, map[string]string{
18566 "name": c.name,
18567 })
18568 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18569 }
18570
18571
18572
18573
18574
18575
18576
18577
18578
18579
18580
18581 func (c *ProjectsLocationsIntegrationsVersionsDownloadCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaDownloadIntegrationVersionResponse, error) {
18582 gensupport.SetOptions(c.urlParams_, opts...)
18583 res, err := c.doRequest("json")
18584 if res != nil && res.StatusCode == http.StatusNotModified {
18585 if res.Body != nil {
18586 res.Body.Close()
18587 }
18588 return nil, gensupport.WrapError(&googleapi.Error{
18589 Code: res.StatusCode,
18590 Header: res.Header,
18591 })
18592 }
18593 if err != nil {
18594 return nil, err
18595 }
18596 defer googleapi.CloseBody(res)
18597 if err := googleapi.CheckResponse(res); err != nil {
18598 return nil, gensupport.WrapError(err)
18599 }
18600 ret := &GoogleCloudIntegrationsV1alphaDownloadIntegrationVersionResponse{
18601 ServerResponse: googleapi.ServerResponse{
18602 Header: res.Header,
18603 HTTPStatusCode: res.StatusCode,
18604 },
18605 }
18606 target := &ret
18607 if err := gensupport.DecodeResponse(target, res); err != nil {
18608 return nil, err
18609 }
18610 return ret, nil
18611
18612
18613
18614
18615
18616
18617
18618
18619
18620
18621
18622
18623
18624
18625
18626
18627
18628
18629
18630
18631
18632
18633
18634
18635
18636
18637
18638
18639
18640
18641
18642
18643
18644
18645
18646
18647
18648
18649
18650
18651
18652 }
18653
18654
18655
18656 type ProjectsLocationsIntegrationsVersionsGetCall struct {
18657 s *Service
18658 name string
18659 urlParams_ gensupport.URLParams
18660 ifNoneMatch_ string
18661 ctx_ context.Context
18662 header_ http.Header
18663 }
18664
18665
18666
18667
18668
18669
18670 func (r *ProjectsLocationsIntegrationsVersionsService) Get(name string) *ProjectsLocationsIntegrationsVersionsGetCall {
18671 c := &ProjectsLocationsIntegrationsVersionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18672 c.name = name
18673 return c
18674 }
18675
18676
18677
18678
18679 func (c *ProjectsLocationsIntegrationsVersionsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsGetCall {
18680 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18681 return c
18682 }
18683
18684
18685
18686
18687
18688
18689 func (c *ProjectsLocationsIntegrationsVersionsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsVersionsGetCall {
18690 c.ifNoneMatch_ = entityTag
18691 return c
18692 }
18693
18694
18695
18696
18697 func (c *ProjectsLocationsIntegrationsVersionsGetCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsGetCall {
18698 c.ctx_ = ctx
18699 return c
18700 }
18701
18702
18703
18704 func (c *ProjectsLocationsIntegrationsVersionsGetCall) Header() http.Header {
18705 if c.header_ == nil {
18706 c.header_ = make(http.Header)
18707 }
18708 return c.header_
18709 }
18710
18711 func (c *ProjectsLocationsIntegrationsVersionsGetCall) doRequest(alt string) (*http.Response, error) {
18712 reqHeaders := make(http.Header)
18713 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
18714 for k, v := range c.header_ {
18715 reqHeaders[k] = v
18716 }
18717 reqHeaders.Set("User-Agent", c.s.userAgent())
18718 if c.ifNoneMatch_ != "" {
18719 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18720 }
18721 var body io.Reader = nil
18722 c.urlParams_.Set("alt", alt)
18723 c.urlParams_.Set("prettyPrint", "false")
18724 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
18725 urls += "?" + c.urlParams_.Encode()
18726 req, err := http.NewRequest("GET", urls, body)
18727 if err != nil {
18728 return nil, err
18729 }
18730 req.Header = reqHeaders
18731 googleapi.Expand(req.URL, map[string]string{
18732 "name": c.name,
18733 })
18734 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18735 }
18736
18737
18738
18739
18740
18741
18742
18743
18744
18745
18746 func (c *ProjectsLocationsIntegrationsVersionsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaIntegrationVersion, error) {
18747 gensupport.SetOptions(c.urlParams_, opts...)
18748 res, err := c.doRequest("json")
18749 if res != nil && res.StatusCode == http.StatusNotModified {
18750 if res.Body != nil {
18751 res.Body.Close()
18752 }
18753 return nil, gensupport.WrapError(&googleapi.Error{
18754 Code: res.StatusCode,
18755 Header: res.Header,
18756 })
18757 }
18758 if err != nil {
18759 return nil, err
18760 }
18761 defer googleapi.CloseBody(res)
18762 if err := googleapi.CheckResponse(res); err != nil {
18763 return nil, gensupport.WrapError(err)
18764 }
18765 ret := &GoogleCloudIntegrationsV1alphaIntegrationVersion{
18766 ServerResponse: googleapi.ServerResponse{
18767 Header: res.Header,
18768 HTTPStatusCode: res.StatusCode,
18769 },
18770 }
18771 target := &ret
18772 if err := gensupport.DecodeResponse(target, res); err != nil {
18773 return nil, err
18774 }
18775 return ret, nil
18776
18777
18778
18779
18780
18781
18782
18783
18784
18785
18786
18787
18788
18789
18790
18791
18792
18793
18794
18795
18796
18797
18798
18799
18800
18801
18802 }
18803
18804
18805
18806 type ProjectsLocationsIntegrationsVersionsListCall struct {
18807 s *Service
18808 parent string
18809 urlParams_ gensupport.URLParams
18810 ifNoneMatch_ string
18811 ctx_ context.Context
18812 header_ http.Header
18813 }
18814
18815
18816
18817
18818
18819
18820
18821
18822
18823
18824
18825
18826
18827
18828 func (r *ProjectsLocationsIntegrationsVersionsService) List(parent string) *ProjectsLocationsIntegrationsVersionsListCall {
18829 c := &ProjectsLocationsIntegrationsVersionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18830 c.parent = parent
18831 return c
18832 }
18833
18834
18835
18836 func (c *ProjectsLocationsIntegrationsVersionsListCall) FieldMask(fieldMask string) *ProjectsLocationsIntegrationsVersionsListCall {
18837 c.urlParams_.Set("fieldMask", fieldMask)
18838 return c
18839 }
18840
18841
18842
18843
18844
18845
18846
18847
18848
18849 func (c *ProjectsLocationsIntegrationsVersionsListCall) Filter(filter string) *ProjectsLocationsIntegrationsVersionsListCall {
18850 c.urlParams_.Set("filter", filter)
18851 return c
18852 }
18853
18854
18855
18856
18857
18858 func (c *ProjectsLocationsIntegrationsVersionsListCall) OrderBy(orderBy string) *ProjectsLocationsIntegrationsVersionsListCall {
18859 c.urlParams_.Set("orderBy", orderBy)
18860 return c
18861 }
18862
18863
18864
18865
18866
18867 func (c *ProjectsLocationsIntegrationsVersionsListCall) PageSize(pageSize int64) *ProjectsLocationsIntegrationsVersionsListCall {
18868 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
18869 return c
18870 }
18871
18872
18873
18874
18875
18876
18877 func (c *ProjectsLocationsIntegrationsVersionsListCall) PageToken(pageToken string) *ProjectsLocationsIntegrationsVersionsListCall {
18878 c.urlParams_.Set("pageToken", pageToken)
18879 return c
18880 }
18881
18882
18883
18884
18885 func (c *ProjectsLocationsIntegrationsVersionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsListCall {
18886 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18887 return c
18888 }
18889
18890
18891
18892
18893
18894
18895 func (c *ProjectsLocationsIntegrationsVersionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsIntegrationsVersionsListCall {
18896 c.ifNoneMatch_ = entityTag
18897 return c
18898 }
18899
18900
18901
18902
18903 func (c *ProjectsLocationsIntegrationsVersionsListCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsListCall {
18904 c.ctx_ = ctx
18905 return c
18906 }
18907
18908
18909
18910 func (c *ProjectsLocationsIntegrationsVersionsListCall) Header() http.Header {
18911 if c.header_ == nil {
18912 c.header_ = make(http.Header)
18913 }
18914 return c.header_
18915 }
18916
18917 func (c *ProjectsLocationsIntegrationsVersionsListCall) doRequest(alt string) (*http.Response, error) {
18918 reqHeaders := make(http.Header)
18919 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
18920 for k, v := range c.header_ {
18921 reqHeaders[k] = v
18922 }
18923 reqHeaders.Set("User-Agent", c.s.userAgent())
18924 if c.ifNoneMatch_ != "" {
18925 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18926 }
18927 var body io.Reader = nil
18928 c.urlParams_.Set("alt", alt)
18929 c.urlParams_.Set("prettyPrint", "false")
18930 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/versions")
18931 urls += "?" + c.urlParams_.Encode()
18932 req, err := http.NewRequest("GET", urls, body)
18933 if err != nil {
18934 return nil, err
18935 }
18936 req.Header = reqHeaders
18937 googleapi.Expand(req.URL, map[string]string{
18938 "parent": c.parent,
18939 })
18940 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18941 }
18942
18943
18944
18945
18946
18947
18948
18949
18950
18951
18952
18953 func (c *ProjectsLocationsIntegrationsVersionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse, error) {
18954 gensupport.SetOptions(c.urlParams_, opts...)
18955 res, err := c.doRequest("json")
18956 if res != nil && res.StatusCode == http.StatusNotModified {
18957 if res.Body != nil {
18958 res.Body.Close()
18959 }
18960 return nil, gensupport.WrapError(&googleapi.Error{
18961 Code: res.StatusCode,
18962 Header: res.Header,
18963 })
18964 }
18965 if err != nil {
18966 return nil, err
18967 }
18968 defer googleapi.CloseBody(res)
18969 if err := googleapi.CheckResponse(res); err != nil {
18970 return nil, gensupport.WrapError(err)
18971 }
18972 ret := &GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse{
18973 ServerResponse: googleapi.ServerResponse{
18974 Header: res.Header,
18975 HTTPStatusCode: res.StatusCode,
18976 },
18977 }
18978 target := &ret
18979 if err := gensupport.DecodeResponse(target, res); err != nil {
18980 return nil, err
18981 }
18982 return ret, nil
18983
18984
18985
18986
18987
18988
18989
18990
18991
18992
18993
18994
18995
18996
18997
18998
18999
19000
19001
19002
19003
19004
19005
19006
19007
19008
19009
19010
19011
19012
19013
19014
19015
19016
19017
19018
19019
19020
19021
19022
19023
19024
19025
19026
19027
19028
19029
19030
19031
19032
19033
19034
19035
19036 }
19037
19038
19039
19040
19041 func (c *ProjectsLocationsIntegrationsVersionsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse) error) error {
19042 c.ctx_ = ctx
19043 defer c.PageToken(c.urlParams_.Get("pageToken"))
19044 for {
19045 x, err := c.Do()
19046 if err != nil {
19047 return err
19048 }
19049 if err := f(x); err != nil {
19050 return err
19051 }
19052 if x.NextPageToken == "" {
19053 return nil
19054 }
19055 c.PageToken(x.NextPageToken)
19056 }
19057 }
19058
19059
19060
19061 type ProjectsLocationsIntegrationsVersionsPatchCall struct {
19062 s *Service
19063 name string
19064 googlecloudintegrationsv1alphaintegrationversion *GoogleCloudIntegrationsV1alphaIntegrationVersion
19065 urlParams_ gensupport.URLParams
19066 ctx_ context.Context
19067 header_ http.Header
19068 }
19069
19070
19071
19072
19073
19074 func (r *ProjectsLocationsIntegrationsVersionsService) Patch(name string, googlecloudintegrationsv1alphaintegrationversion *GoogleCloudIntegrationsV1alphaIntegrationVersion) *ProjectsLocationsIntegrationsVersionsPatchCall {
19075 c := &ProjectsLocationsIntegrationsVersionsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19076 c.name = name
19077 c.googlecloudintegrationsv1alphaintegrationversion = googlecloudintegrationsv1alphaintegrationversion
19078 return c
19079 }
19080
19081
19082
19083
19084 func (c *ProjectsLocationsIntegrationsVersionsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsIntegrationsVersionsPatchCall {
19085 c.urlParams_.Set("updateMask", updateMask)
19086 return c
19087 }
19088
19089
19090
19091
19092 func (c *ProjectsLocationsIntegrationsVersionsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsPatchCall {
19093 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19094 return c
19095 }
19096
19097
19098
19099
19100 func (c *ProjectsLocationsIntegrationsVersionsPatchCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsPatchCall {
19101 c.ctx_ = ctx
19102 return c
19103 }
19104
19105
19106
19107 func (c *ProjectsLocationsIntegrationsVersionsPatchCall) Header() http.Header {
19108 if c.header_ == nil {
19109 c.header_ = make(http.Header)
19110 }
19111 return c.header_
19112 }
19113
19114 func (c *ProjectsLocationsIntegrationsVersionsPatchCall) doRequest(alt string) (*http.Response, error) {
19115 reqHeaders := make(http.Header)
19116 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
19117 for k, v := range c.header_ {
19118 reqHeaders[k] = v
19119 }
19120 reqHeaders.Set("User-Agent", c.s.userAgent())
19121 var body io.Reader = nil
19122 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaintegrationversion)
19123 if err != nil {
19124 return nil, err
19125 }
19126 reqHeaders.Set("Content-Type", "application/json")
19127 c.urlParams_.Set("alt", alt)
19128 c.urlParams_.Set("prettyPrint", "false")
19129 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
19130 urls += "?" + c.urlParams_.Encode()
19131 req, err := http.NewRequest("PATCH", urls, body)
19132 if err != nil {
19133 return nil, err
19134 }
19135 req.Header = reqHeaders
19136 googleapi.Expand(req.URL, map[string]string{
19137 "name": c.name,
19138 })
19139 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19140 }
19141
19142
19143
19144
19145
19146
19147
19148
19149
19150
19151 func (c *ProjectsLocationsIntegrationsVersionsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaIntegrationVersion, error) {
19152 gensupport.SetOptions(c.urlParams_, opts...)
19153 res, err := c.doRequest("json")
19154 if res != nil && res.StatusCode == http.StatusNotModified {
19155 if res.Body != nil {
19156 res.Body.Close()
19157 }
19158 return nil, gensupport.WrapError(&googleapi.Error{
19159 Code: res.StatusCode,
19160 Header: res.Header,
19161 })
19162 }
19163 if err != nil {
19164 return nil, err
19165 }
19166 defer googleapi.CloseBody(res)
19167 if err := googleapi.CheckResponse(res); err != nil {
19168 return nil, gensupport.WrapError(err)
19169 }
19170 ret := &GoogleCloudIntegrationsV1alphaIntegrationVersion{
19171 ServerResponse: googleapi.ServerResponse{
19172 Header: res.Header,
19173 HTTPStatusCode: res.StatusCode,
19174 },
19175 }
19176 target := &ret
19177 if err := gensupport.DecodeResponse(target, res); err != nil {
19178 return nil, err
19179 }
19180 return ret, nil
19181
19182
19183
19184
19185
19186
19187
19188
19189
19190
19191
19192
19193
19194
19195
19196
19197
19198
19199
19200
19201
19202
19203
19204
19205
19206
19207
19208
19209
19210
19211
19212
19213
19214
19215
19216 }
19217
19218
19219
19220 type ProjectsLocationsIntegrationsVersionsPublishCall struct {
19221 s *Service
19222 name string
19223 googlecloudintegrationsv1alphapublishintegrationversionrequest *GoogleCloudIntegrationsV1alphaPublishIntegrationVersionRequest
19224 urlParams_ gensupport.URLParams
19225 ctx_ context.Context
19226 header_ http.Header
19227 }
19228
19229
19230
19231
19232
19233
19234
19235
19236
19237
19238
19239
19240 func (r *ProjectsLocationsIntegrationsVersionsService) Publish(name string, googlecloudintegrationsv1alphapublishintegrationversionrequest *GoogleCloudIntegrationsV1alphaPublishIntegrationVersionRequest) *ProjectsLocationsIntegrationsVersionsPublishCall {
19241 c := &ProjectsLocationsIntegrationsVersionsPublishCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19242 c.name = name
19243 c.googlecloudintegrationsv1alphapublishintegrationversionrequest = googlecloudintegrationsv1alphapublishintegrationversionrequest
19244 return c
19245 }
19246
19247
19248
19249
19250 func (c *ProjectsLocationsIntegrationsVersionsPublishCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsPublishCall {
19251 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19252 return c
19253 }
19254
19255
19256
19257
19258 func (c *ProjectsLocationsIntegrationsVersionsPublishCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsPublishCall {
19259 c.ctx_ = ctx
19260 return c
19261 }
19262
19263
19264
19265 func (c *ProjectsLocationsIntegrationsVersionsPublishCall) Header() http.Header {
19266 if c.header_ == nil {
19267 c.header_ = make(http.Header)
19268 }
19269 return c.header_
19270 }
19271
19272 func (c *ProjectsLocationsIntegrationsVersionsPublishCall) doRequest(alt string) (*http.Response, error) {
19273 reqHeaders := make(http.Header)
19274 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
19275 for k, v := range c.header_ {
19276 reqHeaders[k] = v
19277 }
19278 reqHeaders.Set("User-Agent", c.s.userAgent())
19279 var body io.Reader = nil
19280 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphapublishintegrationversionrequest)
19281 if err != nil {
19282 return nil, err
19283 }
19284 reqHeaders.Set("Content-Type", "application/json")
19285 c.urlParams_.Set("alt", alt)
19286 c.urlParams_.Set("prettyPrint", "false")
19287 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:publish")
19288 urls += "?" + c.urlParams_.Encode()
19289 req, err := http.NewRequest("POST", urls, body)
19290 if err != nil {
19291 return nil, err
19292 }
19293 req.Header = reqHeaders
19294 googleapi.Expand(req.URL, map[string]string{
19295 "name": c.name,
19296 })
19297 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19298 }
19299
19300
19301
19302
19303
19304
19305
19306
19307
19308
19309
19310 func (c *ProjectsLocationsIntegrationsVersionsPublishCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaPublishIntegrationVersionResponse, error) {
19311 gensupport.SetOptions(c.urlParams_, opts...)
19312 res, err := c.doRequest("json")
19313 if res != nil && res.StatusCode == http.StatusNotModified {
19314 if res.Body != nil {
19315 res.Body.Close()
19316 }
19317 return nil, gensupport.WrapError(&googleapi.Error{
19318 Code: res.StatusCode,
19319 Header: res.Header,
19320 })
19321 }
19322 if err != nil {
19323 return nil, err
19324 }
19325 defer googleapi.CloseBody(res)
19326 if err := googleapi.CheckResponse(res); err != nil {
19327 return nil, gensupport.WrapError(err)
19328 }
19329 ret := &GoogleCloudIntegrationsV1alphaPublishIntegrationVersionResponse{
19330 ServerResponse: googleapi.ServerResponse{
19331 Header: res.Header,
19332 HTTPStatusCode: res.StatusCode,
19333 },
19334 }
19335 target := &ret
19336 if err := gensupport.DecodeResponse(target, res); err != nil {
19337 return nil, err
19338 }
19339 return ret, nil
19340
19341
19342
19343
19344
19345
19346
19347
19348
19349
19350
19351
19352
19353
19354
19355
19356
19357
19358
19359
19360
19361
19362
19363
19364
19365
19366
19367
19368
19369 }
19370
19371
19372
19373 type ProjectsLocationsIntegrationsVersionsUnpublishCall struct {
19374 s *Service
19375 name string
19376 googlecloudintegrationsv1alphaunpublishintegrationversionrequest *GoogleCloudIntegrationsV1alphaUnpublishIntegrationVersionRequest
19377 urlParams_ gensupport.URLParams
19378 ctx_ context.Context
19379 header_ http.Header
19380 }
19381
19382
19383
19384
19385
19386
19387
19388
19389
19390
19391 func (r *ProjectsLocationsIntegrationsVersionsService) Unpublish(name string, googlecloudintegrationsv1alphaunpublishintegrationversionrequest *GoogleCloudIntegrationsV1alphaUnpublishIntegrationVersionRequest) *ProjectsLocationsIntegrationsVersionsUnpublishCall {
19392 c := &ProjectsLocationsIntegrationsVersionsUnpublishCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19393 c.name = name
19394 c.googlecloudintegrationsv1alphaunpublishintegrationversionrequest = googlecloudintegrationsv1alphaunpublishintegrationversionrequest
19395 return c
19396 }
19397
19398
19399
19400
19401 func (c *ProjectsLocationsIntegrationsVersionsUnpublishCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsUnpublishCall {
19402 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19403 return c
19404 }
19405
19406
19407
19408
19409 func (c *ProjectsLocationsIntegrationsVersionsUnpublishCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsUnpublishCall {
19410 c.ctx_ = ctx
19411 return c
19412 }
19413
19414
19415
19416 func (c *ProjectsLocationsIntegrationsVersionsUnpublishCall) Header() http.Header {
19417 if c.header_ == nil {
19418 c.header_ = make(http.Header)
19419 }
19420 return c.header_
19421 }
19422
19423 func (c *ProjectsLocationsIntegrationsVersionsUnpublishCall) doRequest(alt string) (*http.Response, error) {
19424 reqHeaders := make(http.Header)
19425 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
19426 for k, v := range c.header_ {
19427 reqHeaders[k] = v
19428 }
19429 reqHeaders.Set("User-Agent", c.s.userAgent())
19430 var body io.Reader = nil
19431 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaunpublishintegrationversionrequest)
19432 if err != nil {
19433 return nil, err
19434 }
19435 reqHeaders.Set("Content-Type", "application/json")
19436 c.urlParams_.Set("alt", alt)
19437 c.urlParams_.Set("prettyPrint", "false")
19438 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:unpublish")
19439 urls += "?" + c.urlParams_.Encode()
19440 req, err := http.NewRequest("POST", urls, body)
19441 if err != nil {
19442 return nil, err
19443 }
19444 req.Header = reqHeaders
19445 googleapi.Expand(req.URL, map[string]string{
19446 "name": c.name,
19447 })
19448 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19449 }
19450
19451
19452
19453
19454
19455
19456
19457
19458 func (c *ProjectsLocationsIntegrationsVersionsUnpublishCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
19459 gensupport.SetOptions(c.urlParams_, opts...)
19460 res, err := c.doRequest("json")
19461 if res != nil && res.StatusCode == http.StatusNotModified {
19462 if res.Body != nil {
19463 res.Body.Close()
19464 }
19465 return nil, gensupport.WrapError(&googleapi.Error{
19466 Code: res.StatusCode,
19467 Header: res.Header,
19468 })
19469 }
19470 if err != nil {
19471 return nil, err
19472 }
19473 defer googleapi.CloseBody(res)
19474 if err := googleapi.CheckResponse(res); err != nil {
19475 return nil, gensupport.WrapError(err)
19476 }
19477 ret := &GoogleProtobufEmpty{
19478 ServerResponse: googleapi.ServerResponse{
19479 Header: res.Header,
19480 HTTPStatusCode: res.StatusCode,
19481 },
19482 }
19483 target := &ret
19484 if err := gensupport.DecodeResponse(target, res); err != nil {
19485 return nil, err
19486 }
19487 return ret, nil
19488
19489
19490
19491
19492
19493
19494
19495
19496
19497
19498
19499
19500
19501
19502
19503
19504
19505
19506
19507
19508
19509
19510
19511
19512
19513
19514
19515
19516
19517 }
19518
19519
19520
19521 type ProjectsLocationsIntegrationsVersionsUploadCall struct {
19522 s *Service
19523 parent string
19524 googlecloudintegrationsv1alphauploadintegrationversionrequest *GoogleCloudIntegrationsV1alphaUploadIntegrationVersionRequest
19525 urlParams_ gensupport.URLParams
19526 ctx_ context.Context
19527 header_ http.Header
19528 }
19529
19530
19531
19532
19533
19534
19535
19536
19537
19538 func (r *ProjectsLocationsIntegrationsVersionsService) Upload(parent string, googlecloudintegrationsv1alphauploadintegrationversionrequest *GoogleCloudIntegrationsV1alphaUploadIntegrationVersionRequest) *ProjectsLocationsIntegrationsVersionsUploadCall {
19539 c := &ProjectsLocationsIntegrationsVersionsUploadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19540 c.parent = parent
19541 c.googlecloudintegrationsv1alphauploadintegrationversionrequest = googlecloudintegrationsv1alphauploadintegrationversionrequest
19542 return c
19543 }
19544
19545
19546
19547
19548 func (c *ProjectsLocationsIntegrationsVersionsUploadCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsUploadCall {
19549 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19550 return c
19551 }
19552
19553
19554
19555
19556 func (c *ProjectsLocationsIntegrationsVersionsUploadCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsUploadCall {
19557 c.ctx_ = ctx
19558 return c
19559 }
19560
19561
19562
19563 func (c *ProjectsLocationsIntegrationsVersionsUploadCall) Header() http.Header {
19564 if c.header_ == nil {
19565 c.header_ = make(http.Header)
19566 }
19567 return c.header_
19568 }
19569
19570 func (c *ProjectsLocationsIntegrationsVersionsUploadCall) doRequest(alt string) (*http.Response, error) {
19571 reqHeaders := make(http.Header)
19572 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
19573 for k, v := range c.header_ {
19574 reqHeaders[k] = v
19575 }
19576 reqHeaders.Set("User-Agent", c.s.userAgent())
19577 var body io.Reader = nil
19578 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphauploadintegrationversionrequest)
19579 if err != nil {
19580 return nil, err
19581 }
19582 reqHeaders.Set("Content-Type", "application/json")
19583 c.urlParams_.Set("alt", alt)
19584 c.urlParams_.Set("prettyPrint", "false")
19585 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/versions:upload")
19586 urls += "?" + c.urlParams_.Encode()
19587 req, err := http.NewRequest("POST", urls, body)
19588 if err != nil {
19589 return nil, err
19590 }
19591 req.Header = reqHeaders
19592 googleapi.Expand(req.URL, map[string]string{
19593 "parent": c.parent,
19594 })
19595 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19596 }
19597
19598
19599
19600
19601
19602
19603
19604
19605
19606
19607
19608 func (c *ProjectsLocationsIntegrationsVersionsUploadCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaUploadIntegrationVersionResponse, error) {
19609 gensupport.SetOptions(c.urlParams_, opts...)
19610 res, err := c.doRequest("json")
19611 if res != nil && res.StatusCode == http.StatusNotModified {
19612 if res.Body != nil {
19613 res.Body.Close()
19614 }
19615 return nil, gensupport.WrapError(&googleapi.Error{
19616 Code: res.StatusCode,
19617 Header: res.Header,
19618 })
19619 }
19620 if err != nil {
19621 return nil, err
19622 }
19623 defer googleapi.CloseBody(res)
19624 if err := googleapi.CheckResponse(res); err != nil {
19625 return nil, gensupport.WrapError(err)
19626 }
19627 ret := &GoogleCloudIntegrationsV1alphaUploadIntegrationVersionResponse{
19628 ServerResponse: googleapi.ServerResponse{
19629 Header: res.Header,
19630 HTTPStatusCode: res.StatusCode,
19631 },
19632 }
19633 target := &ret
19634 if err := gensupport.DecodeResponse(target, res); err != nil {
19635 return nil, err
19636 }
19637 return ret, nil
19638
19639
19640
19641
19642
19643
19644
19645
19646
19647
19648
19649
19650
19651
19652
19653
19654
19655
19656
19657
19658
19659
19660
19661
19662
19663
19664
19665
19666
19667 }
19668
19669
19670
19671 type ProjectsLocationsIntegrationsVersionsValidateCall struct {
19672 s *Service
19673 name string
19674 googlecloudintegrationsv1alphavalidateintegrationversionrequest *GoogleCloudIntegrationsV1alphaValidateIntegrationVersionRequest
19675 urlParams_ gensupport.URLParams
19676 ctx_ context.Context
19677 header_ http.Header
19678 }
19679
19680
19681
19682
19683
19684
19685
19686
19687
19688 func (r *ProjectsLocationsIntegrationsVersionsService) Validate(name string, googlecloudintegrationsv1alphavalidateintegrationversionrequest *GoogleCloudIntegrationsV1alphaValidateIntegrationVersionRequest) *ProjectsLocationsIntegrationsVersionsValidateCall {
19689 c := &ProjectsLocationsIntegrationsVersionsValidateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19690 c.name = name
19691 c.googlecloudintegrationsv1alphavalidateintegrationversionrequest = googlecloudintegrationsv1alphavalidateintegrationversionrequest
19692 return c
19693 }
19694
19695
19696
19697
19698 func (c *ProjectsLocationsIntegrationsVersionsValidateCall) Fields(s ...googleapi.Field) *ProjectsLocationsIntegrationsVersionsValidateCall {
19699 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19700 return c
19701 }
19702
19703
19704
19705
19706 func (c *ProjectsLocationsIntegrationsVersionsValidateCall) Context(ctx context.Context) *ProjectsLocationsIntegrationsVersionsValidateCall {
19707 c.ctx_ = ctx
19708 return c
19709 }
19710
19711
19712
19713 func (c *ProjectsLocationsIntegrationsVersionsValidateCall) Header() http.Header {
19714 if c.header_ == nil {
19715 c.header_ = make(http.Header)
19716 }
19717 return c.header_
19718 }
19719
19720 func (c *ProjectsLocationsIntegrationsVersionsValidateCall) doRequest(alt string) (*http.Response, error) {
19721 reqHeaders := make(http.Header)
19722 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
19723 for k, v := range c.header_ {
19724 reqHeaders[k] = v
19725 }
19726 reqHeaders.Set("User-Agent", c.s.userAgent())
19727 var body io.Reader = nil
19728 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphavalidateintegrationversionrequest)
19729 if err != nil {
19730 return nil, err
19731 }
19732 reqHeaders.Set("Content-Type", "application/json")
19733 c.urlParams_.Set("alt", alt)
19734 c.urlParams_.Set("prettyPrint", "false")
19735 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:validate")
19736 urls += "?" + c.urlParams_.Encode()
19737 req, err := http.NewRequest("POST", urls, body)
19738 if err != nil {
19739 return nil, err
19740 }
19741 req.Header = reqHeaders
19742 googleapi.Expand(req.URL, map[string]string{
19743 "name": c.name,
19744 })
19745 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19746 }
19747
19748
19749
19750
19751
19752
19753
19754
19755
19756
19757
19758 func (c *ProjectsLocationsIntegrationsVersionsValidateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaValidateIntegrationVersionResponse, error) {
19759 gensupport.SetOptions(c.urlParams_, opts...)
19760 res, err := c.doRequest("json")
19761 if res != nil && res.StatusCode == http.StatusNotModified {
19762 if res.Body != nil {
19763 res.Body.Close()
19764 }
19765 return nil, gensupport.WrapError(&googleapi.Error{
19766 Code: res.StatusCode,
19767 Header: res.Header,
19768 })
19769 }
19770 if err != nil {
19771 return nil, err
19772 }
19773 defer googleapi.CloseBody(res)
19774 if err := googleapi.CheckResponse(res); err != nil {
19775 return nil, gensupport.WrapError(err)
19776 }
19777 ret := &GoogleCloudIntegrationsV1alphaValidateIntegrationVersionResponse{
19778 ServerResponse: googleapi.ServerResponse{
19779 Header: res.Header,
19780 HTTPStatusCode: res.StatusCode,
19781 },
19782 }
19783 target := &ret
19784 if err := gensupport.DecodeResponse(target, res); err != nil {
19785 return nil, err
19786 }
19787 return ret, nil
19788
19789
19790
19791
19792
19793
19794
19795
19796
19797
19798
19799
19800
19801
19802
19803
19804
19805
19806
19807
19808
19809
19810
19811
19812
19813
19814
19815
19816
19817 }
19818
19819
19820
19821 type ProjectsLocationsProductsCreateBundleCall struct {
19822 s *Service
19823 parent string
19824 googlecloudintegrationsv1alphacreatebundlerequest *GoogleCloudIntegrationsV1alphaCreateBundleRequest
19825 urlParams_ gensupport.URLParams
19826 ctx_ context.Context
19827 header_ http.Header
19828 }
19829
19830
19831
19832
19833
19834 func (r *ProjectsLocationsProductsService) CreateBundle(parent string, googlecloudintegrationsv1alphacreatebundlerequest *GoogleCloudIntegrationsV1alphaCreateBundleRequest) *ProjectsLocationsProductsCreateBundleCall {
19835 c := &ProjectsLocationsProductsCreateBundleCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19836 c.parent = parent
19837 c.googlecloudintegrationsv1alphacreatebundlerequest = googlecloudintegrationsv1alphacreatebundlerequest
19838 return c
19839 }
19840
19841
19842
19843
19844 func (c *ProjectsLocationsProductsCreateBundleCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsCreateBundleCall {
19845 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19846 return c
19847 }
19848
19849
19850
19851
19852 func (c *ProjectsLocationsProductsCreateBundleCall) Context(ctx context.Context) *ProjectsLocationsProductsCreateBundleCall {
19853 c.ctx_ = ctx
19854 return c
19855 }
19856
19857
19858
19859 func (c *ProjectsLocationsProductsCreateBundleCall) Header() http.Header {
19860 if c.header_ == nil {
19861 c.header_ = make(http.Header)
19862 }
19863 return c.header_
19864 }
19865
19866 func (c *ProjectsLocationsProductsCreateBundleCall) doRequest(alt string) (*http.Response, error) {
19867 reqHeaders := make(http.Header)
19868 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
19869 for k, v := range c.header_ {
19870 reqHeaders[k] = v
19871 }
19872 reqHeaders.Set("User-Agent", c.s.userAgent())
19873 var body io.Reader = nil
19874 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacreatebundlerequest)
19875 if err != nil {
19876 return nil, err
19877 }
19878 reqHeaders.Set("Content-Type", "application/json")
19879 c.urlParams_.Set("alt", alt)
19880 c.urlParams_.Set("prettyPrint", "false")
19881 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}:createBundle")
19882 urls += "?" + c.urlParams_.Encode()
19883 req, err := http.NewRequest("POST", urls, body)
19884 if err != nil {
19885 return nil, err
19886 }
19887 req.Header = reqHeaders
19888 googleapi.Expand(req.URL, map[string]string{
19889 "parent": c.parent,
19890 })
19891 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19892 }
19893
19894
19895
19896
19897
19898
19899
19900
19901
19902
19903 func (c *ProjectsLocationsProductsCreateBundleCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCreateBundleResponse, error) {
19904 gensupport.SetOptions(c.urlParams_, opts...)
19905 res, err := c.doRequest("json")
19906 if res != nil && res.StatusCode == http.StatusNotModified {
19907 if res.Body != nil {
19908 res.Body.Close()
19909 }
19910 return nil, gensupport.WrapError(&googleapi.Error{
19911 Code: res.StatusCode,
19912 Header: res.Header,
19913 })
19914 }
19915 if err != nil {
19916 return nil, err
19917 }
19918 defer googleapi.CloseBody(res)
19919 if err := googleapi.CheckResponse(res); err != nil {
19920 return nil, gensupport.WrapError(err)
19921 }
19922 ret := &GoogleCloudIntegrationsV1alphaCreateBundleResponse{
19923 ServerResponse: googleapi.ServerResponse{
19924 Header: res.Header,
19925 HTTPStatusCode: res.StatusCode,
19926 },
19927 }
19928 target := &ret
19929 if err := gensupport.DecodeResponse(target, res); err != nil {
19930 return nil, err
19931 }
19932 return ret, nil
19933
19934
19935
19936
19937
19938
19939
19940
19941
19942
19943
19944
19945
19946
19947
19948
19949
19950
19951
19952
19953
19954
19955
19956
19957
19958
19959
19960
19961
19962 }
19963
19964
19965
19966 type ProjectsLocationsProductsListTaskEntitiesCall struct {
19967 s *Service
19968 parent string
19969 urlParams_ gensupport.URLParams
19970 ifNoneMatch_ string
19971 ctx_ context.Context
19972 header_ http.Header
19973 }
19974
19975
19976
19977
19978
19979
19980 func (r *ProjectsLocationsProductsService) ListTaskEntities(parent string) *ProjectsLocationsProductsListTaskEntitiesCall {
19981 c := &ProjectsLocationsProductsListTaskEntitiesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19982 c.parent = parent
19983 return c
19984 }
19985
19986
19987
19988
19989 func (c *ProjectsLocationsProductsListTaskEntitiesCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsListTaskEntitiesCall {
19990 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19991 return c
19992 }
19993
19994
19995
19996
19997
19998
19999 func (c *ProjectsLocationsProductsListTaskEntitiesCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsListTaskEntitiesCall {
20000 c.ifNoneMatch_ = entityTag
20001 return c
20002 }
20003
20004
20005
20006
20007 func (c *ProjectsLocationsProductsListTaskEntitiesCall) Context(ctx context.Context) *ProjectsLocationsProductsListTaskEntitiesCall {
20008 c.ctx_ = ctx
20009 return c
20010 }
20011
20012
20013
20014 func (c *ProjectsLocationsProductsListTaskEntitiesCall) Header() http.Header {
20015 if c.header_ == nil {
20016 c.header_ = make(http.Header)
20017 }
20018 return c.header_
20019 }
20020
20021 func (c *ProjectsLocationsProductsListTaskEntitiesCall) doRequest(alt string) (*http.Response, error) {
20022 reqHeaders := make(http.Header)
20023 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
20024 for k, v := range c.header_ {
20025 reqHeaders[k] = v
20026 }
20027 reqHeaders.Set("User-Agent", c.s.userAgent())
20028 if c.ifNoneMatch_ != "" {
20029 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20030 }
20031 var body io.Reader = nil
20032 c.urlParams_.Set("alt", alt)
20033 c.urlParams_.Set("prettyPrint", "false")
20034 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}:listTaskEntities")
20035 urls += "?" + c.urlParams_.Encode()
20036 req, err := http.NewRequest("GET", urls, body)
20037 if err != nil {
20038 return nil, err
20039 }
20040 req.Header = reqHeaders
20041 googleapi.Expand(req.URL, map[string]string{
20042 "parent": c.parent,
20043 })
20044 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20045 }
20046
20047
20048
20049
20050
20051
20052
20053
20054
20055
20056
20057 func (c *ProjectsLocationsProductsListTaskEntitiesCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListTaskEntitiesResponse, error) {
20058 gensupport.SetOptions(c.urlParams_, opts...)
20059 res, err := c.doRequest("json")
20060 if res != nil && res.StatusCode == http.StatusNotModified {
20061 if res.Body != nil {
20062 res.Body.Close()
20063 }
20064 return nil, gensupport.WrapError(&googleapi.Error{
20065 Code: res.StatusCode,
20066 Header: res.Header,
20067 })
20068 }
20069 if err != nil {
20070 return nil, err
20071 }
20072 defer googleapi.CloseBody(res)
20073 if err := googleapi.CheckResponse(res); err != nil {
20074 return nil, gensupport.WrapError(err)
20075 }
20076 ret := &GoogleCloudIntegrationsV1alphaListTaskEntitiesResponse{
20077 ServerResponse: googleapi.ServerResponse{
20078 Header: res.Header,
20079 HTTPStatusCode: res.StatusCode,
20080 },
20081 }
20082 target := &ret
20083 if err := gensupport.DecodeResponse(target, res); err != nil {
20084 return nil, err
20085 }
20086 return ret, nil
20087
20088
20089
20090
20091
20092
20093
20094
20095
20096
20097
20098
20099
20100
20101
20102
20103
20104
20105
20106
20107
20108
20109
20110
20111
20112
20113 }
20114
20115
20116
20117 type ProjectsLocationsProductsAuthConfigsCreateCall struct {
20118 s *Service
20119 parent string
20120 googlecloudintegrationsv1alphaauthconfig *GoogleCloudIntegrationsV1alphaAuthConfig
20121 urlParams_ gensupport.URLParams
20122 ctx_ context.Context
20123 header_ http.Header
20124 }
20125
20126
20127
20128
20129
20130
20131
20132
20133 func (r *ProjectsLocationsProductsAuthConfigsService) Create(parent string, googlecloudintegrationsv1alphaauthconfig *GoogleCloudIntegrationsV1alphaAuthConfig) *ProjectsLocationsProductsAuthConfigsCreateCall {
20134 c := &ProjectsLocationsProductsAuthConfigsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20135 c.parent = parent
20136 c.googlecloudintegrationsv1alphaauthconfig = googlecloudintegrationsv1alphaauthconfig
20137 return c
20138 }
20139
20140
20141
20142
20143
20144
20145
20146
20147
20148
20149
20150
20151
20152
20153
20154
20155
20156
20157 func (c *ProjectsLocationsProductsAuthConfigsCreateCall) ClientCertificateEncryptedPrivateKey(clientCertificateEncryptedPrivateKey string) *ProjectsLocationsProductsAuthConfigsCreateCall {
20158 c.urlParams_.Set("clientCertificate.encryptedPrivateKey", clientCertificateEncryptedPrivateKey)
20159 return c
20160 }
20161
20162
20163
20164
20165
20166
20167 func (c *ProjectsLocationsProductsAuthConfigsCreateCall) ClientCertificatePassphrase(clientCertificatePassphrase string) *ProjectsLocationsProductsAuthConfigsCreateCall {
20168 c.urlParams_.Set("clientCertificate.passphrase", clientCertificatePassphrase)
20169 return c
20170 }
20171
20172
20173
20174
20175
20176
20177
20178
20179
20180
20181
20182
20183
20184
20185
20186
20187
20188
20189 func (c *ProjectsLocationsProductsAuthConfigsCreateCall) ClientCertificateSslCertificate(clientCertificateSslCertificate string) *ProjectsLocationsProductsAuthConfigsCreateCall {
20190 c.urlParams_.Set("clientCertificate.sslCertificate", clientCertificateSslCertificate)
20191 return c
20192 }
20193
20194
20195
20196
20197 func (c *ProjectsLocationsProductsAuthConfigsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsAuthConfigsCreateCall {
20198 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20199 return c
20200 }
20201
20202
20203
20204
20205 func (c *ProjectsLocationsProductsAuthConfigsCreateCall) Context(ctx context.Context) *ProjectsLocationsProductsAuthConfigsCreateCall {
20206 c.ctx_ = ctx
20207 return c
20208 }
20209
20210
20211
20212 func (c *ProjectsLocationsProductsAuthConfigsCreateCall) Header() http.Header {
20213 if c.header_ == nil {
20214 c.header_ = make(http.Header)
20215 }
20216 return c.header_
20217 }
20218
20219 func (c *ProjectsLocationsProductsAuthConfigsCreateCall) doRequest(alt string) (*http.Response, error) {
20220 reqHeaders := make(http.Header)
20221 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
20222 for k, v := range c.header_ {
20223 reqHeaders[k] = v
20224 }
20225 reqHeaders.Set("User-Agent", c.s.userAgent())
20226 var body io.Reader = nil
20227 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaauthconfig)
20228 if err != nil {
20229 return nil, err
20230 }
20231 reqHeaders.Set("Content-Type", "application/json")
20232 c.urlParams_.Set("alt", alt)
20233 c.urlParams_.Set("prettyPrint", "false")
20234 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/authConfigs")
20235 urls += "?" + c.urlParams_.Encode()
20236 req, err := http.NewRequest("POST", urls, body)
20237 if err != nil {
20238 return nil, err
20239 }
20240 req.Header = reqHeaders
20241 googleapi.Expand(req.URL, map[string]string{
20242 "parent": c.parent,
20243 })
20244 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20245 }
20246
20247
20248
20249
20250
20251
20252
20253
20254
20255
20256 func (c *ProjectsLocationsProductsAuthConfigsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaAuthConfig, error) {
20257 gensupport.SetOptions(c.urlParams_, opts...)
20258 res, err := c.doRequest("json")
20259 if res != nil && res.StatusCode == http.StatusNotModified {
20260 if res.Body != nil {
20261 res.Body.Close()
20262 }
20263 return nil, gensupport.WrapError(&googleapi.Error{
20264 Code: res.StatusCode,
20265 Header: res.Header,
20266 })
20267 }
20268 if err != nil {
20269 return nil, err
20270 }
20271 defer googleapi.CloseBody(res)
20272 if err := googleapi.CheckResponse(res); err != nil {
20273 return nil, gensupport.WrapError(err)
20274 }
20275 ret := &GoogleCloudIntegrationsV1alphaAuthConfig{
20276 ServerResponse: googleapi.ServerResponse{
20277 Header: res.Header,
20278 HTTPStatusCode: res.StatusCode,
20279 },
20280 }
20281 target := &ret
20282 if err := gensupport.DecodeResponse(target, res); err != nil {
20283 return nil, err
20284 }
20285 return ret, nil
20286
20287
20288
20289
20290
20291
20292
20293
20294
20295
20296
20297
20298
20299
20300
20301
20302
20303
20304
20305
20306
20307
20308
20309
20310
20311
20312
20313
20314
20315
20316
20317
20318
20319
20320
20321
20322
20323
20324
20325
20326
20327
20328
20329
20330 }
20331
20332
20333
20334 type ProjectsLocationsProductsAuthConfigsDeleteCall struct {
20335 s *Service
20336 name string
20337 urlParams_ gensupport.URLParams
20338 ctx_ context.Context
20339 header_ http.Header
20340 }
20341
20342
20343
20344
20345 func (r *ProjectsLocationsProductsAuthConfigsService) Delete(name string) *ProjectsLocationsProductsAuthConfigsDeleteCall {
20346 c := &ProjectsLocationsProductsAuthConfigsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20347 c.name = name
20348 return c
20349 }
20350
20351
20352
20353
20354 func (c *ProjectsLocationsProductsAuthConfigsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsAuthConfigsDeleteCall {
20355 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20356 return c
20357 }
20358
20359
20360
20361
20362 func (c *ProjectsLocationsProductsAuthConfigsDeleteCall) Context(ctx context.Context) *ProjectsLocationsProductsAuthConfigsDeleteCall {
20363 c.ctx_ = ctx
20364 return c
20365 }
20366
20367
20368
20369 func (c *ProjectsLocationsProductsAuthConfigsDeleteCall) Header() http.Header {
20370 if c.header_ == nil {
20371 c.header_ = make(http.Header)
20372 }
20373 return c.header_
20374 }
20375
20376 func (c *ProjectsLocationsProductsAuthConfigsDeleteCall) doRequest(alt string) (*http.Response, error) {
20377 reqHeaders := make(http.Header)
20378 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
20379 for k, v := range c.header_ {
20380 reqHeaders[k] = v
20381 }
20382 reqHeaders.Set("User-Agent", c.s.userAgent())
20383 var body io.Reader = nil
20384 c.urlParams_.Set("alt", alt)
20385 c.urlParams_.Set("prettyPrint", "false")
20386 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
20387 urls += "?" + c.urlParams_.Encode()
20388 req, err := http.NewRequest("DELETE", urls, body)
20389 if err != nil {
20390 return nil, err
20391 }
20392 req.Header = reqHeaders
20393 googleapi.Expand(req.URL, map[string]string{
20394 "name": c.name,
20395 })
20396 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20397 }
20398
20399
20400
20401
20402
20403
20404
20405
20406 func (c *ProjectsLocationsProductsAuthConfigsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
20407 gensupport.SetOptions(c.urlParams_, opts...)
20408 res, err := c.doRequest("json")
20409 if res != nil && res.StatusCode == http.StatusNotModified {
20410 if res.Body != nil {
20411 res.Body.Close()
20412 }
20413 return nil, gensupport.WrapError(&googleapi.Error{
20414 Code: res.StatusCode,
20415 Header: res.Header,
20416 })
20417 }
20418 if err != nil {
20419 return nil, err
20420 }
20421 defer googleapi.CloseBody(res)
20422 if err := googleapi.CheckResponse(res); err != nil {
20423 return nil, gensupport.WrapError(err)
20424 }
20425 ret := &GoogleProtobufEmpty{
20426 ServerResponse: googleapi.ServerResponse{
20427 Header: res.Header,
20428 HTTPStatusCode: res.StatusCode,
20429 },
20430 }
20431 target := &ret
20432 if err := gensupport.DecodeResponse(target, res); err != nil {
20433 return nil, err
20434 }
20435 return ret, nil
20436
20437
20438
20439
20440
20441
20442
20443
20444
20445
20446
20447
20448
20449
20450
20451
20452
20453
20454
20455
20456
20457
20458
20459
20460
20461
20462 }
20463
20464
20465
20466 type ProjectsLocationsProductsAuthConfigsGetCall struct {
20467 s *Service
20468 name string
20469 urlParams_ gensupport.URLParams
20470 ifNoneMatch_ string
20471 ctx_ context.Context
20472 header_ http.Header
20473 }
20474
20475
20476
20477
20478
20479
20480 func (r *ProjectsLocationsProductsAuthConfigsService) Get(name string) *ProjectsLocationsProductsAuthConfigsGetCall {
20481 c := &ProjectsLocationsProductsAuthConfigsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20482 c.name = name
20483 return c
20484 }
20485
20486
20487
20488
20489 func (c *ProjectsLocationsProductsAuthConfigsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsAuthConfigsGetCall {
20490 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20491 return c
20492 }
20493
20494
20495
20496
20497
20498
20499 func (c *ProjectsLocationsProductsAuthConfigsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsAuthConfigsGetCall {
20500 c.ifNoneMatch_ = entityTag
20501 return c
20502 }
20503
20504
20505
20506
20507 func (c *ProjectsLocationsProductsAuthConfigsGetCall) Context(ctx context.Context) *ProjectsLocationsProductsAuthConfigsGetCall {
20508 c.ctx_ = ctx
20509 return c
20510 }
20511
20512
20513
20514 func (c *ProjectsLocationsProductsAuthConfigsGetCall) Header() http.Header {
20515 if c.header_ == nil {
20516 c.header_ = make(http.Header)
20517 }
20518 return c.header_
20519 }
20520
20521 func (c *ProjectsLocationsProductsAuthConfigsGetCall) doRequest(alt string) (*http.Response, error) {
20522 reqHeaders := make(http.Header)
20523 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
20524 for k, v := range c.header_ {
20525 reqHeaders[k] = v
20526 }
20527 reqHeaders.Set("User-Agent", c.s.userAgent())
20528 if c.ifNoneMatch_ != "" {
20529 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20530 }
20531 var body io.Reader = nil
20532 c.urlParams_.Set("alt", alt)
20533 c.urlParams_.Set("prettyPrint", "false")
20534 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
20535 urls += "?" + c.urlParams_.Encode()
20536 req, err := http.NewRequest("GET", urls, body)
20537 if err != nil {
20538 return nil, err
20539 }
20540 req.Header = reqHeaders
20541 googleapi.Expand(req.URL, map[string]string{
20542 "name": c.name,
20543 })
20544 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20545 }
20546
20547
20548
20549
20550
20551
20552
20553
20554
20555
20556 func (c *ProjectsLocationsProductsAuthConfigsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaAuthConfig, error) {
20557 gensupport.SetOptions(c.urlParams_, opts...)
20558 res, err := c.doRequest("json")
20559 if res != nil && res.StatusCode == http.StatusNotModified {
20560 if res.Body != nil {
20561 res.Body.Close()
20562 }
20563 return nil, gensupport.WrapError(&googleapi.Error{
20564 Code: res.StatusCode,
20565 Header: res.Header,
20566 })
20567 }
20568 if err != nil {
20569 return nil, err
20570 }
20571 defer googleapi.CloseBody(res)
20572 if err := googleapi.CheckResponse(res); err != nil {
20573 return nil, gensupport.WrapError(err)
20574 }
20575 ret := &GoogleCloudIntegrationsV1alphaAuthConfig{
20576 ServerResponse: googleapi.ServerResponse{
20577 Header: res.Header,
20578 HTTPStatusCode: res.StatusCode,
20579 },
20580 }
20581 target := &ret
20582 if err := gensupport.DecodeResponse(target, res); err != nil {
20583 return nil, err
20584 }
20585 return ret, nil
20586
20587
20588
20589
20590
20591
20592
20593
20594
20595
20596
20597
20598
20599
20600
20601
20602
20603
20604
20605
20606
20607
20608
20609
20610
20611
20612 }
20613
20614
20615
20616 type ProjectsLocationsProductsAuthConfigsListCall struct {
20617 s *Service
20618 parent string
20619 urlParams_ gensupport.URLParams
20620 ifNoneMatch_ string
20621 ctx_ context.Context
20622 header_ http.Header
20623 }
20624
20625
20626
20627
20628
20629 func (r *ProjectsLocationsProductsAuthConfigsService) List(parent string) *ProjectsLocationsProductsAuthConfigsListCall {
20630 c := &ProjectsLocationsProductsAuthConfigsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20631 c.parent = parent
20632 return c
20633 }
20634
20635
20636
20637
20638 func (c *ProjectsLocationsProductsAuthConfigsListCall) Filter(filter string) *ProjectsLocationsProductsAuthConfigsListCall {
20639 c.urlParams_.Set("filter", filter)
20640 return c
20641 }
20642
20643
20644
20645 func (c *ProjectsLocationsProductsAuthConfigsListCall) PageSize(pageSize int64) *ProjectsLocationsProductsAuthConfigsListCall {
20646 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
20647 return c
20648 }
20649
20650
20651
20652 func (c *ProjectsLocationsProductsAuthConfigsListCall) PageToken(pageToken string) *ProjectsLocationsProductsAuthConfigsListCall {
20653 c.urlParams_.Set("pageToken", pageToken)
20654 return c
20655 }
20656
20657
20658
20659
20660 func (c *ProjectsLocationsProductsAuthConfigsListCall) ReadMask(readMask string) *ProjectsLocationsProductsAuthConfigsListCall {
20661 c.urlParams_.Set("readMask", readMask)
20662 return c
20663 }
20664
20665
20666
20667
20668 func (c *ProjectsLocationsProductsAuthConfigsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsAuthConfigsListCall {
20669 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20670 return c
20671 }
20672
20673
20674
20675
20676
20677
20678 func (c *ProjectsLocationsProductsAuthConfigsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsAuthConfigsListCall {
20679 c.ifNoneMatch_ = entityTag
20680 return c
20681 }
20682
20683
20684
20685
20686 func (c *ProjectsLocationsProductsAuthConfigsListCall) Context(ctx context.Context) *ProjectsLocationsProductsAuthConfigsListCall {
20687 c.ctx_ = ctx
20688 return c
20689 }
20690
20691
20692
20693 func (c *ProjectsLocationsProductsAuthConfigsListCall) Header() http.Header {
20694 if c.header_ == nil {
20695 c.header_ = make(http.Header)
20696 }
20697 return c.header_
20698 }
20699
20700 func (c *ProjectsLocationsProductsAuthConfigsListCall) doRequest(alt string) (*http.Response, error) {
20701 reqHeaders := make(http.Header)
20702 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
20703 for k, v := range c.header_ {
20704 reqHeaders[k] = v
20705 }
20706 reqHeaders.Set("User-Agent", c.s.userAgent())
20707 if c.ifNoneMatch_ != "" {
20708 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20709 }
20710 var body io.Reader = nil
20711 c.urlParams_.Set("alt", alt)
20712 c.urlParams_.Set("prettyPrint", "false")
20713 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/authConfigs")
20714 urls += "?" + c.urlParams_.Encode()
20715 req, err := http.NewRequest("GET", urls, body)
20716 if err != nil {
20717 return nil, err
20718 }
20719 req.Header = reqHeaders
20720 googleapi.Expand(req.URL, map[string]string{
20721 "parent": c.parent,
20722 })
20723 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20724 }
20725
20726
20727
20728
20729
20730
20731
20732
20733
20734
20735 func (c *ProjectsLocationsProductsAuthConfigsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListAuthConfigsResponse, error) {
20736 gensupport.SetOptions(c.urlParams_, opts...)
20737 res, err := c.doRequest("json")
20738 if res != nil && res.StatusCode == http.StatusNotModified {
20739 if res.Body != nil {
20740 res.Body.Close()
20741 }
20742 return nil, gensupport.WrapError(&googleapi.Error{
20743 Code: res.StatusCode,
20744 Header: res.Header,
20745 })
20746 }
20747 if err != nil {
20748 return nil, err
20749 }
20750 defer googleapi.CloseBody(res)
20751 if err := googleapi.CheckResponse(res); err != nil {
20752 return nil, gensupport.WrapError(err)
20753 }
20754 ret := &GoogleCloudIntegrationsV1alphaListAuthConfigsResponse{
20755 ServerResponse: googleapi.ServerResponse{
20756 Header: res.Header,
20757 HTTPStatusCode: res.StatusCode,
20758 },
20759 }
20760 target := &ret
20761 if err := gensupport.DecodeResponse(target, res); err != nil {
20762 return nil, err
20763 }
20764 return ret, nil
20765
20766
20767
20768
20769
20770
20771
20772
20773
20774
20775
20776
20777
20778
20779
20780
20781
20782
20783
20784
20785
20786
20787
20788
20789
20790
20791
20792
20793
20794
20795
20796
20797
20798
20799
20800
20801
20802
20803
20804
20805
20806
20807
20808
20809
20810
20811
20812
20813 }
20814
20815
20816
20817
20818 func (c *ProjectsLocationsProductsAuthConfigsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListAuthConfigsResponse) error) error {
20819 c.ctx_ = ctx
20820 defer c.PageToken(c.urlParams_.Get("pageToken"))
20821 for {
20822 x, err := c.Do()
20823 if err != nil {
20824 return err
20825 }
20826 if err := f(x); err != nil {
20827 return err
20828 }
20829 if x.NextPageToken == "" {
20830 return nil
20831 }
20832 c.PageToken(x.NextPageToken)
20833 }
20834 }
20835
20836
20837
20838 type ProjectsLocationsProductsAuthConfigsPatchCall struct {
20839 s *Service
20840 name string
20841 googlecloudintegrationsv1alphaauthconfig *GoogleCloudIntegrationsV1alphaAuthConfig
20842 urlParams_ gensupport.URLParams
20843 ctx_ context.Context
20844 header_ http.Header
20845 }
20846
20847
20848
20849
20850
20851
20852
20853
20854
20855 func (r *ProjectsLocationsProductsAuthConfigsService) Patch(name string, googlecloudintegrationsv1alphaauthconfig *GoogleCloudIntegrationsV1alphaAuthConfig) *ProjectsLocationsProductsAuthConfigsPatchCall {
20856 c := &ProjectsLocationsProductsAuthConfigsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20857 c.name = name
20858 c.googlecloudintegrationsv1alphaauthconfig = googlecloudintegrationsv1alphaauthconfig
20859 return c
20860 }
20861
20862
20863
20864
20865
20866
20867
20868
20869
20870
20871
20872
20873
20874
20875
20876
20877
20878
20879 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) ClientCertificateEncryptedPrivateKey(clientCertificateEncryptedPrivateKey string) *ProjectsLocationsProductsAuthConfigsPatchCall {
20880 c.urlParams_.Set("clientCertificate.encryptedPrivateKey", clientCertificateEncryptedPrivateKey)
20881 return c
20882 }
20883
20884
20885
20886
20887
20888
20889 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) ClientCertificatePassphrase(clientCertificatePassphrase string) *ProjectsLocationsProductsAuthConfigsPatchCall {
20890 c.urlParams_.Set("clientCertificate.passphrase", clientCertificatePassphrase)
20891 return c
20892 }
20893
20894
20895
20896
20897
20898
20899
20900
20901
20902
20903
20904
20905
20906
20907
20908
20909
20910
20911 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) ClientCertificateSslCertificate(clientCertificateSslCertificate string) *ProjectsLocationsProductsAuthConfigsPatchCall {
20912 c.urlParams_.Set("clientCertificate.sslCertificate", clientCertificateSslCertificate)
20913 return c
20914 }
20915
20916
20917
20918
20919 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsProductsAuthConfigsPatchCall {
20920 c.urlParams_.Set("updateMask", updateMask)
20921 return c
20922 }
20923
20924
20925
20926
20927 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsAuthConfigsPatchCall {
20928 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20929 return c
20930 }
20931
20932
20933
20934
20935 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) Context(ctx context.Context) *ProjectsLocationsProductsAuthConfigsPatchCall {
20936 c.ctx_ = ctx
20937 return c
20938 }
20939
20940
20941
20942 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) Header() http.Header {
20943 if c.header_ == nil {
20944 c.header_ = make(http.Header)
20945 }
20946 return c.header_
20947 }
20948
20949 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) doRequest(alt string) (*http.Response, error) {
20950 reqHeaders := make(http.Header)
20951 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
20952 for k, v := range c.header_ {
20953 reqHeaders[k] = v
20954 }
20955 reqHeaders.Set("User-Agent", c.s.userAgent())
20956 var body io.Reader = nil
20957 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaauthconfig)
20958 if err != nil {
20959 return nil, err
20960 }
20961 reqHeaders.Set("Content-Type", "application/json")
20962 c.urlParams_.Set("alt", alt)
20963 c.urlParams_.Set("prettyPrint", "false")
20964 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
20965 urls += "?" + c.urlParams_.Encode()
20966 req, err := http.NewRequest("PATCH", urls, body)
20967 if err != nil {
20968 return nil, err
20969 }
20970 req.Header = reqHeaders
20971 googleapi.Expand(req.URL, map[string]string{
20972 "name": c.name,
20973 })
20974 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20975 }
20976
20977
20978
20979
20980
20981
20982
20983
20984
20985
20986 func (c *ProjectsLocationsProductsAuthConfigsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaAuthConfig, error) {
20987 gensupport.SetOptions(c.urlParams_, opts...)
20988 res, err := c.doRequest("json")
20989 if res != nil && res.StatusCode == http.StatusNotModified {
20990 if res.Body != nil {
20991 res.Body.Close()
20992 }
20993 return nil, gensupport.WrapError(&googleapi.Error{
20994 Code: res.StatusCode,
20995 Header: res.Header,
20996 })
20997 }
20998 if err != nil {
20999 return nil, err
21000 }
21001 defer googleapi.CloseBody(res)
21002 if err := googleapi.CheckResponse(res); err != nil {
21003 return nil, gensupport.WrapError(err)
21004 }
21005 ret := &GoogleCloudIntegrationsV1alphaAuthConfig{
21006 ServerResponse: googleapi.ServerResponse{
21007 Header: res.Header,
21008 HTTPStatusCode: res.StatusCode,
21009 },
21010 }
21011 target := &ret
21012 if err := gensupport.DecodeResponse(target, res); err != nil {
21013 return nil, err
21014 }
21015 return ret, nil
21016
21017
21018
21019
21020
21021
21022
21023
21024
21025
21026
21027
21028
21029
21030
21031
21032
21033
21034
21035
21036
21037
21038
21039
21040
21041
21042
21043
21044
21045
21046
21047
21048
21049
21050
21051
21052
21053
21054
21055
21056
21057
21058
21059
21060
21061
21062
21063
21064
21065
21066 }
21067
21068
21069
21070 type ProjectsLocationsProductsCertificatesCreateCall struct {
21071 s *Service
21072 parent string
21073 googlecloudintegrationsv1alphacertificate *GoogleCloudIntegrationsV1alphaCertificate
21074 urlParams_ gensupport.URLParams
21075 ctx_ context.Context
21076 header_ http.Header
21077 }
21078
21079
21080
21081
21082
21083
21084 func (r *ProjectsLocationsProductsCertificatesService) Create(parent string, googlecloudintegrationsv1alphacertificate *GoogleCloudIntegrationsV1alphaCertificate) *ProjectsLocationsProductsCertificatesCreateCall {
21085 c := &ProjectsLocationsProductsCertificatesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21086 c.parent = parent
21087 c.googlecloudintegrationsv1alphacertificate = googlecloudintegrationsv1alphacertificate
21088 return c
21089 }
21090
21091
21092
21093
21094 func (c *ProjectsLocationsProductsCertificatesCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsCertificatesCreateCall {
21095 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21096 return c
21097 }
21098
21099
21100
21101
21102 func (c *ProjectsLocationsProductsCertificatesCreateCall) Context(ctx context.Context) *ProjectsLocationsProductsCertificatesCreateCall {
21103 c.ctx_ = ctx
21104 return c
21105 }
21106
21107
21108
21109 func (c *ProjectsLocationsProductsCertificatesCreateCall) Header() http.Header {
21110 if c.header_ == nil {
21111 c.header_ = make(http.Header)
21112 }
21113 return c.header_
21114 }
21115
21116 func (c *ProjectsLocationsProductsCertificatesCreateCall) doRequest(alt string) (*http.Response, error) {
21117 reqHeaders := make(http.Header)
21118 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
21119 for k, v := range c.header_ {
21120 reqHeaders[k] = v
21121 }
21122 reqHeaders.Set("User-Agent", c.s.userAgent())
21123 var body io.Reader = nil
21124 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacertificate)
21125 if err != nil {
21126 return nil, err
21127 }
21128 reqHeaders.Set("Content-Type", "application/json")
21129 c.urlParams_.Set("alt", alt)
21130 c.urlParams_.Set("prettyPrint", "false")
21131 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/certificates")
21132 urls += "?" + c.urlParams_.Encode()
21133 req, err := http.NewRequest("POST", urls, body)
21134 if err != nil {
21135 return nil, err
21136 }
21137 req.Header = reqHeaders
21138 googleapi.Expand(req.URL, map[string]string{
21139 "parent": c.parent,
21140 })
21141 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21142 }
21143
21144
21145
21146
21147
21148
21149
21150
21151
21152
21153 func (c *ProjectsLocationsProductsCertificatesCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCertificate, error) {
21154 gensupport.SetOptions(c.urlParams_, opts...)
21155 res, err := c.doRequest("json")
21156 if res != nil && res.StatusCode == http.StatusNotModified {
21157 if res.Body != nil {
21158 res.Body.Close()
21159 }
21160 return nil, gensupport.WrapError(&googleapi.Error{
21161 Code: res.StatusCode,
21162 Header: res.Header,
21163 })
21164 }
21165 if err != nil {
21166 return nil, err
21167 }
21168 defer googleapi.CloseBody(res)
21169 if err := googleapi.CheckResponse(res); err != nil {
21170 return nil, gensupport.WrapError(err)
21171 }
21172 ret := &GoogleCloudIntegrationsV1alphaCertificate{
21173 ServerResponse: googleapi.ServerResponse{
21174 Header: res.Header,
21175 HTTPStatusCode: res.StatusCode,
21176 },
21177 }
21178 target := &ret
21179 if err := gensupport.DecodeResponse(target, res); err != nil {
21180 return nil, err
21181 }
21182 return ret, nil
21183
21184
21185
21186
21187
21188
21189
21190
21191
21192
21193
21194
21195
21196
21197
21198
21199
21200
21201
21202
21203
21204
21205
21206
21207
21208
21209
21210
21211
21212 }
21213
21214
21215
21216 type ProjectsLocationsProductsCertificatesDeleteCall struct {
21217 s *Service
21218 name string
21219 urlParams_ gensupport.URLParams
21220 ctx_ context.Context
21221 header_ http.Header
21222 }
21223
21224
21225
21226
21227 func (r *ProjectsLocationsProductsCertificatesService) Delete(name string) *ProjectsLocationsProductsCertificatesDeleteCall {
21228 c := &ProjectsLocationsProductsCertificatesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21229 c.name = name
21230 return c
21231 }
21232
21233
21234
21235
21236 func (c *ProjectsLocationsProductsCertificatesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsCertificatesDeleteCall {
21237 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21238 return c
21239 }
21240
21241
21242
21243
21244 func (c *ProjectsLocationsProductsCertificatesDeleteCall) Context(ctx context.Context) *ProjectsLocationsProductsCertificatesDeleteCall {
21245 c.ctx_ = ctx
21246 return c
21247 }
21248
21249
21250
21251 func (c *ProjectsLocationsProductsCertificatesDeleteCall) Header() http.Header {
21252 if c.header_ == nil {
21253 c.header_ = make(http.Header)
21254 }
21255 return c.header_
21256 }
21257
21258 func (c *ProjectsLocationsProductsCertificatesDeleteCall) doRequest(alt string) (*http.Response, error) {
21259 reqHeaders := make(http.Header)
21260 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
21261 for k, v := range c.header_ {
21262 reqHeaders[k] = v
21263 }
21264 reqHeaders.Set("User-Agent", c.s.userAgent())
21265 var body io.Reader = nil
21266 c.urlParams_.Set("alt", alt)
21267 c.urlParams_.Set("prettyPrint", "false")
21268 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
21269 urls += "?" + c.urlParams_.Encode()
21270 req, err := http.NewRequest("DELETE", urls, body)
21271 if err != nil {
21272 return nil, err
21273 }
21274 req.Header = reqHeaders
21275 googleapi.Expand(req.URL, map[string]string{
21276 "name": c.name,
21277 })
21278 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21279 }
21280
21281
21282
21283
21284
21285
21286
21287
21288 func (c *ProjectsLocationsProductsCertificatesDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
21289 gensupport.SetOptions(c.urlParams_, opts...)
21290 res, err := c.doRequest("json")
21291 if res != nil && res.StatusCode == http.StatusNotModified {
21292 if res.Body != nil {
21293 res.Body.Close()
21294 }
21295 return nil, gensupport.WrapError(&googleapi.Error{
21296 Code: res.StatusCode,
21297 Header: res.Header,
21298 })
21299 }
21300 if err != nil {
21301 return nil, err
21302 }
21303 defer googleapi.CloseBody(res)
21304 if err := googleapi.CheckResponse(res); err != nil {
21305 return nil, gensupport.WrapError(err)
21306 }
21307 ret := &GoogleProtobufEmpty{
21308 ServerResponse: googleapi.ServerResponse{
21309 Header: res.Header,
21310 HTTPStatusCode: res.StatusCode,
21311 },
21312 }
21313 target := &ret
21314 if err := gensupport.DecodeResponse(target, res); err != nil {
21315 return nil, err
21316 }
21317 return ret, nil
21318
21319
21320
21321
21322
21323
21324
21325
21326
21327
21328
21329
21330
21331
21332
21333
21334
21335
21336
21337
21338
21339
21340
21341
21342
21343
21344 }
21345
21346
21347
21348 type ProjectsLocationsProductsCertificatesGetCall struct {
21349 s *Service
21350 name string
21351 urlParams_ gensupport.URLParams
21352 ifNoneMatch_ string
21353 ctx_ context.Context
21354 header_ http.Header
21355 }
21356
21357
21358
21359
21360
21361 func (r *ProjectsLocationsProductsCertificatesService) Get(name string) *ProjectsLocationsProductsCertificatesGetCall {
21362 c := &ProjectsLocationsProductsCertificatesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21363 c.name = name
21364 return c
21365 }
21366
21367
21368
21369
21370 func (c *ProjectsLocationsProductsCertificatesGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsCertificatesGetCall {
21371 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21372 return c
21373 }
21374
21375
21376
21377
21378
21379
21380 func (c *ProjectsLocationsProductsCertificatesGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsCertificatesGetCall {
21381 c.ifNoneMatch_ = entityTag
21382 return c
21383 }
21384
21385
21386
21387
21388 func (c *ProjectsLocationsProductsCertificatesGetCall) Context(ctx context.Context) *ProjectsLocationsProductsCertificatesGetCall {
21389 c.ctx_ = ctx
21390 return c
21391 }
21392
21393
21394
21395 func (c *ProjectsLocationsProductsCertificatesGetCall) Header() http.Header {
21396 if c.header_ == nil {
21397 c.header_ = make(http.Header)
21398 }
21399 return c.header_
21400 }
21401
21402 func (c *ProjectsLocationsProductsCertificatesGetCall) doRequest(alt string) (*http.Response, error) {
21403 reqHeaders := make(http.Header)
21404 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
21405 for k, v := range c.header_ {
21406 reqHeaders[k] = v
21407 }
21408 reqHeaders.Set("User-Agent", c.s.userAgent())
21409 if c.ifNoneMatch_ != "" {
21410 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
21411 }
21412 var body io.Reader = nil
21413 c.urlParams_.Set("alt", alt)
21414 c.urlParams_.Set("prettyPrint", "false")
21415 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
21416 urls += "?" + c.urlParams_.Encode()
21417 req, err := http.NewRequest("GET", urls, body)
21418 if err != nil {
21419 return nil, err
21420 }
21421 req.Header = reqHeaders
21422 googleapi.Expand(req.URL, map[string]string{
21423 "name": c.name,
21424 })
21425 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21426 }
21427
21428
21429
21430
21431
21432
21433
21434
21435
21436
21437 func (c *ProjectsLocationsProductsCertificatesGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCertificate, error) {
21438 gensupport.SetOptions(c.urlParams_, opts...)
21439 res, err := c.doRequest("json")
21440 if res != nil && res.StatusCode == http.StatusNotModified {
21441 if res.Body != nil {
21442 res.Body.Close()
21443 }
21444 return nil, gensupport.WrapError(&googleapi.Error{
21445 Code: res.StatusCode,
21446 Header: res.Header,
21447 })
21448 }
21449 if err != nil {
21450 return nil, err
21451 }
21452 defer googleapi.CloseBody(res)
21453 if err := googleapi.CheckResponse(res); err != nil {
21454 return nil, gensupport.WrapError(err)
21455 }
21456 ret := &GoogleCloudIntegrationsV1alphaCertificate{
21457 ServerResponse: googleapi.ServerResponse{
21458 Header: res.Header,
21459 HTTPStatusCode: res.StatusCode,
21460 },
21461 }
21462 target := &ret
21463 if err := gensupport.DecodeResponse(target, res); err != nil {
21464 return nil, err
21465 }
21466 return ret, nil
21467
21468
21469
21470
21471
21472
21473
21474
21475
21476
21477
21478
21479
21480
21481
21482
21483
21484
21485
21486
21487
21488
21489
21490
21491
21492
21493 }
21494
21495
21496
21497 type ProjectsLocationsProductsCertificatesListCall struct {
21498 s *Service
21499 parent string
21500 urlParams_ gensupport.URLParams
21501 ifNoneMatch_ string
21502 ctx_ context.Context
21503 header_ http.Header
21504 }
21505
21506
21507
21508
21509
21510 func (r *ProjectsLocationsProductsCertificatesService) List(parent string) *ProjectsLocationsProductsCertificatesListCall {
21511 c := &ProjectsLocationsProductsCertificatesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21512 c.parent = parent
21513 return c
21514 }
21515
21516
21517
21518
21519 func (c *ProjectsLocationsProductsCertificatesListCall) Filter(filter string) *ProjectsLocationsProductsCertificatesListCall {
21520 c.urlParams_.Set("filter", filter)
21521 return c
21522 }
21523
21524
21525
21526 func (c *ProjectsLocationsProductsCertificatesListCall) PageSize(pageSize int64) *ProjectsLocationsProductsCertificatesListCall {
21527 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
21528 return c
21529 }
21530
21531
21532
21533 func (c *ProjectsLocationsProductsCertificatesListCall) PageToken(pageToken string) *ProjectsLocationsProductsCertificatesListCall {
21534 c.urlParams_.Set("pageToken", pageToken)
21535 return c
21536 }
21537
21538
21539
21540
21541 func (c *ProjectsLocationsProductsCertificatesListCall) ReadMask(readMask string) *ProjectsLocationsProductsCertificatesListCall {
21542 c.urlParams_.Set("readMask", readMask)
21543 return c
21544 }
21545
21546
21547
21548
21549 func (c *ProjectsLocationsProductsCertificatesListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsCertificatesListCall {
21550 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21551 return c
21552 }
21553
21554
21555
21556
21557
21558
21559 func (c *ProjectsLocationsProductsCertificatesListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsCertificatesListCall {
21560 c.ifNoneMatch_ = entityTag
21561 return c
21562 }
21563
21564
21565
21566
21567 func (c *ProjectsLocationsProductsCertificatesListCall) Context(ctx context.Context) *ProjectsLocationsProductsCertificatesListCall {
21568 c.ctx_ = ctx
21569 return c
21570 }
21571
21572
21573
21574 func (c *ProjectsLocationsProductsCertificatesListCall) Header() http.Header {
21575 if c.header_ == nil {
21576 c.header_ = make(http.Header)
21577 }
21578 return c.header_
21579 }
21580
21581 func (c *ProjectsLocationsProductsCertificatesListCall) doRequest(alt string) (*http.Response, error) {
21582 reqHeaders := make(http.Header)
21583 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
21584 for k, v := range c.header_ {
21585 reqHeaders[k] = v
21586 }
21587 reqHeaders.Set("User-Agent", c.s.userAgent())
21588 if c.ifNoneMatch_ != "" {
21589 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
21590 }
21591 var body io.Reader = nil
21592 c.urlParams_.Set("alt", alt)
21593 c.urlParams_.Set("prettyPrint", "false")
21594 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/certificates")
21595 urls += "?" + c.urlParams_.Encode()
21596 req, err := http.NewRequest("GET", urls, body)
21597 if err != nil {
21598 return nil, err
21599 }
21600 req.Header = reqHeaders
21601 googleapi.Expand(req.URL, map[string]string{
21602 "parent": c.parent,
21603 })
21604 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21605 }
21606
21607
21608
21609
21610
21611
21612
21613
21614
21615
21616
21617 func (c *ProjectsLocationsProductsCertificatesListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListCertificatesResponse, error) {
21618 gensupport.SetOptions(c.urlParams_, opts...)
21619 res, err := c.doRequest("json")
21620 if res != nil && res.StatusCode == http.StatusNotModified {
21621 if res.Body != nil {
21622 res.Body.Close()
21623 }
21624 return nil, gensupport.WrapError(&googleapi.Error{
21625 Code: res.StatusCode,
21626 Header: res.Header,
21627 })
21628 }
21629 if err != nil {
21630 return nil, err
21631 }
21632 defer googleapi.CloseBody(res)
21633 if err := googleapi.CheckResponse(res); err != nil {
21634 return nil, gensupport.WrapError(err)
21635 }
21636 ret := &GoogleCloudIntegrationsV1alphaListCertificatesResponse{
21637 ServerResponse: googleapi.ServerResponse{
21638 Header: res.Header,
21639 HTTPStatusCode: res.StatusCode,
21640 },
21641 }
21642 target := &ret
21643 if err := gensupport.DecodeResponse(target, res); err != nil {
21644 return nil, err
21645 }
21646 return ret, nil
21647
21648
21649
21650
21651
21652
21653
21654
21655
21656
21657
21658
21659
21660
21661
21662
21663
21664
21665
21666
21667
21668
21669
21670
21671
21672
21673
21674
21675
21676
21677
21678
21679
21680
21681
21682
21683
21684
21685
21686
21687
21688
21689
21690
21691
21692
21693
21694
21695 }
21696
21697
21698
21699
21700 func (c *ProjectsLocationsProductsCertificatesListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListCertificatesResponse) error) error {
21701 c.ctx_ = ctx
21702 defer c.PageToken(c.urlParams_.Get("pageToken"))
21703 for {
21704 x, err := c.Do()
21705 if err != nil {
21706 return err
21707 }
21708 if err := f(x); err != nil {
21709 return err
21710 }
21711 if x.NextPageToken == "" {
21712 return nil
21713 }
21714 c.PageToken(x.NextPageToken)
21715 }
21716 }
21717
21718
21719
21720 type ProjectsLocationsProductsCertificatesPatchCall struct {
21721 s *Service
21722 name string
21723 googlecloudintegrationsv1alphacertificate *GoogleCloudIntegrationsV1alphaCertificate
21724 urlParams_ gensupport.URLParams
21725 ctx_ context.Context
21726 header_ http.Header
21727 }
21728
21729
21730
21731
21732
21733
21734
21735 func (r *ProjectsLocationsProductsCertificatesService) Patch(name string, googlecloudintegrationsv1alphacertificate *GoogleCloudIntegrationsV1alphaCertificate) *ProjectsLocationsProductsCertificatesPatchCall {
21736 c := &ProjectsLocationsProductsCertificatesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21737 c.name = name
21738 c.googlecloudintegrationsv1alphacertificate = googlecloudintegrationsv1alphacertificate
21739 return c
21740 }
21741
21742
21743
21744
21745 func (c *ProjectsLocationsProductsCertificatesPatchCall) UpdateMask(updateMask string) *ProjectsLocationsProductsCertificatesPatchCall {
21746 c.urlParams_.Set("updateMask", updateMask)
21747 return c
21748 }
21749
21750
21751
21752
21753 func (c *ProjectsLocationsProductsCertificatesPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsCertificatesPatchCall {
21754 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21755 return c
21756 }
21757
21758
21759
21760
21761 func (c *ProjectsLocationsProductsCertificatesPatchCall) Context(ctx context.Context) *ProjectsLocationsProductsCertificatesPatchCall {
21762 c.ctx_ = ctx
21763 return c
21764 }
21765
21766
21767
21768 func (c *ProjectsLocationsProductsCertificatesPatchCall) Header() http.Header {
21769 if c.header_ == nil {
21770 c.header_ = make(http.Header)
21771 }
21772 return c.header_
21773 }
21774
21775 func (c *ProjectsLocationsProductsCertificatesPatchCall) doRequest(alt string) (*http.Response, error) {
21776 reqHeaders := make(http.Header)
21777 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
21778 for k, v := range c.header_ {
21779 reqHeaders[k] = v
21780 }
21781 reqHeaders.Set("User-Agent", c.s.userAgent())
21782 var body io.Reader = nil
21783 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacertificate)
21784 if err != nil {
21785 return nil, err
21786 }
21787 reqHeaders.Set("Content-Type", "application/json")
21788 c.urlParams_.Set("alt", alt)
21789 c.urlParams_.Set("prettyPrint", "false")
21790 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
21791 urls += "?" + c.urlParams_.Encode()
21792 req, err := http.NewRequest("PATCH", urls, body)
21793 if err != nil {
21794 return nil, err
21795 }
21796 req.Header = reqHeaders
21797 googleapi.Expand(req.URL, map[string]string{
21798 "name": c.name,
21799 })
21800 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21801 }
21802
21803
21804
21805
21806
21807
21808
21809
21810
21811
21812 func (c *ProjectsLocationsProductsCertificatesPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCertificate, error) {
21813 gensupport.SetOptions(c.urlParams_, opts...)
21814 res, err := c.doRequest("json")
21815 if res != nil && res.StatusCode == http.StatusNotModified {
21816 if res.Body != nil {
21817 res.Body.Close()
21818 }
21819 return nil, gensupport.WrapError(&googleapi.Error{
21820 Code: res.StatusCode,
21821 Header: res.Header,
21822 })
21823 }
21824 if err != nil {
21825 return nil, err
21826 }
21827 defer googleapi.CloseBody(res)
21828 if err := googleapi.CheckResponse(res); err != nil {
21829 return nil, gensupport.WrapError(err)
21830 }
21831 ret := &GoogleCloudIntegrationsV1alphaCertificate{
21832 ServerResponse: googleapi.ServerResponse{
21833 Header: res.Header,
21834 HTTPStatusCode: res.StatusCode,
21835 },
21836 }
21837 target := &ret
21838 if err := gensupport.DecodeResponse(target, res); err != nil {
21839 return nil, err
21840 }
21841 return ret, nil
21842
21843
21844
21845
21846
21847
21848
21849
21850
21851
21852
21853
21854
21855
21856
21857
21858
21859
21860
21861
21862
21863
21864
21865
21866
21867
21868
21869
21870
21871
21872
21873
21874
21875
21876
21877 }
21878
21879
21880
21881 type ProjectsLocationsProductsCloudFunctionsCreateCall struct {
21882 s *Service
21883 parent string
21884 googlecloudintegrationsv1alphacreatecloudfunctionrequest *GoogleCloudIntegrationsV1alphaCreateCloudFunctionRequest
21885 urlParams_ gensupport.URLParams
21886 ctx_ context.Context
21887 header_ http.Header
21888 }
21889
21890
21891
21892
21893 func (r *ProjectsLocationsProductsCloudFunctionsService) Create(parent string, googlecloudintegrationsv1alphacreatecloudfunctionrequest *GoogleCloudIntegrationsV1alphaCreateCloudFunctionRequest) *ProjectsLocationsProductsCloudFunctionsCreateCall {
21894 c := &ProjectsLocationsProductsCloudFunctionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
21895 c.parent = parent
21896 c.googlecloudintegrationsv1alphacreatecloudfunctionrequest = googlecloudintegrationsv1alphacreatecloudfunctionrequest
21897 return c
21898 }
21899
21900
21901
21902
21903 func (c *ProjectsLocationsProductsCloudFunctionsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsCloudFunctionsCreateCall {
21904 c.urlParams_.Set("fields", googleapi.CombineFields(s))
21905 return c
21906 }
21907
21908
21909
21910
21911 func (c *ProjectsLocationsProductsCloudFunctionsCreateCall) Context(ctx context.Context) *ProjectsLocationsProductsCloudFunctionsCreateCall {
21912 c.ctx_ = ctx
21913 return c
21914 }
21915
21916
21917
21918 func (c *ProjectsLocationsProductsCloudFunctionsCreateCall) Header() http.Header {
21919 if c.header_ == nil {
21920 c.header_ = make(http.Header)
21921 }
21922 return c.header_
21923 }
21924
21925 func (c *ProjectsLocationsProductsCloudFunctionsCreateCall) doRequest(alt string) (*http.Response, error) {
21926 reqHeaders := make(http.Header)
21927 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
21928 for k, v := range c.header_ {
21929 reqHeaders[k] = v
21930 }
21931 reqHeaders.Set("User-Agent", c.s.userAgent())
21932 var body io.Reader = nil
21933 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacreatecloudfunctionrequest)
21934 if err != nil {
21935 return nil, err
21936 }
21937 reqHeaders.Set("Content-Type", "application/json")
21938 c.urlParams_.Set("alt", alt)
21939 c.urlParams_.Set("prettyPrint", "false")
21940 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/cloudFunctions")
21941 urls += "?" + c.urlParams_.Encode()
21942 req, err := http.NewRequest("POST", urls, body)
21943 if err != nil {
21944 return nil, err
21945 }
21946 req.Header = reqHeaders
21947 googleapi.Expand(req.URL, map[string]string{
21948 "parent": c.parent,
21949 })
21950 return gensupport.SendRequest(c.ctx_, c.s.client, req)
21951 }
21952
21953
21954
21955
21956
21957
21958
21959
21960
21961
21962
21963 func (c *ProjectsLocationsProductsCloudFunctionsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCreateCloudFunctionResponse, error) {
21964 gensupport.SetOptions(c.urlParams_, opts...)
21965 res, err := c.doRequest("json")
21966 if res != nil && res.StatusCode == http.StatusNotModified {
21967 if res.Body != nil {
21968 res.Body.Close()
21969 }
21970 return nil, gensupport.WrapError(&googleapi.Error{
21971 Code: res.StatusCode,
21972 Header: res.Header,
21973 })
21974 }
21975 if err != nil {
21976 return nil, err
21977 }
21978 defer googleapi.CloseBody(res)
21979 if err := googleapi.CheckResponse(res); err != nil {
21980 return nil, gensupport.WrapError(err)
21981 }
21982 ret := &GoogleCloudIntegrationsV1alphaCreateCloudFunctionResponse{
21983 ServerResponse: googleapi.ServerResponse{
21984 Header: res.Header,
21985 HTTPStatusCode: res.StatusCode,
21986 },
21987 }
21988 target := &ret
21989 if err := gensupport.DecodeResponse(target, res); err != nil {
21990 return nil, err
21991 }
21992 return ret, nil
21993
21994
21995
21996
21997
21998
21999
22000
22001
22002
22003
22004
22005
22006
22007
22008
22009
22010
22011
22012
22013
22014
22015
22016
22017
22018
22019
22020
22021
22022 }
22023
22024
22025
22026 type ProjectsLocationsProductsIntegrationsArchiveBundleCall struct {
22027 s *Service
22028 name string
22029 googlecloudintegrationsv1alphaarchivebundlerequest *GoogleCloudIntegrationsV1alphaArchiveBundleRequest
22030 urlParams_ gensupport.URLParams
22031 ctx_ context.Context
22032 header_ http.Header
22033 }
22034
22035
22036
22037
22038
22039
22040 func (r *ProjectsLocationsProductsIntegrationsService) ArchiveBundle(name string, googlecloudintegrationsv1alphaarchivebundlerequest *GoogleCloudIntegrationsV1alphaArchiveBundleRequest) *ProjectsLocationsProductsIntegrationsArchiveBundleCall {
22041 c := &ProjectsLocationsProductsIntegrationsArchiveBundleCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22042 c.name = name
22043 c.googlecloudintegrationsv1alphaarchivebundlerequest = googlecloudintegrationsv1alphaarchivebundlerequest
22044 return c
22045 }
22046
22047
22048
22049
22050 func (c *ProjectsLocationsProductsIntegrationsArchiveBundleCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsArchiveBundleCall {
22051 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22052 return c
22053 }
22054
22055
22056
22057
22058 func (c *ProjectsLocationsProductsIntegrationsArchiveBundleCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsArchiveBundleCall {
22059 c.ctx_ = ctx
22060 return c
22061 }
22062
22063
22064
22065 func (c *ProjectsLocationsProductsIntegrationsArchiveBundleCall) Header() http.Header {
22066 if c.header_ == nil {
22067 c.header_ = make(http.Header)
22068 }
22069 return c.header_
22070 }
22071
22072 func (c *ProjectsLocationsProductsIntegrationsArchiveBundleCall) doRequest(alt string) (*http.Response, error) {
22073 reqHeaders := make(http.Header)
22074 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
22075 for k, v := range c.header_ {
22076 reqHeaders[k] = v
22077 }
22078 reqHeaders.Set("User-Agent", c.s.userAgent())
22079 var body io.Reader = nil
22080 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaarchivebundlerequest)
22081 if err != nil {
22082 return nil, err
22083 }
22084 reqHeaders.Set("Content-Type", "application/json")
22085 c.urlParams_.Set("alt", alt)
22086 c.urlParams_.Set("prettyPrint", "false")
22087 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:archiveBundle")
22088 urls += "?" + c.urlParams_.Encode()
22089 req, err := http.NewRequest("POST", urls, body)
22090 if err != nil {
22091 return nil, err
22092 }
22093 req.Header = reqHeaders
22094 googleapi.Expand(req.URL, map[string]string{
22095 "name": c.name,
22096 })
22097 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22098 }
22099
22100
22101
22102
22103
22104
22105
22106
22107
22108
22109 func (c *ProjectsLocationsProductsIntegrationsArchiveBundleCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaArchiveBundleResponse, error) {
22110 gensupport.SetOptions(c.urlParams_, opts...)
22111 res, err := c.doRequest("json")
22112 if res != nil && res.StatusCode == http.StatusNotModified {
22113 if res.Body != nil {
22114 res.Body.Close()
22115 }
22116 return nil, gensupport.WrapError(&googleapi.Error{
22117 Code: res.StatusCode,
22118 Header: res.Header,
22119 })
22120 }
22121 if err != nil {
22122 return nil, err
22123 }
22124 defer googleapi.CloseBody(res)
22125 if err := googleapi.CheckResponse(res); err != nil {
22126 return nil, gensupport.WrapError(err)
22127 }
22128 ret := &GoogleCloudIntegrationsV1alphaArchiveBundleResponse{
22129 ServerResponse: googleapi.ServerResponse{
22130 Header: res.Header,
22131 HTTPStatusCode: res.StatusCode,
22132 },
22133 }
22134 target := &ret
22135 if err := gensupport.DecodeResponse(target, res); err != nil {
22136 return nil, err
22137 }
22138 return ret, nil
22139
22140
22141
22142
22143
22144
22145
22146
22147
22148
22149
22150
22151
22152
22153
22154
22155
22156
22157
22158
22159
22160
22161
22162
22163
22164
22165
22166
22167
22168 }
22169
22170
22171
22172 type ProjectsLocationsProductsIntegrationsExecuteCall struct {
22173 s *Service
22174 name string
22175 googlecloudintegrationsv1alphaexecuteintegrationsrequest *GoogleCloudIntegrationsV1alphaExecuteIntegrationsRequest
22176 urlParams_ gensupport.URLParams
22177 ctx_ context.Context
22178 header_ http.Header
22179 }
22180
22181
22182
22183
22184
22185
22186
22187
22188
22189
22190 func (r *ProjectsLocationsProductsIntegrationsService) Execute(name string, googlecloudintegrationsv1alphaexecuteintegrationsrequest *GoogleCloudIntegrationsV1alphaExecuteIntegrationsRequest) *ProjectsLocationsProductsIntegrationsExecuteCall {
22191 c := &ProjectsLocationsProductsIntegrationsExecuteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22192 c.name = name
22193 c.googlecloudintegrationsv1alphaexecuteintegrationsrequest = googlecloudintegrationsv1alphaexecuteintegrationsrequest
22194 return c
22195 }
22196
22197
22198
22199
22200 func (c *ProjectsLocationsProductsIntegrationsExecuteCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecuteCall {
22201 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22202 return c
22203 }
22204
22205
22206
22207
22208 func (c *ProjectsLocationsProductsIntegrationsExecuteCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecuteCall {
22209 c.ctx_ = ctx
22210 return c
22211 }
22212
22213
22214
22215 func (c *ProjectsLocationsProductsIntegrationsExecuteCall) Header() http.Header {
22216 if c.header_ == nil {
22217 c.header_ = make(http.Header)
22218 }
22219 return c.header_
22220 }
22221
22222 func (c *ProjectsLocationsProductsIntegrationsExecuteCall) doRequest(alt string) (*http.Response, error) {
22223 reqHeaders := make(http.Header)
22224 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
22225 for k, v := range c.header_ {
22226 reqHeaders[k] = v
22227 }
22228 reqHeaders.Set("User-Agent", c.s.userAgent())
22229 var body io.Reader = nil
22230 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaexecuteintegrationsrequest)
22231 if err != nil {
22232 return nil, err
22233 }
22234 reqHeaders.Set("Content-Type", "application/json")
22235 c.urlParams_.Set("alt", alt)
22236 c.urlParams_.Set("prettyPrint", "false")
22237 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:execute")
22238 urls += "?" + c.urlParams_.Encode()
22239 req, err := http.NewRequest("POST", urls, body)
22240 if err != nil {
22241 return nil, err
22242 }
22243 req.Header = reqHeaders
22244 googleapi.Expand(req.URL, map[string]string{
22245 "name": c.name,
22246 })
22247 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22248 }
22249
22250
22251
22252
22253
22254
22255
22256
22257
22258
22259
22260 func (c *ProjectsLocationsProductsIntegrationsExecuteCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaExecuteIntegrationsResponse, error) {
22261 gensupport.SetOptions(c.urlParams_, opts...)
22262 res, err := c.doRequest("json")
22263 if res != nil && res.StatusCode == http.StatusNotModified {
22264 if res.Body != nil {
22265 res.Body.Close()
22266 }
22267 return nil, gensupport.WrapError(&googleapi.Error{
22268 Code: res.StatusCode,
22269 Header: res.Header,
22270 })
22271 }
22272 if err != nil {
22273 return nil, err
22274 }
22275 defer googleapi.CloseBody(res)
22276 if err := googleapi.CheckResponse(res); err != nil {
22277 return nil, gensupport.WrapError(err)
22278 }
22279 ret := &GoogleCloudIntegrationsV1alphaExecuteIntegrationsResponse{
22280 ServerResponse: googleapi.ServerResponse{
22281 Header: res.Header,
22282 HTTPStatusCode: res.StatusCode,
22283 },
22284 }
22285 target := &ret
22286 if err := gensupport.DecodeResponse(target, res); err != nil {
22287 return nil, err
22288 }
22289 return ret, nil
22290
22291
22292
22293
22294
22295
22296
22297
22298
22299
22300
22301
22302
22303
22304
22305
22306
22307
22308
22309
22310
22311
22312
22313
22314
22315
22316
22317
22318
22319 }
22320
22321
22322
22323 type ProjectsLocationsProductsIntegrationsListCall struct {
22324 s *Service
22325 parent string
22326 urlParams_ gensupport.URLParams
22327 ifNoneMatch_ string
22328 ctx_ context.Context
22329 header_ http.Header
22330 }
22331
22332
22333
22334
22335
22336 func (r *ProjectsLocationsProductsIntegrationsService) List(parent string) *ProjectsLocationsProductsIntegrationsListCall {
22337 c := &ProjectsLocationsProductsIntegrationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22338 c.parent = parent
22339 return c
22340 }
22341
22342
22343
22344
22345
22346
22347
22348
22349
22350 func (c *ProjectsLocationsProductsIntegrationsListCall) Filter(filter string) *ProjectsLocationsProductsIntegrationsListCall {
22351 c.urlParams_.Set("filter", filter)
22352 return c
22353 }
22354
22355
22356
22357
22358
22359 func (c *ProjectsLocationsProductsIntegrationsListCall) OrderBy(orderBy string) *ProjectsLocationsProductsIntegrationsListCall {
22360 c.urlParams_.Set("orderBy", orderBy)
22361 return c
22362 }
22363
22364
22365
22366 func (c *ProjectsLocationsProductsIntegrationsListCall) PageSize(pageSize int64) *ProjectsLocationsProductsIntegrationsListCall {
22367 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
22368 return c
22369 }
22370
22371
22372
22373 func (c *ProjectsLocationsProductsIntegrationsListCall) PageToken(pageToken string) *ProjectsLocationsProductsIntegrationsListCall {
22374 c.urlParams_.Set("pageToken", pageToken)
22375 return c
22376 }
22377
22378
22379
22380
22381 func (c *ProjectsLocationsProductsIntegrationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsListCall {
22382 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22383 return c
22384 }
22385
22386
22387
22388
22389
22390
22391 func (c *ProjectsLocationsProductsIntegrationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsListCall {
22392 c.ifNoneMatch_ = entityTag
22393 return c
22394 }
22395
22396
22397
22398
22399 func (c *ProjectsLocationsProductsIntegrationsListCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsListCall {
22400 c.ctx_ = ctx
22401 return c
22402 }
22403
22404
22405
22406 func (c *ProjectsLocationsProductsIntegrationsListCall) Header() http.Header {
22407 if c.header_ == nil {
22408 c.header_ = make(http.Header)
22409 }
22410 return c.header_
22411 }
22412
22413 func (c *ProjectsLocationsProductsIntegrationsListCall) doRequest(alt string) (*http.Response, error) {
22414 reqHeaders := make(http.Header)
22415 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
22416 for k, v := range c.header_ {
22417 reqHeaders[k] = v
22418 }
22419 reqHeaders.Set("User-Agent", c.s.userAgent())
22420 if c.ifNoneMatch_ != "" {
22421 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
22422 }
22423 var body io.Reader = nil
22424 c.urlParams_.Set("alt", alt)
22425 c.urlParams_.Set("prettyPrint", "false")
22426 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/integrations")
22427 urls += "?" + c.urlParams_.Encode()
22428 req, err := http.NewRequest("GET", urls, body)
22429 if err != nil {
22430 return nil, err
22431 }
22432 req.Header = reqHeaders
22433 googleapi.Expand(req.URL, map[string]string{
22434 "parent": c.parent,
22435 })
22436 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22437 }
22438
22439
22440
22441
22442
22443
22444
22445
22446
22447
22448
22449 func (c *ProjectsLocationsProductsIntegrationsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListIntegrationsResponse, error) {
22450 gensupport.SetOptions(c.urlParams_, opts...)
22451 res, err := c.doRequest("json")
22452 if res != nil && res.StatusCode == http.StatusNotModified {
22453 if res.Body != nil {
22454 res.Body.Close()
22455 }
22456 return nil, gensupport.WrapError(&googleapi.Error{
22457 Code: res.StatusCode,
22458 Header: res.Header,
22459 })
22460 }
22461 if err != nil {
22462 return nil, err
22463 }
22464 defer googleapi.CloseBody(res)
22465 if err := googleapi.CheckResponse(res); err != nil {
22466 return nil, gensupport.WrapError(err)
22467 }
22468 ret := &GoogleCloudIntegrationsV1alphaListIntegrationsResponse{
22469 ServerResponse: googleapi.ServerResponse{
22470 Header: res.Header,
22471 HTTPStatusCode: res.StatusCode,
22472 },
22473 }
22474 target := &ret
22475 if err := gensupport.DecodeResponse(target, res); err != nil {
22476 return nil, err
22477 }
22478 return ret, nil
22479
22480
22481
22482
22483
22484
22485
22486
22487
22488
22489
22490
22491
22492
22493
22494
22495
22496
22497
22498
22499
22500
22501
22502
22503
22504
22505
22506
22507
22508
22509
22510
22511
22512
22513
22514
22515
22516
22517
22518
22519
22520
22521
22522
22523
22524
22525
22526 }
22527
22528
22529
22530
22531 func (c *ProjectsLocationsProductsIntegrationsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListIntegrationsResponse) error) error {
22532 c.ctx_ = ctx
22533 defer c.PageToken(c.urlParams_.Get("pageToken"))
22534 for {
22535 x, err := c.Do()
22536 if err != nil {
22537 return err
22538 }
22539 if err := f(x); err != nil {
22540 return err
22541 }
22542 if x.NextPageToken == "" {
22543 return nil
22544 }
22545 c.PageToken(x.NextPageToken)
22546 }
22547 }
22548
22549
22550
22551 type ProjectsLocationsProductsIntegrationsScheduleCall struct {
22552 s *Service
22553 name string
22554 googlecloudintegrationsv1alphascheduleintegrationsrequest *GoogleCloudIntegrationsV1alphaScheduleIntegrationsRequest
22555 urlParams_ gensupport.URLParams
22556 ctx_ context.Context
22557 header_ http.Header
22558 }
22559
22560
22561
22562
22563
22564 func (r *ProjectsLocationsProductsIntegrationsService) Schedule(name string, googlecloudintegrationsv1alphascheduleintegrationsrequest *GoogleCloudIntegrationsV1alphaScheduleIntegrationsRequest) *ProjectsLocationsProductsIntegrationsScheduleCall {
22565 c := &ProjectsLocationsProductsIntegrationsScheduleCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22566 c.name = name
22567 c.googlecloudintegrationsv1alphascheduleintegrationsrequest = googlecloudintegrationsv1alphascheduleintegrationsrequest
22568 return c
22569 }
22570
22571
22572
22573
22574 func (c *ProjectsLocationsProductsIntegrationsScheduleCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsScheduleCall {
22575 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22576 return c
22577 }
22578
22579
22580
22581
22582 func (c *ProjectsLocationsProductsIntegrationsScheduleCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsScheduleCall {
22583 c.ctx_ = ctx
22584 return c
22585 }
22586
22587
22588
22589 func (c *ProjectsLocationsProductsIntegrationsScheduleCall) Header() http.Header {
22590 if c.header_ == nil {
22591 c.header_ = make(http.Header)
22592 }
22593 return c.header_
22594 }
22595
22596 func (c *ProjectsLocationsProductsIntegrationsScheduleCall) doRequest(alt string) (*http.Response, error) {
22597 reqHeaders := make(http.Header)
22598 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
22599 for k, v := range c.header_ {
22600 reqHeaders[k] = v
22601 }
22602 reqHeaders.Set("User-Agent", c.s.userAgent())
22603 var body io.Reader = nil
22604 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphascheduleintegrationsrequest)
22605 if err != nil {
22606 return nil, err
22607 }
22608 reqHeaders.Set("Content-Type", "application/json")
22609 c.urlParams_.Set("alt", alt)
22610 c.urlParams_.Set("prettyPrint", "false")
22611 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:schedule")
22612 urls += "?" + c.urlParams_.Encode()
22613 req, err := http.NewRequest("POST", urls, body)
22614 if err != nil {
22615 return nil, err
22616 }
22617 req.Header = reqHeaders
22618 googleapi.Expand(req.URL, map[string]string{
22619 "name": c.name,
22620 })
22621 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22622 }
22623
22624
22625
22626
22627
22628
22629
22630
22631
22632
22633
22634 func (c *ProjectsLocationsProductsIntegrationsScheduleCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaScheduleIntegrationsResponse, error) {
22635 gensupport.SetOptions(c.urlParams_, opts...)
22636 res, err := c.doRequest("json")
22637 if res != nil && res.StatusCode == http.StatusNotModified {
22638 if res.Body != nil {
22639 res.Body.Close()
22640 }
22641 return nil, gensupport.WrapError(&googleapi.Error{
22642 Code: res.StatusCode,
22643 Header: res.Header,
22644 })
22645 }
22646 if err != nil {
22647 return nil, err
22648 }
22649 defer googleapi.CloseBody(res)
22650 if err := googleapi.CheckResponse(res); err != nil {
22651 return nil, gensupport.WrapError(err)
22652 }
22653 ret := &GoogleCloudIntegrationsV1alphaScheduleIntegrationsResponse{
22654 ServerResponse: googleapi.ServerResponse{
22655 Header: res.Header,
22656 HTTPStatusCode: res.StatusCode,
22657 },
22658 }
22659 target := &ret
22660 if err := gensupport.DecodeResponse(target, res); err != nil {
22661 return nil, err
22662 }
22663 return ret, nil
22664
22665
22666
22667
22668
22669
22670
22671
22672
22673
22674
22675
22676
22677
22678
22679
22680
22681
22682
22683
22684
22685
22686
22687
22688
22689
22690
22691
22692
22693 }
22694
22695
22696
22697 type ProjectsLocationsProductsIntegrationsTestCall struct {
22698 s *Service
22699 name string
22700 googlecloudintegrationsv1alphatestintegrationsrequest *GoogleCloudIntegrationsV1alphaTestIntegrationsRequest
22701 urlParams_ gensupport.URLParams
22702 ctx_ context.Context
22703 header_ http.Header
22704 }
22705
22706
22707
22708
22709 func (r *ProjectsLocationsProductsIntegrationsService) Test(name string, googlecloudintegrationsv1alphatestintegrationsrequest *GoogleCloudIntegrationsV1alphaTestIntegrationsRequest) *ProjectsLocationsProductsIntegrationsTestCall {
22710 c := &ProjectsLocationsProductsIntegrationsTestCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22711 c.name = name
22712 c.googlecloudintegrationsv1alphatestintegrationsrequest = googlecloudintegrationsv1alphatestintegrationsrequest
22713 return c
22714 }
22715
22716
22717
22718
22719 func (c *ProjectsLocationsProductsIntegrationsTestCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsTestCall {
22720 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22721 return c
22722 }
22723
22724
22725
22726
22727 func (c *ProjectsLocationsProductsIntegrationsTestCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsTestCall {
22728 c.ctx_ = ctx
22729 return c
22730 }
22731
22732
22733
22734 func (c *ProjectsLocationsProductsIntegrationsTestCall) Header() http.Header {
22735 if c.header_ == nil {
22736 c.header_ = make(http.Header)
22737 }
22738 return c.header_
22739 }
22740
22741 func (c *ProjectsLocationsProductsIntegrationsTestCall) doRequest(alt string) (*http.Response, error) {
22742 reqHeaders := make(http.Header)
22743 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
22744 for k, v := range c.header_ {
22745 reqHeaders[k] = v
22746 }
22747 reqHeaders.Set("User-Agent", c.s.userAgent())
22748 var body io.Reader = nil
22749 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphatestintegrationsrequest)
22750 if err != nil {
22751 return nil, err
22752 }
22753 reqHeaders.Set("Content-Type", "application/json")
22754 c.urlParams_.Set("alt", alt)
22755 c.urlParams_.Set("prettyPrint", "false")
22756 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:test")
22757 urls += "?" + c.urlParams_.Encode()
22758 req, err := http.NewRequest("POST", urls, body)
22759 if err != nil {
22760 return nil, err
22761 }
22762 req.Header = reqHeaders
22763 googleapi.Expand(req.URL, map[string]string{
22764 "name": c.name,
22765 })
22766 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22767 }
22768
22769
22770
22771
22772
22773
22774
22775
22776
22777
22778
22779 func (c *ProjectsLocationsProductsIntegrationsTestCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaTestIntegrationsResponse, error) {
22780 gensupport.SetOptions(c.urlParams_, opts...)
22781 res, err := c.doRequest("json")
22782 if res != nil && res.StatusCode == http.StatusNotModified {
22783 if res.Body != nil {
22784 res.Body.Close()
22785 }
22786 return nil, gensupport.WrapError(&googleapi.Error{
22787 Code: res.StatusCode,
22788 Header: res.Header,
22789 })
22790 }
22791 if err != nil {
22792 return nil, err
22793 }
22794 defer googleapi.CloseBody(res)
22795 if err := googleapi.CheckResponse(res); err != nil {
22796 return nil, gensupport.WrapError(err)
22797 }
22798 ret := &GoogleCloudIntegrationsV1alphaTestIntegrationsResponse{
22799 ServerResponse: googleapi.ServerResponse{
22800 Header: res.Header,
22801 HTTPStatusCode: res.StatusCode,
22802 },
22803 }
22804 target := &ret
22805 if err := gensupport.DecodeResponse(target, res); err != nil {
22806 return nil, err
22807 }
22808 return ret, nil
22809
22810
22811
22812
22813
22814
22815
22816
22817
22818
22819
22820
22821
22822
22823
22824
22825
22826
22827
22828
22829
22830
22831
22832
22833
22834
22835
22836
22837
22838 }
22839
22840
22841
22842 type ProjectsLocationsProductsIntegrationsExecutionsCancelCall struct {
22843 s *Service
22844 name string
22845 googlecloudintegrationsv1alphacancelexecutionrequest *GoogleCloudIntegrationsV1alphaCancelExecutionRequest
22846 urlParams_ gensupport.URLParams
22847 ctx_ context.Context
22848 header_ http.Header
22849 }
22850
22851
22852
22853
22854
22855
22856 func (r *ProjectsLocationsProductsIntegrationsExecutionsService) Cancel(name string, googlecloudintegrationsv1alphacancelexecutionrequest *GoogleCloudIntegrationsV1alphaCancelExecutionRequest) *ProjectsLocationsProductsIntegrationsExecutionsCancelCall {
22857 c := &ProjectsLocationsProductsIntegrationsExecutionsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
22858 c.name = name
22859 c.googlecloudintegrationsv1alphacancelexecutionrequest = googlecloudintegrationsv1alphacancelexecutionrequest
22860 return c
22861 }
22862
22863
22864
22865
22866 func (c *ProjectsLocationsProductsIntegrationsExecutionsCancelCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecutionsCancelCall {
22867 c.urlParams_.Set("fields", googleapi.CombineFields(s))
22868 return c
22869 }
22870
22871
22872
22873
22874 func (c *ProjectsLocationsProductsIntegrationsExecutionsCancelCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecutionsCancelCall {
22875 c.ctx_ = ctx
22876 return c
22877 }
22878
22879
22880
22881 func (c *ProjectsLocationsProductsIntegrationsExecutionsCancelCall) Header() http.Header {
22882 if c.header_ == nil {
22883 c.header_ = make(http.Header)
22884 }
22885 return c.header_
22886 }
22887
22888 func (c *ProjectsLocationsProductsIntegrationsExecutionsCancelCall) doRequest(alt string) (*http.Response, error) {
22889 reqHeaders := make(http.Header)
22890 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
22891 for k, v := range c.header_ {
22892 reqHeaders[k] = v
22893 }
22894 reqHeaders.Set("User-Agent", c.s.userAgent())
22895 var body io.Reader = nil
22896 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphacancelexecutionrequest)
22897 if err != nil {
22898 return nil, err
22899 }
22900 reqHeaders.Set("Content-Type", "application/json")
22901 c.urlParams_.Set("alt", alt)
22902 c.urlParams_.Set("prettyPrint", "false")
22903 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:cancel")
22904 urls += "?" + c.urlParams_.Encode()
22905 req, err := http.NewRequest("POST", urls, body)
22906 if err != nil {
22907 return nil, err
22908 }
22909 req.Header = reqHeaders
22910 googleapi.Expand(req.URL, map[string]string{
22911 "name": c.name,
22912 })
22913 return gensupport.SendRequest(c.ctx_, c.s.client, req)
22914 }
22915
22916
22917
22918
22919
22920
22921
22922
22923
22924
22925 func (c *ProjectsLocationsProductsIntegrationsExecutionsCancelCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaCancelExecutionResponse, error) {
22926 gensupport.SetOptions(c.urlParams_, opts...)
22927 res, err := c.doRequest("json")
22928 if res != nil && res.StatusCode == http.StatusNotModified {
22929 if res.Body != nil {
22930 res.Body.Close()
22931 }
22932 return nil, gensupport.WrapError(&googleapi.Error{
22933 Code: res.StatusCode,
22934 Header: res.Header,
22935 })
22936 }
22937 if err != nil {
22938 return nil, err
22939 }
22940 defer googleapi.CloseBody(res)
22941 if err := googleapi.CheckResponse(res); err != nil {
22942 return nil, gensupport.WrapError(err)
22943 }
22944 ret := &GoogleCloudIntegrationsV1alphaCancelExecutionResponse{
22945 ServerResponse: googleapi.ServerResponse{
22946 Header: res.Header,
22947 HTTPStatusCode: res.StatusCode,
22948 },
22949 }
22950 target := &ret
22951 if err := gensupport.DecodeResponse(target, res); err != nil {
22952 return nil, err
22953 }
22954 return ret, nil
22955
22956
22957
22958
22959
22960
22961
22962
22963
22964
22965
22966
22967
22968
22969
22970
22971
22972
22973
22974
22975
22976
22977
22978
22979
22980
22981
22982
22983
22984 }
22985
22986
22987
22988 type ProjectsLocationsProductsIntegrationsExecutionsDownloadCall struct {
22989 s *Service
22990 name string
22991 urlParams_ gensupport.URLParams
22992 ifNoneMatch_ string
22993 ctx_ context.Context
22994 header_ http.Header
22995 }
22996
22997
22998
22999
23000
23001
23002 func (r *ProjectsLocationsProductsIntegrationsExecutionsService) Download(name string) *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall {
23003 c := &ProjectsLocationsProductsIntegrationsExecutionsDownloadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23004 c.name = name
23005 return c
23006 }
23007
23008
23009
23010
23011 func (c *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall {
23012 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23013 return c
23014 }
23015
23016
23017
23018
23019
23020
23021 func (c *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall {
23022 c.ifNoneMatch_ = entityTag
23023 return c
23024 }
23025
23026
23027
23028
23029 func (c *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall {
23030 c.ctx_ = ctx
23031 return c
23032 }
23033
23034
23035
23036 func (c *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall) Header() http.Header {
23037 if c.header_ == nil {
23038 c.header_ = make(http.Header)
23039 }
23040 return c.header_
23041 }
23042
23043 func (c *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall) doRequest(alt string) (*http.Response, error) {
23044 reqHeaders := make(http.Header)
23045 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
23046 for k, v := range c.header_ {
23047 reqHeaders[k] = v
23048 }
23049 reqHeaders.Set("User-Agent", c.s.userAgent())
23050 if c.ifNoneMatch_ != "" {
23051 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
23052 }
23053 var body io.Reader = nil
23054 c.urlParams_.Set("alt", alt)
23055 c.urlParams_.Set("prettyPrint", "false")
23056 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:download")
23057 urls += "?" + c.urlParams_.Encode()
23058 req, err := http.NewRequest("GET", urls, body)
23059 if err != nil {
23060 return nil, err
23061 }
23062 req.Header = reqHeaders
23063 googleapi.Expand(req.URL, map[string]string{
23064 "name": c.name,
23065 })
23066 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23067 }
23068
23069
23070
23071
23072
23073
23074
23075
23076
23077
23078
23079 func (c *ProjectsLocationsProductsIntegrationsExecutionsDownloadCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaDownloadExecutionResponse, error) {
23080 gensupport.SetOptions(c.urlParams_, opts...)
23081 res, err := c.doRequest("json")
23082 if res != nil && res.StatusCode == http.StatusNotModified {
23083 if res.Body != nil {
23084 res.Body.Close()
23085 }
23086 return nil, gensupport.WrapError(&googleapi.Error{
23087 Code: res.StatusCode,
23088 Header: res.Header,
23089 })
23090 }
23091 if err != nil {
23092 return nil, err
23093 }
23094 defer googleapi.CloseBody(res)
23095 if err := googleapi.CheckResponse(res); err != nil {
23096 return nil, gensupport.WrapError(err)
23097 }
23098 ret := &GoogleCloudIntegrationsV1alphaDownloadExecutionResponse{
23099 ServerResponse: googleapi.ServerResponse{
23100 Header: res.Header,
23101 HTTPStatusCode: res.StatusCode,
23102 },
23103 }
23104 target := &ret
23105 if err := gensupport.DecodeResponse(target, res); err != nil {
23106 return nil, err
23107 }
23108 return ret, nil
23109
23110
23111
23112
23113
23114
23115
23116
23117
23118
23119
23120
23121
23122
23123
23124
23125
23126
23127
23128
23129
23130
23131
23132
23133
23134
23135 }
23136
23137
23138
23139 type ProjectsLocationsProductsIntegrationsExecutionsGetCall struct {
23140 s *Service
23141 name string
23142 urlParams_ gensupport.URLParams
23143 ifNoneMatch_ string
23144 ctx_ context.Context
23145 header_ http.Header
23146 }
23147
23148
23149
23150
23151
23152
23153 func (r *ProjectsLocationsProductsIntegrationsExecutionsService) Get(name string) *ProjectsLocationsProductsIntegrationsExecutionsGetCall {
23154 c := &ProjectsLocationsProductsIntegrationsExecutionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23155 c.name = name
23156 return c
23157 }
23158
23159
23160
23161
23162 func (c *ProjectsLocationsProductsIntegrationsExecutionsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecutionsGetCall {
23163 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23164 return c
23165 }
23166
23167
23168
23169
23170
23171
23172 func (c *ProjectsLocationsProductsIntegrationsExecutionsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsExecutionsGetCall {
23173 c.ifNoneMatch_ = entityTag
23174 return c
23175 }
23176
23177
23178
23179
23180 func (c *ProjectsLocationsProductsIntegrationsExecutionsGetCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecutionsGetCall {
23181 c.ctx_ = ctx
23182 return c
23183 }
23184
23185
23186
23187 func (c *ProjectsLocationsProductsIntegrationsExecutionsGetCall) Header() http.Header {
23188 if c.header_ == nil {
23189 c.header_ = make(http.Header)
23190 }
23191 return c.header_
23192 }
23193
23194 func (c *ProjectsLocationsProductsIntegrationsExecutionsGetCall) doRequest(alt string) (*http.Response, error) {
23195 reqHeaders := make(http.Header)
23196 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
23197 for k, v := range c.header_ {
23198 reqHeaders[k] = v
23199 }
23200 reqHeaders.Set("User-Agent", c.s.userAgent())
23201 if c.ifNoneMatch_ != "" {
23202 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
23203 }
23204 var body io.Reader = nil
23205 c.urlParams_.Set("alt", alt)
23206 c.urlParams_.Set("prettyPrint", "false")
23207 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
23208 urls += "?" + c.urlParams_.Encode()
23209 req, err := http.NewRequest("GET", urls, body)
23210 if err != nil {
23211 return nil, err
23212 }
23213 req.Header = reqHeaders
23214 googleapi.Expand(req.URL, map[string]string{
23215 "name": c.name,
23216 })
23217 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23218 }
23219
23220
23221
23222
23223
23224
23225
23226
23227
23228 func (c *ProjectsLocationsProductsIntegrationsExecutionsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaExecution, error) {
23229 gensupport.SetOptions(c.urlParams_, opts...)
23230 res, err := c.doRequest("json")
23231 if res != nil && res.StatusCode == http.StatusNotModified {
23232 if res.Body != nil {
23233 res.Body.Close()
23234 }
23235 return nil, gensupport.WrapError(&googleapi.Error{
23236 Code: res.StatusCode,
23237 Header: res.Header,
23238 })
23239 }
23240 if err != nil {
23241 return nil, err
23242 }
23243 defer googleapi.CloseBody(res)
23244 if err := googleapi.CheckResponse(res); err != nil {
23245 return nil, gensupport.WrapError(err)
23246 }
23247 ret := &GoogleCloudIntegrationsV1alphaExecution{
23248 ServerResponse: googleapi.ServerResponse{
23249 Header: res.Header,
23250 HTTPStatusCode: res.StatusCode,
23251 },
23252 }
23253 target := &ret
23254 if err := gensupport.DecodeResponse(target, res); err != nil {
23255 return nil, err
23256 }
23257 return ret, nil
23258
23259
23260
23261
23262
23263
23264
23265
23266
23267
23268
23269
23270
23271
23272
23273
23274
23275
23276
23277
23278
23279
23280
23281
23282
23283
23284 }
23285
23286
23287
23288 type ProjectsLocationsProductsIntegrationsExecutionsListCall struct {
23289 s *Service
23290 parent string
23291 urlParams_ gensupport.URLParams
23292 ifNoneMatch_ string
23293 ctx_ context.Context
23294 header_ http.Header
23295 }
23296
23297
23298
23299
23300
23301
23302
23303 func (r *ProjectsLocationsProductsIntegrationsExecutionsService) List(parent string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23304 c := &ProjectsLocationsProductsIntegrationsExecutionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23305 c.parent = parent
23306 return c
23307 }
23308
23309
23310
23311
23312
23313
23314
23315
23316 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) Filter(filter string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23317 c.urlParams_.Set("filter", filter)
23318 return c
23319 }
23320
23321
23322
23323 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsCustomFilter(filterParamsCustomFilter string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23324 c.urlParams_.Set("filterParams.customFilter", filterParamsCustomFilter)
23325 return c
23326 }
23327
23328
23329
23330 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsEndTime(filterParamsEndTime int64) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23331 c.urlParams_.Set("filterParams.endTime", fmt.Sprint(filterParamsEndTime))
23332 return c
23333 }
23334
23335
23336
23337 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsEventStatuses(filterParamsEventStatuses ...string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23338 c.urlParams_.SetMulti("filterParams.eventStatuses", append([]string{}, filterParamsEventStatuses...))
23339 return c
23340 }
23341
23342
23343
23344 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsExecutionId(filterParamsExecutionId string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23345 c.urlParams_.Set("filterParams.executionId", filterParamsExecutionId)
23346 return c
23347 }
23348
23349
23350
23351
23352 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsParameterKey(filterParamsParameterKey string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23353 c.urlParams_.Set("filterParams.parameterKey", filterParamsParameterKey)
23354 return c
23355 }
23356
23357
23358
23359
23360 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsParameterPairKey(filterParamsParameterPairKey string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23361 c.urlParams_.Set("filterParams.parameterPairKey", filterParamsParameterPairKey)
23362 return c
23363 }
23364
23365
23366
23367
23368 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsParameterPairValue(filterParamsParameterPairValue string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23369 c.urlParams_.Set("filterParams.parameterPairValue", filterParamsParameterPairValue)
23370 return c
23371 }
23372
23373
23374
23375 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsParameterType(filterParamsParameterType string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23376 c.urlParams_.Set("filterParams.parameterType", filterParamsParameterType)
23377 return c
23378 }
23379
23380
23381
23382
23383 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsParameterValue(filterParamsParameterValue string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23384 c.urlParams_.Set("filterParams.parameterValue", filterParamsParameterValue)
23385 return c
23386 }
23387
23388
23389
23390 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsStartTime(filterParamsStartTime int64) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23391 c.urlParams_.Set("filterParams.startTime", fmt.Sprint(filterParamsStartTime))
23392 return c
23393 }
23394
23395
23396
23397 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsTaskStatuses(filterParamsTaskStatuses ...string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23398 c.urlParams_.SetMulti("filterParams.taskStatuses", append([]string{}, filterParamsTaskStatuses...))
23399 return c
23400 }
23401
23402
23403
23404 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) FilterParamsWorkflowName(filterParamsWorkflowName string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23405 c.urlParams_.Set("filterParams.workflowName", filterParamsWorkflowName)
23406 return c
23407 }
23408
23409
23410
23411
23412 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) OrderBy(orderBy string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23413 c.urlParams_.Set("orderBy", orderBy)
23414 return c
23415 }
23416
23417
23418
23419 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) PageSize(pageSize int64) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23420 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
23421 return c
23422 }
23423
23424
23425
23426 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) PageToken(pageToken string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23427 c.urlParams_.Set("pageToken", pageToken)
23428 return c
23429 }
23430
23431
23432
23433
23434
23435 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) ReadMask(readMask string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23436 c.urlParams_.Set("readMask", readMask)
23437 return c
23438 }
23439
23440
23441
23442
23443
23444 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) RefreshAcl(refreshAcl bool) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23445 c.urlParams_.Set("refreshAcl", fmt.Sprint(refreshAcl))
23446 return c
23447 }
23448
23449
23450
23451
23452
23453
23454 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) TruncateParams(truncateParams bool) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23455 c.urlParams_.Set("truncateParams", fmt.Sprint(truncateParams))
23456 return c
23457 }
23458
23459
23460
23461
23462 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23463 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23464 return c
23465 }
23466
23467
23468
23469
23470
23471
23472 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23473 c.ifNoneMatch_ = entityTag
23474 return c
23475 }
23476
23477
23478
23479
23480 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecutionsListCall {
23481 c.ctx_ = ctx
23482 return c
23483 }
23484
23485
23486
23487 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) Header() http.Header {
23488 if c.header_ == nil {
23489 c.header_ = make(http.Header)
23490 }
23491 return c.header_
23492 }
23493
23494 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) doRequest(alt string) (*http.Response, error) {
23495 reqHeaders := make(http.Header)
23496 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
23497 for k, v := range c.header_ {
23498 reqHeaders[k] = v
23499 }
23500 reqHeaders.Set("User-Agent", c.s.userAgent())
23501 if c.ifNoneMatch_ != "" {
23502 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
23503 }
23504 var body io.Reader = nil
23505 c.urlParams_.Set("alt", alt)
23506 c.urlParams_.Set("prettyPrint", "false")
23507 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/executions")
23508 urls += "?" + c.urlParams_.Encode()
23509 req, err := http.NewRequest("GET", urls, body)
23510 if err != nil {
23511 return nil, err
23512 }
23513 req.Header = reqHeaders
23514 googleapi.Expand(req.URL, map[string]string{
23515 "parent": c.parent,
23516 })
23517 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23518 }
23519
23520
23521
23522
23523
23524
23525
23526
23527
23528
23529 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListExecutionsResponse, error) {
23530 gensupport.SetOptions(c.urlParams_, opts...)
23531 res, err := c.doRequest("json")
23532 if res != nil && res.StatusCode == http.StatusNotModified {
23533 if res.Body != nil {
23534 res.Body.Close()
23535 }
23536 return nil, gensupport.WrapError(&googleapi.Error{
23537 Code: res.StatusCode,
23538 Header: res.Header,
23539 })
23540 }
23541 if err != nil {
23542 return nil, err
23543 }
23544 defer googleapi.CloseBody(res)
23545 if err := googleapi.CheckResponse(res); err != nil {
23546 return nil, gensupport.WrapError(err)
23547 }
23548 ret := &GoogleCloudIntegrationsV1alphaListExecutionsResponse{
23549 ServerResponse: googleapi.ServerResponse{
23550 Header: res.Header,
23551 HTTPStatusCode: res.StatusCode,
23552 },
23553 }
23554 target := &ret
23555 if err := gensupport.DecodeResponse(target, res); err != nil {
23556 return nil, err
23557 }
23558 return ret, nil
23559
23560
23561
23562
23563
23564
23565
23566
23567
23568
23569
23570
23571
23572
23573
23574
23575
23576
23577
23578
23579
23580
23581
23582
23583
23584
23585
23586
23587
23588
23589
23590
23591
23592
23593
23594
23595
23596
23597
23598
23599
23600
23601
23602
23603
23604
23605
23606
23607
23608
23609
23610
23611
23612
23613
23614
23615
23616
23617
23618
23619
23620
23621
23622
23623
23624
23625
23626
23627
23628
23629
23630
23631
23632
23633
23634
23635
23636
23637
23638
23639
23640
23641
23642
23643
23644
23645
23646
23647
23648
23649
23650
23651
23652
23653
23654
23655
23656
23657
23658
23659
23660
23661
23662
23663
23664
23665
23666
23667
23668
23669
23670
23671
23672
23673
23674
23675
23676
23677
23678
23679
23680
23681
23682
23683
23684
23685
23686 }
23687
23688
23689
23690
23691 func (c *ProjectsLocationsProductsIntegrationsExecutionsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListExecutionsResponse) error) error {
23692 c.ctx_ = ctx
23693 defer c.PageToken(c.urlParams_.Get("pageToken"))
23694 for {
23695 x, err := c.Do()
23696 if err != nil {
23697 return err
23698 }
23699 if err := f(x); err != nil {
23700 return err
23701 }
23702 if x.NextPageToken == "" {
23703 return nil
23704 }
23705 c.PageToken(x.NextPageToken)
23706 }
23707 }
23708
23709
23710
23711 type ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall struct {
23712 s *Service
23713 name string
23714 googlecloudintegrationsv1alphaliftsuspensionrequest *GoogleCloudIntegrationsV1alphaLiftSuspensionRequest
23715 urlParams_ gensupport.URLParams
23716 ctx_ context.Context
23717 header_ http.Header
23718 }
23719
23720
23721
23722
23723
23724
23725
23726
23727
23728 func (r *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsService) Lift(name string, googlecloudintegrationsv1alphaliftsuspensionrequest *GoogleCloudIntegrationsV1alphaLiftSuspensionRequest) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall {
23729 c := &ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23730 c.name = name
23731 c.googlecloudintegrationsv1alphaliftsuspensionrequest = googlecloudintegrationsv1alphaliftsuspensionrequest
23732 return c
23733 }
23734
23735
23736
23737
23738 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall {
23739 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23740 return c
23741 }
23742
23743
23744
23745
23746 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall {
23747 c.ctx_ = ctx
23748 return c
23749 }
23750
23751
23752
23753 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall) Header() http.Header {
23754 if c.header_ == nil {
23755 c.header_ = make(http.Header)
23756 }
23757 return c.header_
23758 }
23759
23760 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall) doRequest(alt string) (*http.Response, error) {
23761 reqHeaders := make(http.Header)
23762 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
23763 for k, v := range c.header_ {
23764 reqHeaders[k] = v
23765 }
23766 reqHeaders.Set("User-Agent", c.s.userAgent())
23767 var body io.Reader = nil
23768 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaliftsuspensionrequest)
23769 if err != nil {
23770 return nil, err
23771 }
23772 reqHeaders.Set("Content-Type", "application/json")
23773 c.urlParams_.Set("alt", alt)
23774 c.urlParams_.Set("prettyPrint", "false")
23775 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:lift")
23776 urls += "?" + c.urlParams_.Encode()
23777 req, err := http.NewRequest("POST", urls, body)
23778 if err != nil {
23779 return nil, err
23780 }
23781 req.Header = reqHeaders
23782 googleapi.Expand(req.URL, map[string]string{
23783 "name": c.name,
23784 })
23785 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23786 }
23787
23788
23789
23790
23791
23792
23793
23794
23795
23796
23797 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsLiftCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaLiftSuspensionResponse, error) {
23798 gensupport.SetOptions(c.urlParams_, opts...)
23799 res, err := c.doRequest("json")
23800 if res != nil && res.StatusCode == http.StatusNotModified {
23801 if res.Body != nil {
23802 res.Body.Close()
23803 }
23804 return nil, gensupport.WrapError(&googleapi.Error{
23805 Code: res.StatusCode,
23806 Header: res.Header,
23807 })
23808 }
23809 if err != nil {
23810 return nil, err
23811 }
23812 defer googleapi.CloseBody(res)
23813 if err := googleapi.CheckResponse(res); err != nil {
23814 return nil, gensupport.WrapError(err)
23815 }
23816 ret := &GoogleCloudIntegrationsV1alphaLiftSuspensionResponse{
23817 ServerResponse: googleapi.ServerResponse{
23818 Header: res.Header,
23819 HTTPStatusCode: res.StatusCode,
23820 },
23821 }
23822 target := &ret
23823 if err := gensupport.DecodeResponse(target, res); err != nil {
23824 return nil, err
23825 }
23826 return ret, nil
23827
23828
23829
23830
23831
23832
23833
23834
23835
23836
23837
23838
23839
23840
23841
23842
23843
23844
23845
23846
23847
23848
23849
23850
23851
23852
23853
23854
23855
23856 }
23857
23858
23859
23860 type ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall struct {
23861 s *Service
23862 parent string
23863 urlParams_ gensupport.URLParams
23864 ifNoneMatch_ string
23865 ctx_ context.Context
23866 header_ http.Header
23867 }
23868
23869
23870
23871
23872
23873
23874
23875
23876 func (r *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsService) List(parent string) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall {
23877 c := &ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
23878 c.parent = parent
23879 return c
23880 }
23881
23882
23883 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) Filter(filter string) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall {
23884 c.urlParams_.Set("filter", filter)
23885 return c
23886 }
23887
23888
23889
23890 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) OrderBy(orderBy string) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall {
23891 c.urlParams_.Set("orderBy", orderBy)
23892 return c
23893 }
23894
23895
23896
23897 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) PageSize(pageSize int64) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall {
23898 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
23899 return c
23900 }
23901
23902
23903
23904 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) PageToken(pageToken string) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall {
23905 c.urlParams_.Set("pageToken", pageToken)
23906 return c
23907 }
23908
23909
23910
23911
23912 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall {
23913 c.urlParams_.Set("fields", googleapi.CombineFields(s))
23914 return c
23915 }
23916
23917
23918
23919
23920
23921
23922 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall {
23923 c.ifNoneMatch_ = entityTag
23924 return c
23925 }
23926
23927
23928
23929
23930 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall {
23931 c.ctx_ = ctx
23932 return c
23933 }
23934
23935
23936
23937 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) Header() http.Header {
23938 if c.header_ == nil {
23939 c.header_ = make(http.Header)
23940 }
23941 return c.header_
23942 }
23943
23944 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) doRequest(alt string) (*http.Response, error) {
23945 reqHeaders := make(http.Header)
23946 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
23947 for k, v := range c.header_ {
23948 reqHeaders[k] = v
23949 }
23950 reqHeaders.Set("User-Agent", c.s.userAgent())
23951 if c.ifNoneMatch_ != "" {
23952 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
23953 }
23954 var body io.Reader = nil
23955 c.urlParams_.Set("alt", alt)
23956 c.urlParams_.Set("prettyPrint", "false")
23957 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/suspensions")
23958 urls += "?" + c.urlParams_.Encode()
23959 req, err := http.NewRequest("GET", urls, body)
23960 if err != nil {
23961 return nil, err
23962 }
23963 req.Header = reqHeaders
23964 googleapi.Expand(req.URL, map[string]string{
23965 "parent": c.parent,
23966 })
23967 return gensupport.SendRequest(c.ctx_, c.s.client, req)
23968 }
23969
23970
23971
23972
23973
23974
23975
23976
23977
23978
23979 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListSuspensionsResponse, error) {
23980 gensupport.SetOptions(c.urlParams_, opts...)
23981 res, err := c.doRequest("json")
23982 if res != nil && res.StatusCode == http.StatusNotModified {
23983 if res.Body != nil {
23984 res.Body.Close()
23985 }
23986 return nil, gensupport.WrapError(&googleapi.Error{
23987 Code: res.StatusCode,
23988 Header: res.Header,
23989 })
23990 }
23991 if err != nil {
23992 return nil, err
23993 }
23994 defer googleapi.CloseBody(res)
23995 if err := googleapi.CheckResponse(res); err != nil {
23996 return nil, gensupport.WrapError(err)
23997 }
23998 ret := &GoogleCloudIntegrationsV1alphaListSuspensionsResponse{
23999 ServerResponse: googleapi.ServerResponse{
24000 Header: res.Header,
24001 HTTPStatusCode: res.StatusCode,
24002 },
24003 }
24004 target := &ret
24005 if err := gensupport.DecodeResponse(target, res); err != nil {
24006 return nil, err
24007 }
24008 return ret, nil
24009
24010
24011
24012
24013
24014
24015
24016
24017
24018
24019
24020
24021
24022
24023
24024
24025
24026
24027
24028
24029
24030
24031
24032
24033
24034
24035
24036
24037
24038
24039
24040
24041
24042
24043
24044
24045
24046
24047
24048
24049
24050
24051
24052
24053
24054
24055
24056 }
24057
24058
24059
24060
24061 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListSuspensionsResponse) error) error {
24062 c.ctx_ = ctx
24063 defer c.PageToken(c.urlParams_.Get("pageToken"))
24064 for {
24065 x, err := c.Do()
24066 if err != nil {
24067 return err
24068 }
24069 if err := f(x); err != nil {
24070 return err
24071 }
24072 if x.NextPageToken == "" {
24073 return nil
24074 }
24075 c.PageToken(x.NextPageToken)
24076 }
24077 }
24078
24079
24080
24081 type ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall struct {
24082 s *Service
24083 name string
24084 googlecloudintegrationsv1alpharesolvesuspensionrequest *GoogleCloudIntegrationsV1alphaResolveSuspensionRequest
24085 urlParams_ gensupport.URLParams
24086 ctx_ context.Context
24087 header_ http.Header
24088 }
24089
24090
24091
24092
24093
24094
24095
24096
24097
24098
24099 func (r *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsService) Resolve(name string, googlecloudintegrationsv1alpharesolvesuspensionrequest *GoogleCloudIntegrationsV1alphaResolveSuspensionRequest) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall {
24100 c := &ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24101 c.name = name
24102 c.googlecloudintegrationsv1alpharesolvesuspensionrequest = googlecloudintegrationsv1alpharesolvesuspensionrequest
24103 return c
24104 }
24105
24106
24107
24108
24109 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall {
24110 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24111 return c
24112 }
24113
24114
24115
24116
24117 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall {
24118 c.ctx_ = ctx
24119 return c
24120 }
24121
24122
24123
24124 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall) Header() http.Header {
24125 if c.header_ == nil {
24126 c.header_ = make(http.Header)
24127 }
24128 return c.header_
24129 }
24130
24131 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall) doRequest(alt string) (*http.Response, error) {
24132 reqHeaders := make(http.Header)
24133 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
24134 for k, v := range c.header_ {
24135 reqHeaders[k] = v
24136 }
24137 reqHeaders.Set("User-Agent", c.s.userAgent())
24138 var body io.Reader = nil
24139 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alpharesolvesuspensionrequest)
24140 if err != nil {
24141 return nil, err
24142 }
24143 reqHeaders.Set("Content-Type", "application/json")
24144 c.urlParams_.Set("alt", alt)
24145 c.urlParams_.Set("prettyPrint", "false")
24146 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:resolve")
24147 urls += "?" + c.urlParams_.Encode()
24148 req, err := http.NewRequest("POST", urls, body)
24149 if err != nil {
24150 return nil, err
24151 }
24152 req.Header = reqHeaders
24153 googleapi.Expand(req.URL, map[string]string{
24154 "name": c.name,
24155 })
24156 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24157 }
24158
24159
24160
24161
24162
24163
24164
24165
24166
24167
24168
24169 func (c *ProjectsLocationsProductsIntegrationsExecutionsSuspensionsResolveCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaResolveSuspensionResponse, error) {
24170 gensupport.SetOptions(c.urlParams_, opts...)
24171 res, err := c.doRequest("json")
24172 if res != nil && res.StatusCode == http.StatusNotModified {
24173 if res.Body != nil {
24174 res.Body.Close()
24175 }
24176 return nil, gensupport.WrapError(&googleapi.Error{
24177 Code: res.StatusCode,
24178 Header: res.Header,
24179 })
24180 }
24181 if err != nil {
24182 return nil, err
24183 }
24184 defer googleapi.CloseBody(res)
24185 if err := googleapi.CheckResponse(res); err != nil {
24186 return nil, gensupport.WrapError(err)
24187 }
24188 ret := &GoogleCloudIntegrationsV1alphaResolveSuspensionResponse{
24189 ServerResponse: googleapi.ServerResponse{
24190 Header: res.Header,
24191 HTTPStatusCode: res.StatusCode,
24192 },
24193 }
24194 target := &ret
24195 if err := gensupport.DecodeResponse(target, res); err != nil {
24196 return nil, err
24197 }
24198 return ret, nil
24199
24200
24201
24202
24203
24204
24205
24206
24207
24208
24209
24210
24211
24212
24213
24214
24215
24216
24217
24218
24219
24220
24221
24222
24223
24224
24225
24226
24227
24228 }
24229
24230
24231
24232 type ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall struct {
24233 s *Service
24234 parent string
24235 urlParams_ gensupport.URLParams
24236 ifNoneMatch_ string
24237 ctx_ context.Context
24238 header_ http.Header
24239 }
24240
24241
24242
24243
24244
24245 func (r *ProjectsLocationsProductsIntegrationsExecutionsnapshotsService) List(parent string) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall {
24246 c := &ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24247 c.parent = parent
24248 return c
24249 }
24250
24251
24252
24253 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) Filter(filter string) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall {
24254 c.urlParams_.Set("filter", filter)
24255 return c
24256 }
24257
24258
24259
24260 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) PageSize(pageSize int64) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall {
24261 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
24262 return c
24263 }
24264
24265
24266
24267 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) PageToken(pageToken string) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall {
24268 c.urlParams_.Set("pageToken", pageToken)
24269 return c
24270 }
24271
24272
24273
24274
24275
24276 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) ReadMask(readMask string) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall {
24277 c.urlParams_.Set("readMask", readMask)
24278 return c
24279 }
24280
24281
24282
24283
24284 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall {
24285 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24286 return c
24287 }
24288
24289
24290
24291
24292
24293
24294 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall {
24295 c.ifNoneMatch_ = entityTag
24296 return c
24297 }
24298
24299
24300
24301
24302 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall {
24303 c.ctx_ = ctx
24304 return c
24305 }
24306
24307
24308
24309 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) Header() http.Header {
24310 if c.header_ == nil {
24311 c.header_ = make(http.Header)
24312 }
24313 return c.header_
24314 }
24315
24316 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) doRequest(alt string) (*http.Response, error) {
24317 reqHeaders := make(http.Header)
24318 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
24319 for k, v := range c.header_ {
24320 reqHeaders[k] = v
24321 }
24322 reqHeaders.Set("User-Agent", c.s.userAgent())
24323 if c.ifNoneMatch_ != "" {
24324 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
24325 }
24326 var body io.Reader = nil
24327 c.urlParams_.Set("alt", alt)
24328 c.urlParams_.Set("prettyPrint", "false")
24329 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/executionsnapshots")
24330 urls += "?" + c.urlParams_.Encode()
24331 req, err := http.NewRequest("GET", urls, body)
24332 if err != nil {
24333 return nil, err
24334 }
24335 req.Header = reqHeaders
24336 googleapi.Expand(req.URL, map[string]string{
24337 "parent": c.parent,
24338 })
24339 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24340 }
24341
24342
24343
24344
24345
24346
24347
24348
24349
24350
24351
24352 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse, error) {
24353 gensupport.SetOptions(c.urlParams_, opts...)
24354 res, err := c.doRequest("json")
24355 if res != nil && res.StatusCode == http.StatusNotModified {
24356 if res.Body != nil {
24357 res.Body.Close()
24358 }
24359 return nil, gensupport.WrapError(&googleapi.Error{
24360 Code: res.StatusCode,
24361 Header: res.Header,
24362 })
24363 }
24364 if err != nil {
24365 return nil, err
24366 }
24367 defer googleapi.CloseBody(res)
24368 if err := googleapi.CheckResponse(res); err != nil {
24369 return nil, gensupport.WrapError(err)
24370 }
24371 ret := &GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse{
24372 ServerResponse: googleapi.ServerResponse{
24373 Header: res.Header,
24374 HTTPStatusCode: res.StatusCode,
24375 },
24376 }
24377 target := &ret
24378 if err := gensupport.DecodeResponse(target, res); err != nil {
24379 return nil, err
24380 }
24381 return ret, nil
24382
24383
24384
24385
24386
24387
24388
24389
24390
24391
24392
24393
24394
24395
24396
24397
24398
24399
24400
24401
24402
24403
24404
24405
24406
24407
24408
24409
24410
24411
24412
24413
24414
24415
24416
24417
24418
24419
24420
24421
24422
24423
24424
24425
24426
24427
24428
24429
24430 }
24431
24432
24433
24434
24435 func (c *ProjectsLocationsProductsIntegrationsExecutionsnapshotsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListExecutionSnapshotsResponse) error) error {
24436 c.ctx_ = ctx
24437 defer c.PageToken(c.urlParams_.Get("pageToken"))
24438 for {
24439 x, err := c.Do()
24440 if err != nil {
24441 return err
24442 }
24443 if err := f(x); err != nil {
24444 return err
24445 }
24446 if x.NextPageToken == "" {
24447 return nil
24448 }
24449 c.PageToken(x.NextPageToken)
24450 }
24451 }
24452
24453
24454
24455 type ProjectsLocationsProductsIntegrationsVersionsArchiveCall struct {
24456 s *Service
24457 name string
24458 googlecloudintegrationsv1alphaarchiveintegrationversionrequest *GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionRequest
24459 urlParams_ gensupport.URLParams
24460 ctx_ context.Context
24461 header_ http.Header
24462 }
24463
24464
24465
24466
24467
24468
24469
24470
24471
24472
24473
24474
24475
24476
24477
24478 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Archive(name string, googlecloudintegrationsv1alphaarchiveintegrationversionrequest *GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionRequest) *ProjectsLocationsProductsIntegrationsVersionsArchiveCall {
24479 c := &ProjectsLocationsProductsIntegrationsVersionsArchiveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24480 c.name = name
24481 c.googlecloudintegrationsv1alphaarchiveintegrationversionrequest = googlecloudintegrationsv1alphaarchiveintegrationversionrequest
24482 return c
24483 }
24484
24485
24486
24487
24488 func (c *ProjectsLocationsProductsIntegrationsVersionsArchiveCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsArchiveCall {
24489 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24490 return c
24491 }
24492
24493
24494
24495
24496 func (c *ProjectsLocationsProductsIntegrationsVersionsArchiveCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsArchiveCall {
24497 c.ctx_ = ctx
24498 return c
24499 }
24500
24501
24502
24503 func (c *ProjectsLocationsProductsIntegrationsVersionsArchiveCall) Header() http.Header {
24504 if c.header_ == nil {
24505 c.header_ = make(http.Header)
24506 }
24507 return c.header_
24508 }
24509
24510 func (c *ProjectsLocationsProductsIntegrationsVersionsArchiveCall) doRequest(alt string) (*http.Response, error) {
24511 reqHeaders := make(http.Header)
24512 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
24513 for k, v := range c.header_ {
24514 reqHeaders[k] = v
24515 }
24516 reqHeaders.Set("User-Agent", c.s.userAgent())
24517 var body io.Reader = nil
24518 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaarchiveintegrationversionrequest)
24519 if err != nil {
24520 return nil, err
24521 }
24522 reqHeaders.Set("Content-Type", "application/json")
24523 c.urlParams_.Set("alt", alt)
24524 c.urlParams_.Set("prettyPrint", "false")
24525 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:archive")
24526 urls += "?" + c.urlParams_.Encode()
24527 req, err := http.NewRequest("POST", urls, body)
24528 if err != nil {
24529 return nil, err
24530 }
24531 req.Header = reqHeaders
24532 googleapi.Expand(req.URL, map[string]string{
24533 "name": c.name,
24534 })
24535 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24536 }
24537
24538
24539
24540
24541
24542
24543
24544
24545
24546
24547
24548 func (c *ProjectsLocationsProductsIntegrationsVersionsArchiveCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionResponse, error) {
24549 gensupport.SetOptions(c.urlParams_, opts...)
24550 res, err := c.doRequest("json")
24551 if res != nil && res.StatusCode == http.StatusNotModified {
24552 if res.Body != nil {
24553 res.Body.Close()
24554 }
24555 return nil, gensupport.WrapError(&googleapi.Error{
24556 Code: res.StatusCode,
24557 Header: res.Header,
24558 })
24559 }
24560 if err != nil {
24561 return nil, err
24562 }
24563 defer googleapi.CloseBody(res)
24564 if err := googleapi.CheckResponse(res); err != nil {
24565 return nil, gensupport.WrapError(err)
24566 }
24567 ret := &GoogleCloudIntegrationsV1alphaArchiveIntegrationVersionResponse{
24568 ServerResponse: googleapi.ServerResponse{
24569 Header: res.Header,
24570 HTTPStatusCode: res.StatusCode,
24571 },
24572 }
24573 target := &ret
24574 if err := gensupport.DecodeResponse(target, res); err != nil {
24575 return nil, err
24576 }
24577 return ret, nil
24578
24579
24580
24581
24582
24583
24584
24585
24586
24587
24588
24589
24590
24591
24592
24593
24594
24595
24596
24597
24598
24599
24600
24601
24602
24603
24604
24605
24606
24607 }
24608
24609
24610
24611 type ProjectsLocationsProductsIntegrationsVersionsCreateCall struct {
24612 s *Service
24613 parent string
24614 googlecloudintegrationsv1alphaintegrationversion *GoogleCloudIntegrationsV1alphaIntegrationVersion
24615 urlParams_ gensupport.URLParams
24616 ctx_ context.Context
24617 header_ http.Header
24618 }
24619
24620
24621
24622
24623
24624
24625
24626 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Create(parent string, googlecloudintegrationsv1alphaintegrationversion *GoogleCloudIntegrationsV1alphaIntegrationVersion) *ProjectsLocationsProductsIntegrationsVersionsCreateCall {
24627 c := &ProjectsLocationsProductsIntegrationsVersionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24628 c.parent = parent
24629 c.googlecloudintegrationsv1alphaintegrationversion = googlecloudintegrationsv1alphaintegrationversion
24630 return c
24631 }
24632
24633
24634
24635
24636
24637
24638
24639 func (c *ProjectsLocationsProductsIntegrationsVersionsCreateCall) NewIntegration(newIntegration bool) *ProjectsLocationsProductsIntegrationsVersionsCreateCall {
24640 c.urlParams_.Set("newIntegration", fmt.Sprint(newIntegration))
24641 return c
24642 }
24643
24644
24645
24646
24647 func (c *ProjectsLocationsProductsIntegrationsVersionsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsCreateCall {
24648 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24649 return c
24650 }
24651
24652
24653
24654
24655 func (c *ProjectsLocationsProductsIntegrationsVersionsCreateCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsCreateCall {
24656 c.ctx_ = ctx
24657 return c
24658 }
24659
24660
24661
24662 func (c *ProjectsLocationsProductsIntegrationsVersionsCreateCall) Header() http.Header {
24663 if c.header_ == nil {
24664 c.header_ = make(http.Header)
24665 }
24666 return c.header_
24667 }
24668
24669 func (c *ProjectsLocationsProductsIntegrationsVersionsCreateCall) doRequest(alt string) (*http.Response, error) {
24670 reqHeaders := make(http.Header)
24671 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
24672 for k, v := range c.header_ {
24673 reqHeaders[k] = v
24674 }
24675 reqHeaders.Set("User-Agent", c.s.userAgent())
24676 var body io.Reader = nil
24677 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaintegrationversion)
24678 if err != nil {
24679 return nil, err
24680 }
24681 reqHeaders.Set("Content-Type", "application/json")
24682 c.urlParams_.Set("alt", alt)
24683 c.urlParams_.Set("prettyPrint", "false")
24684 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/versions")
24685 urls += "?" + c.urlParams_.Encode()
24686 req, err := http.NewRequest("POST", urls, body)
24687 if err != nil {
24688 return nil, err
24689 }
24690 req.Header = reqHeaders
24691 googleapi.Expand(req.URL, map[string]string{
24692 "parent": c.parent,
24693 })
24694 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24695 }
24696
24697
24698
24699
24700
24701
24702
24703
24704
24705
24706 func (c *ProjectsLocationsProductsIntegrationsVersionsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaIntegrationVersion, error) {
24707 gensupport.SetOptions(c.urlParams_, opts...)
24708 res, err := c.doRequest("json")
24709 if res != nil && res.StatusCode == http.StatusNotModified {
24710 if res.Body != nil {
24711 res.Body.Close()
24712 }
24713 return nil, gensupport.WrapError(&googleapi.Error{
24714 Code: res.StatusCode,
24715 Header: res.Header,
24716 })
24717 }
24718 if err != nil {
24719 return nil, err
24720 }
24721 defer googleapi.CloseBody(res)
24722 if err := googleapi.CheckResponse(res); err != nil {
24723 return nil, gensupport.WrapError(err)
24724 }
24725 ret := &GoogleCloudIntegrationsV1alphaIntegrationVersion{
24726 ServerResponse: googleapi.ServerResponse{
24727 Header: res.Header,
24728 HTTPStatusCode: res.StatusCode,
24729 },
24730 }
24731 target := &ret
24732 if err := gensupport.DecodeResponse(target, res); err != nil {
24733 return nil, err
24734 }
24735 return ret, nil
24736
24737
24738
24739
24740
24741
24742
24743
24744
24745
24746
24747
24748
24749
24750
24751
24752
24753
24754
24755
24756
24757
24758
24759
24760
24761
24762
24763
24764
24765
24766
24767
24768
24769
24770 }
24771
24772
24773
24774 type ProjectsLocationsProductsIntegrationsVersionsDeactivateCall struct {
24775 s *Service
24776 name string
24777 googlecloudintegrationsv1alphadeactivateintegrationversionrequest *GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionRequest
24778 urlParams_ gensupport.URLParams
24779 ctx_ context.Context
24780 header_ http.Header
24781 }
24782
24783
24784
24785
24786
24787
24788
24789
24790
24791
24792 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Deactivate(name string, googlecloudintegrationsv1alphadeactivateintegrationversionrequest *GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionRequest) *ProjectsLocationsProductsIntegrationsVersionsDeactivateCall {
24793 c := &ProjectsLocationsProductsIntegrationsVersionsDeactivateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24794 c.name = name
24795 c.googlecloudintegrationsv1alphadeactivateintegrationversionrequest = googlecloudintegrationsv1alphadeactivateintegrationversionrequest
24796 return c
24797 }
24798
24799
24800
24801
24802 func (c *ProjectsLocationsProductsIntegrationsVersionsDeactivateCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsDeactivateCall {
24803 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24804 return c
24805 }
24806
24807
24808
24809
24810 func (c *ProjectsLocationsProductsIntegrationsVersionsDeactivateCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsDeactivateCall {
24811 c.ctx_ = ctx
24812 return c
24813 }
24814
24815
24816
24817 func (c *ProjectsLocationsProductsIntegrationsVersionsDeactivateCall) Header() http.Header {
24818 if c.header_ == nil {
24819 c.header_ = make(http.Header)
24820 }
24821 return c.header_
24822 }
24823
24824 func (c *ProjectsLocationsProductsIntegrationsVersionsDeactivateCall) doRequest(alt string) (*http.Response, error) {
24825 reqHeaders := make(http.Header)
24826 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
24827 for k, v := range c.header_ {
24828 reqHeaders[k] = v
24829 }
24830 reqHeaders.Set("User-Agent", c.s.userAgent())
24831 var body io.Reader = nil
24832 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphadeactivateintegrationversionrequest)
24833 if err != nil {
24834 return nil, err
24835 }
24836 reqHeaders.Set("Content-Type", "application/json")
24837 c.urlParams_.Set("alt", alt)
24838 c.urlParams_.Set("prettyPrint", "false")
24839 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:deactivate")
24840 urls += "?" + c.urlParams_.Encode()
24841 req, err := http.NewRequest("POST", urls, body)
24842 if err != nil {
24843 return nil, err
24844 }
24845 req.Header = reqHeaders
24846 googleapi.Expand(req.URL, map[string]string{
24847 "name": c.name,
24848 })
24849 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24850 }
24851
24852
24853
24854
24855
24856
24857
24858
24859
24860
24861
24862 func (c *ProjectsLocationsProductsIntegrationsVersionsDeactivateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionResponse, error) {
24863 gensupport.SetOptions(c.urlParams_, opts...)
24864 res, err := c.doRequest("json")
24865 if res != nil && res.StatusCode == http.StatusNotModified {
24866 if res.Body != nil {
24867 res.Body.Close()
24868 }
24869 return nil, gensupport.WrapError(&googleapi.Error{
24870 Code: res.StatusCode,
24871 Header: res.Header,
24872 })
24873 }
24874 if err != nil {
24875 return nil, err
24876 }
24877 defer googleapi.CloseBody(res)
24878 if err := googleapi.CheckResponse(res); err != nil {
24879 return nil, gensupport.WrapError(err)
24880 }
24881 ret := &GoogleCloudIntegrationsV1alphaDeactivateIntegrationVersionResponse{
24882 ServerResponse: googleapi.ServerResponse{
24883 Header: res.Header,
24884 HTTPStatusCode: res.StatusCode,
24885 },
24886 }
24887 target := &ret
24888 if err := gensupport.DecodeResponse(target, res); err != nil {
24889 return nil, err
24890 }
24891 return ret, nil
24892
24893
24894
24895
24896
24897
24898
24899
24900
24901
24902
24903
24904
24905
24906
24907
24908
24909
24910
24911
24912
24913
24914
24915
24916
24917
24918
24919
24920
24921 }
24922
24923
24924
24925 type ProjectsLocationsProductsIntegrationsVersionsDeleteCall struct {
24926 s *Service
24927 name string
24928 urlParams_ gensupport.URLParams
24929 ctx_ context.Context
24930 header_ http.Header
24931 }
24932
24933
24934
24935
24936
24937
24938
24939
24940
24941
24942
24943
24944
24945
24946
24947 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Delete(name string) *ProjectsLocationsProductsIntegrationsVersionsDeleteCall {
24948 c := &ProjectsLocationsProductsIntegrationsVersionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
24949 c.name = name
24950 return c
24951 }
24952
24953
24954
24955
24956 func (c *ProjectsLocationsProductsIntegrationsVersionsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsDeleteCall {
24957 c.urlParams_.Set("fields", googleapi.CombineFields(s))
24958 return c
24959 }
24960
24961
24962
24963
24964 func (c *ProjectsLocationsProductsIntegrationsVersionsDeleteCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsDeleteCall {
24965 c.ctx_ = ctx
24966 return c
24967 }
24968
24969
24970
24971 func (c *ProjectsLocationsProductsIntegrationsVersionsDeleteCall) Header() http.Header {
24972 if c.header_ == nil {
24973 c.header_ = make(http.Header)
24974 }
24975 return c.header_
24976 }
24977
24978 func (c *ProjectsLocationsProductsIntegrationsVersionsDeleteCall) doRequest(alt string) (*http.Response, error) {
24979 reqHeaders := make(http.Header)
24980 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
24981 for k, v := range c.header_ {
24982 reqHeaders[k] = v
24983 }
24984 reqHeaders.Set("User-Agent", c.s.userAgent())
24985 var body io.Reader = nil
24986 c.urlParams_.Set("alt", alt)
24987 c.urlParams_.Set("prettyPrint", "false")
24988 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
24989 urls += "?" + c.urlParams_.Encode()
24990 req, err := http.NewRequest("DELETE", urls, body)
24991 if err != nil {
24992 return nil, err
24993 }
24994 req.Header = reqHeaders
24995 googleapi.Expand(req.URL, map[string]string{
24996 "name": c.name,
24997 })
24998 return gensupport.SendRequest(c.ctx_, c.s.client, req)
24999 }
25000
25001
25002
25003
25004
25005
25006
25007
25008 func (c *ProjectsLocationsProductsIntegrationsVersionsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
25009 gensupport.SetOptions(c.urlParams_, opts...)
25010 res, err := c.doRequest("json")
25011 if res != nil && res.StatusCode == http.StatusNotModified {
25012 if res.Body != nil {
25013 res.Body.Close()
25014 }
25015 return nil, gensupport.WrapError(&googleapi.Error{
25016 Code: res.StatusCode,
25017 Header: res.Header,
25018 })
25019 }
25020 if err != nil {
25021 return nil, err
25022 }
25023 defer googleapi.CloseBody(res)
25024 if err := googleapi.CheckResponse(res); err != nil {
25025 return nil, gensupport.WrapError(err)
25026 }
25027 ret := &GoogleProtobufEmpty{
25028 ServerResponse: googleapi.ServerResponse{
25029 Header: res.Header,
25030 HTTPStatusCode: res.StatusCode,
25031 },
25032 }
25033 target := &ret
25034 if err := gensupport.DecodeResponse(target, res); err != nil {
25035 return nil, err
25036 }
25037 return ret, nil
25038
25039
25040
25041
25042
25043
25044
25045
25046
25047
25048
25049
25050
25051
25052
25053
25054
25055
25056
25057
25058
25059
25060
25061
25062
25063
25064 }
25065
25066
25067
25068 type ProjectsLocationsProductsIntegrationsVersionsDownloadCall struct {
25069 s *Service
25070 name string
25071 urlParams_ gensupport.URLParams
25072 ifNoneMatch_ string
25073 ctx_ context.Context
25074 header_ http.Header
25075 }
25076
25077
25078
25079
25080
25081
25082
25083
25084 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Download(name string) *ProjectsLocationsProductsIntegrationsVersionsDownloadCall {
25085 c := &ProjectsLocationsProductsIntegrationsVersionsDownloadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25086 c.name = name
25087 return c
25088 }
25089
25090
25091
25092
25093
25094
25095
25096
25097
25098 func (c *ProjectsLocationsProductsIntegrationsVersionsDownloadCall) FileFormat(fileFormat string) *ProjectsLocationsProductsIntegrationsVersionsDownloadCall {
25099 c.urlParams_.Set("fileFormat", fileFormat)
25100 return c
25101 }
25102
25103
25104
25105
25106 func (c *ProjectsLocationsProductsIntegrationsVersionsDownloadCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsDownloadCall {
25107 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25108 return c
25109 }
25110
25111
25112
25113
25114
25115
25116 func (c *ProjectsLocationsProductsIntegrationsVersionsDownloadCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsVersionsDownloadCall {
25117 c.ifNoneMatch_ = entityTag
25118 return c
25119 }
25120
25121
25122
25123
25124 func (c *ProjectsLocationsProductsIntegrationsVersionsDownloadCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsDownloadCall {
25125 c.ctx_ = ctx
25126 return c
25127 }
25128
25129
25130
25131 func (c *ProjectsLocationsProductsIntegrationsVersionsDownloadCall) Header() http.Header {
25132 if c.header_ == nil {
25133 c.header_ = make(http.Header)
25134 }
25135 return c.header_
25136 }
25137
25138 func (c *ProjectsLocationsProductsIntegrationsVersionsDownloadCall) doRequest(alt string) (*http.Response, error) {
25139 reqHeaders := make(http.Header)
25140 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
25141 for k, v := range c.header_ {
25142 reqHeaders[k] = v
25143 }
25144 reqHeaders.Set("User-Agent", c.s.userAgent())
25145 if c.ifNoneMatch_ != "" {
25146 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
25147 }
25148 var body io.Reader = nil
25149 c.urlParams_.Set("alt", alt)
25150 c.urlParams_.Set("prettyPrint", "false")
25151 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:download")
25152 urls += "?" + c.urlParams_.Encode()
25153 req, err := http.NewRequest("GET", urls, body)
25154 if err != nil {
25155 return nil, err
25156 }
25157 req.Header = reqHeaders
25158 googleapi.Expand(req.URL, map[string]string{
25159 "name": c.name,
25160 })
25161 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25162 }
25163
25164
25165
25166
25167
25168
25169
25170
25171
25172
25173
25174 func (c *ProjectsLocationsProductsIntegrationsVersionsDownloadCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaDownloadIntegrationVersionResponse, error) {
25175 gensupport.SetOptions(c.urlParams_, opts...)
25176 res, err := c.doRequest("json")
25177 if res != nil && res.StatusCode == http.StatusNotModified {
25178 if res.Body != nil {
25179 res.Body.Close()
25180 }
25181 return nil, gensupport.WrapError(&googleapi.Error{
25182 Code: res.StatusCode,
25183 Header: res.Header,
25184 })
25185 }
25186 if err != nil {
25187 return nil, err
25188 }
25189 defer googleapi.CloseBody(res)
25190 if err := googleapi.CheckResponse(res); err != nil {
25191 return nil, gensupport.WrapError(err)
25192 }
25193 ret := &GoogleCloudIntegrationsV1alphaDownloadIntegrationVersionResponse{
25194 ServerResponse: googleapi.ServerResponse{
25195 Header: res.Header,
25196 HTTPStatusCode: res.StatusCode,
25197 },
25198 }
25199 target := &ret
25200 if err := gensupport.DecodeResponse(target, res); err != nil {
25201 return nil, err
25202 }
25203 return ret, nil
25204
25205
25206
25207
25208
25209
25210
25211
25212
25213
25214
25215
25216
25217
25218
25219
25220
25221
25222
25223
25224
25225
25226
25227
25228
25229
25230
25231
25232
25233
25234
25235
25236
25237
25238
25239
25240
25241
25242
25243
25244
25245 }
25246
25247
25248
25249 type ProjectsLocationsProductsIntegrationsVersionsGetCall struct {
25250 s *Service
25251 name string
25252 urlParams_ gensupport.URLParams
25253 ifNoneMatch_ string
25254 ctx_ context.Context
25255 header_ http.Header
25256 }
25257
25258
25259
25260
25261
25262
25263 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Get(name string) *ProjectsLocationsProductsIntegrationsVersionsGetCall {
25264 c := &ProjectsLocationsProductsIntegrationsVersionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25265 c.name = name
25266 return c
25267 }
25268
25269
25270
25271
25272 func (c *ProjectsLocationsProductsIntegrationsVersionsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsGetCall {
25273 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25274 return c
25275 }
25276
25277
25278
25279
25280
25281
25282 func (c *ProjectsLocationsProductsIntegrationsVersionsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsVersionsGetCall {
25283 c.ifNoneMatch_ = entityTag
25284 return c
25285 }
25286
25287
25288
25289
25290 func (c *ProjectsLocationsProductsIntegrationsVersionsGetCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsGetCall {
25291 c.ctx_ = ctx
25292 return c
25293 }
25294
25295
25296
25297 func (c *ProjectsLocationsProductsIntegrationsVersionsGetCall) Header() http.Header {
25298 if c.header_ == nil {
25299 c.header_ = make(http.Header)
25300 }
25301 return c.header_
25302 }
25303
25304 func (c *ProjectsLocationsProductsIntegrationsVersionsGetCall) doRequest(alt string) (*http.Response, error) {
25305 reqHeaders := make(http.Header)
25306 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
25307 for k, v := range c.header_ {
25308 reqHeaders[k] = v
25309 }
25310 reqHeaders.Set("User-Agent", c.s.userAgent())
25311 if c.ifNoneMatch_ != "" {
25312 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
25313 }
25314 var body io.Reader = nil
25315 c.urlParams_.Set("alt", alt)
25316 c.urlParams_.Set("prettyPrint", "false")
25317 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
25318 urls += "?" + c.urlParams_.Encode()
25319 req, err := http.NewRequest("GET", urls, body)
25320 if err != nil {
25321 return nil, err
25322 }
25323 req.Header = reqHeaders
25324 googleapi.Expand(req.URL, map[string]string{
25325 "name": c.name,
25326 })
25327 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25328 }
25329
25330
25331
25332
25333
25334
25335
25336
25337
25338
25339 func (c *ProjectsLocationsProductsIntegrationsVersionsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaIntegrationVersion, error) {
25340 gensupport.SetOptions(c.urlParams_, opts...)
25341 res, err := c.doRequest("json")
25342 if res != nil && res.StatusCode == http.StatusNotModified {
25343 if res.Body != nil {
25344 res.Body.Close()
25345 }
25346 return nil, gensupport.WrapError(&googleapi.Error{
25347 Code: res.StatusCode,
25348 Header: res.Header,
25349 })
25350 }
25351 if err != nil {
25352 return nil, err
25353 }
25354 defer googleapi.CloseBody(res)
25355 if err := googleapi.CheckResponse(res); err != nil {
25356 return nil, gensupport.WrapError(err)
25357 }
25358 ret := &GoogleCloudIntegrationsV1alphaIntegrationVersion{
25359 ServerResponse: googleapi.ServerResponse{
25360 Header: res.Header,
25361 HTTPStatusCode: res.StatusCode,
25362 },
25363 }
25364 target := &ret
25365 if err := gensupport.DecodeResponse(target, res); err != nil {
25366 return nil, err
25367 }
25368 return ret, nil
25369
25370
25371
25372
25373
25374
25375
25376
25377
25378
25379
25380
25381
25382
25383
25384
25385
25386
25387
25388
25389
25390
25391
25392
25393
25394
25395 }
25396
25397
25398
25399 type ProjectsLocationsProductsIntegrationsVersionsGetBundleCall struct {
25400 s *Service
25401 name string
25402 urlParams_ gensupport.URLParams
25403 ifNoneMatch_ string
25404 ctx_ context.Context
25405 header_ http.Header
25406 }
25407
25408
25409
25410
25411
25412 func (r *ProjectsLocationsProductsIntegrationsVersionsService) GetBundle(name string) *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall {
25413 c := &ProjectsLocationsProductsIntegrationsVersionsGetBundleCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25414 c.name = name
25415 return c
25416 }
25417
25418
25419
25420
25421 func (c *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall {
25422 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25423 return c
25424 }
25425
25426
25427
25428
25429
25430
25431 func (c *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall {
25432 c.ifNoneMatch_ = entityTag
25433 return c
25434 }
25435
25436
25437
25438
25439 func (c *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall {
25440 c.ctx_ = ctx
25441 return c
25442 }
25443
25444
25445
25446 func (c *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall) Header() http.Header {
25447 if c.header_ == nil {
25448 c.header_ = make(http.Header)
25449 }
25450 return c.header_
25451 }
25452
25453 func (c *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall) doRequest(alt string) (*http.Response, error) {
25454 reqHeaders := make(http.Header)
25455 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
25456 for k, v := range c.header_ {
25457 reqHeaders[k] = v
25458 }
25459 reqHeaders.Set("User-Agent", c.s.userAgent())
25460 if c.ifNoneMatch_ != "" {
25461 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
25462 }
25463 var body io.Reader = nil
25464 c.urlParams_.Set("alt", alt)
25465 c.urlParams_.Set("prettyPrint", "false")
25466 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:getBundle")
25467 urls += "?" + c.urlParams_.Encode()
25468 req, err := http.NewRequest("GET", urls, body)
25469 if err != nil {
25470 return nil, err
25471 }
25472 req.Header = reqHeaders
25473 googleapi.Expand(req.URL, map[string]string{
25474 "name": c.name,
25475 })
25476 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25477 }
25478
25479
25480
25481
25482
25483
25484
25485
25486
25487
25488
25489
25490 func (c *ProjectsLocationsProductsIntegrationsVersionsGetBundleCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaGetBundleResponse, error) {
25491 gensupport.SetOptions(c.urlParams_, opts...)
25492 res, err := c.doRequest("json")
25493 if res != nil && res.StatusCode == http.StatusNotModified {
25494 if res.Body != nil {
25495 res.Body.Close()
25496 }
25497 return nil, gensupport.WrapError(&googleapi.Error{
25498 Code: res.StatusCode,
25499 Header: res.Header,
25500 })
25501 }
25502 if err != nil {
25503 return nil, err
25504 }
25505 defer googleapi.CloseBody(res)
25506 if err := googleapi.CheckResponse(res); err != nil {
25507 return nil, gensupport.WrapError(err)
25508 }
25509 ret := &GoogleCloudIntegrationsV1alphaGetBundleResponse{
25510 ServerResponse: googleapi.ServerResponse{
25511 Header: res.Header,
25512 HTTPStatusCode: res.StatusCode,
25513 },
25514 }
25515 target := &ret
25516 if err := gensupport.DecodeResponse(target, res); err != nil {
25517 return nil, err
25518 }
25519 return ret, nil
25520
25521
25522
25523
25524
25525
25526
25527
25528
25529
25530
25531
25532
25533
25534
25535
25536
25537
25538
25539
25540
25541
25542
25543
25544
25545
25546 }
25547
25548
25549
25550 type ProjectsLocationsProductsIntegrationsVersionsListCall struct {
25551 s *Service
25552 parent string
25553 urlParams_ gensupport.URLParams
25554 ifNoneMatch_ string
25555 ctx_ context.Context
25556 header_ http.Header
25557 }
25558
25559
25560
25561
25562
25563
25564
25565
25566
25567
25568
25569
25570
25571
25572 func (r *ProjectsLocationsProductsIntegrationsVersionsService) List(parent string) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25573 c := &ProjectsLocationsProductsIntegrationsVersionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25574 c.parent = parent
25575 return c
25576 }
25577
25578
25579
25580 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) FieldMask(fieldMask string) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25581 c.urlParams_.Set("fieldMask", fieldMask)
25582 return c
25583 }
25584
25585
25586
25587
25588
25589
25590
25591
25592
25593 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) Filter(filter string) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25594 c.urlParams_.Set("filter", filter)
25595 return c
25596 }
25597
25598
25599
25600
25601
25602 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) OrderBy(orderBy string) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25603 c.urlParams_.Set("orderBy", orderBy)
25604 return c
25605 }
25606
25607
25608
25609
25610
25611 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) PageSize(pageSize int64) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25612 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
25613 return c
25614 }
25615
25616
25617
25618
25619
25620
25621 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) PageToken(pageToken string) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25622 c.urlParams_.Set("pageToken", pageToken)
25623 return c
25624 }
25625
25626
25627
25628
25629 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25630 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25631 return c
25632 }
25633
25634
25635
25636
25637
25638
25639 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25640 c.ifNoneMatch_ = entityTag
25641 return c
25642 }
25643
25644
25645
25646
25647 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsListCall {
25648 c.ctx_ = ctx
25649 return c
25650 }
25651
25652
25653
25654 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) Header() http.Header {
25655 if c.header_ == nil {
25656 c.header_ = make(http.Header)
25657 }
25658 return c.header_
25659 }
25660
25661 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) doRequest(alt string) (*http.Response, error) {
25662 reqHeaders := make(http.Header)
25663 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
25664 for k, v := range c.header_ {
25665 reqHeaders[k] = v
25666 }
25667 reqHeaders.Set("User-Agent", c.s.userAgent())
25668 if c.ifNoneMatch_ != "" {
25669 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
25670 }
25671 var body io.Reader = nil
25672 c.urlParams_.Set("alt", alt)
25673 c.urlParams_.Set("prettyPrint", "false")
25674 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/versions")
25675 urls += "?" + c.urlParams_.Encode()
25676 req, err := http.NewRequest("GET", urls, body)
25677 if err != nil {
25678 return nil, err
25679 }
25680 req.Header = reqHeaders
25681 googleapi.Expand(req.URL, map[string]string{
25682 "parent": c.parent,
25683 })
25684 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25685 }
25686
25687
25688
25689
25690
25691
25692
25693
25694
25695
25696
25697 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse, error) {
25698 gensupport.SetOptions(c.urlParams_, opts...)
25699 res, err := c.doRequest("json")
25700 if res != nil && res.StatusCode == http.StatusNotModified {
25701 if res.Body != nil {
25702 res.Body.Close()
25703 }
25704 return nil, gensupport.WrapError(&googleapi.Error{
25705 Code: res.StatusCode,
25706 Header: res.Header,
25707 })
25708 }
25709 if err != nil {
25710 return nil, err
25711 }
25712 defer googleapi.CloseBody(res)
25713 if err := googleapi.CheckResponse(res); err != nil {
25714 return nil, gensupport.WrapError(err)
25715 }
25716 ret := &GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse{
25717 ServerResponse: googleapi.ServerResponse{
25718 Header: res.Header,
25719 HTTPStatusCode: res.StatusCode,
25720 },
25721 }
25722 target := &ret
25723 if err := gensupport.DecodeResponse(target, res); err != nil {
25724 return nil, err
25725 }
25726 return ret, nil
25727
25728
25729
25730
25731
25732
25733
25734
25735
25736
25737
25738
25739
25740
25741
25742
25743
25744
25745
25746
25747
25748
25749
25750
25751
25752
25753
25754
25755
25756
25757
25758
25759
25760
25761
25762
25763
25764
25765
25766
25767
25768
25769
25770
25771
25772
25773
25774
25775
25776
25777
25778
25779
25780 }
25781
25782
25783
25784
25785 func (c *ProjectsLocationsProductsIntegrationsVersionsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListIntegrationVersionsResponse) error) error {
25786 c.ctx_ = ctx
25787 defer c.PageToken(c.urlParams_.Get("pageToken"))
25788 for {
25789 x, err := c.Do()
25790 if err != nil {
25791 return err
25792 }
25793 if err := f(x); err != nil {
25794 return err
25795 }
25796 if x.NextPageToken == "" {
25797 return nil
25798 }
25799 c.PageToken(x.NextPageToken)
25800 }
25801 }
25802
25803
25804
25805 type ProjectsLocationsProductsIntegrationsVersionsPatchCall struct {
25806 s *Service
25807 name string
25808 googlecloudintegrationsv1alphaintegrationversion *GoogleCloudIntegrationsV1alphaIntegrationVersion
25809 urlParams_ gensupport.URLParams
25810 ctx_ context.Context
25811 header_ http.Header
25812 }
25813
25814
25815
25816
25817
25818 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Patch(name string, googlecloudintegrationsv1alphaintegrationversion *GoogleCloudIntegrationsV1alphaIntegrationVersion) *ProjectsLocationsProductsIntegrationsVersionsPatchCall {
25819 c := &ProjectsLocationsProductsIntegrationsVersionsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25820 c.name = name
25821 c.googlecloudintegrationsv1alphaintegrationversion = googlecloudintegrationsv1alphaintegrationversion
25822 return c
25823 }
25824
25825
25826
25827
25828 func (c *ProjectsLocationsProductsIntegrationsVersionsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsProductsIntegrationsVersionsPatchCall {
25829 c.urlParams_.Set("updateMask", updateMask)
25830 return c
25831 }
25832
25833
25834
25835
25836 func (c *ProjectsLocationsProductsIntegrationsVersionsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsPatchCall {
25837 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25838 return c
25839 }
25840
25841
25842
25843
25844 func (c *ProjectsLocationsProductsIntegrationsVersionsPatchCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsPatchCall {
25845 c.ctx_ = ctx
25846 return c
25847 }
25848
25849
25850
25851 func (c *ProjectsLocationsProductsIntegrationsVersionsPatchCall) Header() http.Header {
25852 if c.header_ == nil {
25853 c.header_ = make(http.Header)
25854 }
25855 return c.header_
25856 }
25857
25858 func (c *ProjectsLocationsProductsIntegrationsVersionsPatchCall) doRequest(alt string) (*http.Response, error) {
25859 reqHeaders := make(http.Header)
25860 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
25861 for k, v := range c.header_ {
25862 reqHeaders[k] = v
25863 }
25864 reqHeaders.Set("User-Agent", c.s.userAgent())
25865 var body io.Reader = nil
25866 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaintegrationversion)
25867 if err != nil {
25868 return nil, err
25869 }
25870 reqHeaders.Set("Content-Type", "application/json")
25871 c.urlParams_.Set("alt", alt)
25872 c.urlParams_.Set("prettyPrint", "false")
25873 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
25874 urls += "?" + c.urlParams_.Encode()
25875 req, err := http.NewRequest("PATCH", urls, body)
25876 if err != nil {
25877 return nil, err
25878 }
25879 req.Header = reqHeaders
25880 googleapi.Expand(req.URL, map[string]string{
25881 "name": c.name,
25882 })
25883 return gensupport.SendRequest(c.ctx_, c.s.client, req)
25884 }
25885
25886
25887
25888
25889
25890
25891
25892
25893
25894
25895 func (c *ProjectsLocationsProductsIntegrationsVersionsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaIntegrationVersion, error) {
25896 gensupport.SetOptions(c.urlParams_, opts...)
25897 res, err := c.doRequest("json")
25898 if res != nil && res.StatusCode == http.StatusNotModified {
25899 if res.Body != nil {
25900 res.Body.Close()
25901 }
25902 return nil, gensupport.WrapError(&googleapi.Error{
25903 Code: res.StatusCode,
25904 Header: res.Header,
25905 })
25906 }
25907 if err != nil {
25908 return nil, err
25909 }
25910 defer googleapi.CloseBody(res)
25911 if err := googleapi.CheckResponse(res); err != nil {
25912 return nil, gensupport.WrapError(err)
25913 }
25914 ret := &GoogleCloudIntegrationsV1alphaIntegrationVersion{
25915 ServerResponse: googleapi.ServerResponse{
25916 Header: res.Header,
25917 HTTPStatusCode: res.StatusCode,
25918 },
25919 }
25920 target := &ret
25921 if err := gensupport.DecodeResponse(target, res); err != nil {
25922 return nil, err
25923 }
25924 return ret, nil
25925
25926
25927
25928
25929
25930
25931
25932
25933
25934
25935
25936
25937
25938
25939
25940
25941
25942
25943
25944
25945
25946
25947
25948
25949
25950
25951
25952
25953
25954
25955
25956
25957
25958
25959
25960 }
25961
25962
25963
25964 type ProjectsLocationsProductsIntegrationsVersionsPublishCall struct {
25965 s *Service
25966 name string
25967 googlecloudintegrationsv1alphapublishintegrationversionrequest *GoogleCloudIntegrationsV1alphaPublishIntegrationVersionRequest
25968 urlParams_ gensupport.URLParams
25969 ctx_ context.Context
25970 header_ http.Header
25971 }
25972
25973
25974
25975
25976
25977
25978
25979
25980
25981
25982
25983
25984 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Publish(name string, googlecloudintegrationsv1alphapublishintegrationversionrequest *GoogleCloudIntegrationsV1alphaPublishIntegrationVersionRequest) *ProjectsLocationsProductsIntegrationsVersionsPublishCall {
25985 c := &ProjectsLocationsProductsIntegrationsVersionsPublishCall{s: r.s, urlParams_: make(gensupport.URLParams)}
25986 c.name = name
25987 c.googlecloudintegrationsv1alphapublishintegrationversionrequest = googlecloudintegrationsv1alphapublishintegrationversionrequest
25988 return c
25989 }
25990
25991
25992
25993
25994 func (c *ProjectsLocationsProductsIntegrationsVersionsPublishCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsPublishCall {
25995 c.urlParams_.Set("fields", googleapi.CombineFields(s))
25996 return c
25997 }
25998
25999
26000
26001
26002 func (c *ProjectsLocationsProductsIntegrationsVersionsPublishCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsPublishCall {
26003 c.ctx_ = ctx
26004 return c
26005 }
26006
26007
26008
26009 func (c *ProjectsLocationsProductsIntegrationsVersionsPublishCall) Header() http.Header {
26010 if c.header_ == nil {
26011 c.header_ = make(http.Header)
26012 }
26013 return c.header_
26014 }
26015
26016 func (c *ProjectsLocationsProductsIntegrationsVersionsPublishCall) doRequest(alt string) (*http.Response, error) {
26017 reqHeaders := make(http.Header)
26018 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
26019 for k, v := range c.header_ {
26020 reqHeaders[k] = v
26021 }
26022 reqHeaders.Set("User-Agent", c.s.userAgent())
26023 var body io.Reader = nil
26024 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphapublishintegrationversionrequest)
26025 if err != nil {
26026 return nil, err
26027 }
26028 reqHeaders.Set("Content-Type", "application/json")
26029 c.urlParams_.Set("alt", alt)
26030 c.urlParams_.Set("prettyPrint", "false")
26031 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:publish")
26032 urls += "?" + c.urlParams_.Encode()
26033 req, err := http.NewRequest("POST", urls, body)
26034 if err != nil {
26035 return nil, err
26036 }
26037 req.Header = reqHeaders
26038 googleapi.Expand(req.URL, map[string]string{
26039 "name": c.name,
26040 })
26041 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26042 }
26043
26044
26045
26046
26047
26048
26049
26050
26051
26052
26053
26054 func (c *ProjectsLocationsProductsIntegrationsVersionsPublishCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaPublishIntegrationVersionResponse, error) {
26055 gensupport.SetOptions(c.urlParams_, opts...)
26056 res, err := c.doRequest("json")
26057 if res != nil && res.StatusCode == http.StatusNotModified {
26058 if res.Body != nil {
26059 res.Body.Close()
26060 }
26061 return nil, gensupport.WrapError(&googleapi.Error{
26062 Code: res.StatusCode,
26063 Header: res.Header,
26064 })
26065 }
26066 if err != nil {
26067 return nil, err
26068 }
26069 defer googleapi.CloseBody(res)
26070 if err := googleapi.CheckResponse(res); err != nil {
26071 return nil, gensupport.WrapError(err)
26072 }
26073 ret := &GoogleCloudIntegrationsV1alphaPublishIntegrationVersionResponse{
26074 ServerResponse: googleapi.ServerResponse{
26075 Header: res.Header,
26076 HTTPStatusCode: res.StatusCode,
26077 },
26078 }
26079 target := &ret
26080 if err := gensupport.DecodeResponse(target, res); err != nil {
26081 return nil, err
26082 }
26083 return ret, nil
26084
26085
26086
26087
26088
26089
26090
26091
26092
26093
26094
26095
26096
26097
26098
26099
26100
26101
26102
26103
26104
26105
26106
26107
26108
26109
26110
26111
26112
26113 }
26114
26115
26116
26117 type ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall struct {
26118 s *Service
26119 integrationVersion string
26120 googlecloudintegrationsv1alphatakeovereditlockrequest *GoogleCloudIntegrationsV1alphaTakeoverEditLockRequest
26121 urlParams_ gensupport.URLParams
26122 ctx_ context.Context
26123 header_ http.Header
26124 }
26125
26126
26127
26128
26129
26130
26131
26132
26133
26134
26135
26136
26137
26138
26139
26140
26141
26142 func (r *ProjectsLocationsProductsIntegrationsVersionsService) TakeoverEditLock(integrationVersion string, googlecloudintegrationsv1alphatakeovereditlockrequest *GoogleCloudIntegrationsV1alphaTakeoverEditLockRequest) *ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall {
26143 c := &ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26144 c.integrationVersion = integrationVersion
26145 c.googlecloudintegrationsv1alphatakeovereditlockrequest = googlecloudintegrationsv1alphatakeovereditlockrequest
26146 return c
26147 }
26148
26149
26150
26151
26152 func (c *ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall {
26153 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26154 return c
26155 }
26156
26157
26158
26159
26160 func (c *ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall {
26161 c.ctx_ = ctx
26162 return c
26163 }
26164
26165
26166
26167 func (c *ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall) Header() http.Header {
26168 if c.header_ == nil {
26169 c.header_ = make(http.Header)
26170 }
26171 return c.header_
26172 }
26173
26174 func (c *ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall) doRequest(alt string) (*http.Response, error) {
26175 reqHeaders := make(http.Header)
26176 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
26177 for k, v := range c.header_ {
26178 reqHeaders[k] = v
26179 }
26180 reqHeaders.Set("User-Agent", c.s.userAgent())
26181 var body io.Reader = nil
26182 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphatakeovereditlockrequest)
26183 if err != nil {
26184 return nil, err
26185 }
26186 reqHeaders.Set("Content-Type", "application/json")
26187 c.urlParams_.Set("alt", alt)
26188 c.urlParams_.Set("prettyPrint", "false")
26189 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+integrationVersion}:takeoverEditLock")
26190 urls += "?" + c.urlParams_.Encode()
26191 req, err := http.NewRequest("POST", urls, body)
26192 if err != nil {
26193 return nil, err
26194 }
26195 req.Header = reqHeaders
26196 googleapi.Expand(req.URL, map[string]string{
26197 "integrationVersion": c.integrationVersion,
26198 })
26199 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26200 }
26201
26202
26203
26204
26205
26206
26207
26208
26209
26210
26211
26212 func (c *ProjectsLocationsProductsIntegrationsVersionsTakeoverEditLockCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaTakeoverEditLockResponse, error) {
26213 gensupport.SetOptions(c.urlParams_, opts...)
26214 res, err := c.doRequest("json")
26215 if res != nil && res.StatusCode == http.StatusNotModified {
26216 if res.Body != nil {
26217 res.Body.Close()
26218 }
26219 return nil, gensupport.WrapError(&googleapi.Error{
26220 Code: res.StatusCode,
26221 Header: res.Header,
26222 })
26223 }
26224 if err != nil {
26225 return nil, err
26226 }
26227 defer googleapi.CloseBody(res)
26228 if err := googleapi.CheckResponse(res); err != nil {
26229 return nil, gensupport.WrapError(err)
26230 }
26231 ret := &GoogleCloudIntegrationsV1alphaTakeoverEditLockResponse{
26232 ServerResponse: googleapi.ServerResponse{
26233 Header: res.Header,
26234 HTTPStatusCode: res.StatusCode,
26235 },
26236 }
26237 target := &ret
26238 if err := gensupport.DecodeResponse(target, res); err != nil {
26239 return nil, err
26240 }
26241 return ret, nil
26242
26243
26244
26245
26246
26247
26248
26249
26250
26251
26252
26253
26254
26255
26256
26257
26258
26259
26260
26261
26262
26263
26264
26265
26266
26267
26268
26269
26270
26271 }
26272
26273
26274
26275 type ProjectsLocationsProductsIntegrationsVersionsUnpublishCall struct {
26276 s *Service
26277 name string
26278 googlecloudintegrationsv1alphaunpublishintegrationversionrequest *GoogleCloudIntegrationsV1alphaUnpublishIntegrationVersionRequest
26279 urlParams_ gensupport.URLParams
26280 ctx_ context.Context
26281 header_ http.Header
26282 }
26283
26284
26285
26286
26287
26288
26289
26290
26291
26292
26293 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Unpublish(name string, googlecloudintegrationsv1alphaunpublishintegrationversionrequest *GoogleCloudIntegrationsV1alphaUnpublishIntegrationVersionRequest) *ProjectsLocationsProductsIntegrationsVersionsUnpublishCall {
26294 c := &ProjectsLocationsProductsIntegrationsVersionsUnpublishCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26295 c.name = name
26296 c.googlecloudintegrationsv1alphaunpublishintegrationversionrequest = googlecloudintegrationsv1alphaunpublishintegrationversionrequest
26297 return c
26298 }
26299
26300
26301
26302
26303 func (c *ProjectsLocationsProductsIntegrationsVersionsUnpublishCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsUnpublishCall {
26304 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26305 return c
26306 }
26307
26308
26309
26310
26311 func (c *ProjectsLocationsProductsIntegrationsVersionsUnpublishCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsUnpublishCall {
26312 c.ctx_ = ctx
26313 return c
26314 }
26315
26316
26317
26318 func (c *ProjectsLocationsProductsIntegrationsVersionsUnpublishCall) Header() http.Header {
26319 if c.header_ == nil {
26320 c.header_ = make(http.Header)
26321 }
26322 return c.header_
26323 }
26324
26325 func (c *ProjectsLocationsProductsIntegrationsVersionsUnpublishCall) doRequest(alt string) (*http.Response, error) {
26326 reqHeaders := make(http.Header)
26327 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
26328 for k, v := range c.header_ {
26329 reqHeaders[k] = v
26330 }
26331 reqHeaders.Set("User-Agent", c.s.userAgent())
26332 var body io.Reader = nil
26333 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaunpublishintegrationversionrequest)
26334 if err != nil {
26335 return nil, err
26336 }
26337 reqHeaders.Set("Content-Type", "application/json")
26338 c.urlParams_.Set("alt", alt)
26339 c.urlParams_.Set("prettyPrint", "false")
26340 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:unpublish")
26341 urls += "?" + c.urlParams_.Encode()
26342 req, err := http.NewRequest("POST", urls, body)
26343 if err != nil {
26344 return nil, err
26345 }
26346 req.Header = reqHeaders
26347 googleapi.Expand(req.URL, map[string]string{
26348 "name": c.name,
26349 })
26350 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26351 }
26352
26353
26354
26355
26356
26357
26358
26359
26360 func (c *ProjectsLocationsProductsIntegrationsVersionsUnpublishCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
26361 gensupport.SetOptions(c.urlParams_, opts...)
26362 res, err := c.doRequest("json")
26363 if res != nil && res.StatusCode == http.StatusNotModified {
26364 if res.Body != nil {
26365 res.Body.Close()
26366 }
26367 return nil, gensupport.WrapError(&googleapi.Error{
26368 Code: res.StatusCode,
26369 Header: res.Header,
26370 })
26371 }
26372 if err != nil {
26373 return nil, err
26374 }
26375 defer googleapi.CloseBody(res)
26376 if err := googleapi.CheckResponse(res); err != nil {
26377 return nil, gensupport.WrapError(err)
26378 }
26379 ret := &GoogleProtobufEmpty{
26380 ServerResponse: googleapi.ServerResponse{
26381 Header: res.Header,
26382 HTTPStatusCode: res.StatusCode,
26383 },
26384 }
26385 target := &ret
26386 if err := gensupport.DecodeResponse(target, res); err != nil {
26387 return nil, err
26388 }
26389 return ret, nil
26390
26391
26392
26393
26394
26395
26396
26397
26398
26399
26400
26401
26402
26403
26404
26405
26406
26407
26408
26409
26410
26411
26412
26413
26414
26415
26416
26417
26418
26419 }
26420
26421
26422
26423 type ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall struct {
26424 s *Service
26425 name string
26426 googlecloudintegrationsv1alphaupdatebundlerequest *GoogleCloudIntegrationsV1alphaUpdateBundleRequest
26427 urlParams_ gensupport.URLParams
26428 ctx_ context.Context
26429 header_ http.Header
26430 }
26431
26432
26433
26434
26435
26436 func (r *ProjectsLocationsProductsIntegrationsVersionsService) UpdateBundle(name string, googlecloudintegrationsv1alphaupdatebundlerequest *GoogleCloudIntegrationsV1alphaUpdateBundleRequest) *ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall {
26437 c := &ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26438 c.name = name
26439 c.googlecloudintegrationsv1alphaupdatebundlerequest = googlecloudintegrationsv1alphaupdatebundlerequest
26440 return c
26441 }
26442
26443
26444
26445
26446 func (c *ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall {
26447 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26448 return c
26449 }
26450
26451
26452
26453
26454 func (c *ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall {
26455 c.ctx_ = ctx
26456 return c
26457 }
26458
26459
26460
26461 func (c *ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall) Header() http.Header {
26462 if c.header_ == nil {
26463 c.header_ = make(http.Header)
26464 }
26465 return c.header_
26466 }
26467
26468 func (c *ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall) doRequest(alt string) (*http.Response, error) {
26469 reqHeaders := make(http.Header)
26470 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
26471 for k, v := range c.header_ {
26472 reqHeaders[k] = v
26473 }
26474 reqHeaders.Set("User-Agent", c.s.userAgent())
26475 var body io.Reader = nil
26476 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphaupdatebundlerequest)
26477 if err != nil {
26478 return nil, err
26479 }
26480 reqHeaders.Set("Content-Type", "application/json")
26481 c.urlParams_.Set("alt", alt)
26482 c.urlParams_.Set("prettyPrint", "false")
26483 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:updateBundle")
26484 urls += "?" + c.urlParams_.Encode()
26485 req, err := http.NewRequest("PATCH", urls, body)
26486 if err != nil {
26487 return nil, err
26488 }
26489 req.Header = reqHeaders
26490 googleapi.Expand(req.URL, map[string]string{
26491 "name": c.name,
26492 })
26493 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26494 }
26495
26496
26497
26498
26499
26500
26501
26502
26503
26504
26505 func (c *ProjectsLocationsProductsIntegrationsVersionsUpdateBundleCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaUpdateBundleResponse, error) {
26506 gensupport.SetOptions(c.urlParams_, opts...)
26507 res, err := c.doRequest("json")
26508 if res != nil && res.StatusCode == http.StatusNotModified {
26509 if res.Body != nil {
26510 res.Body.Close()
26511 }
26512 return nil, gensupport.WrapError(&googleapi.Error{
26513 Code: res.StatusCode,
26514 Header: res.Header,
26515 })
26516 }
26517 if err != nil {
26518 return nil, err
26519 }
26520 defer googleapi.CloseBody(res)
26521 if err := googleapi.CheckResponse(res); err != nil {
26522 return nil, gensupport.WrapError(err)
26523 }
26524 ret := &GoogleCloudIntegrationsV1alphaUpdateBundleResponse{
26525 ServerResponse: googleapi.ServerResponse{
26526 Header: res.Header,
26527 HTTPStatusCode: res.StatusCode,
26528 },
26529 }
26530 target := &ret
26531 if err := gensupport.DecodeResponse(target, res); err != nil {
26532 return nil, err
26533 }
26534 return ret, nil
26535
26536
26537
26538
26539
26540
26541
26542
26543
26544
26545
26546
26547
26548
26549
26550
26551
26552
26553
26554
26555
26556
26557
26558
26559
26560
26561
26562
26563
26564 }
26565
26566
26567
26568 type ProjectsLocationsProductsIntegrationsVersionsUploadCall struct {
26569 s *Service
26570 parent string
26571 googlecloudintegrationsv1alphauploadintegrationversionrequest *GoogleCloudIntegrationsV1alphaUploadIntegrationVersionRequest
26572 urlParams_ gensupport.URLParams
26573 ctx_ context.Context
26574 header_ http.Header
26575 }
26576
26577
26578
26579
26580
26581
26582
26583
26584
26585 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Upload(parent string, googlecloudintegrationsv1alphauploadintegrationversionrequest *GoogleCloudIntegrationsV1alphaUploadIntegrationVersionRequest) *ProjectsLocationsProductsIntegrationsVersionsUploadCall {
26586 c := &ProjectsLocationsProductsIntegrationsVersionsUploadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26587 c.parent = parent
26588 c.googlecloudintegrationsv1alphauploadintegrationversionrequest = googlecloudintegrationsv1alphauploadintegrationversionrequest
26589 return c
26590 }
26591
26592
26593
26594
26595 func (c *ProjectsLocationsProductsIntegrationsVersionsUploadCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsUploadCall {
26596 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26597 return c
26598 }
26599
26600
26601
26602
26603 func (c *ProjectsLocationsProductsIntegrationsVersionsUploadCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsUploadCall {
26604 c.ctx_ = ctx
26605 return c
26606 }
26607
26608
26609
26610 func (c *ProjectsLocationsProductsIntegrationsVersionsUploadCall) Header() http.Header {
26611 if c.header_ == nil {
26612 c.header_ = make(http.Header)
26613 }
26614 return c.header_
26615 }
26616
26617 func (c *ProjectsLocationsProductsIntegrationsVersionsUploadCall) doRequest(alt string) (*http.Response, error) {
26618 reqHeaders := make(http.Header)
26619 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
26620 for k, v := range c.header_ {
26621 reqHeaders[k] = v
26622 }
26623 reqHeaders.Set("User-Agent", c.s.userAgent())
26624 var body io.Reader = nil
26625 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphauploadintegrationversionrequest)
26626 if err != nil {
26627 return nil, err
26628 }
26629 reqHeaders.Set("Content-Type", "application/json")
26630 c.urlParams_.Set("alt", alt)
26631 c.urlParams_.Set("prettyPrint", "false")
26632 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/versions:upload")
26633 urls += "?" + c.urlParams_.Encode()
26634 req, err := http.NewRequest("POST", urls, body)
26635 if err != nil {
26636 return nil, err
26637 }
26638 req.Header = reqHeaders
26639 googleapi.Expand(req.URL, map[string]string{
26640 "parent": c.parent,
26641 })
26642 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26643 }
26644
26645
26646
26647
26648
26649
26650
26651
26652
26653
26654
26655 func (c *ProjectsLocationsProductsIntegrationsVersionsUploadCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaUploadIntegrationVersionResponse, error) {
26656 gensupport.SetOptions(c.urlParams_, opts...)
26657 res, err := c.doRequest("json")
26658 if res != nil && res.StatusCode == http.StatusNotModified {
26659 if res.Body != nil {
26660 res.Body.Close()
26661 }
26662 return nil, gensupport.WrapError(&googleapi.Error{
26663 Code: res.StatusCode,
26664 Header: res.Header,
26665 })
26666 }
26667 if err != nil {
26668 return nil, err
26669 }
26670 defer googleapi.CloseBody(res)
26671 if err := googleapi.CheckResponse(res); err != nil {
26672 return nil, gensupport.WrapError(err)
26673 }
26674 ret := &GoogleCloudIntegrationsV1alphaUploadIntegrationVersionResponse{
26675 ServerResponse: googleapi.ServerResponse{
26676 Header: res.Header,
26677 HTTPStatusCode: res.StatusCode,
26678 },
26679 }
26680 target := &ret
26681 if err := gensupport.DecodeResponse(target, res); err != nil {
26682 return nil, err
26683 }
26684 return ret, nil
26685
26686
26687
26688
26689
26690
26691
26692
26693
26694
26695
26696
26697
26698
26699
26700
26701
26702
26703
26704
26705
26706
26707
26708
26709
26710
26711
26712
26713
26714 }
26715
26716
26717
26718 type ProjectsLocationsProductsIntegrationsVersionsValidateCall struct {
26719 s *Service
26720 name string
26721 googlecloudintegrationsv1alphavalidateintegrationversionrequest *GoogleCloudIntegrationsV1alphaValidateIntegrationVersionRequest
26722 urlParams_ gensupport.URLParams
26723 ctx_ context.Context
26724 header_ http.Header
26725 }
26726
26727
26728
26729
26730
26731
26732
26733
26734
26735 func (r *ProjectsLocationsProductsIntegrationsVersionsService) Validate(name string, googlecloudintegrationsv1alphavalidateintegrationversionrequest *GoogleCloudIntegrationsV1alphaValidateIntegrationVersionRequest) *ProjectsLocationsProductsIntegrationsVersionsValidateCall {
26736 c := &ProjectsLocationsProductsIntegrationsVersionsValidateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26737 c.name = name
26738 c.googlecloudintegrationsv1alphavalidateintegrationversionrequest = googlecloudintegrationsv1alphavalidateintegrationversionrequest
26739 return c
26740 }
26741
26742
26743
26744
26745 func (c *ProjectsLocationsProductsIntegrationsVersionsValidateCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsIntegrationsVersionsValidateCall {
26746 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26747 return c
26748 }
26749
26750
26751
26752
26753 func (c *ProjectsLocationsProductsIntegrationsVersionsValidateCall) Context(ctx context.Context) *ProjectsLocationsProductsIntegrationsVersionsValidateCall {
26754 c.ctx_ = ctx
26755 return c
26756 }
26757
26758
26759
26760 func (c *ProjectsLocationsProductsIntegrationsVersionsValidateCall) Header() http.Header {
26761 if c.header_ == nil {
26762 c.header_ = make(http.Header)
26763 }
26764 return c.header_
26765 }
26766
26767 func (c *ProjectsLocationsProductsIntegrationsVersionsValidateCall) doRequest(alt string) (*http.Response, error) {
26768 reqHeaders := make(http.Header)
26769 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
26770 for k, v := range c.header_ {
26771 reqHeaders[k] = v
26772 }
26773 reqHeaders.Set("User-Agent", c.s.userAgent())
26774 var body io.Reader = nil
26775 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphavalidateintegrationversionrequest)
26776 if err != nil {
26777 return nil, err
26778 }
26779 reqHeaders.Set("Content-Type", "application/json")
26780 c.urlParams_.Set("alt", alt)
26781 c.urlParams_.Set("prettyPrint", "false")
26782 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:validate")
26783 urls += "?" + c.urlParams_.Encode()
26784 req, err := http.NewRequest("POST", urls, body)
26785 if err != nil {
26786 return nil, err
26787 }
26788 req.Header = reqHeaders
26789 googleapi.Expand(req.URL, map[string]string{
26790 "name": c.name,
26791 })
26792 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26793 }
26794
26795
26796
26797
26798
26799
26800
26801
26802
26803
26804
26805 func (c *ProjectsLocationsProductsIntegrationsVersionsValidateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaValidateIntegrationVersionResponse, error) {
26806 gensupport.SetOptions(c.urlParams_, opts...)
26807 res, err := c.doRequest("json")
26808 if res != nil && res.StatusCode == http.StatusNotModified {
26809 if res.Body != nil {
26810 res.Body.Close()
26811 }
26812 return nil, gensupport.WrapError(&googleapi.Error{
26813 Code: res.StatusCode,
26814 Header: res.Header,
26815 })
26816 }
26817 if err != nil {
26818 return nil, err
26819 }
26820 defer googleapi.CloseBody(res)
26821 if err := googleapi.CheckResponse(res); err != nil {
26822 return nil, gensupport.WrapError(err)
26823 }
26824 ret := &GoogleCloudIntegrationsV1alphaValidateIntegrationVersionResponse{
26825 ServerResponse: googleapi.ServerResponse{
26826 Header: res.Header,
26827 HTTPStatusCode: res.StatusCode,
26828 },
26829 }
26830 target := &ret
26831 if err := gensupport.DecodeResponse(target, res); err != nil {
26832 return nil, err
26833 }
26834 return ret, nil
26835
26836
26837
26838
26839
26840
26841
26842
26843
26844
26845
26846
26847
26848
26849
26850
26851
26852
26853
26854
26855
26856
26857
26858
26859
26860
26861
26862
26863
26864 }
26865
26866
26867
26868 type ProjectsLocationsProductsSfdcInstancesCreateCall struct {
26869 s *Service
26870 parent string
26871 googlecloudintegrationsv1alphasfdcinstance *GoogleCloudIntegrationsV1alphaSfdcInstance
26872 urlParams_ gensupport.URLParams
26873 ctx_ context.Context
26874 header_ http.Header
26875 }
26876
26877
26878
26879
26880
26881 func (r *ProjectsLocationsProductsSfdcInstancesService) Create(parent string, googlecloudintegrationsv1alphasfdcinstance *GoogleCloudIntegrationsV1alphaSfdcInstance) *ProjectsLocationsProductsSfdcInstancesCreateCall {
26882 c := &ProjectsLocationsProductsSfdcInstancesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
26883 c.parent = parent
26884 c.googlecloudintegrationsv1alphasfdcinstance = googlecloudintegrationsv1alphasfdcinstance
26885 return c
26886 }
26887
26888
26889
26890
26891 func (c *ProjectsLocationsProductsSfdcInstancesCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesCreateCall {
26892 c.urlParams_.Set("fields", googleapi.CombineFields(s))
26893 return c
26894 }
26895
26896
26897
26898
26899 func (c *ProjectsLocationsProductsSfdcInstancesCreateCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesCreateCall {
26900 c.ctx_ = ctx
26901 return c
26902 }
26903
26904
26905
26906 func (c *ProjectsLocationsProductsSfdcInstancesCreateCall) Header() http.Header {
26907 if c.header_ == nil {
26908 c.header_ = make(http.Header)
26909 }
26910 return c.header_
26911 }
26912
26913 func (c *ProjectsLocationsProductsSfdcInstancesCreateCall) doRequest(alt string) (*http.Response, error) {
26914 reqHeaders := make(http.Header)
26915 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
26916 for k, v := range c.header_ {
26917 reqHeaders[k] = v
26918 }
26919 reqHeaders.Set("User-Agent", c.s.userAgent())
26920 var body io.Reader = nil
26921 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphasfdcinstance)
26922 if err != nil {
26923 return nil, err
26924 }
26925 reqHeaders.Set("Content-Type", "application/json")
26926 c.urlParams_.Set("alt", alt)
26927 c.urlParams_.Set("prettyPrint", "false")
26928 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/sfdcInstances")
26929 urls += "?" + c.urlParams_.Encode()
26930 req, err := http.NewRequest("POST", urls, body)
26931 if err != nil {
26932 return nil, err
26933 }
26934 req.Header = reqHeaders
26935 googleapi.Expand(req.URL, map[string]string{
26936 "parent": c.parent,
26937 })
26938 return gensupport.SendRequest(c.ctx_, c.s.client, req)
26939 }
26940
26941
26942
26943
26944
26945
26946
26947
26948
26949
26950 func (c *ProjectsLocationsProductsSfdcInstancesCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcInstance, error) {
26951 gensupport.SetOptions(c.urlParams_, opts...)
26952 res, err := c.doRequest("json")
26953 if res != nil && res.StatusCode == http.StatusNotModified {
26954 if res.Body != nil {
26955 res.Body.Close()
26956 }
26957 return nil, gensupport.WrapError(&googleapi.Error{
26958 Code: res.StatusCode,
26959 Header: res.Header,
26960 })
26961 }
26962 if err != nil {
26963 return nil, err
26964 }
26965 defer googleapi.CloseBody(res)
26966 if err := googleapi.CheckResponse(res); err != nil {
26967 return nil, gensupport.WrapError(err)
26968 }
26969 ret := &GoogleCloudIntegrationsV1alphaSfdcInstance{
26970 ServerResponse: googleapi.ServerResponse{
26971 Header: res.Header,
26972 HTTPStatusCode: res.StatusCode,
26973 },
26974 }
26975 target := &ret
26976 if err := gensupport.DecodeResponse(target, res); err != nil {
26977 return nil, err
26978 }
26979 return ret, nil
26980
26981
26982
26983
26984
26985
26986
26987
26988
26989
26990
26991
26992
26993
26994
26995
26996
26997
26998
26999
27000
27001
27002
27003
27004
27005
27006
27007
27008
27009 }
27010
27011
27012
27013 type ProjectsLocationsProductsSfdcInstancesDeleteCall struct {
27014 s *Service
27015 name string
27016 urlParams_ gensupport.URLParams
27017 ctx_ context.Context
27018 header_ http.Header
27019 }
27020
27021
27022
27023
27024 func (r *ProjectsLocationsProductsSfdcInstancesService) Delete(name string) *ProjectsLocationsProductsSfdcInstancesDeleteCall {
27025 c := &ProjectsLocationsProductsSfdcInstancesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27026 c.name = name
27027 return c
27028 }
27029
27030
27031
27032
27033 func (c *ProjectsLocationsProductsSfdcInstancesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesDeleteCall {
27034 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27035 return c
27036 }
27037
27038
27039
27040
27041 func (c *ProjectsLocationsProductsSfdcInstancesDeleteCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesDeleteCall {
27042 c.ctx_ = ctx
27043 return c
27044 }
27045
27046
27047
27048 func (c *ProjectsLocationsProductsSfdcInstancesDeleteCall) Header() http.Header {
27049 if c.header_ == nil {
27050 c.header_ = make(http.Header)
27051 }
27052 return c.header_
27053 }
27054
27055 func (c *ProjectsLocationsProductsSfdcInstancesDeleteCall) doRequest(alt string) (*http.Response, error) {
27056 reqHeaders := make(http.Header)
27057 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
27058 for k, v := range c.header_ {
27059 reqHeaders[k] = v
27060 }
27061 reqHeaders.Set("User-Agent", c.s.userAgent())
27062 var body io.Reader = nil
27063 c.urlParams_.Set("alt", alt)
27064 c.urlParams_.Set("prettyPrint", "false")
27065 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
27066 urls += "?" + c.urlParams_.Encode()
27067 req, err := http.NewRequest("DELETE", urls, body)
27068 if err != nil {
27069 return nil, err
27070 }
27071 req.Header = reqHeaders
27072 googleapi.Expand(req.URL, map[string]string{
27073 "name": c.name,
27074 })
27075 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27076 }
27077
27078
27079
27080
27081
27082
27083
27084
27085 func (c *ProjectsLocationsProductsSfdcInstancesDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
27086 gensupport.SetOptions(c.urlParams_, opts...)
27087 res, err := c.doRequest("json")
27088 if res != nil && res.StatusCode == http.StatusNotModified {
27089 if res.Body != nil {
27090 res.Body.Close()
27091 }
27092 return nil, gensupport.WrapError(&googleapi.Error{
27093 Code: res.StatusCode,
27094 Header: res.Header,
27095 })
27096 }
27097 if err != nil {
27098 return nil, err
27099 }
27100 defer googleapi.CloseBody(res)
27101 if err := googleapi.CheckResponse(res); err != nil {
27102 return nil, gensupport.WrapError(err)
27103 }
27104 ret := &GoogleProtobufEmpty{
27105 ServerResponse: googleapi.ServerResponse{
27106 Header: res.Header,
27107 HTTPStatusCode: res.StatusCode,
27108 },
27109 }
27110 target := &ret
27111 if err := gensupport.DecodeResponse(target, res); err != nil {
27112 return nil, err
27113 }
27114 return ret, nil
27115
27116
27117
27118
27119
27120
27121
27122
27123
27124
27125
27126
27127
27128
27129
27130
27131
27132
27133
27134
27135
27136
27137
27138
27139
27140
27141 }
27142
27143
27144
27145 type ProjectsLocationsProductsSfdcInstancesGetCall struct {
27146 s *Service
27147 name string
27148 urlParams_ gensupport.URLParams
27149 ifNoneMatch_ string
27150 ctx_ context.Context
27151 header_ http.Header
27152 }
27153
27154
27155
27156
27157
27158 func (r *ProjectsLocationsProductsSfdcInstancesService) Get(name string) *ProjectsLocationsProductsSfdcInstancesGetCall {
27159 c := &ProjectsLocationsProductsSfdcInstancesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27160 c.name = name
27161 return c
27162 }
27163
27164
27165
27166
27167 func (c *ProjectsLocationsProductsSfdcInstancesGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesGetCall {
27168 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27169 return c
27170 }
27171
27172
27173
27174
27175
27176
27177 func (c *ProjectsLocationsProductsSfdcInstancesGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsSfdcInstancesGetCall {
27178 c.ifNoneMatch_ = entityTag
27179 return c
27180 }
27181
27182
27183
27184
27185 func (c *ProjectsLocationsProductsSfdcInstancesGetCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesGetCall {
27186 c.ctx_ = ctx
27187 return c
27188 }
27189
27190
27191
27192 func (c *ProjectsLocationsProductsSfdcInstancesGetCall) Header() http.Header {
27193 if c.header_ == nil {
27194 c.header_ = make(http.Header)
27195 }
27196 return c.header_
27197 }
27198
27199 func (c *ProjectsLocationsProductsSfdcInstancesGetCall) doRequest(alt string) (*http.Response, error) {
27200 reqHeaders := make(http.Header)
27201 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
27202 for k, v := range c.header_ {
27203 reqHeaders[k] = v
27204 }
27205 reqHeaders.Set("User-Agent", c.s.userAgent())
27206 if c.ifNoneMatch_ != "" {
27207 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
27208 }
27209 var body io.Reader = nil
27210 c.urlParams_.Set("alt", alt)
27211 c.urlParams_.Set("prettyPrint", "false")
27212 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
27213 urls += "?" + c.urlParams_.Encode()
27214 req, err := http.NewRequest("GET", urls, body)
27215 if err != nil {
27216 return nil, err
27217 }
27218 req.Header = reqHeaders
27219 googleapi.Expand(req.URL, map[string]string{
27220 "name": c.name,
27221 })
27222 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27223 }
27224
27225
27226
27227
27228
27229
27230
27231
27232
27233
27234 func (c *ProjectsLocationsProductsSfdcInstancesGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcInstance, error) {
27235 gensupport.SetOptions(c.urlParams_, opts...)
27236 res, err := c.doRequest("json")
27237 if res != nil && res.StatusCode == http.StatusNotModified {
27238 if res.Body != nil {
27239 res.Body.Close()
27240 }
27241 return nil, gensupport.WrapError(&googleapi.Error{
27242 Code: res.StatusCode,
27243 Header: res.Header,
27244 })
27245 }
27246 if err != nil {
27247 return nil, err
27248 }
27249 defer googleapi.CloseBody(res)
27250 if err := googleapi.CheckResponse(res); err != nil {
27251 return nil, gensupport.WrapError(err)
27252 }
27253 ret := &GoogleCloudIntegrationsV1alphaSfdcInstance{
27254 ServerResponse: googleapi.ServerResponse{
27255 Header: res.Header,
27256 HTTPStatusCode: res.StatusCode,
27257 },
27258 }
27259 target := &ret
27260 if err := gensupport.DecodeResponse(target, res); err != nil {
27261 return nil, err
27262 }
27263 return ret, nil
27264
27265
27266
27267
27268
27269
27270
27271
27272
27273
27274
27275
27276
27277
27278
27279
27280
27281
27282
27283
27284
27285
27286
27287
27288
27289
27290 }
27291
27292
27293
27294 type ProjectsLocationsProductsSfdcInstancesListCall struct {
27295 s *Service
27296 parent string
27297 urlParams_ gensupport.URLParams
27298 ifNoneMatch_ string
27299 ctx_ context.Context
27300 header_ http.Header
27301 }
27302
27303
27304
27305
27306
27307 func (r *ProjectsLocationsProductsSfdcInstancesService) List(parent string) *ProjectsLocationsProductsSfdcInstancesListCall {
27308 c := &ProjectsLocationsProductsSfdcInstancesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27309 c.parent = parent
27310 return c
27311 }
27312
27313
27314
27315
27316 func (c *ProjectsLocationsProductsSfdcInstancesListCall) Filter(filter string) *ProjectsLocationsProductsSfdcInstancesListCall {
27317 c.urlParams_.Set("filter", filter)
27318 return c
27319 }
27320
27321
27322
27323 func (c *ProjectsLocationsProductsSfdcInstancesListCall) PageSize(pageSize int64) *ProjectsLocationsProductsSfdcInstancesListCall {
27324 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
27325 return c
27326 }
27327
27328
27329
27330 func (c *ProjectsLocationsProductsSfdcInstancesListCall) PageToken(pageToken string) *ProjectsLocationsProductsSfdcInstancesListCall {
27331 c.urlParams_.Set("pageToken", pageToken)
27332 return c
27333 }
27334
27335
27336
27337
27338 func (c *ProjectsLocationsProductsSfdcInstancesListCall) ReadMask(readMask string) *ProjectsLocationsProductsSfdcInstancesListCall {
27339 c.urlParams_.Set("readMask", readMask)
27340 return c
27341 }
27342
27343
27344
27345
27346 func (c *ProjectsLocationsProductsSfdcInstancesListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesListCall {
27347 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27348 return c
27349 }
27350
27351
27352
27353
27354
27355
27356 func (c *ProjectsLocationsProductsSfdcInstancesListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsSfdcInstancesListCall {
27357 c.ifNoneMatch_ = entityTag
27358 return c
27359 }
27360
27361
27362
27363
27364 func (c *ProjectsLocationsProductsSfdcInstancesListCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesListCall {
27365 c.ctx_ = ctx
27366 return c
27367 }
27368
27369
27370
27371 func (c *ProjectsLocationsProductsSfdcInstancesListCall) Header() http.Header {
27372 if c.header_ == nil {
27373 c.header_ = make(http.Header)
27374 }
27375 return c.header_
27376 }
27377
27378 func (c *ProjectsLocationsProductsSfdcInstancesListCall) doRequest(alt string) (*http.Response, error) {
27379 reqHeaders := make(http.Header)
27380 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
27381 for k, v := range c.header_ {
27382 reqHeaders[k] = v
27383 }
27384 reqHeaders.Set("User-Agent", c.s.userAgent())
27385 if c.ifNoneMatch_ != "" {
27386 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
27387 }
27388 var body io.Reader = nil
27389 c.urlParams_.Set("alt", alt)
27390 c.urlParams_.Set("prettyPrint", "false")
27391 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/sfdcInstances")
27392 urls += "?" + c.urlParams_.Encode()
27393 req, err := http.NewRequest("GET", urls, body)
27394 if err != nil {
27395 return nil, err
27396 }
27397 req.Header = reqHeaders
27398 googleapi.Expand(req.URL, map[string]string{
27399 "parent": c.parent,
27400 })
27401 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27402 }
27403
27404
27405
27406
27407
27408
27409
27410
27411
27412
27413
27414 func (c *ProjectsLocationsProductsSfdcInstancesListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse, error) {
27415 gensupport.SetOptions(c.urlParams_, opts...)
27416 res, err := c.doRequest("json")
27417 if res != nil && res.StatusCode == http.StatusNotModified {
27418 if res.Body != nil {
27419 res.Body.Close()
27420 }
27421 return nil, gensupport.WrapError(&googleapi.Error{
27422 Code: res.StatusCode,
27423 Header: res.Header,
27424 })
27425 }
27426 if err != nil {
27427 return nil, err
27428 }
27429 defer googleapi.CloseBody(res)
27430 if err := googleapi.CheckResponse(res); err != nil {
27431 return nil, gensupport.WrapError(err)
27432 }
27433 ret := &GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse{
27434 ServerResponse: googleapi.ServerResponse{
27435 Header: res.Header,
27436 HTTPStatusCode: res.StatusCode,
27437 },
27438 }
27439 target := &ret
27440 if err := gensupport.DecodeResponse(target, res); err != nil {
27441 return nil, err
27442 }
27443 return ret, nil
27444
27445
27446
27447
27448
27449
27450
27451
27452
27453
27454
27455
27456
27457
27458
27459
27460
27461
27462
27463
27464
27465
27466
27467
27468
27469
27470
27471
27472
27473
27474
27475
27476
27477
27478
27479
27480
27481
27482
27483
27484
27485
27486
27487
27488
27489
27490
27491
27492 }
27493
27494
27495
27496
27497 func (c *ProjectsLocationsProductsSfdcInstancesListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse) error) error {
27498 c.ctx_ = ctx
27499 defer c.PageToken(c.urlParams_.Get("pageToken"))
27500 for {
27501 x, err := c.Do()
27502 if err != nil {
27503 return err
27504 }
27505 if err := f(x); err != nil {
27506 return err
27507 }
27508 if x.NextPageToken == "" {
27509 return nil
27510 }
27511 c.PageToken(x.NextPageToken)
27512 }
27513 }
27514
27515
27516
27517 type ProjectsLocationsProductsSfdcInstancesPatchCall struct {
27518 s *Service
27519 name string
27520 googlecloudintegrationsv1alphasfdcinstance *GoogleCloudIntegrationsV1alphaSfdcInstance
27521 urlParams_ gensupport.URLParams
27522 ctx_ context.Context
27523 header_ http.Header
27524 }
27525
27526
27527
27528
27529
27530
27531
27532 func (r *ProjectsLocationsProductsSfdcInstancesService) Patch(name string, googlecloudintegrationsv1alphasfdcinstance *GoogleCloudIntegrationsV1alphaSfdcInstance) *ProjectsLocationsProductsSfdcInstancesPatchCall {
27533 c := &ProjectsLocationsProductsSfdcInstancesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27534 c.name = name
27535 c.googlecloudintegrationsv1alphasfdcinstance = googlecloudintegrationsv1alphasfdcinstance
27536 return c
27537 }
27538
27539
27540
27541
27542 func (c *ProjectsLocationsProductsSfdcInstancesPatchCall) UpdateMask(updateMask string) *ProjectsLocationsProductsSfdcInstancesPatchCall {
27543 c.urlParams_.Set("updateMask", updateMask)
27544 return c
27545 }
27546
27547
27548
27549
27550 func (c *ProjectsLocationsProductsSfdcInstancesPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesPatchCall {
27551 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27552 return c
27553 }
27554
27555
27556
27557
27558 func (c *ProjectsLocationsProductsSfdcInstancesPatchCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesPatchCall {
27559 c.ctx_ = ctx
27560 return c
27561 }
27562
27563
27564
27565 func (c *ProjectsLocationsProductsSfdcInstancesPatchCall) Header() http.Header {
27566 if c.header_ == nil {
27567 c.header_ = make(http.Header)
27568 }
27569 return c.header_
27570 }
27571
27572 func (c *ProjectsLocationsProductsSfdcInstancesPatchCall) doRequest(alt string) (*http.Response, error) {
27573 reqHeaders := make(http.Header)
27574 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
27575 for k, v := range c.header_ {
27576 reqHeaders[k] = v
27577 }
27578 reqHeaders.Set("User-Agent", c.s.userAgent())
27579 var body io.Reader = nil
27580 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphasfdcinstance)
27581 if err != nil {
27582 return nil, err
27583 }
27584 reqHeaders.Set("Content-Type", "application/json")
27585 c.urlParams_.Set("alt", alt)
27586 c.urlParams_.Set("prettyPrint", "false")
27587 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
27588 urls += "?" + c.urlParams_.Encode()
27589 req, err := http.NewRequest("PATCH", urls, body)
27590 if err != nil {
27591 return nil, err
27592 }
27593 req.Header = reqHeaders
27594 googleapi.Expand(req.URL, map[string]string{
27595 "name": c.name,
27596 })
27597 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27598 }
27599
27600
27601
27602
27603
27604
27605
27606
27607
27608
27609 func (c *ProjectsLocationsProductsSfdcInstancesPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcInstance, error) {
27610 gensupport.SetOptions(c.urlParams_, opts...)
27611 res, err := c.doRequest("json")
27612 if res != nil && res.StatusCode == http.StatusNotModified {
27613 if res.Body != nil {
27614 res.Body.Close()
27615 }
27616 return nil, gensupport.WrapError(&googleapi.Error{
27617 Code: res.StatusCode,
27618 Header: res.Header,
27619 })
27620 }
27621 if err != nil {
27622 return nil, err
27623 }
27624 defer googleapi.CloseBody(res)
27625 if err := googleapi.CheckResponse(res); err != nil {
27626 return nil, gensupport.WrapError(err)
27627 }
27628 ret := &GoogleCloudIntegrationsV1alphaSfdcInstance{
27629 ServerResponse: googleapi.ServerResponse{
27630 Header: res.Header,
27631 HTTPStatusCode: res.StatusCode,
27632 },
27633 }
27634 target := &ret
27635 if err := gensupport.DecodeResponse(target, res); err != nil {
27636 return nil, err
27637 }
27638 return ret, nil
27639
27640
27641
27642
27643
27644
27645
27646
27647
27648
27649
27650
27651
27652
27653
27654
27655
27656
27657
27658
27659
27660
27661
27662
27663
27664
27665
27666
27667
27668
27669
27670
27671
27672
27673
27674 }
27675
27676
27677
27678 type ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall struct {
27679 s *Service
27680 parent string
27681 googlecloudintegrationsv1alphasfdcchannel *GoogleCloudIntegrationsV1alphaSfdcChannel
27682 urlParams_ gensupport.URLParams
27683 ctx_ context.Context
27684 header_ http.Header
27685 }
27686
27687
27688
27689
27690
27691 func (r *ProjectsLocationsProductsSfdcInstancesSfdcChannelsService) Create(parent string, googlecloudintegrationsv1alphasfdcchannel *GoogleCloudIntegrationsV1alphaSfdcChannel) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall {
27692 c := &ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27693 c.parent = parent
27694 c.googlecloudintegrationsv1alphasfdcchannel = googlecloudintegrationsv1alphasfdcchannel
27695 return c
27696 }
27697
27698
27699
27700
27701 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall {
27702 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27703 return c
27704 }
27705
27706
27707
27708
27709 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall {
27710 c.ctx_ = ctx
27711 return c
27712 }
27713
27714
27715
27716 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall) Header() http.Header {
27717 if c.header_ == nil {
27718 c.header_ = make(http.Header)
27719 }
27720 return c.header_
27721 }
27722
27723 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall) doRequest(alt string) (*http.Response, error) {
27724 reqHeaders := make(http.Header)
27725 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
27726 for k, v := range c.header_ {
27727 reqHeaders[k] = v
27728 }
27729 reqHeaders.Set("User-Agent", c.s.userAgent())
27730 var body io.Reader = nil
27731 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphasfdcchannel)
27732 if err != nil {
27733 return nil, err
27734 }
27735 reqHeaders.Set("Content-Type", "application/json")
27736 c.urlParams_.Set("alt", alt)
27737 c.urlParams_.Set("prettyPrint", "false")
27738 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/sfdcChannels")
27739 urls += "?" + c.urlParams_.Encode()
27740 req, err := http.NewRequest("POST", urls, body)
27741 if err != nil {
27742 return nil, err
27743 }
27744 req.Header = reqHeaders
27745 googleapi.Expand(req.URL, map[string]string{
27746 "parent": c.parent,
27747 })
27748 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27749 }
27750
27751
27752
27753
27754
27755
27756
27757
27758
27759
27760 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcChannel, error) {
27761 gensupport.SetOptions(c.urlParams_, opts...)
27762 res, err := c.doRequest("json")
27763 if res != nil && res.StatusCode == http.StatusNotModified {
27764 if res.Body != nil {
27765 res.Body.Close()
27766 }
27767 return nil, gensupport.WrapError(&googleapi.Error{
27768 Code: res.StatusCode,
27769 Header: res.Header,
27770 })
27771 }
27772 if err != nil {
27773 return nil, err
27774 }
27775 defer googleapi.CloseBody(res)
27776 if err := googleapi.CheckResponse(res); err != nil {
27777 return nil, gensupport.WrapError(err)
27778 }
27779 ret := &GoogleCloudIntegrationsV1alphaSfdcChannel{
27780 ServerResponse: googleapi.ServerResponse{
27781 Header: res.Header,
27782 HTTPStatusCode: res.StatusCode,
27783 },
27784 }
27785 target := &ret
27786 if err := gensupport.DecodeResponse(target, res); err != nil {
27787 return nil, err
27788 }
27789 return ret, nil
27790
27791
27792
27793
27794
27795
27796
27797
27798
27799
27800
27801
27802
27803
27804
27805
27806
27807
27808
27809
27810
27811
27812
27813
27814
27815
27816
27817
27818
27819 }
27820
27821
27822
27823 type ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall struct {
27824 s *Service
27825 name string
27826 urlParams_ gensupport.URLParams
27827 ctx_ context.Context
27828 header_ http.Header
27829 }
27830
27831
27832
27833
27834 func (r *ProjectsLocationsProductsSfdcInstancesSfdcChannelsService) Delete(name string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall {
27835 c := &ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27836 c.name = name
27837 return c
27838 }
27839
27840
27841
27842
27843 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall {
27844 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27845 return c
27846 }
27847
27848
27849
27850
27851 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall {
27852 c.ctx_ = ctx
27853 return c
27854 }
27855
27856
27857
27858 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall) Header() http.Header {
27859 if c.header_ == nil {
27860 c.header_ = make(http.Header)
27861 }
27862 return c.header_
27863 }
27864
27865 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall) doRequest(alt string) (*http.Response, error) {
27866 reqHeaders := make(http.Header)
27867 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
27868 for k, v := range c.header_ {
27869 reqHeaders[k] = v
27870 }
27871 reqHeaders.Set("User-Agent", c.s.userAgent())
27872 var body io.Reader = nil
27873 c.urlParams_.Set("alt", alt)
27874 c.urlParams_.Set("prettyPrint", "false")
27875 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
27876 urls += "?" + c.urlParams_.Encode()
27877 req, err := http.NewRequest("DELETE", urls, body)
27878 if err != nil {
27879 return nil, err
27880 }
27881 req.Header = reqHeaders
27882 googleapi.Expand(req.URL, map[string]string{
27883 "name": c.name,
27884 })
27885 return gensupport.SendRequest(c.ctx_, c.s.client, req)
27886 }
27887
27888
27889
27890
27891
27892
27893
27894
27895 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
27896 gensupport.SetOptions(c.urlParams_, opts...)
27897 res, err := c.doRequest("json")
27898 if res != nil && res.StatusCode == http.StatusNotModified {
27899 if res.Body != nil {
27900 res.Body.Close()
27901 }
27902 return nil, gensupport.WrapError(&googleapi.Error{
27903 Code: res.StatusCode,
27904 Header: res.Header,
27905 })
27906 }
27907 if err != nil {
27908 return nil, err
27909 }
27910 defer googleapi.CloseBody(res)
27911 if err := googleapi.CheckResponse(res); err != nil {
27912 return nil, gensupport.WrapError(err)
27913 }
27914 ret := &GoogleProtobufEmpty{
27915 ServerResponse: googleapi.ServerResponse{
27916 Header: res.Header,
27917 HTTPStatusCode: res.StatusCode,
27918 },
27919 }
27920 target := &ret
27921 if err := gensupport.DecodeResponse(target, res); err != nil {
27922 return nil, err
27923 }
27924 return ret, nil
27925
27926
27927
27928
27929
27930
27931
27932
27933
27934
27935
27936
27937
27938
27939
27940
27941
27942
27943
27944
27945
27946
27947
27948
27949
27950
27951 }
27952
27953
27954
27955 type ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall struct {
27956 s *Service
27957 name string
27958 urlParams_ gensupport.URLParams
27959 ifNoneMatch_ string
27960 ctx_ context.Context
27961 header_ http.Header
27962 }
27963
27964
27965
27966
27967
27968 func (r *ProjectsLocationsProductsSfdcInstancesSfdcChannelsService) Get(name string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall {
27969 c := &ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
27970 c.name = name
27971 return c
27972 }
27973
27974
27975
27976
27977 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall {
27978 c.urlParams_.Set("fields", googleapi.CombineFields(s))
27979 return c
27980 }
27981
27982
27983
27984
27985
27986
27987 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall {
27988 c.ifNoneMatch_ = entityTag
27989 return c
27990 }
27991
27992
27993
27994
27995 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall {
27996 c.ctx_ = ctx
27997 return c
27998 }
27999
28000
28001
28002 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall) Header() http.Header {
28003 if c.header_ == nil {
28004 c.header_ = make(http.Header)
28005 }
28006 return c.header_
28007 }
28008
28009 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall) doRequest(alt string) (*http.Response, error) {
28010 reqHeaders := make(http.Header)
28011 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
28012 for k, v := range c.header_ {
28013 reqHeaders[k] = v
28014 }
28015 reqHeaders.Set("User-Agent", c.s.userAgent())
28016 if c.ifNoneMatch_ != "" {
28017 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
28018 }
28019 var body io.Reader = nil
28020 c.urlParams_.Set("alt", alt)
28021 c.urlParams_.Set("prettyPrint", "false")
28022 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
28023 urls += "?" + c.urlParams_.Encode()
28024 req, err := http.NewRequest("GET", urls, body)
28025 if err != nil {
28026 return nil, err
28027 }
28028 req.Header = reqHeaders
28029 googleapi.Expand(req.URL, map[string]string{
28030 "name": c.name,
28031 })
28032 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28033 }
28034
28035
28036
28037
28038
28039
28040
28041
28042
28043
28044 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcChannel, error) {
28045 gensupport.SetOptions(c.urlParams_, opts...)
28046 res, err := c.doRequest("json")
28047 if res != nil && res.StatusCode == http.StatusNotModified {
28048 if res.Body != nil {
28049 res.Body.Close()
28050 }
28051 return nil, gensupport.WrapError(&googleapi.Error{
28052 Code: res.StatusCode,
28053 Header: res.Header,
28054 })
28055 }
28056 if err != nil {
28057 return nil, err
28058 }
28059 defer googleapi.CloseBody(res)
28060 if err := googleapi.CheckResponse(res); err != nil {
28061 return nil, gensupport.WrapError(err)
28062 }
28063 ret := &GoogleCloudIntegrationsV1alphaSfdcChannel{
28064 ServerResponse: googleapi.ServerResponse{
28065 Header: res.Header,
28066 HTTPStatusCode: res.StatusCode,
28067 },
28068 }
28069 target := &ret
28070 if err := gensupport.DecodeResponse(target, res); err != nil {
28071 return nil, err
28072 }
28073 return ret, nil
28074
28075
28076
28077
28078
28079
28080
28081
28082
28083
28084
28085
28086
28087
28088
28089
28090
28091
28092
28093
28094
28095
28096
28097
28098
28099
28100 }
28101
28102
28103
28104 type ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall struct {
28105 s *Service
28106 parent string
28107 urlParams_ gensupport.URLParams
28108 ifNoneMatch_ string
28109 ctx_ context.Context
28110 header_ http.Header
28111 }
28112
28113
28114
28115
28116
28117 func (r *ProjectsLocationsProductsSfdcInstancesSfdcChannelsService) List(parent string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall {
28118 c := &ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28119 c.parent = parent
28120 return c
28121 }
28122
28123
28124
28125
28126 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) Filter(filter string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall {
28127 c.urlParams_.Set("filter", filter)
28128 return c
28129 }
28130
28131
28132
28133 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) PageSize(pageSize int64) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall {
28134 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
28135 return c
28136 }
28137
28138
28139
28140 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) PageToken(pageToken string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall {
28141 c.urlParams_.Set("pageToken", pageToken)
28142 return c
28143 }
28144
28145
28146
28147
28148 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) ReadMask(readMask string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall {
28149 c.urlParams_.Set("readMask", readMask)
28150 return c
28151 }
28152
28153
28154
28155
28156 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall {
28157 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28158 return c
28159 }
28160
28161
28162
28163
28164
28165
28166 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall {
28167 c.ifNoneMatch_ = entityTag
28168 return c
28169 }
28170
28171
28172
28173
28174 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall {
28175 c.ctx_ = ctx
28176 return c
28177 }
28178
28179
28180
28181 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) Header() http.Header {
28182 if c.header_ == nil {
28183 c.header_ = make(http.Header)
28184 }
28185 return c.header_
28186 }
28187
28188 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) doRequest(alt string) (*http.Response, error) {
28189 reqHeaders := make(http.Header)
28190 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
28191 for k, v := range c.header_ {
28192 reqHeaders[k] = v
28193 }
28194 reqHeaders.Set("User-Agent", c.s.userAgent())
28195 if c.ifNoneMatch_ != "" {
28196 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
28197 }
28198 var body io.Reader = nil
28199 c.urlParams_.Set("alt", alt)
28200 c.urlParams_.Set("prettyPrint", "false")
28201 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/sfdcChannels")
28202 urls += "?" + c.urlParams_.Encode()
28203 req, err := http.NewRequest("GET", urls, body)
28204 if err != nil {
28205 return nil, err
28206 }
28207 req.Header = reqHeaders
28208 googleapi.Expand(req.URL, map[string]string{
28209 "parent": c.parent,
28210 })
28211 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28212 }
28213
28214
28215
28216
28217
28218
28219
28220
28221
28222
28223
28224 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse, error) {
28225 gensupport.SetOptions(c.urlParams_, opts...)
28226 res, err := c.doRequest("json")
28227 if res != nil && res.StatusCode == http.StatusNotModified {
28228 if res.Body != nil {
28229 res.Body.Close()
28230 }
28231 return nil, gensupport.WrapError(&googleapi.Error{
28232 Code: res.StatusCode,
28233 Header: res.Header,
28234 })
28235 }
28236 if err != nil {
28237 return nil, err
28238 }
28239 defer googleapi.CloseBody(res)
28240 if err := googleapi.CheckResponse(res); err != nil {
28241 return nil, gensupport.WrapError(err)
28242 }
28243 ret := &GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse{
28244 ServerResponse: googleapi.ServerResponse{
28245 Header: res.Header,
28246 HTTPStatusCode: res.StatusCode,
28247 },
28248 }
28249 target := &ret
28250 if err := gensupport.DecodeResponse(target, res); err != nil {
28251 return nil, err
28252 }
28253 return ret, nil
28254
28255
28256
28257
28258
28259
28260
28261
28262
28263
28264
28265
28266
28267
28268
28269
28270
28271
28272
28273
28274
28275
28276
28277
28278
28279
28280
28281
28282
28283
28284
28285
28286
28287
28288
28289
28290
28291
28292
28293
28294
28295
28296
28297
28298
28299
28300
28301
28302 }
28303
28304
28305
28306
28307 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse) error) error {
28308 c.ctx_ = ctx
28309 defer c.PageToken(c.urlParams_.Get("pageToken"))
28310 for {
28311 x, err := c.Do()
28312 if err != nil {
28313 return err
28314 }
28315 if err := f(x); err != nil {
28316 return err
28317 }
28318 if x.NextPageToken == "" {
28319 return nil
28320 }
28321 c.PageToken(x.NextPageToken)
28322 }
28323 }
28324
28325
28326
28327 type ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall struct {
28328 s *Service
28329 name string
28330 googlecloudintegrationsv1alphasfdcchannel *GoogleCloudIntegrationsV1alphaSfdcChannel
28331 urlParams_ gensupport.URLParams
28332 ctx_ context.Context
28333 header_ http.Header
28334 }
28335
28336
28337
28338
28339
28340
28341
28342 func (r *ProjectsLocationsProductsSfdcInstancesSfdcChannelsService) Patch(name string, googlecloudintegrationsv1alphasfdcchannel *GoogleCloudIntegrationsV1alphaSfdcChannel) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall {
28343 c := &ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28344 c.name = name
28345 c.googlecloudintegrationsv1alphasfdcchannel = googlecloudintegrationsv1alphasfdcchannel
28346 return c
28347 }
28348
28349
28350
28351
28352 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall {
28353 c.urlParams_.Set("updateMask", updateMask)
28354 return c
28355 }
28356
28357
28358
28359
28360 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall {
28361 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28362 return c
28363 }
28364
28365
28366
28367
28368 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall) Context(ctx context.Context) *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall {
28369 c.ctx_ = ctx
28370 return c
28371 }
28372
28373
28374
28375 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall) Header() http.Header {
28376 if c.header_ == nil {
28377 c.header_ = make(http.Header)
28378 }
28379 return c.header_
28380 }
28381
28382 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall) doRequest(alt string) (*http.Response, error) {
28383 reqHeaders := make(http.Header)
28384 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
28385 for k, v := range c.header_ {
28386 reqHeaders[k] = v
28387 }
28388 reqHeaders.Set("User-Agent", c.s.userAgent())
28389 var body io.Reader = nil
28390 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphasfdcchannel)
28391 if err != nil {
28392 return nil, err
28393 }
28394 reqHeaders.Set("Content-Type", "application/json")
28395 c.urlParams_.Set("alt", alt)
28396 c.urlParams_.Set("prettyPrint", "false")
28397 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
28398 urls += "?" + c.urlParams_.Encode()
28399 req, err := http.NewRequest("PATCH", urls, body)
28400 if err != nil {
28401 return nil, err
28402 }
28403 req.Header = reqHeaders
28404 googleapi.Expand(req.URL, map[string]string{
28405 "name": c.name,
28406 })
28407 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28408 }
28409
28410
28411
28412
28413
28414
28415
28416
28417
28418
28419 func (c *ProjectsLocationsProductsSfdcInstancesSfdcChannelsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcChannel, error) {
28420 gensupport.SetOptions(c.urlParams_, opts...)
28421 res, err := c.doRequest("json")
28422 if res != nil && res.StatusCode == http.StatusNotModified {
28423 if res.Body != nil {
28424 res.Body.Close()
28425 }
28426 return nil, gensupport.WrapError(&googleapi.Error{
28427 Code: res.StatusCode,
28428 Header: res.Header,
28429 })
28430 }
28431 if err != nil {
28432 return nil, err
28433 }
28434 defer googleapi.CloseBody(res)
28435 if err := googleapi.CheckResponse(res); err != nil {
28436 return nil, gensupport.WrapError(err)
28437 }
28438 ret := &GoogleCloudIntegrationsV1alphaSfdcChannel{
28439 ServerResponse: googleapi.ServerResponse{
28440 Header: res.Header,
28441 HTTPStatusCode: res.StatusCode,
28442 },
28443 }
28444 target := &ret
28445 if err := gensupport.DecodeResponse(target, res); err != nil {
28446 return nil, err
28447 }
28448 return ret, nil
28449
28450
28451
28452
28453
28454
28455
28456
28457
28458
28459
28460
28461
28462
28463
28464
28465
28466
28467
28468
28469
28470
28471
28472
28473
28474
28475
28476
28477
28478
28479
28480
28481
28482
28483
28484 }
28485
28486
28487
28488 type ProjectsLocationsSfdcInstancesCreateCall struct {
28489 s *Service
28490 parent string
28491 googlecloudintegrationsv1alphasfdcinstance *GoogleCloudIntegrationsV1alphaSfdcInstance
28492 urlParams_ gensupport.URLParams
28493 ctx_ context.Context
28494 header_ http.Header
28495 }
28496
28497
28498
28499
28500
28501 func (r *ProjectsLocationsSfdcInstancesService) Create(parent string, googlecloudintegrationsv1alphasfdcinstance *GoogleCloudIntegrationsV1alphaSfdcInstance) *ProjectsLocationsSfdcInstancesCreateCall {
28502 c := &ProjectsLocationsSfdcInstancesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28503 c.parent = parent
28504 c.googlecloudintegrationsv1alphasfdcinstance = googlecloudintegrationsv1alphasfdcinstance
28505 return c
28506 }
28507
28508
28509
28510
28511 func (c *ProjectsLocationsSfdcInstancesCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesCreateCall {
28512 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28513 return c
28514 }
28515
28516
28517
28518
28519 func (c *ProjectsLocationsSfdcInstancesCreateCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesCreateCall {
28520 c.ctx_ = ctx
28521 return c
28522 }
28523
28524
28525
28526 func (c *ProjectsLocationsSfdcInstancesCreateCall) Header() http.Header {
28527 if c.header_ == nil {
28528 c.header_ = make(http.Header)
28529 }
28530 return c.header_
28531 }
28532
28533 func (c *ProjectsLocationsSfdcInstancesCreateCall) doRequest(alt string) (*http.Response, error) {
28534 reqHeaders := make(http.Header)
28535 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
28536 for k, v := range c.header_ {
28537 reqHeaders[k] = v
28538 }
28539 reqHeaders.Set("User-Agent", c.s.userAgent())
28540 var body io.Reader = nil
28541 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphasfdcinstance)
28542 if err != nil {
28543 return nil, err
28544 }
28545 reqHeaders.Set("Content-Type", "application/json")
28546 c.urlParams_.Set("alt", alt)
28547 c.urlParams_.Set("prettyPrint", "false")
28548 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/sfdcInstances")
28549 urls += "?" + c.urlParams_.Encode()
28550 req, err := http.NewRequest("POST", urls, body)
28551 if err != nil {
28552 return nil, err
28553 }
28554 req.Header = reqHeaders
28555 googleapi.Expand(req.URL, map[string]string{
28556 "parent": c.parent,
28557 })
28558 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28559 }
28560
28561
28562
28563
28564
28565
28566
28567
28568
28569
28570 func (c *ProjectsLocationsSfdcInstancesCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcInstance, error) {
28571 gensupport.SetOptions(c.urlParams_, opts...)
28572 res, err := c.doRequest("json")
28573 if res != nil && res.StatusCode == http.StatusNotModified {
28574 if res.Body != nil {
28575 res.Body.Close()
28576 }
28577 return nil, gensupport.WrapError(&googleapi.Error{
28578 Code: res.StatusCode,
28579 Header: res.Header,
28580 })
28581 }
28582 if err != nil {
28583 return nil, err
28584 }
28585 defer googleapi.CloseBody(res)
28586 if err := googleapi.CheckResponse(res); err != nil {
28587 return nil, gensupport.WrapError(err)
28588 }
28589 ret := &GoogleCloudIntegrationsV1alphaSfdcInstance{
28590 ServerResponse: googleapi.ServerResponse{
28591 Header: res.Header,
28592 HTTPStatusCode: res.StatusCode,
28593 },
28594 }
28595 target := &ret
28596 if err := gensupport.DecodeResponse(target, res); err != nil {
28597 return nil, err
28598 }
28599 return ret, nil
28600
28601
28602
28603
28604
28605
28606
28607
28608
28609
28610
28611
28612
28613
28614
28615
28616
28617
28618
28619
28620
28621
28622
28623
28624
28625
28626
28627
28628
28629 }
28630
28631
28632
28633 type ProjectsLocationsSfdcInstancesDeleteCall struct {
28634 s *Service
28635 name string
28636 urlParams_ gensupport.URLParams
28637 ctx_ context.Context
28638 header_ http.Header
28639 }
28640
28641
28642
28643
28644 func (r *ProjectsLocationsSfdcInstancesService) Delete(name string) *ProjectsLocationsSfdcInstancesDeleteCall {
28645 c := &ProjectsLocationsSfdcInstancesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28646 c.name = name
28647 return c
28648 }
28649
28650
28651
28652
28653 func (c *ProjectsLocationsSfdcInstancesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesDeleteCall {
28654 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28655 return c
28656 }
28657
28658
28659
28660
28661 func (c *ProjectsLocationsSfdcInstancesDeleteCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesDeleteCall {
28662 c.ctx_ = ctx
28663 return c
28664 }
28665
28666
28667
28668 func (c *ProjectsLocationsSfdcInstancesDeleteCall) Header() http.Header {
28669 if c.header_ == nil {
28670 c.header_ = make(http.Header)
28671 }
28672 return c.header_
28673 }
28674
28675 func (c *ProjectsLocationsSfdcInstancesDeleteCall) doRequest(alt string) (*http.Response, error) {
28676 reqHeaders := make(http.Header)
28677 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
28678 for k, v := range c.header_ {
28679 reqHeaders[k] = v
28680 }
28681 reqHeaders.Set("User-Agent", c.s.userAgent())
28682 var body io.Reader = nil
28683 c.urlParams_.Set("alt", alt)
28684 c.urlParams_.Set("prettyPrint", "false")
28685 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
28686 urls += "?" + c.urlParams_.Encode()
28687 req, err := http.NewRequest("DELETE", urls, body)
28688 if err != nil {
28689 return nil, err
28690 }
28691 req.Header = reqHeaders
28692 googleapi.Expand(req.URL, map[string]string{
28693 "name": c.name,
28694 })
28695 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28696 }
28697
28698
28699
28700
28701
28702
28703
28704
28705 func (c *ProjectsLocationsSfdcInstancesDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
28706 gensupport.SetOptions(c.urlParams_, opts...)
28707 res, err := c.doRequest("json")
28708 if res != nil && res.StatusCode == http.StatusNotModified {
28709 if res.Body != nil {
28710 res.Body.Close()
28711 }
28712 return nil, gensupport.WrapError(&googleapi.Error{
28713 Code: res.StatusCode,
28714 Header: res.Header,
28715 })
28716 }
28717 if err != nil {
28718 return nil, err
28719 }
28720 defer googleapi.CloseBody(res)
28721 if err := googleapi.CheckResponse(res); err != nil {
28722 return nil, gensupport.WrapError(err)
28723 }
28724 ret := &GoogleProtobufEmpty{
28725 ServerResponse: googleapi.ServerResponse{
28726 Header: res.Header,
28727 HTTPStatusCode: res.StatusCode,
28728 },
28729 }
28730 target := &ret
28731 if err := gensupport.DecodeResponse(target, res); err != nil {
28732 return nil, err
28733 }
28734 return ret, nil
28735
28736
28737
28738
28739
28740
28741
28742
28743
28744
28745
28746
28747
28748
28749
28750
28751
28752
28753
28754
28755
28756
28757
28758
28759
28760
28761 }
28762
28763
28764
28765 type ProjectsLocationsSfdcInstancesGetCall struct {
28766 s *Service
28767 name string
28768 urlParams_ gensupport.URLParams
28769 ifNoneMatch_ string
28770 ctx_ context.Context
28771 header_ http.Header
28772 }
28773
28774
28775
28776
28777
28778 func (r *ProjectsLocationsSfdcInstancesService) Get(name string) *ProjectsLocationsSfdcInstancesGetCall {
28779 c := &ProjectsLocationsSfdcInstancesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28780 c.name = name
28781 return c
28782 }
28783
28784
28785
28786
28787 func (c *ProjectsLocationsSfdcInstancesGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesGetCall {
28788 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28789 return c
28790 }
28791
28792
28793
28794
28795
28796
28797 func (c *ProjectsLocationsSfdcInstancesGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsSfdcInstancesGetCall {
28798 c.ifNoneMatch_ = entityTag
28799 return c
28800 }
28801
28802
28803
28804
28805 func (c *ProjectsLocationsSfdcInstancesGetCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesGetCall {
28806 c.ctx_ = ctx
28807 return c
28808 }
28809
28810
28811
28812 func (c *ProjectsLocationsSfdcInstancesGetCall) Header() http.Header {
28813 if c.header_ == nil {
28814 c.header_ = make(http.Header)
28815 }
28816 return c.header_
28817 }
28818
28819 func (c *ProjectsLocationsSfdcInstancesGetCall) doRequest(alt string) (*http.Response, error) {
28820 reqHeaders := make(http.Header)
28821 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
28822 for k, v := range c.header_ {
28823 reqHeaders[k] = v
28824 }
28825 reqHeaders.Set("User-Agent", c.s.userAgent())
28826 if c.ifNoneMatch_ != "" {
28827 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
28828 }
28829 var body io.Reader = nil
28830 c.urlParams_.Set("alt", alt)
28831 c.urlParams_.Set("prettyPrint", "false")
28832 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
28833 urls += "?" + c.urlParams_.Encode()
28834 req, err := http.NewRequest("GET", urls, body)
28835 if err != nil {
28836 return nil, err
28837 }
28838 req.Header = reqHeaders
28839 googleapi.Expand(req.URL, map[string]string{
28840 "name": c.name,
28841 })
28842 return gensupport.SendRequest(c.ctx_, c.s.client, req)
28843 }
28844
28845
28846
28847
28848
28849
28850
28851
28852
28853
28854 func (c *ProjectsLocationsSfdcInstancesGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcInstance, error) {
28855 gensupport.SetOptions(c.urlParams_, opts...)
28856 res, err := c.doRequest("json")
28857 if res != nil && res.StatusCode == http.StatusNotModified {
28858 if res.Body != nil {
28859 res.Body.Close()
28860 }
28861 return nil, gensupport.WrapError(&googleapi.Error{
28862 Code: res.StatusCode,
28863 Header: res.Header,
28864 })
28865 }
28866 if err != nil {
28867 return nil, err
28868 }
28869 defer googleapi.CloseBody(res)
28870 if err := googleapi.CheckResponse(res); err != nil {
28871 return nil, gensupport.WrapError(err)
28872 }
28873 ret := &GoogleCloudIntegrationsV1alphaSfdcInstance{
28874 ServerResponse: googleapi.ServerResponse{
28875 Header: res.Header,
28876 HTTPStatusCode: res.StatusCode,
28877 },
28878 }
28879 target := &ret
28880 if err := gensupport.DecodeResponse(target, res); err != nil {
28881 return nil, err
28882 }
28883 return ret, nil
28884
28885
28886
28887
28888
28889
28890
28891
28892
28893
28894
28895
28896
28897
28898
28899
28900
28901
28902
28903
28904
28905
28906
28907
28908
28909
28910 }
28911
28912
28913
28914 type ProjectsLocationsSfdcInstancesListCall struct {
28915 s *Service
28916 parent string
28917 urlParams_ gensupport.URLParams
28918 ifNoneMatch_ string
28919 ctx_ context.Context
28920 header_ http.Header
28921 }
28922
28923
28924
28925
28926
28927 func (r *ProjectsLocationsSfdcInstancesService) List(parent string) *ProjectsLocationsSfdcInstancesListCall {
28928 c := &ProjectsLocationsSfdcInstancesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
28929 c.parent = parent
28930 return c
28931 }
28932
28933
28934
28935
28936 func (c *ProjectsLocationsSfdcInstancesListCall) Filter(filter string) *ProjectsLocationsSfdcInstancesListCall {
28937 c.urlParams_.Set("filter", filter)
28938 return c
28939 }
28940
28941
28942
28943 func (c *ProjectsLocationsSfdcInstancesListCall) PageSize(pageSize int64) *ProjectsLocationsSfdcInstancesListCall {
28944 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
28945 return c
28946 }
28947
28948
28949
28950 func (c *ProjectsLocationsSfdcInstancesListCall) PageToken(pageToken string) *ProjectsLocationsSfdcInstancesListCall {
28951 c.urlParams_.Set("pageToken", pageToken)
28952 return c
28953 }
28954
28955
28956
28957
28958 func (c *ProjectsLocationsSfdcInstancesListCall) ReadMask(readMask string) *ProjectsLocationsSfdcInstancesListCall {
28959 c.urlParams_.Set("readMask", readMask)
28960 return c
28961 }
28962
28963
28964
28965
28966 func (c *ProjectsLocationsSfdcInstancesListCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesListCall {
28967 c.urlParams_.Set("fields", googleapi.CombineFields(s))
28968 return c
28969 }
28970
28971
28972
28973
28974
28975
28976 func (c *ProjectsLocationsSfdcInstancesListCall) IfNoneMatch(entityTag string) *ProjectsLocationsSfdcInstancesListCall {
28977 c.ifNoneMatch_ = entityTag
28978 return c
28979 }
28980
28981
28982
28983
28984 func (c *ProjectsLocationsSfdcInstancesListCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesListCall {
28985 c.ctx_ = ctx
28986 return c
28987 }
28988
28989
28990
28991 func (c *ProjectsLocationsSfdcInstancesListCall) Header() http.Header {
28992 if c.header_ == nil {
28993 c.header_ = make(http.Header)
28994 }
28995 return c.header_
28996 }
28997
28998 func (c *ProjectsLocationsSfdcInstancesListCall) doRequest(alt string) (*http.Response, error) {
28999 reqHeaders := make(http.Header)
29000 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
29001 for k, v := range c.header_ {
29002 reqHeaders[k] = v
29003 }
29004 reqHeaders.Set("User-Agent", c.s.userAgent())
29005 if c.ifNoneMatch_ != "" {
29006 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
29007 }
29008 var body io.Reader = nil
29009 c.urlParams_.Set("alt", alt)
29010 c.urlParams_.Set("prettyPrint", "false")
29011 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/sfdcInstances")
29012 urls += "?" + c.urlParams_.Encode()
29013 req, err := http.NewRequest("GET", urls, body)
29014 if err != nil {
29015 return nil, err
29016 }
29017 req.Header = reqHeaders
29018 googleapi.Expand(req.URL, map[string]string{
29019 "parent": c.parent,
29020 })
29021 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29022 }
29023
29024
29025
29026
29027
29028
29029
29030
29031
29032
29033
29034 func (c *ProjectsLocationsSfdcInstancesListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse, error) {
29035 gensupport.SetOptions(c.urlParams_, opts...)
29036 res, err := c.doRequest("json")
29037 if res != nil && res.StatusCode == http.StatusNotModified {
29038 if res.Body != nil {
29039 res.Body.Close()
29040 }
29041 return nil, gensupport.WrapError(&googleapi.Error{
29042 Code: res.StatusCode,
29043 Header: res.Header,
29044 })
29045 }
29046 if err != nil {
29047 return nil, err
29048 }
29049 defer googleapi.CloseBody(res)
29050 if err := googleapi.CheckResponse(res); err != nil {
29051 return nil, gensupport.WrapError(err)
29052 }
29053 ret := &GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse{
29054 ServerResponse: googleapi.ServerResponse{
29055 Header: res.Header,
29056 HTTPStatusCode: res.StatusCode,
29057 },
29058 }
29059 target := &ret
29060 if err := gensupport.DecodeResponse(target, res); err != nil {
29061 return nil, err
29062 }
29063 return ret, nil
29064
29065
29066
29067
29068
29069
29070
29071
29072
29073
29074
29075
29076
29077
29078
29079
29080
29081
29082
29083
29084
29085
29086
29087
29088
29089
29090
29091
29092
29093
29094
29095
29096
29097
29098
29099
29100
29101
29102
29103
29104
29105
29106
29107
29108
29109
29110
29111
29112 }
29113
29114
29115
29116
29117 func (c *ProjectsLocationsSfdcInstancesListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListSfdcInstancesResponse) error) error {
29118 c.ctx_ = ctx
29119 defer c.PageToken(c.urlParams_.Get("pageToken"))
29120 for {
29121 x, err := c.Do()
29122 if err != nil {
29123 return err
29124 }
29125 if err := f(x); err != nil {
29126 return err
29127 }
29128 if x.NextPageToken == "" {
29129 return nil
29130 }
29131 c.PageToken(x.NextPageToken)
29132 }
29133 }
29134
29135
29136
29137 type ProjectsLocationsSfdcInstancesPatchCall struct {
29138 s *Service
29139 name string
29140 googlecloudintegrationsv1alphasfdcinstance *GoogleCloudIntegrationsV1alphaSfdcInstance
29141 urlParams_ gensupport.URLParams
29142 ctx_ context.Context
29143 header_ http.Header
29144 }
29145
29146
29147
29148
29149
29150
29151
29152 func (r *ProjectsLocationsSfdcInstancesService) Patch(name string, googlecloudintegrationsv1alphasfdcinstance *GoogleCloudIntegrationsV1alphaSfdcInstance) *ProjectsLocationsSfdcInstancesPatchCall {
29153 c := &ProjectsLocationsSfdcInstancesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29154 c.name = name
29155 c.googlecloudintegrationsv1alphasfdcinstance = googlecloudintegrationsv1alphasfdcinstance
29156 return c
29157 }
29158
29159
29160
29161
29162 func (c *ProjectsLocationsSfdcInstancesPatchCall) UpdateMask(updateMask string) *ProjectsLocationsSfdcInstancesPatchCall {
29163 c.urlParams_.Set("updateMask", updateMask)
29164 return c
29165 }
29166
29167
29168
29169
29170 func (c *ProjectsLocationsSfdcInstancesPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesPatchCall {
29171 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29172 return c
29173 }
29174
29175
29176
29177
29178 func (c *ProjectsLocationsSfdcInstancesPatchCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesPatchCall {
29179 c.ctx_ = ctx
29180 return c
29181 }
29182
29183
29184
29185 func (c *ProjectsLocationsSfdcInstancesPatchCall) Header() http.Header {
29186 if c.header_ == nil {
29187 c.header_ = make(http.Header)
29188 }
29189 return c.header_
29190 }
29191
29192 func (c *ProjectsLocationsSfdcInstancesPatchCall) doRequest(alt string) (*http.Response, error) {
29193 reqHeaders := make(http.Header)
29194 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
29195 for k, v := range c.header_ {
29196 reqHeaders[k] = v
29197 }
29198 reqHeaders.Set("User-Agent", c.s.userAgent())
29199 var body io.Reader = nil
29200 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphasfdcinstance)
29201 if err != nil {
29202 return nil, err
29203 }
29204 reqHeaders.Set("Content-Type", "application/json")
29205 c.urlParams_.Set("alt", alt)
29206 c.urlParams_.Set("prettyPrint", "false")
29207 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
29208 urls += "?" + c.urlParams_.Encode()
29209 req, err := http.NewRequest("PATCH", urls, body)
29210 if err != nil {
29211 return nil, err
29212 }
29213 req.Header = reqHeaders
29214 googleapi.Expand(req.URL, map[string]string{
29215 "name": c.name,
29216 })
29217 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29218 }
29219
29220
29221
29222
29223
29224
29225
29226
29227
29228
29229 func (c *ProjectsLocationsSfdcInstancesPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcInstance, error) {
29230 gensupport.SetOptions(c.urlParams_, opts...)
29231 res, err := c.doRequest("json")
29232 if res != nil && res.StatusCode == http.StatusNotModified {
29233 if res.Body != nil {
29234 res.Body.Close()
29235 }
29236 return nil, gensupport.WrapError(&googleapi.Error{
29237 Code: res.StatusCode,
29238 Header: res.Header,
29239 })
29240 }
29241 if err != nil {
29242 return nil, err
29243 }
29244 defer googleapi.CloseBody(res)
29245 if err := googleapi.CheckResponse(res); err != nil {
29246 return nil, gensupport.WrapError(err)
29247 }
29248 ret := &GoogleCloudIntegrationsV1alphaSfdcInstance{
29249 ServerResponse: googleapi.ServerResponse{
29250 Header: res.Header,
29251 HTTPStatusCode: res.StatusCode,
29252 },
29253 }
29254 target := &ret
29255 if err := gensupport.DecodeResponse(target, res); err != nil {
29256 return nil, err
29257 }
29258 return ret, nil
29259
29260
29261
29262
29263
29264
29265
29266
29267
29268
29269
29270
29271
29272
29273
29274
29275
29276
29277
29278
29279
29280
29281
29282
29283
29284
29285
29286
29287
29288
29289
29290
29291
29292
29293
29294 }
29295
29296
29297
29298 type ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall struct {
29299 s *Service
29300 parent string
29301 googlecloudintegrationsv1alphasfdcchannel *GoogleCloudIntegrationsV1alphaSfdcChannel
29302 urlParams_ gensupport.URLParams
29303 ctx_ context.Context
29304 header_ http.Header
29305 }
29306
29307
29308
29309
29310
29311 func (r *ProjectsLocationsSfdcInstancesSfdcChannelsService) Create(parent string, googlecloudintegrationsv1alphasfdcchannel *GoogleCloudIntegrationsV1alphaSfdcChannel) *ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall {
29312 c := &ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29313 c.parent = parent
29314 c.googlecloudintegrationsv1alphasfdcchannel = googlecloudintegrationsv1alphasfdcchannel
29315 return c
29316 }
29317
29318
29319
29320
29321 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall {
29322 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29323 return c
29324 }
29325
29326
29327
29328
29329 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall {
29330 c.ctx_ = ctx
29331 return c
29332 }
29333
29334
29335
29336 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall) Header() http.Header {
29337 if c.header_ == nil {
29338 c.header_ = make(http.Header)
29339 }
29340 return c.header_
29341 }
29342
29343 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall) doRequest(alt string) (*http.Response, error) {
29344 reqHeaders := make(http.Header)
29345 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
29346 for k, v := range c.header_ {
29347 reqHeaders[k] = v
29348 }
29349 reqHeaders.Set("User-Agent", c.s.userAgent())
29350 var body io.Reader = nil
29351 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphasfdcchannel)
29352 if err != nil {
29353 return nil, err
29354 }
29355 reqHeaders.Set("Content-Type", "application/json")
29356 c.urlParams_.Set("alt", alt)
29357 c.urlParams_.Set("prettyPrint", "false")
29358 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/sfdcChannels")
29359 urls += "?" + c.urlParams_.Encode()
29360 req, err := http.NewRequest("POST", urls, body)
29361 if err != nil {
29362 return nil, err
29363 }
29364 req.Header = reqHeaders
29365 googleapi.Expand(req.URL, map[string]string{
29366 "parent": c.parent,
29367 })
29368 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29369 }
29370
29371
29372
29373
29374
29375
29376
29377
29378
29379
29380 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcChannel, error) {
29381 gensupport.SetOptions(c.urlParams_, opts...)
29382 res, err := c.doRequest("json")
29383 if res != nil && res.StatusCode == http.StatusNotModified {
29384 if res.Body != nil {
29385 res.Body.Close()
29386 }
29387 return nil, gensupport.WrapError(&googleapi.Error{
29388 Code: res.StatusCode,
29389 Header: res.Header,
29390 })
29391 }
29392 if err != nil {
29393 return nil, err
29394 }
29395 defer googleapi.CloseBody(res)
29396 if err := googleapi.CheckResponse(res); err != nil {
29397 return nil, gensupport.WrapError(err)
29398 }
29399 ret := &GoogleCloudIntegrationsV1alphaSfdcChannel{
29400 ServerResponse: googleapi.ServerResponse{
29401 Header: res.Header,
29402 HTTPStatusCode: res.StatusCode,
29403 },
29404 }
29405 target := &ret
29406 if err := gensupport.DecodeResponse(target, res); err != nil {
29407 return nil, err
29408 }
29409 return ret, nil
29410
29411
29412
29413
29414
29415
29416
29417
29418
29419
29420
29421
29422
29423
29424
29425
29426
29427
29428
29429
29430
29431
29432
29433
29434
29435
29436
29437
29438
29439 }
29440
29441
29442
29443 type ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall struct {
29444 s *Service
29445 name string
29446 urlParams_ gensupport.URLParams
29447 ctx_ context.Context
29448 header_ http.Header
29449 }
29450
29451
29452
29453
29454 func (r *ProjectsLocationsSfdcInstancesSfdcChannelsService) Delete(name string) *ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall {
29455 c := &ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29456 c.name = name
29457 return c
29458 }
29459
29460
29461
29462
29463 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall {
29464 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29465 return c
29466 }
29467
29468
29469
29470
29471 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall {
29472 c.ctx_ = ctx
29473 return c
29474 }
29475
29476
29477
29478 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall) Header() http.Header {
29479 if c.header_ == nil {
29480 c.header_ = make(http.Header)
29481 }
29482 return c.header_
29483 }
29484
29485 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall) doRequest(alt string) (*http.Response, error) {
29486 reqHeaders := make(http.Header)
29487 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
29488 for k, v := range c.header_ {
29489 reqHeaders[k] = v
29490 }
29491 reqHeaders.Set("User-Agent", c.s.userAgent())
29492 var body io.Reader = nil
29493 c.urlParams_.Set("alt", alt)
29494 c.urlParams_.Set("prettyPrint", "false")
29495 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
29496 urls += "?" + c.urlParams_.Encode()
29497 req, err := http.NewRequest("DELETE", urls, body)
29498 if err != nil {
29499 return nil, err
29500 }
29501 req.Header = reqHeaders
29502 googleapi.Expand(req.URL, map[string]string{
29503 "name": c.name,
29504 })
29505 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29506 }
29507
29508
29509
29510
29511
29512
29513
29514
29515 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleProtobufEmpty, error) {
29516 gensupport.SetOptions(c.urlParams_, opts...)
29517 res, err := c.doRequest("json")
29518 if res != nil && res.StatusCode == http.StatusNotModified {
29519 if res.Body != nil {
29520 res.Body.Close()
29521 }
29522 return nil, gensupport.WrapError(&googleapi.Error{
29523 Code: res.StatusCode,
29524 Header: res.Header,
29525 })
29526 }
29527 if err != nil {
29528 return nil, err
29529 }
29530 defer googleapi.CloseBody(res)
29531 if err := googleapi.CheckResponse(res); err != nil {
29532 return nil, gensupport.WrapError(err)
29533 }
29534 ret := &GoogleProtobufEmpty{
29535 ServerResponse: googleapi.ServerResponse{
29536 Header: res.Header,
29537 HTTPStatusCode: res.StatusCode,
29538 },
29539 }
29540 target := &ret
29541 if err := gensupport.DecodeResponse(target, res); err != nil {
29542 return nil, err
29543 }
29544 return ret, nil
29545
29546
29547
29548
29549
29550
29551
29552
29553
29554
29555
29556
29557
29558
29559
29560
29561
29562
29563
29564
29565
29566
29567
29568
29569
29570
29571 }
29572
29573
29574
29575 type ProjectsLocationsSfdcInstancesSfdcChannelsGetCall struct {
29576 s *Service
29577 name string
29578 urlParams_ gensupport.URLParams
29579 ifNoneMatch_ string
29580 ctx_ context.Context
29581 header_ http.Header
29582 }
29583
29584
29585
29586
29587
29588 func (r *ProjectsLocationsSfdcInstancesSfdcChannelsService) Get(name string) *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall {
29589 c := &ProjectsLocationsSfdcInstancesSfdcChannelsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29590 c.name = name
29591 return c
29592 }
29593
29594
29595
29596
29597 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall {
29598 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29599 return c
29600 }
29601
29602
29603
29604
29605
29606
29607 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall {
29608 c.ifNoneMatch_ = entityTag
29609 return c
29610 }
29611
29612
29613
29614
29615 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall {
29616 c.ctx_ = ctx
29617 return c
29618 }
29619
29620
29621
29622 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall) Header() http.Header {
29623 if c.header_ == nil {
29624 c.header_ = make(http.Header)
29625 }
29626 return c.header_
29627 }
29628
29629 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall) doRequest(alt string) (*http.Response, error) {
29630 reqHeaders := make(http.Header)
29631 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
29632 for k, v := range c.header_ {
29633 reqHeaders[k] = v
29634 }
29635 reqHeaders.Set("User-Agent", c.s.userAgent())
29636 if c.ifNoneMatch_ != "" {
29637 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
29638 }
29639 var body io.Reader = nil
29640 c.urlParams_.Set("alt", alt)
29641 c.urlParams_.Set("prettyPrint", "false")
29642 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
29643 urls += "?" + c.urlParams_.Encode()
29644 req, err := http.NewRequest("GET", urls, body)
29645 if err != nil {
29646 return nil, err
29647 }
29648 req.Header = reqHeaders
29649 googleapi.Expand(req.URL, map[string]string{
29650 "name": c.name,
29651 })
29652 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29653 }
29654
29655
29656
29657
29658
29659
29660
29661
29662
29663
29664 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcChannel, error) {
29665 gensupport.SetOptions(c.urlParams_, opts...)
29666 res, err := c.doRequest("json")
29667 if res != nil && res.StatusCode == http.StatusNotModified {
29668 if res.Body != nil {
29669 res.Body.Close()
29670 }
29671 return nil, gensupport.WrapError(&googleapi.Error{
29672 Code: res.StatusCode,
29673 Header: res.Header,
29674 })
29675 }
29676 if err != nil {
29677 return nil, err
29678 }
29679 defer googleapi.CloseBody(res)
29680 if err := googleapi.CheckResponse(res); err != nil {
29681 return nil, gensupport.WrapError(err)
29682 }
29683 ret := &GoogleCloudIntegrationsV1alphaSfdcChannel{
29684 ServerResponse: googleapi.ServerResponse{
29685 Header: res.Header,
29686 HTTPStatusCode: res.StatusCode,
29687 },
29688 }
29689 target := &ret
29690 if err := gensupport.DecodeResponse(target, res); err != nil {
29691 return nil, err
29692 }
29693 return ret, nil
29694
29695
29696
29697
29698
29699
29700
29701
29702
29703
29704
29705
29706
29707
29708
29709
29710
29711
29712
29713
29714
29715
29716
29717
29718
29719
29720 }
29721
29722
29723
29724 type ProjectsLocationsSfdcInstancesSfdcChannelsListCall struct {
29725 s *Service
29726 parent string
29727 urlParams_ gensupport.URLParams
29728 ifNoneMatch_ string
29729 ctx_ context.Context
29730 header_ http.Header
29731 }
29732
29733
29734
29735
29736
29737 func (r *ProjectsLocationsSfdcInstancesSfdcChannelsService) List(parent string) *ProjectsLocationsSfdcInstancesSfdcChannelsListCall {
29738 c := &ProjectsLocationsSfdcInstancesSfdcChannelsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29739 c.parent = parent
29740 return c
29741 }
29742
29743
29744
29745
29746 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) Filter(filter string) *ProjectsLocationsSfdcInstancesSfdcChannelsListCall {
29747 c.urlParams_.Set("filter", filter)
29748 return c
29749 }
29750
29751
29752
29753 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) PageSize(pageSize int64) *ProjectsLocationsSfdcInstancesSfdcChannelsListCall {
29754 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
29755 return c
29756 }
29757
29758
29759
29760 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) PageToken(pageToken string) *ProjectsLocationsSfdcInstancesSfdcChannelsListCall {
29761 c.urlParams_.Set("pageToken", pageToken)
29762 return c
29763 }
29764
29765
29766
29767
29768 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) ReadMask(readMask string) *ProjectsLocationsSfdcInstancesSfdcChannelsListCall {
29769 c.urlParams_.Set("readMask", readMask)
29770 return c
29771 }
29772
29773
29774
29775
29776 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesSfdcChannelsListCall {
29777 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29778 return c
29779 }
29780
29781
29782
29783
29784
29785
29786 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsSfdcInstancesSfdcChannelsListCall {
29787 c.ifNoneMatch_ = entityTag
29788 return c
29789 }
29790
29791
29792
29793
29794 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesSfdcChannelsListCall {
29795 c.ctx_ = ctx
29796 return c
29797 }
29798
29799
29800
29801 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) Header() http.Header {
29802 if c.header_ == nil {
29803 c.header_ = make(http.Header)
29804 }
29805 return c.header_
29806 }
29807
29808 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) doRequest(alt string) (*http.Response, error) {
29809 reqHeaders := make(http.Header)
29810 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
29811 for k, v := range c.header_ {
29812 reqHeaders[k] = v
29813 }
29814 reqHeaders.Set("User-Agent", c.s.userAgent())
29815 if c.ifNoneMatch_ != "" {
29816 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
29817 }
29818 var body io.Reader = nil
29819 c.urlParams_.Set("alt", alt)
29820 c.urlParams_.Set("prettyPrint", "false")
29821 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/sfdcChannels")
29822 urls += "?" + c.urlParams_.Encode()
29823 req, err := http.NewRequest("GET", urls, body)
29824 if err != nil {
29825 return nil, err
29826 }
29827 req.Header = reqHeaders
29828 googleapi.Expand(req.URL, map[string]string{
29829 "parent": c.parent,
29830 })
29831 return gensupport.SendRequest(c.ctx_, c.s.client, req)
29832 }
29833
29834
29835
29836
29837
29838
29839
29840
29841
29842
29843
29844 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse, error) {
29845 gensupport.SetOptions(c.urlParams_, opts...)
29846 res, err := c.doRequest("json")
29847 if res != nil && res.StatusCode == http.StatusNotModified {
29848 if res.Body != nil {
29849 res.Body.Close()
29850 }
29851 return nil, gensupport.WrapError(&googleapi.Error{
29852 Code: res.StatusCode,
29853 Header: res.Header,
29854 })
29855 }
29856 if err != nil {
29857 return nil, err
29858 }
29859 defer googleapi.CloseBody(res)
29860 if err := googleapi.CheckResponse(res); err != nil {
29861 return nil, gensupport.WrapError(err)
29862 }
29863 ret := &GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse{
29864 ServerResponse: googleapi.ServerResponse{
29865 Header: res.Header,
29866 HTTPStatusCode: res.StatusCode,
29867 },
29868 }
29869 target := &ret
29870 if err := gensupport.DecodeResponse(target, res); err != nil {
29871 return nil, err
29872 }
29873 return ret, nil
29874
29875
29876
29877
29878
29879
29880
29881
29882
29883
29884
29885
29886
29887
29888
29889
29890
29891
29892
29893
29894
29895
29896
29897
29898
29899
29900
29901
29902
29903
29904
29905
29906
29907
29908
29909
29910
29911
29912
29913
29914
29915
29916
29917
29918
29919
29920
29921
29922 }
29923
29924
29925
29926
29927 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsListCall) Pages(ctx context.Context, f func(*GoogleCloudIntegrationsV1alphaListSfdcChannelsResponse) error) error {
29928 c.ctx_ = ctx
29929 defer c.PageToken(c.urlParams_.Get("pageToken"))
29930 for {
29931 x, err := c.Do()
29932 if err != nil {
29933 return err
29934 }
29935 if err := f(x); err != nil {
29936 return err
29937 }
29938 if x.NextPageToken == "" {
29939 return nil
29940 }
29941 c.PageToken(x.NextPageToken)
29942 }
29943 }
29944
29945
29946
29947 type ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall struct {
29948 s *Service
29949 name string
29950 googlecloudintegrationsv1alphasfdcchannel *GoogleCloudIntegrationsV1alphaSfdcChannel
29951 urlParams_ gensupport.URLParams
29952 ctx_ context.Context
29953 header_ http.Header
29954 }
29955
29956
29957
29958
29959
29960
29961
29962 func (r *ProjectsLocationsSfdcInstancesSfdcChannelsService) Patch(name string, googlecloudintegrationsv1alphasfdcchannel *GoogleCloudIntegrationsV1alphaSfdcChannel) *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall {
29963 c := &ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
29964 c.name = name
29965 c.googlecloudintegrationsv1alphasfdcchannel = googlecloudintegrationsv1alphasfdcchannel
29966 return c
29967 }
29968
29969
29970
29971
29972 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall {
29973 c.urlParams_.Set("updateMask", updateMask)
29974 return c
29975 }
29976
29977
29978
29979
29980 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall {
29981 c.urlParams_.Set("fields", googleapi.CombineFields(s))
29982 return c
29983 }
29984
29985
29986
29987
29988 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall) Context(ctx context.Context) *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall {
29989 c.ctx_ = ctx
29990 return c
29991 }
29992
29993
29994
29995 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall) Header() http.Header {
29996 if c.header_ == nil {
29997 c.header_ = make(http.Header)
29998 }
29999 return c.header_
30000 }
30001
30002 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall) doRequest(alt string) (*http.Response, error) {
30003 reqHeaders := make(http.Header)
30004 reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
30005 for k, v := range c.header_ {
30006 reqHeaders[k] = v
30007 }
30008 reqHeaders.Set("User-Agent", c.s.userAgent())
30009 var body io.Reader = nil
30010 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudintegrationsv1alphasfdcchannel)
30011 if err != nil {
30012 return nil, err
30013 }
30014 reqHeaders.Set("Content-Type", "application/json")
30015 c.urlParams_.Set("alt", alt)
30016 c.urlParams_.Set("prettyPrint", "false")
30017 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
30018 urls += "?" + c.urlParams_.Encode()
30019 req, err := http.NewRequest("PATCH", urls, body)
30020 if err != nil {
30021 return nil, err
30022 }
30023 req.Header = reqHeaders
30024 googleapi.Expand(req.URL, map[string]string{
30025 "name": c.name,
30026 })
30027 return gensupport.SendRequest(c.ctx_, c.s.client, req)
30028 }
30029
30030
30031
30032
30033
30034
30035
30036
30037
30038
30039 func (c *ProjectsLocationsSfdcInstancesSfdcChannelsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudIntegrationsV1alphaSfdcChannel, error) {
30040 gensupport.SetOptions(c.urlParams_, opts...)
30041 res, err := c.doRequest("json")
30042 if res != nil && res.StatusCode == http.StatusNotModified {
30043 if res.Body != nil {
30044 res.Body.Close()
30045 }
30046 return nil, gensupport.WrapError(&googleapi.Error{
30047 Code: res.StatusCode,
30048 Header: res.Header,
30049 })
30050 }
30051 if err != nil {
30052 return nil, err
30053 }
30054 defer googleapi.CloseBody(res)
30055 if err := googleapi.CheckResponse(res); err != nil {
30056 return nil, gensupport.WrapError(err)
30057 }
30058 ret := &GoogleCloudIntegrationsV1alphaSfdcChannel{
30059 ServerResponse: googleapi.ServerResponse{
30060 Header: res.Header,
30061 HTTPStatusCode: res.StatusCode,
30062 },
30063 }
30064 target := &ret
30065 if err := gensupport.DecodeResponse(target, res); err != nil {
30066 return nil, err
30067 }
30068 return ret, nil
30069
30070
30071
30072
30073
30074
30075
30076
30077
30078
30079
30080
30081
30082
30083
30084
30085
30086
30087
30088
30089
30090
30091
30092
30093
30094
30095
30096
30097
30098
30099
30100
30101
30102
30103
30104 }
30105
View as plain text