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