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 beyondcorp
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 = "beyondcorp:v1alpha"
90 const apiName = "beyondcorp"
91 const apiVersion = "v1alpha"
92 const basePath = "https://beyondcorp.googleapis.com/"
93 const basePathTemplate = "https://beyondcorp.UNIVERSE_DOMAIN/"
94 const mtlsBasePath = "https://beyondcorp.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.Organizations = NewOrganizationsService(s)
139 s.Projects = NewProjectsService(s)
140 return s, nil
141 }
142
143 type Service struct {
144 client *http.Client
145 BasePath string
146 UserAgent string
147
148 Organizations *OrganizationsService
149
150 Projects *ProjectsService
151 }
152
153 func (s *Service) userAgent() string {
154 if s.UserAgent == "" {
155 return googleapi.UserAgent
156 }
157 return googleapi.UserAgent + " " + s.UserAgent
158 }
159
160 func NewOrganizationsService(s *Service) *OrganizationsService {
161 rs := &OrganizationsService{s: s}
162 rs.Locations = NewOrganizationsLocationsService(s)
163 return rs
164 }
165
166 type OrganizationsService struct {
167 s *Service
168
169 Locations *OrganizationsLocationsService
170 }
171
172 func NewOrganizationsLocationsService(s *Service) *OrganizationsLocationsService {
173 rs := &OrganizationsLocationsService{s: s}
174 rs.Global = NewOrganizationsLocationsGlobalService(s)
175 rs.Insights = NewOrganizationsLocationsInsightsService(s)
176 rs.Operations = NewOrganizationsLocationsOperationsService(s)
177 rs.Subscriptions = NewOrganizationsLocationsSubscriptionsService(s)
178 return rs
179 }
180
181 type OrganizationsLocationsService struct {
182 s *Service
183
184 Global *OrganizationsLocationsGlobalService
185
186 Insights *OrganizationsLocationsInsightsService
187
188 Operations *OrganizationsLocationsOperationsService
189
190 Subscriptions *OrganizationsLocationsSubscriptionsService
191 }
192
193 func NewOrganizationsLocationsGlobalService(s *Service) *OrganizationsLocationsGlobalService {
194 rs := &OrganizationsLocationsGlobalService{s: s}
195 rs.PartnerTenants = NewOrganizationsLocationsGlobalPartnerTenantsService(s)
196 return rs
197 }
198
199 type OrganizationsLocationsGlobalService struct {
200 s *Service
201
202 PartnerTenants *OrganizationsLocationsGlobalPartnerTenantsService
203 }
204
205 func NewOrganizationsLocationsGlobalPartnerTenantsService(s *Service) *OrganizationsLocationsGlobalPartnerTenantsService {
206 rs := &OrganizationsLocationsGlobalPartnerTenantsService{s: s}
207 rs.BrowserDlpRules = NewOrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService(s)
208 rs.ProxyConfigs = NewOrganizationsLocationsGlobalPartnerTenantsProxyConfigsService(s)
209 return rs
210 }
211
212 type OrganizationsLocationsGlobalPartnerTenantsService struct {
213 s *Service
214
215 BrowserDlpRules *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService
216
217 ProxyConfigs *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService
218 }
219
220 func NewOrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService(s *Service) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService {
221 rs := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService{s: s}
222 return rs
223 }
224
225 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService struct {
226 s *Service
227 }
228
229 func NewOrganizationsLocationsGlobalPartnerTenantsProxyConfigsService(s *Service) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService {
230 rs := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService{s: s}
231 return rs
232 }
233
234 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService struct {
235 s *Service
236 }
237
238 func NewOrganizationsLocationsInsightsService(s *Service) *OrganizationsLocationsInsightsService {
239 rs := &OrganizationsLocationsInsightsService{s: s}
240 return rs
241 }
242
243 type OrganizationsLocationsInsightsService struct {
244 s *Service
245 }
246
247 func NewOrganizationsLocationsOperationsService(s *Service) *OrganizationsLocationsOperationsService {
248 rs := &OrganizationsLocationsOperationsService{s: s}
249 return rs
250 }
251
252 type OrganizationsLocationsOperationsService struct {
253 s *Service
254 }
255
256 func NewOrganizationsLocationsSubscriptionsService(s *Service) *OrganizationsLocationsSubscriptionsService {
257 rs := &OrganizationsLocationsSubscriptionsService{s: s}
258 return rs
259 }
260
261 type OrganizationsLocationsSubscriptionsService struct {
262 s *Service
263 }
264
265 func NewProjectsService(s *Service) *ProjectsService {
266 rs := &ProjectsService{s: s}
267 rs.Locations = NewProjectsLocationsService(s)
268 return rs
269 }
270
271 type ProjectsService struct {
272 s *Service
273
274 Locations *ProjectsLocationsService
275 }
276
277 func NewProjectsLocationsService(s *Service) *ProjectsLocationsService {
278 rs := &ProjectsLocationsService{s: s}
279 rs.AppConnections = NewProjectsLocationsAppConnectionsService(s)
280 rs.AppConnectors = NewProjectsLocationsAppConnectorsService(s)
281 rs.AppGateways = NewProjectsLocationsAppGatewaysService(s)
282 rs.ApplicationDomains = NewProjectsLocationsApplicationDomainsService(s)
283 rs.Applications = NewProjectsLocationsApplicationsService(s)
284 rs.ClientConnectorServices = NewProjectsLocationsClientConnectorServicesService(s)
285 rs.ClientGateways = NewProjectsLocationsClientGatewaysService(s)
286 rs.Connections = NewProjectsLocationsConnectionsService(s)
287 rs.Connectors = NewProjectsLocationsConnectorsService(s)
288 rs.Insights = NewProjectsLocationsInsightsService(s)
289 rs.NetConnections = NewProjectsLocationsNetConnectionsService(s)
290 rs.Operations = NewProjectsLocationsOperationsService(s)
291 rs.SecurityGateways = NewProjectsLocationsSecurityGatewaysService(s)
292 return rs
293 }
294
295 type ProjectsLocationsService struct {
296 s *Service
297
298 AppConnections *ProjectsLocationsAppConnectionsService
299
300 AppConnectors *ProjectsLocationsAppConnectorsService
301
302 AppGateways *ProjectsLocationsAppGatewaysService
303
304 ApplicationDomains *ProjectsLocationsApplicationDomainsService
305
306 Applications *ProjectsLocationsApplicationsService
307
308 ClientConnectorServices *ProjectsLocationsClientConnectorServicesService
309
310 ClientGateways *ProjectsLocationsClientGatewaysService
311
312 Connections *ProjectsLocationsConnectionsService
313
314 Connectors *ProjectsLocationsConnectorsService
315
316 Insights *ProjectsLocationsInsightsService
317
318 NetConnections *ProjectsLocationsNetConnectionsService
319
320 Operations *ProjectsLocationsOperationsService
321
322 SecurityGateways *ProjectsLocationsSecurityGatewaysService
323 }
324
325 func NewProjectsLocationsAppConnectionsService(s *Service) *ProjectsLocationsAppConnectionsService {
326 rs := &ProjectsLocationsAppConnectionsService{s: s}
327 return rs
328 }
329
330 type ProjectsLocationsAppConnectionsService struct {
331 s *Service
332 }
333
334 func NewProjectsLocationsAppConnectorsService(s *Service) *ProjectsLocationsAppConnectorsService {
335 rs := &ProjectsLocationsAppConnectorsService{s: s}
336 return rs
337 }
338
339 type ProjectsLocationsAppConnectorsService struct {
340 s *Service
341 }
342
343 func NewProjectsLocationsAppGatewaysService(s *Service) *ProjectsLocationsAppGatewaysService {
344 rs := &ProjectsLocationsAppGatewaysService{s: s}
345 return rs
346 }
347
348 type ProjectsLocationsAppGatewaysService struct {
349 s *Service
350 }
351
352 func NewProjectsLocationsApplicationDomainsService(s *Service) *ProjectsLocationsApplicationDomainsService {
353 rs := &ProjectsLocationsApplicationDomainsService{s: s}
354 return rs
355 }
356
357 type ProjectsLocationsApplicationDomainsService struct {
358 s *Service
359 }
360
361 func NewProjectsLocationsApplicationsService(s *Service) *ProjectsLocationsApplicationsService {
362 rs := &ProjectsLocationsApplicationsService{s: s}
363 return rs
364 }
365
366 type ProjectsLocationsApplicationsService struct {
367 s *Service
368 }
369
370 func NewProjectsLocationsClientConnectorServicesService(s *Service) *ProjectsLocationsClientConnectorServicesService {
371 rs := &ProjectsLocationsClientConnectorServicesService{s: s}
372 return rs
373 }
374
375 type ProjectsLocationsClientConnectorServicesService struct {
376 s *Service
377 }
378
379 func NewProjectsLocationsClientGatewaysService(s *Service) *ProjectsLocationsClientGatewaysService {
380 rs := &ProjectsLocationsClientGatewaysService{s: s}
381 return rs
382 }
383
384 type ProjectsLocationsClientGatewaysService struct {
385 s *Service
386 }
387
388 func NewProjectsLocationsConnectionsService(s *Service) *ProjectsLocationsConnectionsService {
389 rs := &ProjectsLocationsConnectionsService{s: s}
390 return rs
391 }
392
393 type ProjectsLocationsConnectionsService struct {
394 s *Service
395 }
396
397 func NewProjectsLocationsConnectorsService(s *Service) *ProjectsLocationsConnectorsService {
398 rs := &ProjectsLocationsConnectorsService{s: s}
399 return rs
400 }
401
402 type ProjectsLocationsConnectorsService struct {
403 s *Service
404 }
405
406 func NewProjectsLocationsInsightsService(s *Service) *ProjectsLocationsInsightsService {
407 rs := &ProjectsLocationsInsightsService{s: s}
408 return rs
409 }
410
411 type ProjectsLocationsInsightsService struct {
412 s *Service
413 }
414
415 func NewProjectsLocationsNetConnectionsService(s *Service) *ProjectsLocationsNetConnectionsService {
416 rs := &ProjectsLocationsNetConnectionsService{s: s}
417 return rs
418 }
419
420 type ProjectsLocationsNetConnectionsService struct {
421 s *Service
422 }
423
424 func NewProjectsLocationsOperationsService(s *Service) *ProjectsLocationsOperationsService {
425 rs := &ProjectsLocationsOperationsService{s: s}
426 return rs
427 }
428
429 type ProjectsLocationsOperationsService struct {
430 s *Service
431 }
432
433 func NewProjectsLocationsSecurityGatewaysService(s *Service) *ProjectsLocationsSecurityGatewaysService {
434 rs := &ProjectsLocationsSecurityGatewaysService{s: s}
435 return rs
436 }
437
438 type ProjectsLocationsSecurityGatewaysService struct {
439 s *Service
440 }
441
442
443 type AllocatedConnection struct {
444
445 IngressPort int64 `json:"ingressPort,omitempty"`
446
447 PscUri string `json:"pscUri,omitempty"`
448
449
450
451
452
453 ForceSendFields []string `json:"-"`
454
455
456
457
458 NullFields []string `json:"-"`
459 }
460
461 func (s *AllocatedConnection) MarshalJSON() ([]byte, error) {
462 type NoMethod AllocatedConnection
463 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
464 }
465
466
467
468
469
470 type AppGateway struct {
471
472
473 AllocatedConnections []*AllocatedConnection `json:"allocatedConnections,omitempty"`
474
475 CreateTime string `json:"createTime,omitempty"`
476
477
478 DisplayName string `json:"displayName,omitempty"`
479
480
481
482
483
484
485 HostType string `json:"hostType,omitempty"`
486
487 Labels map[string]string `json:"labels,omitempty"`
488
489
490 Name string `json:"name,omitempty"`
491
492 SatisfiesPzi bool `json:"satisfiesPzi,omitempty"`
493
494 SatisfiesPzs bool `json:"satisfiesPzs,omitempty"`
495
496
497
498
499
500
501
502
503
504
505 State string `json:"state,omitempty"`
506
507
508
509
510
511
512 Type string `json:"type,omitempty"`
513
514
515 Uid string `json:"uid,omitempty"`
516
517 UpdateTime string `json:"updateTime,omitempty"`
518
519 Uri string `json:"uri,omitempty"`
520
521
522 googleapi.ServerResponse `json:"-"`
523
524
525
526
527
528 ForceSendFields []string `json:"-"`
529
530
531
532
533 NullFields []string `json:"-"`
534 }
535
536 func (s *AppGateway) MarshalJSON() ([]byte, error) {
537 type NoMethod AppGateway
538 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
539 }
540
541
542
543 type AppGatewayOperationMetadata struct {
544
545 ApiVersion string `json:"apiVersion,omitempty"`
546
547 CreateTime string `json:"createTime,omitempty"`
548
549 EndTime string `json:"endTime,omitempty"`
550
551
552
553
554 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
555
556 StatusMessage string `json:"statusMessage,omitempty"`
557
558
559 Target string `json:"target,omitempty"`
560
561 Verb string `json:"verb,omitempty"`
562
563
564
565
566
567 ForceSendFields []string `json:"-"`
568
569
570
571
572 NullFields []string `json:"-"`
573 }
574
575 func (s *AppGatewayOperationMetadata) MarshalJSON() ([]byte, error) {
576 type NoMethod AppGatewayOperationMetadata
577 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
578 }
579
580
581
582 type ApplicationEndpoint struct {
583
584 Host string `json:"host,omitempty"`
585
586 Port int64 `json:"port,omitempty"`
587
588
589
590
591
592 ForceSendFields []string `json:"-"`
593
594
595
596
597 NullFields []string `json:"-"`
598 }
599
600 func (s *ApplicationEndpoint) MarshalJSON() ([]byte, error) {
601 type NoMethod ApplicationEndpoint
602 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
603 }
604
605
606
607 type CloudPubSubNotificationConfig struct {
608
609
610 PubsubSubscription string `json:"pubsubSubscription,omitempty"`
611
612
613
614
615
616 ForceSendFields []string `json:"-"`
617
618
619
620
621 NullFields []string `json:"-"`
622 }
623
624 func (s *CloudPubSubNotificationConfig) MarshalJSON() ([]byte, error) {
625 type NoMethod CloudPubSubNotificationConfig
626 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
627 }
628
629
630
631 type CloudSecurityZerotrustApplinkAppConnectorProtoConnectionConfig struct {
632
633
634 ApplicationEndpoint string `json:"applicationEndpoint,omitempty"`
635
636
637 ApplicationName string `json:"applicationName,omitempty"`
638
639
640 Gateway []*CloudSecurityZerotrustApplinkAppConnectorProtoGateway `json:"gateway,omitempty"`
641
642
643
644 Name string `json:"name,omitempty"`
645
646 Project string `json:"project,omitempty"`
647
648
649 TunnelsPerGateway int64 `json:"tunnelsPerGateway,omitempty"`
650
651
652 UserPort int64 `json:"userPort,omitempty"`
653
654
655
656
657
658 ForceSendFields []string `json:"-"`
659
660
661
662
663 NullFields []string `json:"-"`
664 }
665
666 func (s *CloudSecurityZerotrustApplinkAppConnectorProtoConnectionConfig) MarshalJSON() ([]byte, error) {
667 type NoMethod CloudSecurityZerotrustApplinkAppConnectorProtoConnectionConfig
668 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
669 }
670
671
672
673 type CloudSecurityZerotrustApplinkAppConnectorProtoConnectorDetails struct {
674 }
675
676
677
678 type CloudSecurityZerotrustApplinkAppConnectorProtoGateway struct {
679
680
681 Interface string `json:"interface,omitempty"`
682
683
684
685
686
687 Name string `json:"name,omitempty"`
688
689
690 Port int64 `json:"port,omitempty"`
691
692
693
694
695
696
697 Project string `json:"project,omitempty"`
698
699
700 SelfLink string `json:"selfLink,omitempty"`
701
702
703
704 Zone string `json:"zone,omitempty"`
705
706
707
708
709
710 ForceSendFields []string `json:"-"`
711
712
713
714
715 NullFields []string `json:"-"`
716 }
717
718 func (s *CloudSecurityZerotrustApplinkAppConnectorProtoGateway) MarshalJSON() ([]byte, error) {
719 type NoMethod CloudSecurityZerotrustApplinkAppConnectorProtoGateway
720 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
721 }
722
723
724
725 type CloudSecurityZerotrustApplinkLogagentProtoLogAgentDetails struct {
726 }
727
728
729
730
731
732 type Connection struct {
733
734
735 ApplicationEndpoint *ApplicationEndpoint `json:"applicationEndpoint,omitempty"`
736
737
738
739 Connectors []string `json:"connectors,omitempty"`
740
741 CreateTime string `json:"createTime,omitempty"`
742
743
744 DisplayName string `json:"displayName,omitempty"`
745
746 Gateway *Gateway `json:"gateway,omitempty"`
747
748 Labels map[string]string `json:"labels,omitempty"`
749
750
751 Name string `json:"name,omitempty"`
752
753
754
755
756
757
758
759
760
761
762 State string `json:"state,omitempty"`
763
764
765
766
767
768
769 Type string `json:"type,omitempty"`
770
771
772 Uid string `json:"uid,omitempty"`
773
774 UpdateTime string `json:"updateTime,omitempty"`
775
776
777 googleapi.ServerResponse `json:"-"`
778
779
780
781
782
783 ForceSendFields []string `json:"-"`
784
785
786
787
788 NullFields []string `json:"-"`
789 }
790
791 func (s *Connection) MarshalJSON() ([]byte, error) {
792 type NoMethod Connection
793 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
794 }
795
796
797 type ConnectionDetails struct {
798
799 Connection *Connection `json:"connection,omitempty"`
800
801
802
803
804 RecentMigVms []string `json:"recentMigVms,omitempty"`
805
806
807
808
809
810 ForceSendFields []string `json:"-"`
811
812
813
814
815 NullFields []string `json:"-"`
816 }
817
818 func (s *ConnectionDetails) MarshalJSON() ([]byte, error) {
819 type NoMethod ConnectionDetails
820 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
821 }
822
823
824
825 type ConnectionOperationMetadata struct {
826
827 ApiVersion string `json:"apiVersion,omitempty"`
828
829 CreateTime string `json:"createTime,omitempty"`
830
831 EndTime string `json:"endTime,omitempty"`
832
833
834
835
836 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
837
838 StatusMessage string `json:"statusMessage,omitempty"`
839
840
841 Target string `json:"target,omitempty"`
842
843 Verb string `json:"verb,omitempty"`
844
845
846
847
848
849 ForceSendFields []string `json:"-"`
850
851
852
853
854 NullFields []string `json:"-"`
855 }
856
857 func (s *ConnectionOperationMetadata) MarshalJSON() ([]byte, error) {
858 type NoMethod ConnectionOperationMetadata
859 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
860 }
861
862
863
864
865
866
867 type Connector struct {
868
869 CreateTime string `json:"createTime,omitempty"`
870
871
872 DisplayName string `json:"displayName,omitempty"`
873
874 Labels map[string]string `json:"labels,omitempty"`
875
876
877 Name string `json:"name,omitempty"`
878
879
880 PrincipalInfo *PrincipalInfo `json:"principalInfo,omitempty"`
881
882 ResourceInfo *ResourceInfo `json:"resourceInfo,omitempty"`
883
884
885
886
887
888
889
890
891
892
893 State string `json:"state,omitempty"`
894
895
896 Uid string `json:"uid,omitempty"`
897
898 UpdateTime string `json:"updateTime,omitempty"`
899
900
901 googleapi.ServerResponse `json:"-"`
902
903
904
905
906
907 ForceSendFields []string `json:"-"`
908
909
910
911
912 NullFields []string `json:"-"`
913 }
914
915 func (s *Connector) MarshalJSON() ([]byte, error) {
916 type NoMethod Connector
917 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
918 }
919
920
921
922 type ConnectorInstanceConfig struct {
923
924
925 ImageConfig *ImageConfig `json:"imageConfig,omitempty"`
926
927 InstanceConfig googleapi.RawMessage `json:"instanceConfig,omitempty"`
928
929
930
931 NotificationConfig *NotificationConfig `json:"notificationConfig,omitempty"`
932
933
934
935 SequenceNumber int64 `json:"sequenceNumber,omitempty,string"`
936
937
938
939
940
941 ForceSendFields []string `json:"-"`
942
943
944
945
946 NullFields []string `json:"-"`
947 }
948
949 func (s *ConnectorInstanceConfig) MarshalJSON() ([]byte, error) {
950 type NoMethod ConnectorInstanceConfig
951 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
952 }
953
954
955
956 type ConnectorOperationMetadata struct {
957
958 ApiVersion string `json:"apiVersion,omitempty"`
959
960 CreateTime string `json:"createTime,omitempty"`
961
962 EndTime string `json:"endTime,omitempty"`
963
964
965
966
967 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
968
969 StatusMessage string `json:"statusMessage,omitempty"`
970
971
972 Target string `json:"target,omitempty"`
973
974 Verb string `json:"verb,omitempty"`
975
976
977
978
979
980 ForceSendFields []string `json:"-"`
981
982
983
984
985 NullFields []string `json:"-"`
986 }
987
988 func (s *ConnectorOperationMetadata) MarshalJSON() ([]byte, error) {
989 type NoMethod ConnectorOperationMetadata
990 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
991 }
992
993
994
995 type ContainerHealthDetails struct {
996
997 CurrentConfigVersion string `json:"currentConfigVersion,omitempty"`
998
999 ErrorMsg string `json:"errorMsg,omitempty"`
1000
1001 ExpectedConfigVersion string `json:"expectedConfigVersion,omitempty"`
1002
1003
1004 ExtendedStatus map[string]string `json:"extendedStatus,omitempty"`
1005
1006
1007
1008
1009
1010 ForceSendFields []string `json:"-"`
1011
1012
1013
1014
1015 NullFields []string `json:"-"`
1016 }
1017
1018 func (s *ContainerHealthDetails) MarshalJSON() ([]byte, error) {
1019 type NoMethod ContainerHealthDetails
1020 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1021 }
1022
1023
1024
1025
1026
1027 type Empty struct {
1028
1029 googleapi.ServerResponse `json:"-"`
1030 }
1031
1032
1033
1034 type Gateway struct {
1035
1036
1037
1038
1039
1040
1041 Type string `json:"type,omitempty"`
1042
1043 Uri string `json:"uri,omitempty"`
1044
1045
1046 UserPort int64 `json:"userPort,omitempty"`
1047
1048
1049
1050
1051
1052 ForceSendFields []string `json:"-"`
1053
1054
1055
1056
1057 NullFields []string `json:"-"`
1058 }
1059
1060 func (s *Gateway) MarshalJSON() ([]byte, error) {
1061 type NoMethod Gateway
1062 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1063 }
1064
1065
1066
1067 type GoogleCloudBeyondcorpAppconnectionsV1AppConnectionOperationMetadata struct {
1068
1069 ApiVersion string `json:"apiVersion,omitempty"`
1070
1071 CreateTime string `json:"createTime,omitempty"`
1072
1073 EndTime string `json:"endTime,omitempty"`
1074
1075
1076
1077
1078 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
1079
1080 StatusMessage string `json:"statusMessage,omitempty"`
1081
1082
1083 Target string `json:"target,omitempty"`
1084
1085 Verb string `json:"verb,omitempty"`
1086
1087
1088
1089
1090
1091 ForceSendFields []string `json:"-"`
1092
1093
1094
1095
1096 NullFields []string `json:"-"`
1097 }
1098
1099 func (s *GoogleCloudBeyondcorpAppconnectionsV1AppConnectionOperationMetadata) MarshalJSON() ([]byte, error) {
1100 type NoMethod GoogleCloudBeyondcorpAppconnectionsV1AppConnectionOperationMetadata
1101 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1102 }
1103
1104
1105
1106
1107
1108
1109 type GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection struct {
1110
1111
1112 ApplicationEndpoint *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionApplicationEndpoint `json:"applicationEndpoint,omitempty"`
1113
1114
1115
1116 Connectors []string `json:"connectors,omitempty"`
1117
1118 CreateTime string `json:"createTime,omitempty"`
1119
1120
1121 DisplayName string `json:"displayName,omitempty"`
1122
1123 Gateway *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionGateway `json:"gateway,omitempty"`
1124
1125 Labels map[string]string `json:"labels,omitempty"`
1126
1127
1128 Name string `json:"name,omitempty"`
1129
1130 SatisfiesPzi bool `json:"satisfiesPzi,omitempty"`
1131
1132 SatisfiesPzs bool `json:"satisfiesPzs,omitempty"`
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143 State string `json:"state,omitempty"`
1144
1145
1146
1147
1148
1149
1150 Type string `json:"type,omitempty"`
1151
1152
1153 Uid string `json:"uid,omitempty"`
1154
1155 UpdateTime string `json:"updateTime,omitempty"`
1156
1157
1158 googleapi.ServerResponse `json:"-"`
1159
1160
1161
1162
1163
1164 ForceSendFields []string `json:"-"`
1165
1166
1167
1168
1169 NullFields []string `json:"-"`
1170 }
1171
1172 func (s *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection) MarshalJSON() ([]byte, error) {
1173 type NoMethod GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection
1174 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1175 }
1176
1177
1178
1179 type GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionApplicationEndpoint struct {
1180
1181 Host string `json:"host,omitempty"`
1182
1183 Port int64 `json:"port,omitempty"`
1184
1185
1186
1187
1188
1189 ForceSendFields []string `json:"-"`
1190
1191
1192
1193
1194 NullFields []string `json:"-"`
1195 }
1196
1197 func (s *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionApplicationEndpoint) MarshalJSON() ([]byte, error) {
1198 type NoMethod GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionApplicationEndpoint
1199 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1200 }
1201
1202
1203
1204
1205 type GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionGateway struct {
1206
1207
1208 AppGateway string `json:"appGateway,omitempty"`
1209
1210
1211 IngressPort int64 `json:"ingressPort,omitempty"`
1212
1213 L7psc string `json:"l7psc,omitempty"`
1214
1215
1216
1217
1218
1219
1220 Type string `json:"type,omitempty"`
1221
1222 Uri string `json:"uri,omitempty"`
1223
1224
1225
1226
1227
1228 ForceSendFields []string `json:"-"`
1229
1230
1231
1232
1233 NullFields []string `json:"-"`
1234 }
1235
1236 func (s *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionGateway) MarshalJSON() ([]byte, error) {
1237 type NoMethod GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionGateway
1238 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1239 }
1240
1241
1242
1243 type GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionOperationMetadata struct {
1244
1245 ApiVersion string `json:"apiVersion,omitempty"`
1246
1247 CreateTime string `json:"createTime,omitempty"`
1248
1249 EndTime string `json:"endTime,omitempty"`
1250
1251
1252
1253
1254 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
1255
1256 StatusMessage string `json:"statusMessage,omitempty"`
1257
1258
1259 Target string `json:"target,omitempty"`
1260
1261 Verb string `json:"verb,omitempty"`
1262
1263
1264
1265
1266
1267 ForceSendFields []string `json:"-"`
1268
1269
1270
1271
1272 NullFields []string `json:"-"`
1273 }
1274
1275 func (s *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionOperationMetadata) MarshalJSON() ([]byte, error) {
1276 type NoMethod GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnectionOperationMetadata
1277 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1278 }
1279
1280
1281
1282 type GoogleCloudBeyondcorpAppconnectionsV1alphaListAppConnectionsResponse struct {
1283
1284 AppConnections []*GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection `json:"appConnections,omitempty"`
1285
1286
1287 NextPageToken string `json:"nextPageToken,omitempty"`
1288
1289 Unreachable []string `json:"unreachable,omitempty"`
1290
1291
1292 googleapi.ServerResponse `json:"-"`
1293
1294
1295
1296
1297
1298 ForceSendFields []string `json:"-"`
1299
1300
1301
1302
1303 NullFields []string `json:"-"`
1304 }
1305
1306 func (s *GoogleCloudBeyondcorpAppconnectionsV1alphaListAppConnectionsResponse) MarshalJSON() ([]byte, error) {
1307 type NoMethod GoogleCloudBeyondcorpAppconnectionsV1alphaListAppConnectionsResponse
1308 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1309 }
1310
1311
1312
1313 type GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponse struct {
1314
1315
1316 AppConnectionDetails []*GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponseAppConnectionDetails `json:"appConnectionDetails,omitempty"`
1317
1318
1319 NextPageToken string `json:"nextPageToken,omitempty"`
1320
1321 Unreachable []string `json:"unreachable,omitempty"`
1322
1323
1324 googleapi.ServerResponse `json:"-"`
1325
1326
1327
1328
1329
1330 ForceSendFields []string `json:"-"`
1331
1332
1333
1334
1335 NullFields []string `json:"-"`
1336 }
1337
1338 func (s *GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponse) MarshalJSON() ([]byte, error) {
1339 type NoMethod GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponse
1340 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1341 }
1342
1343
1344
1345 type GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponseAppConnectionDetails struct {
1346
1347 AppConnection *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection `json:"appConnection,omitempty"`
1348
1349
1350
1351
1352 RecentMigVms []string `json:"recentMigVms,omitempty"`
1353
1354
1355
1356
1357
1358 ForceSendFields []string `json:"-"`
1359
1360
1361
1362
1363 NullFields []string `json:"-"`
1364 }
1365
1366 func (s *GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponseAppConnectionDetails) MarshalJSON() ([]byte, error) {
1367 type NoMethod GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponseAppConnectionDetails
1368 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1369 }
1370
1371
1372
1373 type GoogleCloudBeyondcorpAppconnectorsV1AppConnectorOperationMetadata struct {
1374
1375 ApiVersion string `json:"apiVersion,omitempty"`
1376
1377 CreateTime string `json:"createTime,omitempty"`
1378
1379 EndTime string `json:"endTime,omitempty"`
1380
1381
1382
1383
1384 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
1385
1386 StatusMessage string `json:"statusMessage,omitempty"`
1387
1388
1389 Target string `json:"target,omitempty"`
1390
1391 Verb string `json:"verb,omitempty"`
1392
1393
1394
1395
1396
1397 ForceSendFields []string `json:"-"`
1398
1399
1400
1401
1402 NullFields []string `json:"-"`
1403 }
1404
1405 func (s *GoogleCloudBeyondcorpAppconnectorsV1AppConnectorOperationMetadata) MarshalJSON() ([]byte, error) {
1406 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1AppConnectorOperationMetadata
1407 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1408 }
1409
1410
1411
1412 type GoogleCloudBeyondcorpAppconnectorsV1ContainerHealthDetails struct {
1413
1414 CurrentConfigVersion string `json:"currentConfigVersion,omitempty"`
1415
1416 ErrorMsg string `json:"errorMsg,omitempty"`
1417
1418 ExpectedConfigVersion string `json:"expectedConfigVersion,omitempty"`
1419
1420
1421 ExtendedStatus map[string]string `json:"extendedStatus,omitempty"`
1422
1423
1424
1425
1426
1427 ForceSendFields []string `json:"-"`
1428
1429
1430
1431
1432 NullFields []string `json:"-"`
1433 }
1434
1435 func (s *GoogleCloudBeyondcorpAppconnectorsV1ContainerHealthDetails) MarshalJSON() ([]byte, error) {
1436 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1ContainerHealthDetails
1437 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1438 }
1439
1440
1441
1442 type GoogleCloudBeyondcorpAppconnectorsV1RemoteAgentDetails struct {
1443 }
1444
1445
1446
1447
1448
1449
1450
1451 type GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector struct {
1452
1453 CreateTime string `json:"createTime,omitempty"`
1454
1455
1456 DisplayName string `json:"displayName,omitempty"`
1457
1458 Labels map[string]string `json:"labels,omitempty"`
1459
1460
1461 Name string `json:"name,omitempty"`
1462
1463
1464 PrincipalInfo *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorPrincipalInfo `json:"principalInfo,omitempty"`
1465
1466 ResourceInfo *GoogleCloudBeyondcorpAppconnectorsV1alphaResourceInfo `json:"resourceInfo,omitempty"`
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477 State string `json:"state,omitempty"`
1478
1479
1480 Uid string `json:"uid,omitempty"`
1481
1482 UpdateTime string `json:"updateTime,omitempty"`
1483
1484
1485 googleapi.ServerResponse `json:"-"`
1486
1487
1488
1489
1490
1491 ForceSendFields []string `json:"-"`
1492
1493
1494
1495
1496 NullFields []string `json:"-"`
1497 }
1498
1499 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector) MarshalJSON() ([]byte, error) {
1500 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector
1501 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1502 }
1503
1504
1505
1506 type GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorInstanceConfig struct {
1507
1508
1509 ImageConfig *GoogleCloudBeyondcorpAppconnectorsV1alphaImageConfig `json:"imageConfig,omitempty"`
1510
1511 InstanceConfig googleapi.RawMessage `json:"instanceConfig,omitempty"`
1512
1513
1514
1515 NotificationConfig *GoogleCloudBeyondcorpAppconnectorsV1alphaNotificationConfig `json:"notificationConfig,omitempty"`
1516
1517
1518
1519 SequenceNumber int64 `json:"sequenceNumber,omitempty,string"`
1520
1521
1522
1523
1524
1525 ForceSendFields []string `json:"-"`
1526
1527
1528
1529
1530 NullFields []string `json:"-"`
1531 }
1532
1533 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorInstanceConfig) MarshalJSON() ([]byte, error) {
1534 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorInstanceConfig
1535 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1536 }
1537
1538
1539
1540 type GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorOperationMetadata struct {
1541
1542 ApiVersion string `json:"apiVersion,omitempty"`
1543
1544 CreateTime string `json:"createTime,omitempty"`
1545
1546 EndTime string `json:"endTime,omitempty"`
1547
1548
1549
1550
1551 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
1552
1553 StatusMessage string `json:"statusMessage,omitempty"`
1554
1555
1556 Target string `json:"target,omitempty"`
1557
1558 Verb string `json:"verb,omitempty"`
1559
1560
1561
1562
1563
1564 ForceSendFields []string `json:"-"`
1565
1566
1567
1568
1569 NullFields []string `json:"-"`
1570 }
1571
1572 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorOperationMetadata) MarshalJSON() ([]byte, error) {
1573 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorOperationMetadata
1574 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1575 }
1576
1577
1578
1579 type GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorPrincipalInfo struct {
1580
1581 ServiceAccount *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorPrincipalInfoServiceAccount `json:"serviceAccount,omitempty"`
1582
1583
1584
1585
1586
1587 ForceSendFields []string `json:"-"`
1588
1589
1590
1591
1592 NullFields []string `json:"-"`
1593 }
1594
1595 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorPrincipalInfo) MarshalJSON() ([]byte, error) {
1596 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorPrincipalInfo
1597 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1598 }
1599
1600
1601
1602 type GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorPrincipalInfoServiceAccount struct {
1603
1604 Email string `json:"email,omitempty"`
1605
1606
1607
1608
1609
1610 ForceSendFields []string `json:"-"`
1611
1612
1613
1614
1615 NullFields []string `json:"-"`
1616 }
1617
1618 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorPrincipalInfoServiceAccount) MarshalJSON() ([]byte, error) {
1619 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorPrincipalInfoServiceAccount
1620 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1621 }
1622
1623
1624
1625 type GoogleCloudBeyondcorpAppconnectorsV1alphaContainerHealthDetails struct {
1626
1627 CurrentConfigVersion string `json:"currentConfigVersion,omitempty"`
1628
1629 ErrorMsg string `json:"errorMsg,omitempty"`
1630
1631 ExpectedConfigVersion string `json:"expectedConfigVersion,omitempty"`
1632
1633
1634 ExtendedStatus map[string]string `json:"extendedStatus,omitempty"`
1635
1636
1637
1638
1639
1640 ForceSendFields []string `json:"-"`
1641
1642
1643
1644
1645 NullFields []string `json:"-"`
1646 }
1647
1648 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaContainerHealthDetails) MarshalJSON() ([]byte, error) {
1649 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaContainerHealthDetails
1650 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1651 }
1652
1653
1654
1655 type GoogleCloudBeyondcorpAppconnectorsV1alphaImageConfig struct {
1656
1657
1658
1659 StableImage string `json:"stableImage,omitempty"`
1660
1661
1662
1663 TargetImage string `json:"targetImage,omitempty"`
1664
1665
1666
1667
1668
1669 ForceSendFields []string `json:"-"`
1670
1671
1672
1673
1674 NullFields []string `json:"-"`
1675 }
1676
1677 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaImageConfig) MarshalJSON() ([]byte, error) {
1678 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaImageConfig
1679 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1680 }
1681
1682
1683
1684 type GoogleCloudBeyondcorpAppconnectorsV1alphaListAppConnectorsResponse struct {
1685
1686 AppConnectors []*GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector `json:"appConnectors,omitempty"`
1687
1688
1689 NextPageToken string `json:"nextPageToken,omitempty"`
1690
1691 Unreachable []string `json:"unreachable,omitempty"`
1692
1693
1694 googleapi.ServerResponse `json:"-"`
1695
1696
1697
1698
1699
1700 ForceSendFields []string `json:"-"`
1701
1702
1703
1704
1705 NullFields []string `json:"-"`
1706 }
1707
1708 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaListAppConnectorsResponse) MarshalJSON() ([]byte, error) {
1709 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaListAppConnectorsResponse
1710 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1711 }
1712
1713
1714
1715 type GoogleCloudBeyondcorpAppconnectorsV1alphaNotificationConfig struct {
1716
1717 PubsubNotification *GoogleCloudBeyondcorpAppconnectorsV1alphaNotificationConfigCloudPubSubNotificationConfig `json:"pubsubNotification,omitempty"`
1718
1719
1720
1721
1722
1723 ForceSendFields []string `json:"-"`
1724
1725
1726
1727
1728 NullFields []string `json:"-"`
1729 }
1730
1731 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaNotificationConfig) MarshalJSON() ([]byte, error) {
1732 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaNotificationConfig
1733 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1734 }
1735
1736
1737
1738 type GoogleCloudBeyondcorpAppconnectorsV1alphaNotificationConfigCloudPubSubNotificationConfig struct {
1739
1740
1741 PubsubSubscription string `json:"pubsubSubscription,omitempty"`
1742
1743
1744
1745
1746
1747 ForceSendFields []string `json:"-"`
1748
1749
1750
1751
1752 NullFields []string `json:"-"`
1753 }
1754
1755 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaNotificationConfigCloudPubSubNotificationConfig) MarshalJSON() ([]byte, error) {
1756 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaNotificationConfigCloudPubSubNotificationConfig
1757 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1758 }
1759
1760
1761
1762 type GoogleCloudBeyondcorpAppconnectorsV1alphaRemoteAgentDetails struct {
1763 }
1764
1765
1766
1767 type GoogleCloudBeyondcorpAppconnectorsV1alphaReportStatusRequest struct {
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779 RequestId string `json:"requestId,omitempty"`
1780
1781 ResourceInfo *GoogleCloudBeyondcorpAppconnectorsV1alphaResourceInfo `json:"resourceInfo,omitempty"`
1782
1783
1784 ValidateOnly bool `json:"validateOnly,omitempty"`
1785
1786
1787
1788
1789
1790 ForceSendFields []string `json:"-"`
1791
1792
1793
1794
1795 NullFields []string `json:"-"`
1796 }
1797
1798 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaReportStatusRequest) MarshalJSON() ([]byte, error) {
1799 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaReportStatusRequest
1800 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1801 }
1802
1803
1804
1805 type GoogleCloudBeyondcorpAppconnectorsV1alphaResolveInstanceConfigResponse struct {
1806
1807 InstanceConfig *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnectorInstanceConfig `json:"instanceConfig,omitempty"`
1808
1809
1810 googleapi.ServerResponse `json:"-"`
1811
1812
1813
1814
1815
1816 ForceSendFields []string `json:"-"`
1817
1818
1819
1820
1821 NullFields []string `json:"-"`
1822 }
1823
1824 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaResolveInstanceConfigResponse) MarshalJSON() ([]byte, error) {
1825 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaResolveInstanceConfigResponse
1826 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1827 }
1828
1829
1830
1831
1832
1833 type GoogleCloudBeyondcorpAppconnectorsV1alphaResourceInfo struct {
1834
1835 Id string `json:"id,omitempty"`
1836
1837 Resource googleapi.RawMessage `json:"resource,omitempty"`
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848 Status string `json:"status,omitempty"`
1849
1850 Sub []*GoogleCloudBeyondcorpAppconnectorsV1alphaResourceInfo `json:"sub,omitempty"`
1851
1852
1853 Time string `json:"time,omitempty"`
1854
1855
1856
1857
1858
1859 ForceSendFields []string `json:"-"`
1860
1861
1862
1863
1864 NullFields []string `json:"-"`
1865 }
1866
1867 func (s *GoogleCloudBeyondcorpAppconnectorsV1alphaResourceInfo) MarshalJSON() ([]byte, error) {
1868 type NoMethod GoogleCloudBeyondcorpAppconnectorsV1alphaResourceInfo
1869 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1870 }
1871
1872
1873
1874 type GoogleCloudBeyondcorpAppgatewaysV1AppGatewayOperationMetadata struct {
1875
1876 ApiVersion string `json:"apiVersion,omitempty"`
1877
1878 CreateTime string `json:"createTime,omitempty"`
1879
1880 EndTime string `json:"endTime,omitempty"`
1881
1882
1883
1884
1885 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
1886
1887 StatusMessage string `json:"statusMessage,omitempty"`
1888
1889
1890 Target string `json:"target,omitempty"`
1891
1892 Verb string `json:"verb,omitempty"`
1893
1894
1895
1896
1897
1898 ForceSendFields []string `json:"-"`
1899
1900
1901
1902
1903 NullFields []string `json:"-"`
1904 }
1905
1906 func (s *GoogleCloudBeyondcorpAppgatewaysV1AppGatewayOperationMetadata) MarshalJSON() ([]byte, error) {
1907 type NoMethod GoogleCloudBeyondcorpAppgatewaysV1AppGatewayOperationMetadata
1908 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1909 }
1910
1911
1912
1913 type GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule struct {
1914
1915 Group *GoogleCloudBeyondcorpPartnerservicesV1alphaGroup `json:"group,omitempty"`
1916
1917
1918 Name string `json:"name,omitempty"`
1919
1920 RuleSetting *GoogleCloudBeyondcorpPartnerservicesV1alphaRuleSetting `json:"ruleSetting,omitempty"`
1921
1922
1923 googleapi.ServerResponse `json:"-"`
1924
1925
1926
1927
1928
1929 ForceSendFields []string `json:"-"`
1930
1931
1932
1933
1934 NullFields []string `json:"-"`
1935 }
1936
1937 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule) MarshalJSON() ([]byte, error) {
1938 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule
1939 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1940 }
1941
1942
1943
1944 type GoogleCloudBeyondcorpPartnerservicesV1alphaEncryptionInfo struct {
1945
1946 EncryptionSaEmail string `json:"encryptionSaEmail,omitempty"`
1947
1948 Jwk string `json:"jwk,omitempty"`
1949
1950
1951
1952
1953
1954 ForceSendFields []string `json:"-"`
1955
1956
1957
1958
1959 NullFields []string `json:"-"`
1960 }
1961
1962 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaEncryptionInfo) MarshalJSON() ([]byte, error) {
1963 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaEncryptionInfo
1964 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1965 }
1966
1967
1968
1969 type GoogleCloudBeyondcorpPartnerservicesV1alphaGroup struct {
1970
1971 Email string `json:"email,omitempty"`
1972
1973 Id string `json:"id,omitempty"`
1974
1975
1976
1977
1978
1979 ForceSendFields []string `json:"-"`
1980
1981
1982
1983
1984 NullFields []string `json:"-"`
1985 }
1986
1987 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaGroup) MarshalJSON() ([]byte, error) {
1988 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaGroup
1989 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1990 }
1991
1992
1993
1994 type GoogleCloudBeyondcorpPartnerservicesV1alphaListBrowserDlpRulesResponse struct {
1995
1996 BrowserDlpRules []*GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule `json:"browserDlpRules,omitempty"`
1997
1998
1999 googleapi.ServerResponse `json:"-"`
2000
2001
2002
2003
2004
2005 ForceSendFields []string `json:"-"`
2006
2007
2008
2009
2010 NullFields []string `json:"-"`
2011 }
2012
2013 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaListBrowserDlpRulesResponse) MarshalJSON() ([]byte, error) {
2014 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaListBrowserDlpRulesResponse
2015 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2016 }
2017
2018
2019
2020 type GoogleCloudBeyondcorpPartnerservicesV1alphaListPartnerTenantsResponse struct {
2021
2022
2023 NextPageToken string `json:"nextPageToken,omitempty"`
2024
2025 PartnerTenants []*GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant `json:"partnerTenants,omitempty"`
2026
2027
2028 googleapi.ServerResponse `json:"-"`
2029
2030
2031
2032
2033
2034 ForceSendFields []string `json:"-"`
2035
2036
2037
2038
2039 NullFields []string `json:"-"`
2040 }
2041
2042 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaListPartnerTenantsResponse) MarshalJSON() ([]byte, error) {
2043 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaListPartnerTenantsResponse
2044 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2045 }
2046
2047
2048
2049 type GoogleCloudBeyondcorpPartnerservicesV1alphaListProxyConfigsResponse struct {
2050
2051
2052 NextPageToken string `json:"nextPageToken,omitempty"`
2053
2054 ProxyConfigs []*GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig `json:"proxyConfigs,omitempty"`
2055
2056
2057 googleapi.ServerResponse `json:"-"`
2058
2059
2060
2061
2062
2063 ForceSendFields []string `json:"-"`
2064
2065
2066
2067
2068 NullFields []string `json:"-"`
2069 }
2070
2071 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaListProxyConfigsResponse) MarshalJSON() ([]byte, error) {
2072 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaListProxyConfigsResponse
2073 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2074 }
2075
2076
2077
2078 type GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerMetadata struct {
2079
2080
2081 InternalTenantId string `json:"internalTenantId,omitempty"`
2082
2083
2084 PartnerTenantId string `json:"partnerTenantId,omitempty"`
2085
2086
2087
2088
2089
2090 ForceSendFields []string `json:"-"`
2091
2092
2093
2094
2095 NullFields []string `json:"-"`
2096 }
2097
2098 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerMetadata) MarshalJSON() ([]byte, error) {
2099 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerMetadata
2100 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2101 }
2102
2103
2104
2105 type GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerServiceOperationMetadata struct {
2106
2107 ApiVersion string `json:"apiVersion,omitempty"`
2108
2109 CreateTime string `json:"createTime,omitempty"`
2110
2111 EndTime string `json:"endTime,omitempty"`
2112
2113
2114
2115
2116 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
2117
2118 StatusMessage string `json:"statusMessage,omitempty"`
2119
2120
2121 Target string `json:"target,omitempty"`
2122
2123 Verb string `json:"verb,omitempty"`
2124
2125
2126
2127
2128
2129 ForceSendFields []string `json:"-"`
2130
2131
2132
2133
2134 NullFields []string `json:"-"`
2135 }
2136
2137 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerServiceOperationMetadata) MarshalJSON() ([]byte, error) {
2138 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerServiceOperationMetadata
2139 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2140 }
2141
2142
2143
2144 type GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant struct {
2145
2146 CreateTime string `json:"createTime,omitempty"`
2147
2148
2149 DisplayName string `json:"displayName,omitempty"`
2150
2151
2152
2153 Group *GoogleCloudBeyondcorpPartnerservicesV1alphaGroup `json:"group,omitempty"`
2154
2155
2156 Name string `json:"name,omitempty"`
2157
2158
2159 PartnerMetadata *GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerMetadata `json:"partnerMetadata,omitempty"`
2160
2161 UpdateTime string `json:"updateTime,omitempty"`
2162
2163
2164 googleapi.ServerResponse `json:"-"`
2165
2166
2167
2168
2169
2170 ForceSendFields []string `json:"-"`
2171
2172
2173
2174
2175 NullFields []string `json:"-"`
2176 }
2177
2178 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant) MarshalJSON() ([]byte, error) {
2179 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant
2180 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2181 }
2182
2183
2184
2185 type GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig struct {
2186
2187 CreateTime string `json:"createTime,omitempty"`
2188
2189
2190 DisplayName string `json:"displayName,omitempty"`
2191
2192 EncryptionInfo *GoogleCloudBeyondcorpPartnerservicesV1alphaEncryptionInfo `json:"encryptionInfo,omitempty"`
2193
2194 Name string `json:"name,omitempty"`
2195
2196 ProxyUri string `json:"proxyUri,omitempty"`
2197
2198 RoutingInfo *GoogleCloudBeyondcorpPartnerservicesV1alphaRoutingInfo `json:"routingInfo,omitempty"`
2199
2200
2201 TransportInfo *GoogleCloudBeyondcorpPartnerservicesV1alphaTransportInfo `json:"transportInfo,omitempty"`
2202
2203 UpdateTime string `json:"updateTime,omitempty"`
2204
2205
2206 googleapi.ServerResponse `json:"-"`
2207
2208
2209
2210
2211
2212 ForceSendFields []string `json:"-"`
2213
2214
2215
2216
2217 NullFields []string `json:"-"`
2218 }
2219
2220 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig) MarshalJSON() ([]byte, error) {
2221 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig
2222 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2223 }
2224
2225
2226
2227 type GoogleCloudBeyondcorpPartnerservicesV1alphaRoutingInfo struct {
2228
2229 PacUri string `json:"pacUri,omitempty"`
2230
2231
2232
2233
2234
2235 ForceSendFields []string `json:"-"`
2236
2237
2238
2239
2240 NullFields []string `json:"-"`
2241 }
2242
2243 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaRoutingInfo) MarshalJSON() ([]byte, error) {
2244 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaRoutingInfo
2245 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2246 }
2247
2248
2249
2250 type GoogleCloudBeyondcorpPartnerservicesV1alphaRuleSetting struct {
2251
2252 Type string `json:"type,omitempty"`
2253
2254 Value googleapi.RawMessage `json:"value,omitempty"`
2255
2256
2257
2258
2259
2260 ForceSendFields []string `json:"-"`
2261
2262
2263
2264
2265 NullFields []string `json:"-"`
2266 }
2267
2268 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaRuleSetting) MarshalJSON() ([]byte, error) {
2269 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaRuleSetting
2270 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2271 }
2272
2273
2274
2275 type GoogleCloudBeyondcorpPartnerservicesV1alphaTransportInfo struct {
2276
2277
2278 ServerCaCertPem string `json:"serverCaCertPem,omitempty"`
2279
2280
2281 SslDecryptCaCertPem string `json:"sslDecryptCaCertPem,omitempty"`
2282
2283
2284
2285
2286
2287 ForceSendFields []string `json:"-"`
2288
2289
2290
2291
2292 NullFields []string `json:"-"`
2293 }
2294
2295 func (s *GoogleCloudBeyondcorpPartnerservicesV1alphaTransportInfo) MarshalJSON() ([]byte, error) {
2296 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1alphaTransportInfo
2297 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2298 }
2299
2300
2301
2302 type GoogleCloudBeyondcorpPartnerservicesV1mainPartnerServiceOperationMetadata struct {
2303
2304 ApiVersion string `json:"apiVersion,omitempty"`
2305
2306 CreateTime string `json:"createTime,omitempty"`
2307
2308 EndTime string `json:"endTime,omitempty"`
2309
2310
2311
2312
2313 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
2314
2315 StatusMessage string `json:"statusMessage,omitempty"`
2316
2317
2318 Target string `json:"target,omitempty"`
2319
2320 Verb string `json:"verb,omitempty"`
2321
2322
2323
2324
2325
2326 ForceSendFields []string `json:"-"`
2327
2328
2329
2330
2331 NullFields []string `json:"-"`
2332 }
2333
2334 func (s *GoogleCloudBeyondcorpPartnerservicesV1mainPartnerServiceOperationMetadata) MarshalJSON() ([]byte, error) {
2335 type NoMethod GoogleCloudBeyondcorpPartnerservicesV1mainPartnerServiceOperationMetadata
2336 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2337 }
2338
2339
2340
2341 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaAppliedConfig struct {
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352 Aggregation string `json:"aggregation,omitempty"`
2353
2354 CustomGrouping *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaCustomGrouping `json:"customGrouping,omitempty"`
2355
2356
2357 EndTime string `json:"endTime,omitempty"`
2358
2359 FieldFilter string `json:"fieldFilter,omitempty"`
2360
2361 Group string `json:"group,omitempty"`
2362
2363
2364 StartTime string `json:"startTime,omitempty"`
2365
2366
2367
2368
2369
2370 ForceSendFields []string `json:"-"`
2371
2372
2373
2374
2375 NullFields []string `json:"-"`
2376 }
2377
2378 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaAppliedConfig) MarshalJSON() ([]byte, error) {
2379 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaAppliedConfig
2380 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2381 }
2382
2383
2384
2385 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse struct {
2386
2387
2388 AppliedConfig *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaAppliedConfig `json:"appliedConfig,omitempty"`
2389
2390
2391 NextPageToken string `json:"nextPageToken,omitempty"`
2392
2393
2394 Rows []*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRow `json:"rows,omitempty"`
2395
2396
2397 googleapi.ServerResponse `json:"-"`
2398
2399
2400
2401
2402
2403 ForceSendFields []string `json:"-"`
2404
2405
2406
2407
2408 NullFields []string `json:"-"`
2409 }
2410
2411 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse) MarshalJSON() ([]byte, error) {
2412 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse
2413 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2414 }
2415
2416
2417
2418
2419 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaCustomGrouping struct {
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429 FieldFilter string `json:"fieldFilter,omitempty"`
2430
2431
2432
2433 GroupFields []string `json:"groupFields,omitempty"`
2434
2435
2436
2437
2438
2439 ForceSendFields []string `json:"-"`
2440
2441
2442
2443
2444 NullFields []string `json:"-"`
2445 }
2446
2447 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaCustomGrouping) MarshalJSON() ([]byte, error) {
2448 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaCustomGrouping
2449 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2450 }
2451
2452
2453
2454 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsight struct {
2455
2456
2457 AppliedConfig *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaAppliedConfig `json:"appliedConfig,omitempty"`
2458
2459 Metadata *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsightMetadata `json:"metadata,omitempty"`
2460
2461
2462
2463 Name string `json:"name,omitempty"`
2464
2465 Rows []*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRow `json:"rows,omitempty"`
2466
2467
2468 googleapi.ServerResponse `json:"-"`
2469
2470
2471
2472
2473
2474 ForceSendFields []string `json:"-"`
2475
2476
2477
2478
2479 NullFields []string `json:"-"`
2480 }
2481
2482 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsight) MarshalJSON() ([]byte, error) {
2483 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsight
2484 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2485 }
2486
2487
2488
2489
2490 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsightMetadata struct {
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501 Aggregations []string `json:"aggregations,omitempty"`
2502
2503 Category string `json:"category,omitempty"`
2504
2505 DisplayName string `json:"displayName,omitempty"`
2506
2507 Fields []*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsightMetadataField `json:"fields,omitempty"`
2508
2509 Groups []string `json:"groups,omitempty"`
2510
2511 SubCategory string `json:"subCategory,omitempty"`
2512
2513
2514 Type string `json:"type,omitempty"`
2515
2516
2517
2518
2519
2520 ForceSendFields []string `json:"-"`
2521
2522
2523
2524
2525 NullFields []string `json:"-"`
2526 }
2527
2528 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsightMetadata) MarshalJSON() ([]byte, error) {
2529 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsightMetadata
2530 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2531 }
2532
2533
2534
2535
2536 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsightMetadataField struct {
2537
2538 Description string `json:"description,omitempty"`
2539
2540 DisplayName string `json:"displayName,omitempty"`
2541
2542
2543 FilterAlias string `json:"filterAlias,omitempty"`
2544
2545
2546 Filterable bool `json:"filterable,omitempty"`
2547
2548
2549 Groupable bool `json:"groupable,omitempty"`
2550
2551 Id string `json:"id,omitempty"`
2552
2553
2554
2555
2556
2557 ForceSendFields []string `json:"-"`
2558
2559
2560
2561
2562 NullFields []string `json:"-"`
2563 }
2564
2565 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsightMetadataField) MarshalJSON() ([]byte, error) {
2566 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsightMetadataField
2567 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2568 }
2569
2570
2571
2572 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse struct {
2573
2574 Insights []*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsight `json:"insights,omitempty"`
2575
2576
2577 NextPageToken string `json:"nextPageToken,omitempty"`
2578
2579
2580 googleapi.ServerResponse `json:"-"`
2581
2582
2583
2584
2585
2586 ForceSendFields []string `json:"-"`
2587
2588
2589
2590
2591 NullFields []string `json:"-"`
2592 }
2593
2594 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse) MarshalJSON() ([]byte, error) {
2595 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse
2596 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2597 }
2598
2599
2600
2601 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRow struct {
2602
2603 FieldValues []*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRowFieldVal `json:"fieldValues,omitempty"`
2604
2605
2606
2607
2608
2609 ForceSendFields []string `json:"-"`
2610
2611
2612
2613
2614 NullFields []string `json:"-"`
2615 }
2616
2617 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRow) MarshalJSON() ([]byte, error) {
2618 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRow
2619 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2620 }
2621
2622
2623
2624
2625 type GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRowFieldVal struct {
2626
2627 DisplayName string `json:"displayName,omitempty"`
2628
2629
2630 FilterAlias string `json:"filterAlias,omitempty"`
2631
2632 Id string `json:"id,omitempty"`
2633
2634
2635 Value string `json:"value,omitempty"`
2636
2637
2638
2639
2640
2641 ForceSendFields []string `json:"-"`
2642
2643
2644
2645
2646 NullFields []string `json:"-"`
2647 }
2648
2649 func (s *GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRowFieldVal) MarshalJSON() ([]byte, error) {
2650 type NoMethod GoogleCloudBeyondcorpSaasplatformInsightsV1alphaRowFieldVal
2651 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2652 }
2653
2654
2655
2656 type GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaCancelSubscriptionResponse struct {
2657
2658 EffectiveCancellationTime string `json:"effectiveCancellationTime,omitempty"`
2659
2660
2661 googleapi.ServerResponse `json:"-"`
2662
2663
2664
2665
2666
2667 ForceSendFields []string `json:"-"`
2668
2669
2670
2671
2672 NullFields []string `json:"-"`
2673 }
2674
2675 func (s *GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaCancelSubscriptionResponse) MarshalJSON() ([]byte, error) {
2676 type NoMethod GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaCancelSubscriptionResponse
2677 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2678 }
2679
2680
2681
2682 type GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaListSubscriptionsResponse struct {
2683
2684
2685 NextPageToken string `json:"nextPageToken,omitempty"`
2686
2687 Subscriptions []*GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription `json:"subscriptions,omitempty"`
2688
2689
2690 googleapi.ServerResponse `json:"-"`
2691
2692
2693
2694
2695
2696 ForceSendFields []string `json:"-"`
2697
2698
2699
2700
2701 NullFields []string `json:"-"`
2702 }
2703
2704 func (s *GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaListSubscriptionsResponse) MarshalJSON() ([]byte, error) {
2705 type NoMethod GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaListSubscriptionsResponse
2706 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2707 }
2708
2709
2710
2711
2712
2713 type GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription struct {
2714
2715
2716 AutoRenewEnabled bool `json:"autoRenewEnabled,omitempty"`
2717
2718
2719
2720 BillingAccount string `json:"billingAccount,omitempty"`
2721
2722 CreateTime string `json:"createTime,omitempty"`
2723
2724 EndTime string `json:"endTime,omitempty"`
2725
2726
2727 Name string `json:"name,omitempty"`
2728
2729 SeatCount int64 `json:"seatCount,omitempty,string"`
2730
2731
2732
2733
2734
2735 Sku string `json:"sku,omitempty"`
2736
2737 StartTime string `json:"startTime,omitempty"`
2738
2739
2740
2741
2742
2743
2744
2745 State string `json:"state,omitempty"`
2746
2747
2748
2749
2750
2751
2752
2753 Type string `json:"type,omitempty"`
2754
2755
2756 googleapi.ServerResponse `json:"-"`
2757
2758
2759
2760
2761
2762 ForceSendFields []string `json:"-"`
2763
2764
2765
2766
2767 NullFields []string `json:"-"`
2768 }
2769
2770 func (s *GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription) MarshalJSON() ([]byte, error) {
2771 type NoMethod GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription
2772 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2773 }
2774
2775
2776
2777 type GoogleCloudBeyondcorpSecuritygatewaysV1alphaListSecurityGatewaysResponse struct {
2778
2779
2780 NextPageToken string `json:"nextPageToken,omitempty"`
2781
2782 SecurityGateways []*GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway `json:"securityGateways,omitempty"`
2783
2784 Unreachable []string `json:"unreachable,omitempty"`
2785
2786
2787 googleapi.ServerResponse `json:"-"`
2788
2789
2790
2791
2792
2793 ForceSendFields []string `json:"-"`
2794
2795
2796
2797
2798 NullFields []string `json:"-"`
2799 }
2800
2801 func (s *GoogleCloudBeyondcorpSecuritygatewaysV1alphaListSecurityGatewaysResponse) MarshalJSON() ([]byte, error) {
2802 type NoMethod GoogleCloudBeyondcorpSecuritygatewaysV1alphaListSecurityGatewaysResponse
2803 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2804 }
2805
2806
2807
2808 type GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway struct {
2809
2810 CreateTime string `json:"createTime,omitempty"`
2811
2812
2813 DisplayName string `json:"displayName,omitempty"`
2814
2815
2816 ExternalIps []string `json:"externalIps,omitempty"`
2817
2818 Name string `json:"name,omitempty"`
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831 State string `json:"state,omitempty"`
2832
2833 UpdateTime string `json:"updateTime,omitempty"`
2834
2835
2836 googleapi.ServerResponse `json:"-"`
2837
2838
2839
2840
2841
2842 ForceSendFields []string `json:"-"`
2843
2844
2845
2846
2847 NullFields []string `json:"-"`
2848 }
2849
2850 func (s *GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway) MarshalJSON() ([]byte, error) {
2851 type NoMethod GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway
2852 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2853 }
2854
2855
2856
2857
2858 type GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGatewayOperationMetadata struct {
2859
2860 ApiVersion string `json:"apiVersion,omitempty"`
2861
2862 CreateTime string `json:"createTime,omitempty"`
2863
2864 EndTime string `json:"endTime,omitempty"`
2865
2866
2867
2868
2869 RequestedCancellation bool `json:"requestedCancellation,omitempty"`
2870
2871 StatusMessage string `json:"statusMessage,omitempty"`
2872
2873
2874 Target string `json:"target,omitempty"`
2875
2876 Verb string `json:"verb,omitempty"`
2877
2878
2879
2880
2881
2882 ForceSendFields []string `json:"-"`
2883
2884
2885
2886
2887 NullFields []string `json:"-"`
2888 }
2889
2890 func (s *GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGatewayOperationMetadata) MarshalJSON() ([]byte, error) {
2891 type NoMethod GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGatewayOperationMetadata
2892 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2893 }
2894
2895
2896
2897 type GoogleCloudLocationListLocationsResponse struct {
2898
2899
2900 Locations []*GoogleCloudLocationLocation `json:"locations,omitempty"`
2901
2902 NextPageToken string `json:"nextPageToken,omitempty"`
2903
2904
2905 googleapi.ServerResponse `json:"-"`
2906
2907
2908
2909
2910
2911 ForceSendFields []string `json:"-"`
2912
2913
2914
2915
2916 NullFields []string `json:"-"`
2917 }
2918
2919 func (s *GoogleCloudLocationListLocationsResponse) MarshalJSON() ([]byte, error) {
2920 type NoMethod GoogleCloudLocationListLocationsResponse
2921 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2922 }
2923
2924
2925
2926 type GoogleCloudLocationLocation struct {
2927
2928
2929 DisplayName string `json:"displayName,omitempty"`
2930
2931
2932 Labels map[string]string `json:"labels,omitempty"`
2933
2934 LocationId string `json:"locationId,omitempty"`
2935
2936
2937 Metadata googleapi.RawMessage `json:"metadata,omitempty"`
2938
2939
2940
2941 Name string `json:"name,omitempty"`
2942
2943
2944 googleapi.ServerResponse `json:"-"`
2945
2946
2947
2948
2949
2950 ForceSendFields []string `json:"-"`
2951
2952
2953
2954
2955 NullFields []string `json:"-"`
2956 }
2957
2958 func (s *GoogleCloudLocationLocation) MarshalJSON() ([]byte, error) {
2959 type NoMethod GoogleCloudLocationLocation
2960 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2961 }
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979 type GoogleIamV1AuditConfig struct {
2980
2981 AuditLogConfigs []*GoogleIamV1AuditLogConfig `json:"auditLogConfigs,omitempty"`
2982
2983
2984
2985 Service string `json:"service,omitempty"`
2986
2987
2988
2989
2990
2991 ForceSendFields []string `json:"-"`
2992
2993
2994
2995
2996 NullFields []string `json:"-"`
2997 }
2998
2999 func (s *GoogleIamV1AuditConfig) MarshalJSON() ([]byte, error) {
3000 type NoMethod GoogleIamV1AuditConfig
3001 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3002 }
3003
3004
3005
3006
3007
3008
3009 type GoogleIamV1AuditLogConfig struct {
3010
3011
3012 ExemptedMembers []string `json:"exemptedMembers,omitempty"`
3013
3014
3015
3016
3017
3018
3019
3020 LogType string `json:"logType,omitempty"`
3021
3022
3023
3024
3025
3026 ForceSendFields []string `json:"-"`
3027
3028
3029
3030
3031 NullFields []string `json:"-"`
3032 }
3033
3034 func (s *GoogleIamV1AuditLogConfig) MarshalJSON() ([]byte, error) {
3035 type NoMethod GoogleIamV1AuditLogConfig
3036 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3037 }
3038
3039
3040 type GoogleIamV1Binding struct {
3041
3042
3043
3044
3045
3046
3047
3048
3049 Condition *GoogleTypeExpr `json:"condition,omitempty"`
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112 Members []string `json:"members,omitempty"`
3113
3114
3115
3116
3117
3118
3119 Role string `json:"role,omitempty"`
3120
3121
3122
3123
3124
3125 ForceSendFields []string `json:"-"`
3126
3127
3128
3129
3130 NullFields []string `json:"-"`
3131 }
3132
3133 func (s *GoogleIamV1Binding) MarshalJSON() ([]byte, error) {
3134 type NoMethod GoogleIamV1Binding
3135 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3136 }
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168 type GoogleIamV1Policy struct {
3169
3170 AuditConfigs []*GoogleIamV1AuditConfig `json:"auditConfigs,omitempty"`
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180 Bindings []*GoogleIamV1Binding `json:"bindings,omitempty"`
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192 Etag string `json:"etag,omitempty"`
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208 Version int64 `json:"version,omitempty"`
3209
3210
3211 googleapi.ServerResponse `json:"-"`
3212
3213
3214
3215
3216
3217 ForceSendFields []string `json:"-"`
3218
3219
3220
3221
3222 NullFields []string `json:"-"`
3223 }
3224
3225 func (s *GoogleIamV1Policy) MarshalJSON() ([]byte, error) {
3226 type NoMethod GoogleIamV1Policy
3227 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3228 }
3229
3230
3231 type GoogleIamV1SetIamPolicyRequest struct {
3232
3233
3234
3235
3236 Policy *GoogleIamV1Policy `json:"policy,omitempty"`
3237
3238
3239
3240 UpdateMask string `json:"updateMask,omitempty"`
3241
3242
3243
3244
3245
3246 ForceSendFields []string `json:"-"`
3247
3248
3249
3250
3251 NullFields []string `json:"-"`
3252 }
3253
3254 func (s *GoogleIamV1SetIamPolicyRequest) MarshalJSON() ([]byte, error) {
3255 type NoMethod GoogleIamV1SetIamPolicyRequest
3256 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3257 }
3258
3259
3260
3261 type GoogleIamV1TestIamPermissionsRequest struct {
3262
3263
3264
3265
3266 Permissions []string `json:"permissions,omitempty"`
3267
3268
3269
3270
3271
3272 ForceSendFields []string `json:"-"`
3273
3274
3275
3276
3277 NullFields []string `json:"-"`
3278 }
3279
3280 func (s *GoogleIamV1TestIamPermissionsRequest) MarshalJSON() ([]byte, error) {
3281 type NoMethod GoogleIamV1TestIamPermissionsRequest
3282 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3283 }
3284
3285
3286
3287 type GoogleIamV1TestIamPermissionsResponse struct {
3288
3289
3290 Permissions []string `json:"permissions,omitempty"`
3291
3292
3293 googleapi.ServerResponse `json:"-"`
3294
3295
3296
3297
3298
3299 ForceSendFields []string `json:"-"`
3300
3301
3302
3303
3304 NullFields []string `json:"-"`
3305 }
3306
3307 func (s *GoogleIamV1TestIamPermissionsResponse) MarshalJSON() ([]byte, error) {
3308 type NoMethod GoogleIamV1TestIamPermissionsResponse
3309 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3310 }
3311
3312
3313
3314 type GoogleLongrunningCancelOperationRequest struct {
3315 }
3316
3317
3318
3319 type GoogleLongrunningListOperationsResponse struct {
3320
3321 NextPageToken string `json:"nextPageToken,omitempty"`
3322
3323
3324 Operations []*GoogleLongrunningOperation `json:"operations,omitempty"`
3325
3326
3327 googleapi.ServerResponse `json:"-"`
3328
3329
3330
3331
3332
3333 ForceSendFields []string `json:"-"`
3334
3335
3336
3337
3338 NullFields []string `json:"-"`
3339 }
3340
3341 func (s *GoogleLongrunningListOperationsResponse) MarshalJSON() ([]byte, error) {
3342 type NoMethod GoogleLongrunningListOperationsResponse
3343 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3344 }
3345
3346
3347
3348 type GoogleLongrunningOperation struct {
3349
3350
3351
3352 Done bool `json:"done,omitempty"`
3353
3354 Error *GoogleRpcStatus `json:"error,omitempty"`
3355
3356
3357
3358
3359 Metadata googleapi.RawMessage `json:"metadata,omitempty"`
3360
3361
3362
3363 Name string `json:"name,omitempty"`
3364
3365
3366
3367
3368
3369
3370
3371 Response googleapi.RawMessage `json:"response,omitempty"`
3372
3373
3374 googleapi.ServerResponse `json:"-"`
3375
3376
3377
3378
3379
3380 ForceSendFields []string `json:"-"`
3381
3382
3383
3384
3385 NullFields []string `json:"-"`
3386 }
3387
3388 func (s *GoogleLongrunningOperation) MarshalJSON() ([]byte, error) {
3389 type NoMethod GoogleLongrunningOperation
3390 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3391 }
3392
3393
3394
3395
3396
3397
3398
3399 type GoogleRpcStatus struct {
3400
3401 Code int64 `json:"code,omitempty"`
3402
3403
3404 Details []googleapi.RawMessage `json:"details,omitempty"`
3405
3406
3407
3408 Message string `json:"message,omitempty"`
3409
3410
3411
3412
3413
3414 ForceSendFields []string `json:"-"`
3415
3416
3417
3418
3419 NullFields []string `json:"-"`
3420 }
3421
3422 func (s *GoogleRpcStatus) MarshalJSON() ([]byte, error) {
3423 type NoMethod GoogleRpcStatus
3424 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3425 }
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443 type GoogleTypeExpr struct {
3444
3445
3446 Description string `json:"description,omitempty"`
3447
3448
3449 Expression string `json:"expression,omitempty"`
3450
3451
3452 Location string `json:"location,omitempty"`
3453
3454
3455
3456 Title string `json:"title,omitempty"`
3457
3458
3459
3460
3461
3462 ForceSendFields []string `json:"-"`
3463
3464
3465
3466
3467 NullFields []string `json:"-"`
3468 }
3469
3470 func (s *GoogleTypeExpr) MarshalJSON() ([]byte, error) {
3471 type NoMethod GoogleTypeExpr
3472 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3473 }
3474
3475
3476 type ImageConfig struct {
3477
3478
3479 StableImage string `json:"stableImage,omitempty"`
3480
3481
3482 TargetImage string `json:"targetImage,omitempty"`
3483
3484
3485
3486
3487
3488 ForceSendFields []string `json:"-"`
3489
3490
3491
3492
3493 NullFields []string `json:"-"`
3494 }
3495
3496 func (s *ImageConfig) MarshalJSON() ([]byte, error) {
3497 type NoMethod ImageConfig
3498 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3499 }
3500
3501
3502 type ListAppGatewaysResponse struct {
3503
3504 AppGateways []*AppGateway `json:"appGateways,omitempty"`
3505
3506
3507 NextPageToken string `json:"nextPageToken,omitempty"`
3508
3509 Unreachable []string `json:"unreachable,omitempty"`
3510
3511
3512 googleapi.ServerResponse `json:"-"`
3513
3514
3515
3516
3517
3518 ForceSendFields []string `json:"-"`
3519
3520
3521
3522
3523 NullFields []string `json:"-"`
3524 }
3525
3526 func (s *ListAppGatewaysResponse) MarshalJSON() ([]byte, error) {
3527 type NoMethod ListAppGatewaysResponse
3528 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3529 }
3530
3531
3532 type ListConnectionsResponse struct {
3533
3534 Connections []*Connection `json:"connections,omitempty"`
3535
3536
3537 NextPageToken string `json:"nextPageToken,omitempty"`
3538
3539 Unreachable []string `json:"unreachable,omitempty"`
3540
3541
3542 googleapi.ServerResponse `json:"-"`
3543
3544
3545
3546
3547
3548 ForceSendFields []string `json:"-"`
3549
3550
3551
3552
3553 NullFields []string `json:"-"`
3554 }
3555
3556 func (s *ListConnectionsResponse) MarshalJSON() ([]byte, error) {
3557 type NoMethod ListConnectionsResponse
3558 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3559 }
3560
3561
3562 type ListConnectorsResponse struct {
3563
3564 Connectors []*Connector `json:"connectors,omitempty"`
3565
3566
3567 NextPageToken string `json:"nextPageToken,omitempty"`
3568
3569 Unreachable []string `json:"unreachable,omitempty"`
3570
3571
3572 googleapi.ServerResponse `json:"-"`
3573
3574
3575
3576
3577
3578 ForceSendFields []string `json:"-"`
3579
3580
3581
3582
3583 NullFields []string `json:"-"`
3584 }
3585
3586 func (s *ListConnectorsResponse) MarshalJSON() ([]byte, error) {
3587 type NoMethod ListConnectorsResponse
3588 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3589 }
3590
3591
3592
3593 type NotificationConfig struct {
3594
3595
3596 PubsubNotification *CloudPubSubNotificationConfig `json:"pubsubNotification,omitempty"`
3597
3598
3599
3600
3601
3602 ForceSendFields []string `json:"-"`
3603
3604
3605
3606
3607 NullFields []string `json:"-"`
3608 }
3609
3610 func (s *NotificationConfig) MarshalJSON() ([]byte, error) {
3611 type NoMethod NotificationConfig
3612 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3613 }
3614
3615
3616 type PrincipalInfo struct {
3617
3618 ServiceAccount *ServiceAccount `json:"serviceAccount,omitempty"`
3619
3620
3621
3622
3623
3624 ForceSendFields []string `json:"-"`
3625
3626
3627
3628
3629 NullFields []string `json:"-"`
3630 }
3631
3632 func (s *PrincipalInfo) MarshalJSON() ([]byte, error) {
3633 type NoMethod PrincipalInfo
3634 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3635 }
3636
3637
3638
3639 type RemoteAgentDetails struct {
3640 }
3641
3642
3643 type ReportStatusRequest struct {
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655 RequestId string `json:"requestId,omitempty"`
3656
3657 ResourceInfo *ResourceInfo `json:"resourceInfo,omitempty"`
3658
3659
3660 ValidateOnly bool `json:"validateOnly,omitempty"`
3661
3662
3663
3664
3665
3666 ForceSendFields []string `json:"-"`
3667
3668
3669
3670
3671 NullFields []string `json:"-"`
3672 }
3673
3674 func (s *ReportStatusRequest) MarshalJSON() ([]byte, error) {
3675 type NoMethod ReportStatusRequest
3676 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3677 }
3678
3679
3680
3681 type ResolveConnectionsResponse struct {
3682
3683
3684 ConnectionDetails []*ConnectionDetails `json:"connectionDetails,omitempty"`
3685
3686
3687 NextPageToken string `json:"nextPageToken,omitempty"`
3688
3689 Unreachable []string `json:"unreachable,omitempty"`
3690
3691
3692 googleapi.ServerResponse `json:"-"`
3693
3694
3695
3696
3697
3698 ForceSendFields []string `json:"-"`
3699
3700
3701
3702
3703 NullFields []string `json:"-"`
3704 }
3705
3706 func (s *ResolveConnectionsResponse) MarshalJSON() ([]byte, error) {
3707 type NoMethod ResolveConnectionsResponse
3708 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3709 }
3710
3711
3712
3713 type ResolveInstanceConfigResponse struct {
3714
3715 InstanceConfig *ConnectorInstanceConfig `json:"instanceConfig,omitempty"`
3716
3717
3718 googleapi.ServerResponse `json:"-"`
3719
3720
3721
3722
3723
3724 ForceSendFields []string `json:"-"`
3725
3726
3727
3728
3729 NullFields []string `json:"-"`
3730 }
3731
3732 func (s *ResolveInstanceConfigResponse) MarshalJSON() ([]byte, error) {
3733 type NoMethod ResolveInstanceConfigResponse
3734 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3735 }
3736
3737
3738
3739 type ResourceInfo struct {
3740
3741 Id string `json:"id,omitempty"`
3742
3743 Resource googleapi.RawMessage `json:"resource,omitempty"`
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754 Status string `json:"status,omitempty"`
3755
3756 Sub []*ResourceInfo `json:"sub,omitempty"`
3757
3758
3759 Time string `json:"time,omitempty"`
3760
3761
3762
3763
3764
3765 ForceSendFields []string `json:"-"`
3766
3767
3768
3769
3770 NullFields []string `json:"-"`
3771 }
3772
3773 func (s *ResourceInfo) MarshalJSON() ([]byte, error) {
3774 type NoMethod ResourceInfo
3775 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3776 }
3777
3778
3779 type ServiceAccount struct {
3780
3781 Email string `json:"email,omitempty"`
3782
3783
3784
3785
3786
3787 ForceSendFields []string `json:"-"`
3788
3789
3790
3791
3792 NullFields []string `json:"-"`
3793 }
3794
3795 func (s *ServiceAccount) MarshalJSON() ([]byte, error) {
3796 type NoMethod ServiceAccount
3797 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3798 }
3799
3800
3801
3802 type Tunnelv1ProtoTunnelerError struct {
3803
3804 Err string `json:"err,omitempty"`
3805
3806
3807 Retryable bool `json:"retryable,omitempty"`
3808
3809
3810
3811
3812
3813 ForceSendFields []string `json:"-"`
3814
3815
3816
3817
3818 NullFields []string `json:"-"`
3819 }
3820
3821 func (s *Tunnelv1ProtoTunnelerError) MarshalJSON() ([]byte, error) {
3822 type NoMethod Tunnelv1ProtoTunnelerError
3823 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3824 }
3825
3826
3827
3828 type Tunnelv1ProtoTunnelerInfo struct {
3829
3830
3831
3832
3833 BackoffRetryCount int64 `json:"backoffRetryCount,omitempty"`
3834
3835 Id string `json:"id,omitempty"`
3836
3837
3838 LatestErr *Tunnelv1ProtoTunnelerError `json:"latestErr,omitempty"`
3839
3840
3841 LatestRetryTime string `json:"latestRetryTime,omitempty"`
3842
3843
3844 TotalRetryCount int64 `json:"totalRetryCount,omitempty"`
3845
3846
3847
3848
3849
3850 ForceSendFields []string `json:"-"`
3851
3852
3853
3854
3855 NullFields []string `json:"-"`
3856 }
3857
3858 func (s *Tunnelv1ProtoTunnelerInfo) MarshalJSON() ([]byte, error) {
3859 type NoMethod Tunnelv1ProtoTunnelerInfo
3860 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3861 }
3862
3863 type OrganizationsLocationsGlobalPartnerTenantsCreateCall struct {
3864 s *Service
3865 parent string
3866 googlecloudbeyondcorppartnerservicesv1alphapartnertenant *GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant
3867 urlParams_ gensupport.URLParams
3868 ctx_ context.Context
3869 header_ http.Header
3870 }
3871
3872
3873
3874
3875
3876
3877
3878 func (r *OrganizationsLocationsGlobalPartnerTenantsService) Create(parent string, googlecloudbeyondcorppartnerservicesv1alphapartnertenant *GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant) *OrganizationsLocationsGlobalPartnerTenantsCreateCall {
3879 c := &OrganizationsLocationsGlobalPartnerTenantsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
3880 c.parent = parent
3881 c.googlecloudbeyondcorppartnerservicesv1alphapartnertenant = googlecloudbeyondcorppartnerservicesv1alphapartnertenant
3882 return c
3883 }
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896 func (c *OrganizationsLocationsGlobalPartnerTenantsCreateCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsCreateCall {
3897 c.urlParams_.Set("requestId", requestId)
3898 return c
3899 }
3900
3901
3902
3903
3904 func (c *OrganizationsLocationsGlobalPartnerTenantsCreateCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsCreateCall {
3905 c.urlParams_.Set("fields", googleapi.CombineFields(s))
3906 return c
3907 }
3908
3909
3910 func (c *OrganizationsLocationsGlobalPartnerTenantsCreateCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsCreateCall {
3911 c.ctx_ = ctx
3912 return c
3913 }
3914
3915
3916
3917 func (c *OrganizationsLocationsGlobalPartnerTenantsCreateCall) Header() http.Header {
3918 if c.header_ == nil {
3919 c.header_ = make(http.Header)
3920 }
3921 return c.header_
3922 }
3923
3924 func (c *OrganizationsLocationsGlobalPartnerTenantsCreateCall) doRequest(alt string) (*http.Response, error) {
3925 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
3926 var body io.Reader = nil
3927 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorppartnerservicesv1alphapartnertenant)
3928 if err != nil {
3929 return nil, err
3930 }
3931 c.urlParams_.Set("alt", alt)
3932 c.urlParams_.Set("prettyPrint", "false")
3933 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/partnerTenants")
3934 urls += "?" + c.urlParams_.Encode()
3935 req, err := http.NewRequest("POST", urls, body)
3936 if err != nil {
3937 return nil, err
3938 }
3939 req.Header = reqHeaders
3940 googleapi.Expand(req.URL, map[string]string{
3941 "parent": c.parent,
3942 })
3943 return gensupport.SendRequest(c.ctx_, c.s.client, req)
3944 }
3945
3946
3947
3948
3949
3950
3951
3952 func (c *OrganizationsLocationsGlobalPartnerTenantsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
3953 gensupport.SetOptions(c.urlParams_, opts...)
3954 res, err := c.doRequest("json")
3955 if res != nil && res.StatusCode == http.StatusNotModified {
3956 if res.Body != nil {
3957 res.Body.Close()
3958 }
3959 return nil, gensupport.WrapError(&googleapi.Error{
3960 Code: res.StatusCode,
3961 Header: res.Header,
3962 })
3963 }
3964 if err != nil {
3965 return nil, err
3966 }
3967 defer googleapi.CloseBody(res)
3968 if err := googleapi.CheckResponse(res); err != nil {
3969 return nil, gensupport.WrapError(err)
3970 }
3971 ret := &GoogleLongrunningOperation{
3972 ServerResponse: googleapi.ServerResponse{
3973 Header: res.Header,
3974 HTTPStatusCode: res.StatusCode,
3975 },
3976 }
3977 target := &ret
3978 if err := gensupport.DecodeResponse(target, res); err != nil {
3979 return nil, err
3980 }
3981 return ret, nil
3982 }
3983
3984 type OrganizationsLocationsGlobalPartnerTenantsDeleteCall struct {
3985 s *Service
3986 name string
3987 urlParams_ gensupport.URLParams
3988 ctx_ context.Context
3989 header_ http.Header
3990 }
3991
3992
3993
3994
3995 func (r *OrganizationsLocationsGlobalPartnerTenantsService) Delete(name string) *OrganizationsLocationsGlobalPartnerTenantsDeleteCall {
3996 c := &OrganizationsLocationsGlobalPartnerTenantsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
3997 c.name = name
3998 return c
3999 }
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012 func (c *OrganizationsLocationsGlobalPartnerTenantsDeleteCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsDeleteCall {
4013 c.urlParams_.Set("requestId", requestId)
4014 return c
4015 }
4016
4017
4018
4019
4020 func (c *OrganizationsLocationsGlobalPartnerTenantsDeleteCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsDeleteCall {
4021 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4022 return c
4023 }
4024
4025
4026 func (c *OrganizationsLocationsGlobalPartnerTenantsDeleteCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsDeleteCall {
4027 c.ctx_ = ctx
4028 return c
4029 }
4030
4031
4032
4033 func (c *OrganizationsLocationsGlobalPartnerTenantsDeleteCall) Header() http.Header {
4034 if c.header_ == nil {
4035 c.header_ = make(http.Header)
4036 }
4037 return c.header_
4038 }
4039
4040 func (c *OrganizationsLocationsGlobalPartnerTenantsDeleteCall) doRequest(alt string) (*http.Response, error) {
4041 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4042 var body io.Reader = nil
4043 c.urlParams_.Set("alt", alt)
4044 c.urlParams_.Set("prettyPrint", "false")
4045 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
4046 urls += "?" + c.urlParams_.Encode()
4047 req, err := http.NewRequest("DELETE", urls, body)
4048 if err != nil {
4049 return nil, err
4050 }
4051 req.Header = reqHeaders
4052 googleapi.Expand(req.URL, map[string]string{
4053 "name": c.name,
4054 })
4055 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4056 }
4057
4058
4059
4060
4061
4062
4063
4064 func (c *OrganizationsLocationsGlobalPartnerTenantsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
4065 gensupport.SetOptions(c.urlParams_, opts...)
4066 res, err := c.doRequest("json")
4067 if res != nil && res.StatusCode == http.StatusNotModified {
4068 if res.Body != nil {
4069 res.Body.Close()
4070 }
4071 return nil, gensupport.WrapError(&googleapi.Error{
4072 Code: res.StatusCode,
4073 Header: res.Header,
4074 })
4075 }
4076 if err != nil {
4077 return nil, err
4078 }
4079 defer googleapi.CloseBody(res)
4080 if err := googleapi.CheckResponse(res); err != nil {
4081 return nil, gensupport.WrapError(err)
4082 }
4083 ret := &GoogleLongrunningOperation{
4084 ServerResponse: googleapi.ServerResponse{
4085 Header: res.Header,
4086 HTTPStatusCode: res.StatusCode,
4087 },
4088 }
4089 target := &ret
4090 if err := gensupport.DecodeResponse(target, res); err != nil {
4091 return nil, err
4092 }
4093 return ret, nil
4094 }
4095
4096 type OrganizationsLocationsGlobalPartnerTenantsGetCall struct {
4097 s *Service
4098 name string
4099 urlParams_ gensupport.URLParams
4100 ifNoneMatch_ string
4101 ctx_ context.Context
4102 header_ http.Header
4103 }
4104
4105
4106
4107
4108
4109
4110 func (r *OrganizationsLocationsGlobalPartnerTenantsService) Get(name string) *OrganizationsLocationsGlobalPartnerTenantsGetCall {
4111 c := &OrganizationsLocationsGlobalPartnerTenantsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4112 c.name = name
4113 return c
4114 }
4115
4116
4117
4118
4119 func (c *OrganizationsLocationsGlobalPartnerTenantsGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsGetCall {
4120 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4121 return c
4122 }
4123
4124
4125
4126
4127 func (c *OrganizationsLocationsGlobalPartnerTenantsGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsGetCall {
4128 c.ifNoneMatch_ = entityTag
4129 return c
4130 }
4131
4132
4133 func (c *OrganizationsLocationsGlobalPartnerTenantsGetCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsGetCall {
4134 c.ctx_ = ctx
4135 return c
4136 }
4137
4138
4139
4140 func (c *OrganizationsLocationsGlobalPartnerTenantsGetCall) Header() http.Header {
4141 if c.header_ == nil {
4142 c.header_ = make(http.Header)
4143 }
4144 return c.header_
4145 }
4146
4147 func (c *OrganizationsLocationsGlobalPartnerTenantsGetCall) doRequest(alt string) (*http.Response, error) {
4148 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4149 if c.ifNoneMatch_ != "" {
4150 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
4151 }
4152 var body io.Reader = nil
4153 c.urlParams_.Set("alt", alt)
4154 c.urlParams_.Set("prettyPrint", "false")
4155 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
4156 urls += "?" + c.urlParams_.Encode()
4157 req, err := http.NewRequest("GET", urls, body)
4158 if err != nil {
4159 return nil, err
4160 }
4161 req.Header = reqHeaders
4162 googleapi.Expand(req.URL, map[string]string{
4163 "name": c.name,
4164 })
4165 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4166 }
4167
4168
4169
4170
4171
4172
4173
4174 func (c *OrganizationsLocationsGlobalPartnerTenantsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant, error) {
4175 gensupport.SetOptions(c.urlParams_, opts...)
4176 res, err := c.doRequest("json")
4177 if res != nil && res.StatusCode == http.StatusNotModified {
4178 if res.Body != nil {
4179 res.Body.Close()
4180 }
4181 return nil, gensupport.WrapError(&googleapi.Error{
4182 Code: res.StatusCode,
4183 Header: res.Header,
4184 })
4185 }
4186 if err != nil {
4187 return nil, err
4188 }
4189 defer googleapi.CloseBody(res)
4190 if err := googleapi.CheckResponse(res); err != nil {
4191 return nil, gensupport.WrapError(err)
4192 }
4193 ret := &GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant{
4194 ServerResponse: googleapi.ServerResponse{
4195 Header: res.Header,
4196 HTTPStatusCode: res.StatusCode,
4197 },
4198 }
4199 target := &ret
4200 if err := gensupport.DecodeResponse(target, res); err != nil {
4201 return nil, err
4202 }
4203 return ret, nil
4204 }
4205
4206 type OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall struct {
4207 s *Service
4208 resource string
4209 urlParams_ gensupport.URLParams
4210 ifNoneMatch_ string
4211 ctx_ context.Context
4212 header_ http.Header
4213 }
4214
4215
4216
4217
4218
4219
4220
4221 func (r *OrganizationsLocationsGlobalPartnerTenantsService) GetIamPolicy(resource string) *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall {
4222 c := &OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4223 c.resource = resource
4224 return c
4225 }
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239 func (c *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall {
4240 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
4241 return c
4242 }
4243
4244
4245
4246
4247 func (c *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall {
4248 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4249 return c
4250 }
4251
4252
4253
4254
4255 func (c *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall {
4256 c.ifNoneMatch_ = entityTag
4257 return c
4258 }
4259
4260
4261 func (c *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall {
4262 c.ctx_ = ctx
4263 return c
4264 }
4265
4266
4267
4268 func (c *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall) Header() http.Header {
4269 if c.header_ == nil {
4270 c.header_ = make(http.Header)
4271 }
4272 return c.header_
4273 }
4274
4275 func (c *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
4276 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4277 if c.ifNoneMatch_ != "" {
4278 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
4279 }
4280 var body io.Reader = nil
4281 c.urlParams_.Set("alt", alt)
4282 c.urlParams_.Set("prettyPrint", "false")
4283 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
4284 urls += "?" + c.urlParams_.Encode()
4285 req, err := http.NewRequest("GET", urls, body)
4286 if err != nil {
4287 return nil, err
4288 }
4289 req.Header = reqHeaders
4290 googleapi.Expand(req.URL, map[string]string{
4291 "resource": c.resource,
4292 })
4293 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4294 }
4295
4296
4297
4298
4299
4300
4301
4302 func (c *OrganizationsLocationsGlobalPartnerTenantsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
4303 gensupport.SetOptions(c.urlParams_, opts...)
4304 res, err := c.doRequest("json")
4305 if res != nil && res.StatusCode == http.StatusNotModified {
4306 if res.Body != nil {
4307 res.Body.Close()
4308 }
4309 return nil, gensupport.WrapError(&googleapi.Error{
4310 Code: res.StatusCode,
4311 Header: res.Header,
4312 })
4313 }
4314 if err != nil {
4315 return nil, err
4316 }
4317 defer googleapi.CloseBody(res)
4318 if err := googleapi.CheckResponse(res); err != nil {
4319 return nil, gensupport.WrapError(err)
4320 }
4321 ret := &GoogleIamV1Policy{
4322 ServerResponse: googleapi.ServerResponse{
4323 Header: res.Header,
4324 HTTPStatusCode: res.StatusCode,
4325 },
4326 }
4327 target := &ret
4328 if err := gensupport.DecodeResponse(target, res); err != nil {
4329 return nil, err
4330 }
4331 return ret, nil
4332 }
4333
4334 type OrganizationsLocationsGlobalPartnerTenantsListCall struct {
4335 s *Service
4336 parent string
4337 urlParams_ gensupport.URLParams
4338 ifNoneMatch_ string
4339 ctx_ context.Context
4340 header_ http.Header
4341 }
4342
4343
4344
4345
4346
4347 func (r *OrganizationsLocationsGlobalPartnerTenantsService) List(parent string) *OrganizationsLocationsGlobalPartnerTenantsListCall {
4348 c := &OrganizationsLocationsGlobalPartnerTenantsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4349 c.parent = parent
4350 return c
4351 }
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) Filter(filter string) *OrganizationsLocationsGlobalPartnerTenantsListCall {
4364 c.urlParams_.Set("filter", filter)
4365 return c
4366 }
4367
4368
4369
4370
4371
4372 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) OrderBy(orderBy string) *OrganizationsLocationsGlobalPartnerTenantsListCall {
4373 c.urlParams_.Set("orderBy", orderBy)
4374 return c
4375 }
4376
4377
4378
4379
4380
4381
4382 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) PageSize(pageSize int64) *OrganizationsLocationsGlobalPartnerTenantsListCall {
4383 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
4384 return c
4385 }
4386
4387
4388
4389 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) PageToken(pageToken string) *OrganizationsLocationsGlobalPartnerTenantsListCall {
4390 c.urlParams_.Set("pageToken", pageToken)
4391 return c
4392 }
4393
4394
4395
4396
4397 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsListCall {
4398 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4399 return c
4400 }
4401
4402
4403
4404
4405 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsListCall {
4406 c.ifNoneMatch_ = entityTag
4407 return c
4408 }
4409
4410
4411 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsListCall {
4412 c.ctx_ = ctx
4413 return c
4414 }
4415
4416
4417
4418 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) Header() http.Header {
4419 if c.header_ == nil {
4420 c.header_ = make(http.Header)
4421 }
4422 return c.header_
4423 }
4424
4425 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) doRequest(alt string) (*http.Response, error) {
4426 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
4427 if c.ifNoneMatch_ != "" {
4428 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
4429 }
4430 var body io.Reader = nil
4431 c.urlParams_.Set("alt", alt)
4432 c.urlParams_.Set("prettyPrint", "false")
4433 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/partnerTenants")
4434 urls += "?" + c.urlParams_.Encode()
4435 req, err := http.NewRequest("GET", urls, body)
4436 if err != nil {
4437 return nil, err
4438 }
4439 req.Header = reqHeaders
4440 googleapi.Expand(req.URL, map[string]string{
4441 "parent": c.parent,
4442 })
4443 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4444 }
4445
4446
4447
4448
4449
4450
4451
4452 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpPartnerservicesV1alphaListPartnerTenantsResponse, error) {
4453 gensupport.SetOptions(c.urlParams_, opts...)
4454 res, err := c.doRequest("json")
4455 if res != nil && res.StatusCode == http.StatusNotModified {
4456 if res.Body != nil {
4457 res.Body.Close()
4458 }
4459 return nil, gensupport.WrapError(&googleapi.Error{
4460 Code: res.StatusCode,
4461 Header: res.Header,
4462 })
4463 }
4464 if err != nil {
4465 return nil, err
4466 }
4467 defer googleapi.CloseBody(res)
4468 if err := googleapi.CheckResponse(res); err != nil {
4469 return nil, gensupport.WrapError(err)
4470 }
4471 ret := &GoogleCloudBeyondcorpPartnerservicesV1alphaListPartnerTenantsResponse{
4472 ServerResponse: googleapi.ServerResponse{
4473 Header: res.Header,
4474 HTTPStatusCode: res.StatusCode,
4475 },
4476 }
4477 target := &ret
4478 if err := gensupport.DecodeResponse(target, res); err != nil {
4479 return nil, err
4480 }
4481 return ret, nil
4482 }
4483
4484
4485
4486
4487 func (c *OrganizationsLocationsGlobalPartnerTenantsListCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpPartnerservicesV1alphaListPartnerTenantsResponse) error) error {
4488 c.ctx_ = ctx
4489 defer c.PageToken(c.urlParams_.Get("pageToken"))
4490 for {
4491 x, err := c.Do()
4492 if err != nil {
4493 return err
4494 }
4495 if err := f(x); err != nil {
4496 return err
4497 }
4498 if x.NextPageToken == "" {
4499 return nil
4500 }
4501 c.PageToken(x.NextPageToken)
4502 }
4503 }
4504
4505 type OrganizationsLocationsGlobalPartnerTenantsPatchCall struct {
4506 s *Service
4507 name string
4508 googlecloudbeyondcorppartnerservicesv1alphapartnertenant *GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant
4509 urlParams_ gensupport.URLParams
4510 ctx_ context.Context
4511 header_ http.Header
4512 }
4513
4514
4515
4516
4517
4518 func (r *OrganizationsLocationsGlobalPartnerTenantsService) Patch(name string, googlecloudbeyondcorppartnerservicesv1alphapartnertenant *GoogleCloudBeyondcorpPartnerservicesV1alphaPartnerTenant) *OrganizationsLocationsGlobalPartnerTenantsPatchCall {
4519 c := &OrganizationsLocationsGlobalPartnerTenantsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4520 c.name = name
4521 c.googlecloudbeyondcorppartnerservicesv1alphapartnertenant = googlecloudbeyondcorppartnerservicesv1alphapartnertenant
4522 return c
4523 }
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536 func (c *OrganizationsLocationsGlobalPartnerTenantsPatchCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsPatchCall {
4537 c.urlParams_.Set("requestId", requestId)
4538 return c
4539 }
4540
4541
4542
4543
4544
4545
4546
4547
4548 func (c *OrganizationsLocationsGlobalPartnerTenantsPatchCall) UpdateMask(updateMask string) *OrganizationsLocationsGlobalPartnerTenantsPatchCall {
4549 c.urlParams_.Set("updateMask", updateMask)
4550 return c
4551 }
4552
4553
4554
4555
4556 func (c *OrganizationsLocationsGlobalPartnerTenantsPatchCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsPatchCall {
4557 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4558 return c
4559 }
4560
4561
4562 func (c *OrganizationsLocationsGlobalPartnerTenantsPatchCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsPatchCall {
4563 c.ctx_ = ctx
4564 return c
4565 }
4566
4567
4568
4569 func (c *OrganizationsLocationsGlobalPartnerTenantsPatchCall) Header() http.Header {
4570 if c.header_ == nil {
4571 c.header_ = make(http.Header)
4572 }
4573 return c.header_
4574 }
4575
4576 func (c *OrganizationsLocationsGlobalPartnerTenantsPatchCall) doRequest(alt string) (*http.Response, error) {
4577 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
4578 var body io.Reader = nil
4579 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorppartnerservicesv1alphapartnertenant)
4580 if err != nil {
4581 return nil, err
4582 }
4583 c.urlParams_.Set("alt", alt)
4584 c.urlParams_.Set("prettyPrint", "false")
4585 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
4586 urls += "?" + c.urlParams_.Encode()
4587 req, err := http.NewRequest("PATCH", urls, body)
4588 if err != nil {
4589 return nil, err
4590 }
4591 req.Header = reqHeaders
4592 googleapi.Expand(req.URL, map[string]string{
4593 "name": c.name,
4594 })
4595 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4596 }
4597
4598
4599
4600
4601
4602
4603
4604 func (c *OrganizationsLocationsGlobalPartnerTenantsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
4605 gensupport.SetOptions(c.urlParams_, opts...)
4606 res, err := c.doRequest("json")
4607 if res != nil && res.StatusCode == http.StatusNotModified {
4608 if res.Body != nil {
4609 res.Body.Close()
4610 }
4611 return nil, gensupport.WrapError(&googleapi.Error{
4612 Code: res.StatusCode,
4613 Header: res.Header,
4614 })
4615 }
4616 if err != nil {
4617 return nil, err
4618 }
4619 defer googleapi.CloseBody(res)
4620 if err := googleapi.CheckResponse(res); err != nil {
4621 return nil, gensupport.WrapError(err)
4622 }
4623 ret := &GoogleLongrunningOperation{
4624 ServerResponse: googleapi.ServerResponse{
4625 Header: res.Header,
4626 HTTPStatusCode: res.StatusCode,
4627 },
4628 }
4629 target := &ret
4630 if err := gensupport.DecodeResponse(target, res); err != nil {
4631 return nil, err
4632 }
4633 return ret, nil
4634 }
4635
4636 type OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall struct {
4637 s *Service
4638 resource string
4639 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
4640 urlParams_ gensupport.URLParams
4641 ctx_ context.Context
4642 header_ http.Header
4643 }
4644
4645
4646
4647
4648
4649
4650
4651
4652 func (r *OrganizationsLocationsGlobalPartnerTenantsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall {
4653 c := &OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4654 c.resource = resource
4655 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
4656 return c
4657 }
4658
4659
4660
4661
4662 func (c *OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall {
4663 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4664 return c
4665 }
4666
4667
4668 func (c *OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall {
4669 c.ctx_ = ctx
4670 return c
4671 }
4672
4673
4674
4675 func (c *OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall) Header() http.Header {
4676 if c.header_ == nil {
4677 c.header_ = make(http.Header)
4678 }
4679 return c.header_
4680 }
4681
4682 func (c *OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
4683 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
4684 var body io.Reader = nil
4685 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
4686 if err != nil {
4687 return nil, err
4688 }
4689 c.urlParams_.Set("alt", alt)
4690 c.urlParams_.Set("prettyPrint", "false")
4691 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
4692 urls += "?" + c.urlParams_.Encode()
4693 req, err := http.NewRequest("POST", urls, body)
4694 if err != nil {
4695 return nil, err
4696 }
4697 req.Header = reqHeaders
4698 googleapi.Expand(req.URL, map[string]string{
4699 "resource": c.resource,
4700 })
4701 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4702 }
4703
4704
4705
4706
4707
4708
4709
4710 func (c *OrganizationsLocationsGlobalPartnerTenantsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
4711 gensupport.SetOptions(c.urlParams_, opts...)
4712 res, err := c.doRequest("json")
4713 if res != nil && res.StatusCode == http.StatusNotModified {
4714 if res.Body != nil {
4715 res.Body.Close()
4716 }
4717 return nil, gensupport.WrapError(&googleapi.Error{
4718 Code: res.StatusCode,
4719 Header: res.Header,
4720 })
4721 }
4722 if err != nil {
4723 return nil, err
4724 }
4725 defer googleapi.CloseBody(res)
4726 if err := googleapi.CheckResponse(res); err != nil {
4727 return nil, gensupport.WrapError(err)
4728 }
4729 ret := &GoogleIamV1Policy{
4730 ServerResponse: googleapi.ServerResponse{
4731 Header: res.Header,
4732 HTTPStatusCode: res.StatusCode,
4733 },
4734 }
4735 target := &ret
4736 if err := gensupport.DecodeResponse(target, res); err != nil {
4737 return nil, err
4738 }
4739 return ret, nil
4740 }
4741
4742 type OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall struct {
4743 s *Service
4744 resource string
4745 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
4746 urlParams_ gensupport.URLParams
4747 ctx_ context.Context
4748 header_ http.Header
4749 }
4750
4751
4752
4753
4754
4755
4756
4757
4758
4759
4760
4761 func (r *OrganizationsLocationsGlobalPartnerTenantsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall {
4762 c := &OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4763 c.resource = resource
4764 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
4765 return c
4766 }
4767
4768
4769
4770
4771 func (c *OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall {
4772 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4773 return c
4774 }
4775
4776
4777 func (c *OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall {
4778 c.ctx_ = ctx
4779 return c
4780 }
4781
4782
4783
4784 func (c *OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall) Header() http.Header {
4785 if c.header_ == nil {
4786 c.header_ = make(http.Header)
4787 }
4788 return c.header_
4789 }
4790
4791 func (c *OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
4792 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
4793 var body io.Reader = nil
4794 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
4795 if err != nil {
4796 return nil, err
4797 }
4798 c.urlParams_.Set("alt", alt)
4799 c.urlParams_.Set("prettyPrint", "false")
4800 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
4801 urls += "?" + c.urlParams_.Encode()
4802 req, err := http.NewRequest("POST", urls, body)
4803 if err != nil {
4804 return nil, err
4805 }
4806 req.Header = reqHeaders
4807 googleapi.Expand(req.URL, map[string]string{
4808 "resource": c.resource,
4809 })
4810 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4811 }
4812
4813
4814
4815
4816
4817
4818
4819 func (c *OrganizationsLocationsGlobalPartnerTenantsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
4820 gensupport.SetOptions(c.urlParams_, opts...)
4821 res, err := c.doRequest("json")
4822 if res != nil && res.StatusCode == http.StatusNotModified {
4823 if res.Body != nil {
4824 res.Body.Close()
4825 }
4826 return nil, gensupport.WrapError(&googleapi.Error{
4827 Code: res.StatusCode,
4828 Header: res.Header,
4829 })
4830 }
4831 if err != nil {
4832 return nil, err
4833 }
4834 defer googleapi.CloseBody(res)
4835 if err := googleapi.CheckResponse(res); err != nil {
4836 return nil, gensupport.WrapError(err)
4837 }
4838 ret := &GoogleIamV1TestIamPermissionsResponse{
4839 ServerResponse: googleapi.ServerResponse{
4840 Header: res.Header,
4841 HTTPStatusCode: res.StatusCode,
4842 },
4843 }
4844 target := &ret
4845 if err := gensupport.DecodeResponse(target, res); err != nil {
4846 return nil, err
4847 }
4848 return ret, nil
4849 }
4850
4851 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall struct {
4852 s *Service
4853 parent string
4854 googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule *GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule
4855 urlParams_ gensupport.URLParams
4856 ctx_ context.Context
4857 header_ http.Header
4858 }
4859
4860
4861
4862
4863
4864
4865
4866 func (r *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService) Create(parent string, googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule *GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall {
4867 c := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4868 c.parent = parent
4869 c.googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule = googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule
4870 return c
4871 }
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall {
4885 c.urlParams_.Set("requestId", requestId)
4886 return c
4887 }
4888
4889
4890
4891
4892 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall {
4893 c.urlParams_.Set("fields", googleapi.CombineFields(s))
4894 return c
4895 }
4896
4897
4898 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall {
4899 c.ctx_ = ctx
4900 return c
4901 }
4902
4903
4904
4905 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall) Header() http.Header {
4906 if c.header_ == nil {
4907 c.header_ = make(http.Header)
4908 }
4909 return c.header_
4910 }
4911
4912 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall) doRequest(alt string) (*http.Response, error) {
4913 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
4914 var body io.Reader = nil
4915 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule)
4916 if err != nil {
4917 return nil, err
4918 }
4919 c.urlParams_.Set("alt", alt)
4920 c.urlParams_.Set("prettyPrint", "false")
4921 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/browserDlpRules")
4922 urls += "?" + c.urlParams_.Encode()
4923 req, err := http.NewRequest("POST", urls, body)
4924 if err != nil {
4925 return nil, err
4926 }
4927 req.Header = reqHeaders
4928 googleapi.Expand(req.URL, map[string]string{
4929 "parent": c.parent,
4930 })
4931 return gensupport.SendRequest(c.ctx_, c.s.client, req)
4932 }
4933
4934
4935
4936
4937
4938
4939
4940 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
4941 gensupport.SetOptions(c.urlParams_, opts...)
4942 res, err := c.doRequest("json")
4943 if res != nil && res.StatusCode == http.StatusNotModified {
4944 if res.Body != nil {
4945 res.Body.Close()
4946 }
4947 return nil, gensupport.WrapError(&googleapi.Error{
4948 Code: res.StatusCode,
4949 Header: res.Header,
4950 })
4951 }
4952 if err != nil {
4953 return nil, err
4954 }
4955 defer googleapi.CloseBody(res)
4956 if err := googleapi.CheckResponse(res); err != nil {
4957 return nil, gensupport.WrapError(err)
4958 }
4959 ret := &GoogleLongrunningOperation{
4960 ServerResponse: googleapi.ServerResponse{
4961 Header: res.Header,
4962 HTTPStatusCode: res.StatusCode,
4963 },
4964 }
4965 target := &ret
4966 if err := gensupport.DecodeResponse(target, res); err != nil {
4967 return nil, err
4968 }
4969 return ret, nil
4970 }
4971
4972 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall struct {
4973 s *Service
4974 name string
4975 urlParams_ gensupport.URLParams
4976 ctx_ context.Context
4977 header_ http.Header
4978 }
4979
4980
4981
4982
4983
4984
4985 func (r *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService) Delete(name string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall {
4986 c := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
4987 c.name = name
4988 return c
4989 }
4990
4991
4992
4993
4994
4995
4996
4997
4998
4999
5000
5001
5002 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall {
5003 c.urlParams_.Set("requestId", requestId)
5004 return c
5005 }
5006
5007
5008
5009
5010 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall {
5011 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5012 return c
5013 }
5014
5015
5016 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall {
5017 c.ctx_ = ctx
5018 return c
5019 }
5020
5021
5022
5023 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall) Header() http.Header {
5024 if c.header_ == nil {
5025 c.header_ = make(http.Header)
5026 }
5027 return c.header_
5028 }
5029
5030 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall) doRequest(alt string) (*http.Response, error) {
5031 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5032 var body io.Reader = nil
5033 c.urlParams_.Set("alt", alt)
5034 c.urlParams_.Set("prettyPrint", "false")
5035 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
5036 urls += "?" + c.urlParams_.Encode()
5037 req, err := http.NewRequest("DELETE", urls, body)
5038 if err != nil {
5039 return nil, err
5040 }
5041 req.Header = reqHeaders
5042 googleapi.Expand(req.URL, map[string]string{
5043 "name": c.name,
5044 })
5045 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5046 }
5047
5048
5049
5050
5051
5052
5053
5054 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
5055 gensupport.SetOptions(c.urlParams_, opts...)
5056 res, err := c.doRequest("json")
5057 if res != nil && res.StatusCode == http.StatusNotModified {
5058 if res.Body != nil {
5059 res.Body.Close()
5060 }
5061 return nil, gensupport.WrapError(&googleapi.Error{
5062 Code: res.StatusCode,
5063 Header: res.Header,
5064 })
5065 }
5066 if err != nil {
5067 return nil, err
5068 }
5069 defer googleapi.CloseBody(res)
5070 if err := googleapi.CheckResponse(res); err != nil {
5071 return nil, gensupport.WrapError(err)
5072 }
5073 ret := &GoogleLongrunningOperation{
5074 ServerResponse: googleapi.ServerResponse{
5075 Header: res.Header,
5076 HTTPStatusCode: res.StatusCode,
5077 },
5078 }
5079 target := &ret
5080 if err := gensupport.DecodeResponse(target, res); err != nil {
5081 return nil, err
5082 }
5083 return ret, nil
5084 }
5085
5086 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall struct {
5087 s *Service
5088 name string
5089 urlParams_ gensupport.URLParams
5090 ifNoneMatch_ string
5091 ctx_ context.Context
5092 header_ http.Header
5093 }
5094
5095
5096
5097
5098
5099
5100 func (r *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService) Get(name string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall {
5101 c := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5102 c.name = name
5103 return c
5104 }
5105
5106
5107
5108
5109 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall {
5110 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5111 return c
5112 }
5113
5114
5115
5116
5117 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall {
5118 c.ifNoneMatch_ = entityTag
5119 return c
5120 }
5121
5122
5123 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall {
5124 c.ctx_ = ctx
5125 return c
5126 }
5127
5128
5129
5130 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall) Header() http.Header {
5131 if c.header_ == nil {
5132 c.header_ = make(http.Header)
5133 }
5134 return c.header_
5135 }
5136
5137 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall) doRequest(alt string) (*http.Response, error) {
5138 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5139 if c.ifNoneMatch_ != "" {
5140 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5141 }
5142 var body io.Reader = nil
5143 c.urlParams_.Set("alt", alt)
5144 c.urlParams_.Set("prettyPrint", "false")
5145 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
5146 urls += "?" + c.urlParams_.Encode()
5147 req, err := http.NewRequest("GET", urls, body)
5148 if err != nil {
5149 return nil, err
5150 }
5151 req.Header = reqHeaders
5152 googleapi.Expand(req.URL, map[string]string{
5153 "name": c.name,
5154 })
5155 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5156 }
5157
5158
5159
5160
5161
5162
5163
5164 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule, error) {
5165 gensupport.SetOptions(c.urlParams_, opts...)
5166 res, err := c.doRequest("json")
5167 if res != nil && res.StatusCode == http.StatusNotModified {
5168 if res.Body != nil {
5169 res.Body.Close()
5170 }
5171 return nil, gensupport.WrapError(&googleapi.Error{
5172 Code: res.StatusCode,
5173 Header: res.Header,
5174 })
5175 }
5176 if err != nil {
5177 return nil, err
5178 }
5179 defer googleapi.CloseBody(res)
5180 if err := googleapi.CheckResponse(res); err != nil {
5181 return nil, gensupport.WrapError(err)
5182 }
5183 ret := &GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule{
5184 ServerResponse: googleapi.ServerResponse{
5185 Header: res.Header,
5186 HTTPStatusCode: res.StatusCode,
5187 },
5188 }
5189 target := &ret
5190 if err := gensupport.DecodeResponse(target, res); err != nil {
5191 return nil, err
5192 }
5193 return ret, nil
5194 }
5195
5196 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall struct {
5197 s *Service
5198 resource string
5199 urlParams_ gensupport.URLParams
5200 ifNoneMatch_ string
5201 ctx_ context.Context
5202 header_ http.Header
5203 }
5204
5205
5206
5207
5208
5209
5210
5211 func (r *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService) GetIamPolicy(resource string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall {
5212 c := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5213 c.resource = resource
5214 return c
5215 }
5216
5217
5218
5219
5220
5221
5222
5223
5224
5225
5226
5227
5228
5229 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall {
5230 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
5231 return c
5232 }
5233
5234
5235
5236
5237 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall {
5238 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5239 return c
5240 }
5241
5242
5243
5244
5245 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall {
5246 c.ifNoneMatch_ = entityTag
5247 return c
5248 }
5249
5250
5251 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall {
5252 c.ctx_ = ctx
5253 return c
5254 }
5255
5256
5257
5258 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall) Header() http.Header {
5259 if c.header_ == nil {
5260 c.header_ = make(http.Header)
5261 }
5262 return c.header_
5263 }
5264
5265 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
5266 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5267 if c.ifNoneMatch_ != "" {
5268 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5269 }
5270 var body io.Reader = nil
5271 c.urlParams_.Set("alt", alt)
5272 c.urlParams_.Set("prettyPrint", "false")
5273 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
5274 urls += "?" + c.urlParams_.Encode()
5275 req, err := http.NewRequest("GET", urls, body)
5276 if err != nil {
5277 return nil, err
5278 }
5279 req.Header = reqHeaders
5280 googleapi.Expand(req.URL, map[string]string{
5281 "resource": c.resource,
5282 })
5283 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5284 }
5285
5286
5287
5288
5289
5290
5291
5292 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
5293 gensupport.SetOptions(c.urlParams_, opts...)
5294 res, err := c.doRequest("json")
5295 if res != nil && res.StatusCode == http.StatusNotModified {
5296 if res.Body != nil {
5297 res.Body.Close()
5298 }
5299 return nil, gensupport.WrapError(&googleapi.Error{
5300 Code: res.StatusCode,
5301 Header: res.Header,
5302 })
5303 }
5304 if err != nil {
5305 return nil, err
5306 }
5307 defer googleapi.CloseBody(res)
5308 if err := googleapi.CheckResponse(res); err != nil {
5309 return nil, gensupport.WrapError(err)
5310 }
5311 ret := &GoogleIamV1Policy{
5312 ServerResponse: googleapi.ServerResponse{
5313 Header: res.Header,
5314 HTTPStatusCode: res.StatusCode,
5315 },
5316 }
5317 target := &ret
5318 if err := gensupport.DecodeResponse(target, res); err != nil {
5319 return nil, err
5320 }
5321 return ret, nil
5322 }
5323
5324 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall struct {
5325 s *Service
5326 parent string
5327 urlParams_ gensupport.URLParams
5328 ifNoneMatch_ string
5329 ctx_ context.Context
5330 header_ http.Header
5331 }
5332
5333
5334
5335
5336
5337
5338
5339 func (r *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService) List(parent string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall {
5340 c := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5341 c.parent = parent
5342 return c
5343 }
5344
5345
5346
5347
5348 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall {
5349 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5350 return c
5351 }
5352
5353
5354
5355
5356 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall {
5357 c.ifNoneMatch_ = entityTag
5358 return c
5359 }
5360
5361
5362 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall {
5363 c.ctx_ = ctx
5364 return c
5365 }
5366
5367
5368
5369 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall) Header() http.Header {
5370 if c.header_ == nil {
5371 c.header_ = make(http.Header)
5372 }
5373 return c.header_
5374 }
5375
5376 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall) doRequest(alt string) (*http.Response, error) {
5377 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5378 if c.ifNoneMatch_ != "" {
5379 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5380 }
5381 var body io.Reader = nil
5382 c.urlParams_.Set("alt", alt)
5383 c.urlParams_.Set("prettyPrint", "false")
5384 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/browserDlpRules")
5385 urls += "?" + c.urlParams_.Encode()
5386 req, err := http.NewRequest("GET", urls, body)
5387 if err != nil {
5388 return nil, err
5389 }
5390 req.Header = reqHeaders
5391 googleapi.Expand(req.URL, map[string]string{
5392 "parent": c.parent,
5393 })
5394 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5395 }
5396
5397
5398
5399
5400
5401
5402
5403 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpPartnerservicesV1alphaListBrowserDlpRulesResponse, error) {
5404 gensupport.SetOptions(c.urlParams_, opts...)
5405 res, err := c.doRequest("json")
5406 if res != nil && res.StatusCode == http.StatusNotModified {
5407 if res.Body != nil {
5408 res.Body.Close()
5409 }
5410 return nil, gensupport.WrapError(&googleapi.Error{
5411 Code: res.StatusCode,
5412 Header: res.Header,
5413 })
5414 }
5415 if err != nil {
5416 return nil, err
5417 }
5418 defer googleapi.CloseBody(res)
5419 if err := googleapi.CheckResponse(res); err != nil {
5420 return nil, gensupport.WrapError(err)
5421 }
5422 ret := &GoogleCloudBeyondcorpPartnerservicesV1alphaListBrowserDlpRulesResponse{
5423 ServerResponse: googleapi.ServerResponse{
5424 Header: res.Header,
5425 HTTPStatusCode: res.StatusCode,
5426 },
5427 }
5428 target := &ret
5429 if err := gensupport.DecodeResponse(target, res); err != nil {
5430 return nil, err
5431 }
5432 return ret, nil
5433 }
5434
5435 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall struct {
5436 s *Service
5437 name string
5438 googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule *GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule
5439 urlParams_ gensupport.URLParams
5440 ctx_ context.Context
5441 header_ http.Header
5442 }
5443
5444
5445
5446
5447
5448
5449 func (r *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService) Patch(name string, googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule *GoogleCloudBeyondcorpPartnerservicesV1alphaBrowserDlpRule) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall {
5450 c := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5451 c.name = name
5452 c.googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule = googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule
5453 return c
5454 }
5455
5456
5457
5458
5459
5460
5461
5462
5463
5464
5465
5466
5467 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall {
5468 c.urlParams_.Set("requestId", requestId)
5469 return c
5470 }
5471
5472
5473
5474 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall) UpdateMask(updateMask string) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall {
5475 c.urlParams_.Set("updateMask", updateMask)
5476 return c
5477 }
5478
5479
5480
5481
5482 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall {
5483 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5484 return c
5485 }
5486
5487
5488 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall {
5489 c.ctx_ = ctx
5490 return c
5491 }
5492
5493
5494
5495 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall) Header() http.Header {
5496 if c.header_ == nil {
5497 c.header_ = make(http.Header)
5498 }
5499 return c.header_
5500 }
5501
5502 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall) doRequest(alt string) (*http.Response, error) {
5503 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5504 var body io.Reader = nil
5505 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorppartnerservicesv1alphabrowserdlprule)
5506 if err != nil {
5507 return nil, err
5508 }
5509 c.urlParams_.Set("alt", alt)
5510 c.urlParams_.Set("prettyPrint", "false")
5511 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
5512 urls += "?" + c.urlParams_.Encode()
5513 req, err := http.NewRequest("PATCH", urls, body)
5514 if err != nil {
5515 return nil, err
5516 }
5517 req.Header = reqHeaders
5518 googleapi.Expand(req.URL, map[string]string{
5519 "name": c.name,
5520 })
5521 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5522 }
5523
5524
5525
5526
5527
5528
5529
5530 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesPatchCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
5531 gensupport.SetOptions(c.urlParams_, opts...)
5532 res, err := c.doRequest("json")
5533 if res != nil && res.StatusCode == http.StatusNotModified {
5534 if res.Body != nil {
5535 res.Body.Close()
5536 }
5537 return nil, gensupport.WrapError(&googleapi.Error{
5538 Code: res.StatusCode,
5539 Header: res.Header,
5540 })
5541 }
5542 if err != nil {
5543 return nil, err
5544 }
5545 defer googleapi.CloseBody(res)
5546 if err := googleapi.CheckResponse(res); err != nil {
5547 return nil, gensupport.WrapError(err)
5548 }
5549 ret := &GoogleLongrunningOperation{
5550 ServerResponse: googleapi.ServerResponse{
5551 Header: res.Header,
5552 HTTPStatusCode: res.StatusCode,
5553 },
5554 }
5555 target := &ret
5556 if err := gensupport.DecodeResponse(target, res); err != nil {
5557 return nil, err
5558 }
5559 return ret, nil
5560 }
5561
5562 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall struct {
5563 s *Service
5564 resource string
5565 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
5566 urlParams_ gensupport.URLParams
5567 ctx_ context.Context
5568 header_ http.Header
5569 }
5570
5571
5572
5573
5574
5575
5576
5577
5578 func (r *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall {
5579 c := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5580 c.resource = resource
5581 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
5582 return c
5583 }
5584
5585
5586
5587
5588 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall {
5589 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5590 return c
5591 }
5592
5593
5594 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall {
5595 c.ctx_ = ctx
5596 return c
5597 }
5598
5599
5600
5601 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall) Header() http.Header {
5602 if c.header_ == nil {
5603 c.header_ = make(http.Header)
5604 }
5605 return c.header_
5606 }
5607
5608 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
5609 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5610 var body io.Reader = nil
5611 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
5612 if err != nil {
5613 return nil, err
5614 }
5615 c.urlParams_.Set("alt", alt)
5616 c.urlParams_.Set("prettyPrint", "false")
5617 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
5618 urls += "?" + c.urlParams_.Encode()
5619 req, err := http.NewRequest("POST", urls, body)
5620 if err != nil {
5621 return nil, err
5622 }
5623 req.Header = reqHeaders
5624 googleapi.Expand(req.URL, map[string]string{
5625 "resource": c.resource,
5626 })
5627 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5628 }
5629
5630
5631
5632
5633
5634
5635
5636 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
5637 gensupport.SetOptions(c.urlParams_, opts...)
5638 res, err := c.doRequest("json")
5639 if res != nil && res.StatusCode == http.StatusNotModified {
5640 if res.Body != nil {
5641 res.Body.Close()
5642 }
5643 return nil, gensupport.WrapError(&googleapi.Error{
5644 Code: res.StatusCode,
5645 Header: res.Header,
5646 })
5647 }
5648 if err != nil {
5649 return nil, err
5650 }
5651 defer googleapi.CloseBody(res)
5652 if err := googleapi.CheckResponse(res); err != nil {
5653 return nil, gensupport.WrapError(err)
5654 }
5655 ret := &GoogleIamV1Policy{
5656 ServerResponse: googleapi.ServerResponse{
5657 Header: res.Header,
5658 HTTPStatusCode: res.StatusCode,
5659 },
5660 }
5661 target := &ret
5662 if err := gensupport.DecodeResponse(target, res); err != nil {
5663 return nil, err
5664 }
5665 return ret, nil
5666 }
5667
5668 type OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall struct {
5669 s *Service
5670 resource string
5671 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
5672 urlParams_ gensupport.URLParams
5673 ctx_ context.Context
5674 header_ http.Header
5675 }
5676
5677
5678
5679
5680
5681
5682
5683
5684
5685
5686
5687 func (r *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall {
5688 c := &OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5689 c.resource = resource
5690 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
5691 return c
5692 }
5693
5694
5695
5696
5697 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall {
5698 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5699 return c
5700 }
5701
5702
5703 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall {
5704 c.ctx_ = ctx
5705 return c
5706 }
5707
5708
5709
5710 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall) Header() http.Header {
5711 if c.header_ == nil {
5712 c.header_ = make(http.Header)
5713 }
5714 return c.header_
5715 }
5716
5717 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
5718 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5719 var body io.Reader = nil
5720 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
5721 if err != nil {
5722 return nil, err
5723 }
5724 c.urlParams_.Set("alt", alt)
5725 c.urlParams_.Set("prettyPrint", "false")
5726 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
5727 urls += "?" + c.urlParams_.Encode()
5728 req, err := http.NewRequest("POST", urls, body)
5729 if err != nil {
5730 return nil, err
5731 }
5732 req.Header = reqHeaders
5733 googleapi.Expand(req.URL, map[string]string{
5734 "resource": c.resource,
5735 })
5736 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5737 }
5738
5739
5740
5741
5742
5743
5744
5745 func (c *OrganizationsLocationsGlobalPartnerTenantsBrowserDlpRulesTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
5746 gensupport.SetOptions(c.urlParams_, opts...)
5747 res, err := c.doRequest("json")
5748 if res != nil && res.StatusCode == http.StatusNotModified {
5749 if res.Body != nil {
5750 res.Body.Close()
5751 }
5752 return nil, gensupport.WrapError(&googleapi.Error{
5753 Code: res.StatusCode,
5754 Header: res.Header,
5755 })
5756 }
5757 if err != nil {
5758 return nil, err
5759 }
5760 defer googleapi.CloseBody(res)
5761 if err := googleapi.CheckResponse(res); err != nil {
5762 return nil, gensupport.WrapError(err)
5763 }
5764 ret := &GoogleIamV1TestIamPermissionsResponse{
5765 ServerResponse: googleapi.ServerResponse{
5766 Header: res.Header,
5767 HTTPStatusCode: res.StatusCode,
5768 },
5769 }
5770 target := &ret
5771 if err := gensupport.DecodeResponse(target, res); err != nil {
5772 return nil, err
5773 }
5774 return ret, nil
5775 }
5776
5777 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall struct {
5778 s *Service
5779 parent string
5780 googlecloudbeyondcorppartnerservicesv1alphaproxyconfig *GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig
5781 urlParams_ gensupport.URLParams
5782 ctx_ context.Context
5783 header_ http.Header
5784 }
5785
5786
5787
5788
5789
5790
5791
5792
5793 func (r *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService) Create(parent string, googlecloudbeyondcorppartnerservicesv1alphaproxyconfig *GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall {
5794 c := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5795 c.parent = parent
5796 c.googlecloudbeyondcorppartnerservicesv1alphaproxyconfig = googlecloudbeyondcorppartnerservicesv1alphaproxyconfig
5797 return c
5798 }
5799
5800
5801
5802
5803
5804
5805
5806
5807
5808
5809
5810
5811 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall {
5812 c.urlParams_.Set("requestId", requestId)
5813 return c
5814 }
5815
5816
5817
5818
5819 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall {
5820 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5821 return c
5822 }
5823
5824
5825 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall {
5826 c.ctx_ = ctx
5827 return c
5828 }
5829
5830
5831
5832 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall) Header() http.Header {
5833 if c.header_ == nil {
5834 c.header_ = make(http.Header)
5835 }
5836 return c.header_
5837 }
5838
5839 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall) doRequest(alt string) (*http.Response, error) {
5840 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5841 var body io.Reader = nil
5842 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorppartnerservicesv1alphaproxyconfig)
5843 if err != nil {
5844 return nil, err
5845 }
5846 c.urlParams_.Set("alt", alt)
5847 c.urlParams_.Set("prettyPrint", "false")
5848 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/proxyConfigs")
5849 urls += "?" + c.urlParams_.Encode()
5850 req, err := http.NewRequest("POST", urls, body)
5851 if err != nil {
5852 return nil, err
5853 }
5854 req.Header = reqHeaders
5855 googleapi.Expand(req.URL, map[string]string{
5856 "parent": c.parent,
5857 })
5858 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5859 }
5860
5861
5862
5863
5864
5865
5866
5867 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
5868 gensupport.SetOptions(c.urlParams_, opts...)
5869 res, err := c.doRequest("json")
5870 if res != nil && res.StatusCode == http.StatusNotModified {
5871 if res.Body != nil {
5872 res.Body.Close()
5873 }
5874 return nil, gensupport.WrapError(&googleapi.Error{
5875 Code: res.StatusCode,
5876 Header: res.Header,
5877 })
5878 }
5879 if err != nil {
5880 return nil, err
5881 }
5882 defer googleapi.CloseBody(res)
5883 if err := googleapi.CheckResponse(res); err != nil {
5884 return nil, gensupport.WrapError(err)
5885 }
5886 ret := &GoogleLongrunningOperation{
5887 ServerResponse: googleapi.ServerResponse{
5888 Header: res.Header,
5889 HTTPStatusCode: res.StatusCode,
5890 },
5891 }
5892 target := &ret
5893 if err := gensupport.DecodeResponse(target, res); err != nil {
5894 return nil, err
5895 }
5896 return ret, nil
5897 }
5898
5899 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall struct {
5900 s *Service
5901 name string
5902 urlParams_ gensupport.URLParams
5903 ctx_ context.Context
5904 header_ http.Header
5905 }
5906
5907
5908
5909
5910 func (r *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService) Delete(name string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall {
5911 c := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5912 c.name = name
5913 return c
5914 }
5915
5916
5917
5918
5919
5920
5921
5922
5923
5924
5925
5926
5927 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall {
5928 c.urlParams_.Set("requestId", requestId)
5929 return c
5930 }
5931
5932
5933
5934
5935 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall {
5936 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5937 return c
5938 }
5939
5940
5941 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall {
5942 c.ctx_ = ctx
5943 return c
5944 }
5945
5946
5947
5948 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall) Header() http.Header {
5949 if c.header_ == nil {
5950 c.header_ = make(http.Header)
5951 }
5952 return c.header_
5953 }
5954
5955 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall) doRequest(alt string) (*http.Response, error) {
5956 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5957 var body io.Reader = nil
5958 c.urlParams_.Set("alt", alt)
5959 c.urlParams_.Set("prettyPrint", "false")
5960 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
5961 urls += "?" + c.urlParams_.Encode()
5962 req, err := http.NewRequest("DELETE", urls, body)
5963 if err != nil {
5964 return nil, err
5965 }
5966 req.Header = reqHeaders
5967 googleapi.Expand(req.URL, map[string]string{
5968 "name": c.name,
5969 })
5970 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5971 }
5972
5973
5974
5975
5976
5977
5978
5979 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
5980 gensupport.SetOptions(c.urlParams_, opts...)
5981 res, err := c.doRequest("json")
5982 if res != nil && res.StatusCode == http.StatusNotModified {
5983 if res.Body != nil {
5984 res.Body.Close()
5985 }
5986 return nil, gensupport.WrapError(&googleapi.Error{
5987 Code: res.StatusCode,
5988 Header: res.Header,
5989 })
5990 }
5991 if err != nil {
5992 return nil, err
5993 }
5994 defer googleapi.CloseBody(res)
5995 if err := googleapi.CheckResponse(res); err != nil {
5996 return nil, gensupport.WrapError(err)
5997 }
5998 ret := &GoogleLongrunningOperation{
5999 ServerResponse: googleapi.ServerResponse{
6000 Header: res.Header,
6001 HTTPStatusCode: res.StatusCode,
6002 },
6003 }
6004 target := &ret
6005 if err := gensupport.DecodeResponse(target, res); err != nil {
6006 return nil, err
6007 }
6008 return ret, nil
6009 }
6010
6011 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall struct {
6012 s *Service
6013 name string
6014 urlParams_ gensupport.URLParams
6015 ifNoneMatch_ string
6016 ctx_ context.Context
6017 header_ http.Header
6018 }
6019
6020
6021
6022
6023
6024
6025 func (r *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService) Get(name string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall {
6026 c := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6027 c.name = name
6028 return c
6029 }
6030
6031
6032
6033
6034 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall {
6035 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6036 return c
6037 }
6038
6039
6040
6041
6042 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall {
6043 c.ifNoneMatch_ = entityTag
6044 return c
6045 }
6046
6047
6048 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall {
6049 c.ctx_ = ctx
6050 return c
6051 }
6052
6053
6054
6055 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall) Header() http.Header {
6056 if c.header_ == nil {
6057 c.header_ = make(http.Header)
6058 }
6059 return c.header_
6060 }
6061
6062 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall) doRequest(alt string) (*http.Response, error) {
6063 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6064 if c.ifNoneMatch_ != "" {
6065 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6066 }
6067 var body io.Reader = nil
6068 c.urlParams_.Set("alt", alt)
6069 c.urlParams_.Set("prettyPrint", "false")
6070 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
6071 urls += "?" + c.urlParams_.Encode()
6072 req, err := http.NewRequest("GET", urls, body)
6073 if err != nil {
6074 return nil, err
6075 }
6076 req.Header = reqHeaders
6077 googleapi.Expand(req.URL, map[string]string{
6078 "name": c.name,
6079 })
6080 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6081 }
6082
6083
6084
6085
6086
6087
6088
6089
6090
6091 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig, error) {
6092 gensupport.SetOptions(c.urlParams_, opts...)
6093 res, err := c.doRequest("json")
6094 if res != nil && res.StatusCode == http.StatusNotModified {
6095 if res.Body != nil {
6096 res.Body.Close()
6097 }
6098 return nil, gensupport.WrapError(&googleapi.Error{
6099 Code: res.StatusCode,
6100 Header: res.Header,
6101 })
6102 }
6103 if err != nil {
6104 return nil, err
6105 }
6106 defer googleapi.CloseBody(res)
6107 if err := googleapi.CheckResponse(res); err != nil {
6108 return nil, gensupport.WrapError(err)
6109 }
6110 ret := &GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig{
6111 ServerResponse: googleapi.ServerResponse{
6112 Header: res.Header,
6113 HTTPStatusCode: res.StatusCode,
6114 },
6115 }
6116 target := &ret
6117 if err := gensupport.DecodeResponse(target, res); err != nil {
6118 return nil, err
6119 }
6120 return ret, nil
6121 }
6122
6123 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall struct {
6124 s *Service
6125 resource string
6126 urlParams_ gensupport.URLParams
6127 ifNoneMatch_ string
6128 ctx_ context.Context
6129 header_ http.Header
6130 }
6131
6132
6133
6134
6135
6136
6137
6138 func (r *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService) GetIamPolicy(resource string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall {
6139 c := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6140 c.resource = resource
6141 return c
6142 }
6143
6144
6145
6146
6147
6148
6149
6150
6151
6152
6153
6154
6155
6156 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall {
6157 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
6158 return c
6159 }
6160
6161
6162
6163
6164 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall {
6165 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6166 return c
6167 }
6168
6169
6170
6171
6172 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall {
6173 c.ifNoneMatch_ = entityTag
6174 return c
6175 }
6176
6177
6178 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall {
6179 c.ctx_ = ctx
6180 return c
6181 }
6182
6183
6184
6185 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall) Header() http.Header {
6186 if c.header_ == nil {
6187 c.header_ = make(http.Header)
6188 }
6189 return c.header_
6190 }
6191
6192 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
6193 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6194 if c.ifNoneMatch_ != "" {
6195 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6196 }
6197 var body io.Reader = nil
6198 c.urlParams_.Set("alt", alt)
6199 c.urlParams_.Set("prettyPrint", "false")
6200 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
6201 urls += "?" + c.urlParams_.Encode()
6202 req, err := http.NewRequest("GET", urls, body)
6203 if err != nil {
6204 return nil, err
6205 }
6206 req.Header = reqHeaders
6207 googleapi.Expand(req.URL, map[string]string{
6208 "resource": c.resource,
6209 })
6210 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6211 }
6212
6213
6214
6215
6216
6217
6218
6219 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
6220 gensupport.SetOptions(c.urlParams_, opts...)
6221 res, err := c.doRequest("json")
6222 if res != nil && res.StatusCode == http.StatusNotModified {
6223 if res.Body != nil {
6224 res.Body.Close()
6225 }
6226 return nil, gensupport.WrapError(&googleapi.Error{
6227 Code: res.StatusCode,
6228 Header: res.Header,
6229 })
6230 }
6231 if err != nil {
6232 return nil, err
6233 }
6234 defer googleapi.CloseBody(res)
6235 if err := googleapi.CheckResponse(res); err != nil {
6236 return nil, gensupport.WrapError(err)
6237 }
6238 ret := &GoogleIamV1Policy{
6239 ServerResponse: googleapi.ServerResponse{
6240 Header: res.Header,
6241 HTTPStatusCode: res.StatusCode,
6242 },
6243 }
6244 target := &ret
6245 if err := gensupport.DecodeResponse(target, res); err != nil {
6246 return nil, err
6247 }
6248 return ret, nil
6249 }
6250
6251 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall struct {
6252 s *Service
6253 parent string
6254 urlParams_ gensupport.URLParams
6255 ifNoneMatch_ string
6256 ctx_ context.Context
6257 header_ http.Header
6258 }
6259
6260
6261
6262
6263
6264
6265 func (r *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService) List(parent string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall {
6266 c := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6267 c.parent = parent
6268 return c
6269 }
6270
6271
6272
6273
6274
6275
6276
6277
6278
6279
6280
6281
6282 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) Filter(filter string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall {
6283 c.urlParams_.Set("filter", filter)
6284 return c
6285 }
6286
6287
6288
6289
6290
6291 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) OrderBy(orderBy string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall {
6292 c.urlParams_.Set("orderBy", orderBy)
6293 return c
6294 }
6295
6296
6297
6298
6299
6300
6301 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) PageSize(pageSize int64) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall {
6302 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6303 return c
6304 }
6305
6306
6307
6308 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) PageToken(pageToken string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall {
6309 c.urlParams_.Set("pageToken", pageToken)
6310 return c
6311 }
6312
6313
6314
6315
6316 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall {
6317 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6318 return c
6319 }
6320
6321
6322
6323
6324 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall {
6325 c.ifNoneMatch_ = entityTag
6326 return c
6327 }
6328
6329
6330 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall {
6331 c.ctx_ = ctx
6332 return c
6333 }
6334
6335
6336
6337 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) Header() http.Header {
6338 if c.header_ == nil {
6339 c.header_ = make(http.Header)
6340 }
6341 return c.header_
6342 }
6343
6344 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) doRequest(alt string) (*http.Response, error) {
6345 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6346 if c.ifNoneMatch_ != "" {
6347 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6348 }
6349 var body io.Reader = nil
6350 c.urlParams_.Set("alt", alt)
6351 c.urlParams_.Set("prettyPrint", "false")
6352 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/proxyConfigs")
6353 urls += "?" + c.urlParams_.Encode()
6354 req, err := http.NewRequest("GET", urls, body)
6355 if err != nil {
6356 return nil, err
6357 }
6358 req.Header = reqHeaders
6359 googleapi.Expand(req.URL, map[string]string{
6360 "parent": c.parent,
6361 })
6362 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6363 }
6364
6365
6366
6367
6368
6369
6370
6371 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpPartnerservicesV1alphaListProxyConfigsResponse, 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 := &GoogleCloudBeyondcorpPartnerservicesV1alphaListProxyConfigsResponse{
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
6404
6405
6406 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsListCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpPartnerservicesV1alphaListProxyConfigsResponse) error) error {
6407 c.ctx_ = ctx
6408 defer c.PageToken(c.urlParams_.Get("pageToken"))
6409 for {
6410 x, err := c.Do()
6411 if err != nil {
6412 return err
6413 }
6414 if err := f(x); err != nil {
6415 return err
6416 }
6417 if x.NextPageToken == "" {
6418 return nil
6419 }
6420 c.PageToken(x.NextPageToken)
6421 }
6422 }
6423
6424 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall struct {
6425 s *Service
6426 name string
6427 googlecloudbeyondcorppartnerservicesv1alphaproxyconfig *GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig
6428 urlParams_ gensupport.URLParams
6429 ctx_ context.Context
6430 header_ http.Header
6431 }
6432
6433
6434
6435
6436 func (r *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService) Patch(name string, googlecloudbeyondcorppartnerservicesv1alphaproxyconfig *GoogleCloudBeyondcorpPartnerservicesV1alphaProxyConfig) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall {
6437 c := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6438 c.name = name
6439 c.googlecloudbeyondcorppartnerservicesv1alphaproxyconfig = googlecloudbeyondcorppartnerservicesv1alphaproxyconfig
6440 return c
6441 }
6442
6443
6444
6445
6446
6447
6448
6449
6450
6451
6452
6453
6454 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall) RequestId(requestId string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall {
6455 c.urlParams_.Set("requestId", requestId)
6456 return c
6457 }
6458
6459
6460
6461
6462 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall) UpdateMask(updateMask string) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall {
6463 c.urlParams_.Set("updateMask", updateMask)
6464 return c
6465 }
6466
6467
6468
6469
6470 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall {
6471 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6472 return c
6473 }
6474
6475
6476 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall {
6477 c.ctx_ = ctx
6478 return c
6479 }
6480
6481
6482
6483 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall) Header() http.Header {
6484 if c.header_ == nil {
6485 c.header_ = make(http.Header)
6486 }
6487 return c.header_
6488 }
6489
6490 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall) doRequest(alt string) (*http.Response, error) {
6491 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6492 var body io.Reader = nil
6493 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorppartnerservicesv1alphaproxyconfig)
6494 if err != nil {
6495 return nil, err
6496 }
6497 c.urlParams_.Set("alt", alt)
6498 c.urlParams_.Set("prettyPrint", "false")
6499 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
6500 urls += "?" + c.urlParams_.Encode()
6501 req, err := http.NewRequest("PATCH", urls, body)
6502 if err != nil {
6503 return nil, err
6504 }
6505 req.Header = reqHeaders
6506 googleapi.Expand(req.URL, map[string]string{
6507 "name": c.name,
6508 })
6509 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6510 }
6511
6512
6513
6514
6515
6516
6517
6518 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
6519 gensupport.SetOptions(c.urlParams_, opts...)
6520 res, err := c.doRequest("json")
6521 if res != nil && res.StatusCode == http.StatusNotModified {
6522 if res.Body != nil {
6523 res.Body.Close()
6524 }
6525 return nil, gensupport.WrapError(&googleapi.Error{
6526 Code: res.StatusCode,
6527 Header: res.Header,
6528 })
6529 }
6530 if err != nil {
6531 return nil, err
6532 }
6533 defer googleapi.CloseBody(res)
6534 if err := googleapi.CheckResponse(res); err != nil {
6535 return nil, gensupport.WrapError(err)
6536 }
6537 ret := &GoogleLongrunningOperation{
6538 ServerResponse: googleapi.ServerResponse{
6539 Header: res.Header,
6540 HTTPStatusCode: res.StatusCode,
6541 },
6542 }
6543 target := &ret
6544 if err := gensupport.DecodeResponse(target, res); err != nil {
6545 return nil, err
6546 }
6547 return ret, nil
6548 }
6549
6550 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall struct {
6551 s *Service
6552 resource string
6553 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
6554 urlParams_ gensupport.URLParams
6555 ctx_ context.Context
6556 header_ http.Header
6557 }
6558
6559
6560
6561
6562
6563
6564
6565
6566 func (r *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall {
6567 c := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6568 c.resource = resource
6569 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
6570 return c
6571 }
6572
6573
6574
6575
6576 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall {
6577 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6578 return c
6579 }
6580
6581
6582 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall {
6583 c.ctx_ = ctx
6584 return c
6585 }
6586
6587
6588
6589 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall) Header() http.Header {
6590 if c.header_ == nil {
6591 c.header_ = make(http.Header)
6592 }
6593 return c.header_
6594 }
6595
6596 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
6597 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6598 var body io.Reader = nil
6599 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
6600 if err != nil {
6601 return nil, err
6602 }
6603 c.urlParams_.Set("alt", alt)
6604 c.urlParams_.Set("prettyPrint", "false")
6605 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
6606 urls += "?" + c.urlParams_.Encode()
6607 req, err := http.NewRequest("POST", urls, body)
6608 if err != nil {
6609 return nil, err
6610 }
6611 req.Header = reqHeaders
6612 googleapi.Expand(req.URL, map[string]string{
6613 "resource": c.resource,
6614 })
6615 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6616 }
6617
6618
6619
6620
6621
6622
6623
6624 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
6625 gensupport.SetOptions(c.urlParams_, opts...)
6626 res, err := c.doRequest("json")
6627 if res != nil && res.StatusCode == http.StatusNotModified {
6628 if res.Body != nil {
6629 res.Body.Close()
6630 }
6631 return nil, gensupport.WrapError(&googleapi.Error{
6632 Code: res.StatusCode,
6633 Header: res.Header,
6634 })
6635 }
6636 if err != nil {
6637 return nil, err
6638 }
6639 defer googleapi.CloseBody(res)
6640 if err := googleapi.CheckResponse(res); err != nil {
6641 return nil, gensupport.WrapError(err)
6642 }
6643 ret := &GoogleIamV1Policy{
6644 ServerResponse: googleapi.ServerResponse{
6645 Header: res.Header,
6646 HTTPStatusCode: res.StatusCode,
6647 },
6648 }
6649 target := &ret
6650 if err := gensupport.DecodeResponse(target, res); err != nil {
6651 return nil, err
6652 }
6653 return ret, nil
6654 }
6655
6656 type OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall struct {
6657 s *Service
6658 resource string
6659 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
6660 urlParams_ gensupport.URLParams
6661 ctx_ context.Context
6662 header_ http.Header
6663 }
6664
6665
6666
6667
6668
6669
6670
6671
6672
6673
6674
6675 func (r *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall {
6676 c := &OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6677 c.resource = resource
6678 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
6679 return c
6680 }
6681
6682
6683
6684
6685 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall) Fields(s ...googleapi.Field) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall {
6686 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6687 return c
6688 }
6689
6690
6691 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall) Context(ctx context.Context) *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall {
6692 c.ctx_ = ctx
6693 return c
6694 }
6695
6696
6697
6698 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall) Header() http.Header {
6699 if c.header_ == nil {
6700 c.header_ = make(http.Header)
6701 }
6702 return c.header_
6703 }
6704
6705 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
6706 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6707 var body io.Reader = nil
6708 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
6709 if err != nil {
6710 return nil, err
6711 }
6712 c.urlParams_.Set("alt", alt)
6713 c.urlParams_.Set("prettyPrint", "false")
6714 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
6715 urls += "?" + c.urlParams_.Encode()
6716 req, err := http.NewRequest("POST", urls, body)
6717 if err != nil {
6718 return nil, err
6719 }
6720 req.Header = reqHeaders
6721 googleapi.Expand(req.URL, map[string]string{
6722 "resource": c.resource,
6723 })
6724 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6725 }
6726
6727
6728
6729
6730
6731
6732
6733 func (c *OrganizationsLocationsGlobalPartnerTenantsProxyConfigsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
6734 gensupport.SetOptions(c.urlParams_, opts...)
6735 res, err := c.doRequest("json")
6736 if res != nil && res.StatusCode == http.StatusNotModified {
6737 if res.Body != nil {
6738 res.Body.Close()
6739 }
6740 return nil, gensupport.WrapError(&googleapi.Error{
6741 Code: res.StatusCode,
6742 Header: res.Header,
6743 })
6744 }
6745 if err != nil {
6746 return nil, err
6747 }
6748 defer googleapi.CloseBody(res)
6749 if err := googleapi.CheckResponse(res); err != nil {
6750 return nil, gensupport.WrapError(err)
6751 }
6752 ret := &GoogleIamV1TestIamPermissionsResponse{
6753 ServerResponse: googleapi.ServerResponse{
6754 Header: res.Header,
6755 HTTPStatusCode: res.StatusCode,
6756 },
6757 }
6758 target := &ret
6759 if err := gensupport.DecodeResponse(target, res); err != nil {
6760 return nil, err
6761 }
6762 return ret, nil
6763 }
6764
6765 type OrganizationsLocationsInsightsConfiguredInsightCall struct {
6766 s *Service
6767 insight string
6768 urlParams_ gensupport.URLParams
6769 ifNoneMatch_ string
6770 ctx_ context.Context
6771 header_ http.Header
6772 }
6773
6774
6775
6776
6777
6778
6779
6780
6781
6782
6783 func (r *OrganizationsLocationsInsightsService) ConfiguredInsight(insight string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6784 c := &OrganizationsLocationsInsightsConfiguredInsightCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6785 c.insight = insight
6786 return c
6787 }
6788
6789
6790
6791
6792
6793
6794
6795
6796
6797
6798
6799
6800
6801
6802
6803 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) Aggregation(aggregation string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6804 c.urlParams_.Set("aggregation", aggregation)
6805 return c
6806 }
6807
6808
6809
6810
6811
6812
6813
6814
6815
6816
6817
6818 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) CustomGroupingFieldFilter(customGroupingFieldFilter string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6819 c.urlParams_.Set("customGrouping.fieldFilter", customGroupingFieldFilter)
6820 return c
6821 }
6822
6823
6824
6825
6826
6827 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) CustomGroupingGroupFields(customGroupingGroupFields ...string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6828 c.urlParams_.SetMulti("customGrouping.groupFields", append([]string{}, customGroupingGroupFields...))
6829 return c
6830 }
6831
6832
6833
6834 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) EndTime(endTime string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6835 c.urlParams_.Set("endTime", endTime)
6836 return c
6837 }
6838
6839
6840
6841
6842
6843
6844
6845
6846
6847
6848 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) FieldFilter(fieldFilter string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6849 c.urlParams_.Set("fieldFilter", fieldFilter)
6850 return c
6851 }
6852
6853
6854
6855
6856 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) Group(group string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6857 c.urlParams_.Set("group", group)
6858 return c
6859 }
6860
6861
6862
6863
6864 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) PageSize(pageSize int64) *OrganizationsLocationsInsightsConfiguredInsightCall {
6865 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6866 return c
6867 }
6868
6869
6870
6871 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) PageToken(pageToken string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6872 c.urlParams_.Set("pageToken", pageToken)
6873 return c
6874 }
6875
6876
6877
6878 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) StartTime(startTime string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6879 c.urlParams_.Set("startTime", startTime)
6880 return c
6881 }
6882
6883
6884
6885
6886 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) Fields(s ...googleapi.Field) *OrganizationsLocationsInsightsConfiguredInsightCall {
6887 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6888 return c
6889 }
6890
6891
6892
6893
6894 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) IfNoneMatch(entityTag string) *OrganizationsLocationsInsightsConfiguredInsightCall {
6895 c.ifNoneMatch_ = entityTag
6896 return c
6897 }
6898
6899
6900 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) Context(ctx context.Context) *OrganizationsLocationsInsightsConfiguredInsightCall {
6901 c.ctx_ = ctx
6902 return c
6903 }
6904
6905
6906
6907 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) Header() http.Header {
6908 if c.header_ == nil {
6909 c.header_ = make(http.Header)
6910 }
6911 return c.header_
6912 }
6913
6914 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) doRequest(alt string) (*http.Response, error) {
6915 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6916 if c.ifNoneMatch_ != "" {
6917 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6918 }
6919 var body io.Reader = nil
6920 c.urlParams_.Set("alt", alt)
6921 c.urlParams_.Set("prettyPrint", "false")
6922 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+insight}:configuredInsight")
6923 urls += "?" + c.urlParams_.Encode()
6924 req, err := http.NewRequest("GET", urls, body)
6925 if err != nil {
6926 return nil, err
6927 }
6928 req.Header = reqHeaders
6929 googleapi.Expand(req.URL, map[string]string{
6930 "insight": c.insight,
6931 })
6932 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6933 }
6934
6935
6936
6937
6938
6939
6940
6941 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse, error) {
6942 gensupport.SetOptions(c.urlParams_, opts...)
6943 res, err := c.doRequest("json")
6944 if res != nil && res.StatusCode == http.StatusNotModified {
6945 if res.Body != nil {
6946 res.Body.Close()
6947 }
6948 return nil, gensupport.WrapError(&googleapi.Error{
6949 Code: res.StatusCode,
6950 Header: res.Header,
6951 })
6952 }
6953 if err != nil {
6954 return nil, err
6955 }
6956 defer googleapi.CloseBody(res)
6957 if err := googleapi.CheckResponse(res); err != nil {
6958 return nil, gensupport.WrapError(err)
6959 }
6960 ret := &GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse{
6961 ServerResponse: googleapi.ServerResponse{
6962 Header: res.Header,
6963 HTTPStatusCode: res.StatusCode,
6964 },
6965 }
6966 target := &ret
6967 if err := gensupport.DecodeResponse(target, res); err != nil {
6968 return nil, err
6969 }
6970 return ret, nil
6971 }
6972
6973
6974
6975
6976 func (c *OrganizationsLocationsInsightsConfiguredInsightCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse) error) error {
6977 c.ctx_ = ctx
6978 defer c.PageToken(c.urlParams_.Get("pageToken"))
6979 for {
6980 x, err := c.Do()
6981 if err != nil {
6982 return err
6983 }
6984 if err := f(x); err != nil {
6985 return err
6986 }
6987 if x.NextPageToken == "" {
6988 return nil
6989 }
6990 c.PageToken(x.NextPageToken)
6991 }
6992 }
6993
6994 type OrganizationsLocationsInsightsGetCall struct {
6995 s *Service
6996 name string
6997 urlParams_ gensupport.URLParams
6998 ifNoneMatch_ string
6999 ctx_ context.Context
7000 header_ http.Header
7001 }
7002
7003
7004
7005
7006
7007
7008
7009
7010
7011
7012
7013
7014
7015 func (r *OrganizationsLocationsInsightsService) Get(name string) *OrganizationsLocationsInsightsGetCall {
7016 c := &OrganizationsLocationsInsightsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7017 c.name = name
7018 return c
7019 }
7020
7021
7022
7023
7024
7025
7026
7027
7028
7029
7030
7031
7032
7033
7034
7035 func (c *OrganizationsLocationsInsightsGetCall) View(view string) *OrganizationsLocationsInsightsGetCall {
7036 c.urlParams_.Set("view", view)
7037 return c
7038 }
7039
7040
7041
7042
7043 func (c *OrganizationsLocationsInsightsGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsInsightsGetCall {
7044 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7045 return c
7046 }
7047
7048
7049
7050
7051 func (c *OrganizationsLocationsInsightsGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsInsightsGetCall {
7052 c.ifNoneMatch_ = entityTag
7053 return c
7054 }
7055
7056
7057 func (c *OrganizationsLocationsInsightsGetCall) Context(ctx context.Context) *OrganizationsLocationsInsightsGetCall {
7058 c.ctx_ = ctx
7059 return c
7060 }
7061
7062
7063
7064 func (c *OrganizationsLocationsInsightsGetCall) Header() http.Header {
7065 if c.header_ == nil {
7066 c.header_ = make(http.Header)
7067 }
7068 return c.header_
7069 }
7070
7071 func (c *OrganizationsLocationsInsightsGetCall) doRequest(alt string) (*http.Response, error) {
7072 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7073 if c.ifNoneMatch_ != "" {
7074 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7075 }
7076 var body io.Reader = nil
7077 c.urlParams_.Set("alt", alt)
7078 c.urlParams_.Set("prettyPrint", "false")
7079 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
7080 urls += "?" + c.urlParams_.Encode()
7081 req, err := http.NewRequest("GET", urls, body)
7082 if err != nil {
7083 return nil, err
7084 }
7085 req.Header = reqHeaders
7086 googleapi.Expand(req.URL, map[string]string{
7087 "name": c.name,
7088 })
7089 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7090 }
7091
7092
7093
7094
7095
7096
7097
7098 func (c *OrganizationsLocationsInsightsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsight, error) {
7099 gensupport.SetOptions(c.urlParams_, opts...)
7100 res, err := c.doRequest("json")
7101 if res != nil && res.StatusCode == http.StatusNotModified {
7102 if res.Body != nil {
7103 res.Body.Close()
7104 }
7105 return nil, gensupport.WrapError(&googleapi.Error{
7106 Code: res.StatusCode,
7107 Header: res.Header,
7108 })
7109 }
7110 if err != nil {
7111 return nil, err
7112 }
7113 defer googleapi.CloseBody(res)
7114 if err := googleapi.CheckResponse(res); err != nil {
7115 return nil, gensupport.WrapError(err)
7116 }
7117 ret := &GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsight{
7118 ServerResponse: googleapi.ServerResponse{
7119 Header: res.Header,
7120 HTTPStatusCode: res.StatusCode,
7121 },
7122 }
7123 target := &ret
7124 if err := gensupport.DecodeResponse(target, res); err != nil {
7125 return nil, err
7126 }
7127 return ret, nil
7128 }
7129
7130 type OrganizationsLocationsInsightsListCall struct {
7131 s *Service
7132 parent string
7133 urlParams_ gensupport.URLParams
7134 ifNoneMatch_ string
7135 ctx_ context.Context
7136 header_ http.Header
7137 }
7138
7139
7140
7141
7142
7143
7144
7145
7146 func (r *OrganizationsLocationsInsightsService) List(parent string) *OrganizationsLocationsInsightsListCall {
7147 c := &OrganizationsLocationsInsightsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7148 c.parent = parent
7149 return c
7150 }
7151
7152
7153
7154
7155
7156
7157
7158
7159
7160
7161
7162
7163 func (c *OrganizationsLocationsInsightsListCall) Filter(filter string) *OrganizationsLocationsInsightsListCall {
7164 c.urlParams_.Set("filter", filter)
7165 return c
7166 }
7167
7168
7169
7170 func (c *OrganizationsLocationsInsightsListCall) OrderBy(orderBy string) *OrganizationsLocationsInsightsListCall {
7171 c.urlParams_.Set("orderBy", orderBy)
7172 return c
7173 }
7174
7175
7176
7177
7178 func (c *OrganizationsLocationsInsightsListCall) PageSize(pageSize int64) *OrganizationsLocationsInsightsListCall {
7179 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
7180 return c
7181 }
7182
7183
7184
7185 func (c *OrganizationsLocationsInsightsListCall) PageToken(pageToken string) *OrganizationsLocationsInsightsListCall {
7186 c.urlParams_.Set("pageToken", pageToken)
7187 return c
7188 }
7189
7190
7191
7192
7193
7194
7195
7196
7197
7198
7199
7200
7201
7202
7203
7204 func (c *OrganizationsLocationsInsightsListCall) View(view string) *OrganizationsLocationsInsightsListCall {
7205 c.urlParams_.Set("view", view)
7206 return c
7207 }
7208
7209
7210
7211
7212 func (c *OrganizationsLocationsInsightsListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsInsightsListCall {
7213 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7214 return c
7215 }
7216
7217
7218
7219
7220 func (c *OrganizationsLocationsInsightsListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsInsightsListCall {
7221 c.ifNoneMatch_ = entityTag
7222 return c
7223 }
7224
7225
7226 func (c *OrganizationsLocationsInsightsListCall) Context(ctx context.Context) *OrganizationsLocationsInsightsListCall {
7227 c.ctx_ = ctx
7228 return c
7229 }
7230
7231
7232
7233 func (c *OrganizationsLocationsInsightsListCall) Header() http.Header {
7234 if c.header_ == nil {
7235 c.header_ = make(http.Header)
7236 }
7237 return c.header_
7238 }
7239
7240 func (c *OrganizationsLocationsInsightsListCall) doRequest(alt string) (*http.Response, error) {
7241 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7242 if c.ifNoneMatch_ != "" {
7243 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7244 }
7245 var body io.Reader = nil
7246 c.urlParams_.Set("alt", alt)
7247 c.urlParams_.Set("prettyPrint", "false")
7248 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/insights")
7249 urls += "?" + c.urlParams_.Encode()
7250 req, err := http.NewRequest("GET", urls, body)
7251 if err != nil {
7252 return nil, err
7253 }
7254 req.Header = reqHeaders
7255 googleapi.Expand(req.URL, map[string]string{
7256 "parent": c.parent,
7257 })
7258 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7259 }
7260
7261
7262
7263
7264
7265
7266
7267 func (c *OrganizationsLocationsInsightsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse, error) {
7268 gensupport.SetOptions(c.urlParams_, opts...)
7269 res, err := c.doRequest("json")
7270 if res != nil && res.StatusCode == http.StatusNotModified {
7271 if res.Body != nil {
7272 res.Body.Close()
7273 }
7274 return nil, gensupport.WrapError(&googleapi.Error{
7275 Code: res.StatusCode,
7276 Header: res.Header,
7277 })
7278 }
7279 if err != nil {
7280 return nil, err
7281 }
7282 defer googleapi.CloseBody(res)
7283 if err := googleapi.CheckResponse(res); err != nil {
7284 return nil, gensupport.WrapError(err)
7285 }
7286 ret := &GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse{
7287 ServerResponse: googleapi.ServerResponse{
7288 Header: res.Header,
7289 HTTPStatusCode: res.StatusCode,
7290 },
7291 }
7292 target := &ret
7293 if err := gensupport.DecodeResponse(target, res); err != nil {
7294 return nil, err
7295 }
7296 return ret, nil
7297 }
7298
7299
7300
7301
7302 func (c *OrganizationsLocationsInsightsListCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse) error) error {
7303 c.ctx_ = ctx
7304 defer c.PageToken(c.urlParams_.Get("pageToken"))
7305 for {
7306 x, err := c.Do()
7307 if err != nil {
7308 return err
7309 }
7310 if err := f(x); err != nil {
7311 return err
7312 }
7313 if x.NextPageToken == "" {
7314 return nil
7315 }
7316 c.PageToken(x.NextPageToken)
7317 }
7318 }
7319
7320 type OrganizationsLocationsOperationsCancelCall struct {
7321 s *Service
7322 name string
7323 googlelongrunningcanceloperationrequest *GoogleLongrunningCancelOperationRequest
7324 urlParams_ gensupport.URLParams
7325 ctx_ context.Context
7326 header_ http.Header
7327 }
7328
7329
7330
7331
7332
7333
7334
7335
7336
7337
7338
7339
7340 func (r *OrganizationsLocationsOperationsService) Cancel(name string, googlelongrunningcanceloperationrequest *GoogleLongrunningCancelOperationRequest) *OrganizationsLocationsOperationsCancelCall {
7341 c := &OrganizationsLocationsOperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7342 c.name = name
7343 c.googlelongrunningcanceloperationrequest = googlelongrunningcanceloperationrequest
7344 return c
7345 }
7346
7347
7348
7349
7350 func (c *OrganizationsLocationsOperationsCancelCall) Fields(s ...googleapi.Field) *OrganizationsLocationsOperationsCancelCall {
7351 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7352 return c
7353 }
7354
7355
7356 func (c *OrganizationsLocationsOperationsCancelCall) Context(ctx context.Context) *OrganizationsLocationsOperationsCancelCall {
7357 c.ctx_ = ctx
7358 return c
7359 }
7360
7361
7362
7363 func (c *OrganizationsLocationsOperationsCancelCall) Header() http.Header {
7364 if c.header_ == nil {
7365 c.header_ = make(http.Header)
7366 }
7367 return c.header_
7368 }
7369
7370 func (c *OrganizationsLocationsOperationsCancelCall) doRequest(alt string) (*http.Response, error) {
7371 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7372 var body io.Reader = nil
7373 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlelongrunningcanceloperationrequest)
7374 if err != nil {
7375 return nil, err
7376 }
7377 c.urlParams_.Set("alt", alt)
7378 c.urlParams_.Set("prettyPrint", "false")
7379 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}:cancel")
7380 urls += "?" + c.urlParams_.Encode()
7381 req, err := http.NewRequest("POST", urls, body)
7382 if err != nil {
7383 return nil, err
7384 }
7385 req.Header = reqHeaders
7386 googleapi.Expand(req.URL, map[string]string{
7387 "name": c.name,
7388 })
7389 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7390 }
7391
7392
7393
7394
7395
7396
7397 func (c *OrganizationsLocationsOperationsCancelCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
7398 gensupport.SetOptions(c.urlParams_, opts...)
7399 res, err := c.doRequest("json")
7400 if res != nil && res.StatusCode == http.StatusNotModified {
7401 if res.Body != nil {
7402 res.Body.Close()
7403 }
7404 return nil, gensupport.WrapError(&googleapi.Error{
7405 Code: res.StatusCode,
7406 Header: res.Header,
7407 })
7408 }
7409 if err != nil {
7410 return nil, err
7411 }
7412 defer googleapi.CloseBody(res)
7413 if err := googleapi.CheckResponse(res); err != nil {
7414 return nil, gensupport.WrapError(err)
7415 }
7416 ret := &Empty{
7417 ServerResponse: googleapi.ServerResponse{
7418 Header: res.Header,
7419 HTTPStatusCode: res.StatusCode,
7420 },
7421 }
7422 target := &ret
7423 if err := gensupport.DecodeResponse(target, res); err != nil {
7424 return nil, err
7425 }
7426 return ret, nil
7427 }
7428
7429 type OrganizationsLocationsOperationsDeleteCall struct {
7430 s *Service
7431 name string
7432 urlParams_ gensupport.URLParams
7433 ctx_ context.Context
7434 header_ http.Header
7435 }
7436
7437
7438
7439
7440
7441
7442
7443 func (r *OrganizationsLocationsOperationsService) Delete(name string) *OrganizationsLocationsOperationsDeleteCall {
7444 c := &OrganizationsLocationsOperationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7445 c.name = name
7446 return c
7447 }
7448
7449
7450
7451
7452 func (c *OrganizationsLocationsOperationsDeleteCall) Fields(s ...googleapi.Field) *OrganizationsLocationsOperationsDeleteCall {
7453 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7454 return c
7455 }
7456
7457
7458 func (c *OrganizationsLocationsOperationsDeleteCall) Context(ctx context.Context) *OrganizationsLocationsOperationsDeleteCall {
7459 c.ctx_ = ctx
7460 return c
7461 }
7462
7463
7464
7465 func (c *OrganizationsLocationsOperationsDeleteCall) Header() http.Header {
7466 if c.header_ == nil {
7467 c.header_ = make(http.Header)
7468 }
7469 return c.header_
7470 }
7471
7472 func (c *OrganizationsLocationsOperationsDeleteCall) doRequest(alt string) (*http.Response, error) {
7473 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7474 var body io.Reader = nil
7475 c.urlParams_.Set("alt", alt)
7476 c.urlParams_.Set("prettyPrint", "false")
7477 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
7478 urls += "?" + c.urlParams_.Encode()
7479 req, err := http.NewRequest("DELETE", urls, body)
7480 if err != nil {
7481 return nil, err
7482 }
7483 req.Header = reqHeaders
7484 googleapi.Expand(req.URL, map[string]string{
7485 "name": c.name,
7486 })
7487 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7488 }
7489
7490
7491
7492
7493
7494
7495 func (c *OrganizationsLocationsOperationsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
7496 gensupport.SetOptions(c.urlParams_, opts...)
7497 res, err := c.doRequest("json")
7498 if res != nil && res.StatusCode == http.StatusNotModified {
7499 if res.Body != nil {
7500 res.Body.Close()
7501 }
7502 return nil, gensupport.WrapError(&googleapi.Error{
7503 Code: res.StatusCode,
7504 Header: res.Header,
7505 })
7506 }
7507 if err != nil {
7508 return nil, err
7509 }
7510 defer googleapi.CloseBody(res)
7511 if err := googleapi.CheckResponse(res); err != nil {
7512 return nil, gensupport.WrapError(err)
7513 }
7514 ret := &Empty{
7515 ServerResponse: googleapi.ServerResponse{
7516 Header: res.Header,
7517 HTTPStatusCode: res.StatusCode,
7518 },
7519 }
7520 target := &ret
7521 if err := gensupport.DecodeResponse(target, res); err != nil {
7522 return nil, err
7523 }
7524 return ret, nil
7525 }
7526
7527 type OrganizationsLocationsOperationsGetCall struct {
7528 s *Service
7529 name string
7530 urlParams_ gensupport.URLParams
7531 ifNoneMatch_ string
7532 ctx_ context.Context
7533 header_ http.Header
7534 }
7535
7536
7537
7538
7539
7540
7541 func (r *OrganizationsLocationsOperationsService) Get(name string) *OrganizationsLocationsOperationsGetCall {
7542 c := &OrganizationsLocationsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7543 c.name = name
7544 return c
7545 }
7546
7547
7548
7549
7550 func (c *OrganizationsLocationsOperationsGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsOperationsGetCall {
7551 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7552 return c
7553 }
7554
7555
7556
7557
7558 func (c *OrganizationsLocationsOperationsGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsOperationsGetCall {
7559 c.ifNoneMatch_ = entityTag
7560 return c
7561 }
7562
7563
7564 func (c *OrganizationsLocationsOperationsGetCall) Context(ctx context.Context) *OrganizationsLocationsOperationsGetCall {
7565 c.ctx_ = ctx
7566 return c
7567 }
7568
7569
7570
7571 func (c *OrganizationsLocationsOperationsGetCall) Header() http.Header {
7572 if c.header_ == nil {
7573 c.header_ = make(http.Header)
7574 }
7575 return c.header_
7576 }
7577
7578 func (c *OrganizationsLocationsOperationsGetCall) doRequest(alt string) (*http.Response, error) {
7579 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7580 if c.ifNoneMatch_ != "" {
7581 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7582 }
7583 var body io.Reader = nil
7584 c.urlParams_.Set("alt", alt)
7585 c.urlParams_.Set("prettyPrint", "false")
7586 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
7587 urls += "?" + c.urlParams_.Encode()
7588 req, err := http.NewRequest("GET", urls, body)
7589 if err != nil {
7590 return nil, err
7591 }
7592 req.Header = reqHeaders
7593 googleapi.Expand(req.URL, map[string]string{
7594 "name": c.name,
7595 })
7596 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7597 }
7598
7599
7600
7601
7602
7603
7604
7605 func (c *OrganizationsLocationsOperationsGetCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
7606 gensupport.SetOptions(c.urlParams_, opts...)
7607 res, err := c.doRequest("json")
7608 if res != nil && res.StatusCode == http.StatusNotModified {
7609 if res.Body != nil {
7610 res.Body.Close()
7611 }
7612 return nil, gensupport.WrapError(&googleapi.Error{
7613 Code: res.StatusCode,
7614 Header: res.Header,
7615 })
7616 }
7617 if err != nil {
7618 return nil, err
7619 }
7620 defer googleapi.CloseBody(res)
7621 if err := googleapi.CheckResponse(res); err != nil {
7622 return nil, gensupport.WrapError(err)
7623 }
7624 ret := &GoogleLongrunningOperation{
7625 ServerResponse: googleapi.ServerResponse{
7626 Header: res.Header,
7627 HTTPStatusCode: res.StatusCode,
7628 },
7629 }
7630 target := &ret
7631 if err := gensupport.DecodeResponse(target, res); err != nil {
7632 return nil, err
7633 }
7634 return ret, nil
7635 }
7636
7637 type OrganizationsLocationsOperationsListCall struct {
7638 s *Service
7639 name string
7640 urlParams_ gensupport.URLParams
7641 ifNoneMatch_ string
7642 ctx_ context.Context
7643 header_ http.Header
7644 }
7645
7646
7647
7648
7649
7650 func (r *OrganizationsLocationsOperationsService) List(name string) *OrganizationsLocationsOperationsListCall {
7651 c := &OrganizationsLocationsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7652 c.name = name
7653 return c
7654 }
7655
7656
7657 func (c *OrganizationsLocationsOperationsListCall) Filter(filter string) *OrganizationsLocationsOperationsListCall {
7658 c.urlParams_.Set("filter", filter)
7659 return c
7660 }
7661
7662
7663
7664 func (c *OrganizationsLocationsOperationsListCall) PageSize(pageSize int64) *OrganizationsLocationsOperationsListCall {
7665 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
7666 return c
7667 }
7668
7669
7670
7671 func (c *OrganizationsLocationsOperationsListCall) PageToken(pageToken string) *OrganizationsLocationsOperationsListCall {
7672 c.urlParams_.Set("pageToken", pageToken)
7673 return c
7674 }
7675
7676
7677
7678
7679 func (c *OrganizationsLocationsOperationsListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsOperationsListCall {
7680 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7681 return c
7682 }
7683
7684
7685
7686
7687 func (c *OrganizationsLocationsOperationsListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsOperationsListCall {
7688 c.ifNoneMatch_ = entityTag
7689 return c
7690 }
7691
7692
7693 func (c *OrganizationsLocationsOperationsListCall) Context(ctx context.Context) *OrganizationsLocationsOperationsListCall {
7694 c.ctx_ = ctx
7695 return c
7696 }
7697
7698
7699
7700 func (c *OrganizationsLocationsOperationsListCall) Header() http.Header {
7701 if c.header_ == nil {
7702 c.header_ = make(http.Header)
7703 }
7704 return c.header_
7705 }
7706
7707 func (c *OrganizationsLocationsOperationsListCall) doRequest(alt string) (*http.Response, error) {
7708 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7709 if c.ifNoneMatch_ != "" {
7710 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7711 }
7712 var body io.Reader = nil
7713 c.urlParams_.Set("alt", alt)
7714 c.urlParams_.Set("prettyPrint", "false")
7715 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}/operations")
7716 urls += "?" + c.urlParams_.Encode()
7717 req, err := http.NewRequest("GET", urls, body)
7718 if err != nil {
7719 return nil, err
7720 }
7721 req.Header = reqHeaders
7722 googleapi.Expand(req.URL, map[string]string{
7723 "name": c.name,
7724 })
7725 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7726 }
7727
7728
7729
7730
7731
7732
7733
7734 func (c *OrganizationsLocationsOperationsListCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningListOperationsResponse, error) {
7735 gensupport.SetOptions(c.urlParams_, opts...)
7736 res, err := c.doRequest("json")
7737 if res != nil && res.StatusCode == http.StatusNotModified {
7738 if res.Body != nil {
7739 res.Body.Close()
7740 }
7741 return nil, gensupport.WrapError(&googleapi.Error{
7742 Code: res.StatusCode,
7743 Header: res.Header,
7744 })
7745 }
7746 if err != nil {
7747 return nil, err
7748 }
7749 defer googleapi.CloseBody(res)
7750 if err := googleapi.CheckResponse(res); err != nil {
7751 return nil, gensupport.WrapError(err)
7752 }
7753 ret := &GoogleLongrunningListOperationsResponse{
7754 ServerResponse: googleapi.ServerResponse{
7755 Header: res.Header,
7756 HTTPStatusCode: res.StatusCode,
7757 },
7758 }
7759 target := &ret
7760 if err := gensupport.DecodeResponse(target, res); err != nil {
7761 return nil, err
7762 }
7763 return ret, nil
7764 }
7765
7766
7767
7768
7769 func (c *OrganizationsLocationsOperationsListCall) Pages(ctx context.Context, f func(*GoogleLongrunningListOperationsResponse) error) error {
7770 c.ctx_ = ctx
7771 defer c.PageToken(c.urlParams_.Get("pageToken"))
7772 for {
7773 x, err := c.Do()
7774 if err != nil {
7775 return err
7776 }
7777 if err := f(x); err != nil {
7778 return err
7779 }
7780 if x.NextPageToken == "" {
7781 return nil
7782 }
7783 c.PageToken(x.NextPageToken)
7784 }
7785 }
7786
7787 type OrganizationsLocationsSubscriptionsCancelCall struct {
7788 s *Service
7789 name string
7790 urlParams_ gensupport.URLParams
7791 ifNoneMatch_ string
7792 ctx_ context.Context
7793 header_ http.Header
7794 }
7795
7796
7797
7798
7799
7800
7801
7802 func (r *OrganizationsLocationsSubscriptionsService) Cancel(name string) *OrganizationsLocationsSubscriptionsCancelCall {
7803 c := &OrganizationsLocationsSubscriptionsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7804 c.name = name
7805 return c
7806 }
7807
7808
7809
7810
7811
7812
7813
7814
7815
7816
7817
7818
7819 func (c *OrganizationsLocationsSubscriptionsCancelCall) RequestId(requestId string) *OrganizationsLocationsSubscriptionsCancelCall {
7820 c.urlParams_.Set("requestId", requestId)
7821 return c
7822 }
7823
7824
7825
7826
7827 func (c *OrganizationsLocationsSubscriptionsCancelCall) Fields(s ...googleapi.Field) *OrganizationsLocationsSubscriptionsCancelCall {
7828 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7829 return c
7830 }
7831
7832
7833
7834
7835 func (c *OrganizationsLocationsSubscriptionsCancelCall) IfNoneMatch(entityTag string) *OrganizationsLocationsSubscriptionsCancelCall {
7836 c.ifNoneMatch_ = entityTag
7837 return c
7838 }
7839
7840
7841 func (c *OrganizationsLocationsSubscriptionsCancelCall) Context(ctx context.Context) *OrganizationsLocationsSubscriptionsCancelCall {
7842 c.ctx_ = ctx
7843 return c
7844 }
7845
7846
7847
7848 func (c *OrganizationsLocationsSubscriptionsCancelCall) Header() http.Header {
7849 if c.header_ == nil {
7850 c.header_ = make(http.Header)
7851 }
7852 return c.header_
7853 }
7854
7855 func (c *OrganizationsLocationsSubscriptionsCancelCall) doRequest(alt string) (*http.Response, error) {
7856 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7857 if c.ifNoneMatch_ != "" {
7858 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7859 }
7860 var body io.Reader = nil
7861 c.urlParams_.Set("alt", alt)
7862 c.urlParams_.Set("prettyPrint", "false")
7863 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}:cancel")
7864 urls += "?" + c.urlParams_.Encode()
7865 req, err := http.NewRequest("GET", urls, body)
7866 if err != nil {
7867 return nil, err
7868 }
7869 req.Header = reqHeaders
7870 googleapi.Expand(req.URL, map[string]string{
7871 "name": c.name,
7872 })
7873 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7874 }
7875
7876
7877
7878
7879
7880
7881
7882 func (c *OrganizationsLocationsSubscriptionsCancelCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaCancelSubscriptionResponse, error) {
7883 gensupport.SetOptions(c.urlParams_, opts...)
7884 res, err := c.doRequest("json")
7885 if res != nil && res.StatusCode == http.StatusNotModified {
7886 if res.Body != nil {
7887 res.Body.Close()
7888 }
7889 return nil, gensupport.WrapError(&googleapi.Error{
7890 Code: res.StatusCode,
7891 Header: res.Header,
7892 })
7893 }
7894 if err != nil {
7895 return nil, err
7896 }
7897 defer googleapi.CloseBody(res)
7898 if err := googleapi.CheckResponse(res); err != nil {
7899 return nil, gensupport.WrapError(err)
7900 }
7901 ret := &GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaCancelSubscriptionResponse{
7902 ServerResponse: googleapi.ServerResponse{
7903 Header: res.Header,
7904 HTTPStatusCode: res.StatusCode,
7905 },
7906 }
7907 target := &ret
7908 if err := gensupport.DecodeResponse(target, res); err != nil {
7909 return nil, err
7910 }
7911 return ret, nil
7912 }
7913
7914 type OrganizationsLocationsSubscriptionsCreateCall struct {
7915 s *Service
7916 parent string
7917 googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription *GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription
7918 urlParams_ gensupport.URLParams
7919 ctx_ context.Context
7920 header_ http.Header
7921 }
7922
7923
7924
7925
7926
7927
7928
7929 func (r *OrganizationsLocationsSubscriptionsService) Create(parent string, googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription *GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription) *OrganizationsLocationsSubscriptionsCreateCall {
7930 c := &OrganizationsLocationsSubscriptionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7931 c.parent = parent
7932 c.googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription = googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription
7933 return c
7934 }
7935
7936
7937
7938
7939 func (c *OrganizationsLocationsSubscriptionsCreateCall) Fields(s ...googleapi.Field) *OrganizationsLocationsSubscriptionsCreateCall {
7940 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7941 return c
7942 }
7943
7944
7945 func (c *OrganizationsLocationsSubscriptionsCreateCall) Context(ctx context.Context) *OrganizationsLocationsSubscriptionsCreateCall {
7946 c.ctx_ = ctx
7947 return c
7948 }
7949
7950
7951
7952 func (c *OrganizationsLocationsSubscriptionsCreateCall) Header() http.Header {
7953 if c.header_ == nil {
7954 c.header_ = make(http.Header)
7955 }
7956 return c.header_
7957 }
7958
7959 func (c *OrganizationsLocationsSubscriptionsCreateCall) doRequest(alt string) (*http.Response, error) {
7960 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7961 var body io.Reader = nil
7962 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription)
7963 if err != nil {
7964 return nil, err
7965 }
7966 c.urlParams_.Set("alt", alt)
7967 c.urlParams_.Set("prettyPrint", "false")
7968 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/subscriptions")
7969 urls += "?" + c.urlParams_.Encode()
7970 req, err := http.NewRequest("POST", urls, body)
7971 if err != nil {
7972 return nil, err
7973 }
7974 req.Header = reqHeaders
7975 googleapi.Expand(req.URL, map[string]string{
7976 "parent": c.parent,
7977 })
7978 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7979 }
7980
7981
7982
7983
7984
7985
7986
7987 func (c *OrganizationsLocationsSubscriptionsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription, error) {
7988 gensupport.SetOptions(c.urlParams_, opts...)
7989 res, err := c.doRequest("json")
7990 if res != nil && res.StatusCode == http.StatusNotModified {
7991 if res.Body != nil {
7992 res.Body.Close()
7993 }
7994 return nil, gensupport.WrapError(&googleapi.Error{
7995 Code: res.StatusCode,
7996 Header: res.Header,
7997 })
7998 }
7999 if err != nil {
8000 return nil, err
8001 }
8002 defer googleapi.CloseBody(res)
8003 if err := googleapi.CheckResponse(res); err != nil {
8004 return nil, gensupport.WrapError(err)
8005 }
8006 ret := &GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription{
8007 ServerResponse: googleapi.ServerResponse{
8008 Header: res.Header,
8009 HTTPStatusCode: res.StatusCode,
8010 },
8011 }
8012 target := &ret
8013 if err := gensupport.DecodeResponse(target, res); err != nil {
8014 return nil, err
8015 }
8016 return ret, nil
8017 }
8018
8019 type OrganizationsLocationsSubscriptionsGetCall struct {
8020 s *Service
8021 name string
8022 urlParams_ gensupport.URLParams
8023 ifNoneMatch_ string
8024 ctx_ context.Context
8025 header_ http.Header
8026 }
8027
8028
8029
8030
8031
8032
8033 func (r *OrganizationsLocationsSubscriptionsService) Get(name string) *OrganizationsLocationsSubscriptionsGetCall {
8034 c := &OrganizationsLocationsSubscriptionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8035 c.name = name
8036 return c
8037 }
8038
8039
8040
8041
8042 func (c *OrganizationsLocationsSubscriptionsGetCall) Fields(s ...googleapi.Field) *OrganizationsLocationsSubscriptionsGetCall {
8043 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8044 return c
8045 }
8046
8047
8048
8049
8050 func (c *OrganizationsLocationsSubscriptionsGetCall) IfNoneMatch(entityTag string) *OrganizationsLocationsSubscriptionsGetCall {
8051 c.ifNoneMatch_ = entityTag
8052 return c
8053 }
8054
8055
8056 func (c *OrganizationsLocationsSubscriptionsGetCall) Context(ctx context.Context) *OrganizationsLocationsSubscriptionsGetCall {
8057 c.ctx_ = ctx
8058 return c
8059 }
8060
8061
8062
8063 func (c *OrganizationsLocationsSubscriptionsGetCall) Header() http.Header {
8064 if c.header_ == nil {
8065 c.header_ = make(http.Header)
8066 }
8067 return c.header_
8068 }
8069
8070 func (c *OrganizationsLocationsSubscriptionsGetCall) doRequest(alt string) (*http.Response, error) {
8071 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8072 if c.ifNoneMatch_ != "" {
8073 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8074 }
8075 var body io.Reader = nil
8076 c.urlParams_.Set("alt", alt)
8077 c.urlParams_.Set("prettyPrint", "false")
8078 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
8079 urls += "?" + c.urlParams_.Encode()
8080 req, err := http.NewRequest("GET", urls, body)
8081 if err != nil {
8082 return nil, err
8083 }
8084 req.Header = reqHeaders
8085 googleapi.Expand(req.URL, map[string]string{
8086 "name": c.name,
8087 })
8088 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8089 }
8090
8091
8092
8093
8094
8095
8096
8097 func (c *OrganizationsLocationsSubscriptionsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription, error) {
8098 gensupport.SetOptions(c.urlParams_, opts...)
8099 res, err := c.doRequest("json")
8100 if res != nil && res.StatusCode == http.StatusNotModified {
8101 if res.Body != nil {
8102 res.Body.Close()
8103 }
8104 return nil, gensupport.WrapError(&googleapi.Error{
8105 Code: res.StatusCode,
8106 Header: res.Header,
8107 })
8108 }
8109 if err != nil {
8110 return nil, err
8111 }
8112 defer googleapi.CloseBody(res)
8113 if err := googleapi.CheckResponse(res); err != nil {
8114 return nil, gensupport.WrapError(err)
8115 }
8116 ret := &GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription{
8117 ServerResponse: googleapi.ServerResponse{
8118 Header: res.Header,
8119 HTTPStatusCode: res.StatusCode,
8120 },
8121 }
8122 target := &ret
8123 if err := gensupport.DecodeResponse(target, res); err != nil {
8124 return nil, err
8125 }
8126 return ret, nil
8127 }
8128
8129 type OrganizationsLocationsSubscriptionsListCall struct {
8130 s *Service
8131 parent string
8132 urlParams_ gensupport.URLParams
8133 ifNoneMatch_ string
8134 ctx_ context.Context
8135 header_ http.Header
8136 }
8137
8138
8139
8140
8141
8142 func (r *OrganizationsLocationsSubscriptionsService) List(parent string) *OrganizationsLocationsSubscriptionsListCall {
8143 c := &OrganizationsLocationsSubscriptionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8144 c.parent = parent
8145 return c
8146 }
8147
8148
8149
8150
8151
8152
8153 func (c *OrganizationsLocationsSubscriptionsListCall) PageSize(pageSize int64) *OrganizationsLocationsSubscriptionsListCall {
8154 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
8155 return c
8156 }
8157
8158
8159
8160 func (c *OrganizationsLocationsSubscriptionsListCall) PageToken(pageToken string) *OrganizationsLocationsSubscriptionsListCall {
8161 c.urlParams_.Set("pageToken", pageToken)
8162 return c
8163 }
8164
8165
8166
8167
8168 func (c *OrganizationsLocationsSubscriptionsListCall) Fields(s ...googleapi.Field) *OrganizationsLocationsSubscriptionsListCall {
8169 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8170 return c
8171 }
8172
8173
8174
8175
8176 func (c *OrganizationsLocationsSubscriptionsListCall) IfNoneMatch(entityTag string) *OrganizationsLocationsSubscriptionsListCall {
8177 c.ifNoneMatch_ = entityTag
8178 return c
8179 }
8180
8181
8182 func (c *OrganizationsLocationsSubscriptionsListCall) Context(ctx context.Context) *OrganizationsLocationsSubscriptionsListCall {
8183 c.ctx_ = ctx
8184 return c
8185 }
8186
8187
8188
8189 func (c *OrganizationsLocationsSubscriptionsListCall) Header() http.Header {
8190 if c.header_ == nil {
8191 c.header_ = make(http.Header)
8192 }
8193 return c.header_
8194 }
8195
8196 func (c *OrganizationsLocationsSubscriptionsListCall) doRequest(alt string) (*http.Response, error) {
8197 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8198 if c.ifNoneMatch_ != "" {
8199 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8200 }
8201 var body io.Reader = nil
8202 c.urlParams_.Set("alt", alt)
8203 c.urlParams_.Set("prettyPrint", "false")
8204 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/subscriptions")
8205 urls += "?" + c.urlParams_.Encode()
8206 req, err := http.NewRequest("GET", urls, body)
8207 if err != nil {
8208 return nil, err
8209 }
8210 req.Header = reqHeaders
8211 googleapi.Expand(req.URL, map[string]string{
8212 "parent": c.parent,
8213 })
8214 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8215 }
8216
8217
8218
8219
8220
8221
8222
8223 func (c *OrganizationsLocationsSubscriptionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaListSubscriptionsResponse, error) {
8224 gensupport.SetOptions(c.urlParams_, opts...)
8225 res, err := c.doRequest("json")
8226 if res != nil && res.StatusCode == http.StatusNotModified {
8227 if res.Body != nil {
8228 res.Body.Close()
8229 }
8230 return nil, gensupport.WrapError(&googleapi.Error{
8231 Code: res.StatusCode,
8232 Header: res.Header,
8233 })
8234 }
8235 if err != nil {
8236 return nil, err
8237 }
8238 defer googleapi.CloseBody(res)
8239 if err := googleapi.CheckResponse(res); err != nil {
8240 return nil, gensupport.WrapError(err)
8241 }
8242 ret := &GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaListSubscriptionsResponse{
8243 ServerResponse: googleapi.ServerResponse{
8244 Header: res.Header,
8245 HTTPStatusCode: res.StatusCode,
8246 },
8247 }
8248 target := &ret
8249 if err := gensupport.DecodeResponse(target, res); err != nil {
8250 return nil, err
8251 }
8252 return ret, nil
8253 }
8254
8255
8256
8257
8258 func (c *OrganizationsLocationsSubscriptionsListCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaListSubscriptionsResponse) error) error {
8259 c.ctx_ = ctx
8260 defer c.PageToken(c.urlParams_.Get("pageToken"))
8261 for {
8262 x, err := c.Do()
8263 if err != nil {
8264 return err
8265 }
8266 if err := f(x); err != nil {
8267 return err
8268 }
8269 if x.NextPageToken == "" {
8270 return nil
8271 }
8272 c.PageToken(x.NextPageToken)
8273 }
8274 }
8275
8276 type OrganizationsLocationsSubscriptionsPatchCall struct {
8277 s *Service
8278 name string
8279 googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription *GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription
8280 urlParams_ gensupport.URLParams
8281 ctx_ context.Context
8282 header_ http.Header
8283 }
8284
8285
8286
8287
8288
8289
8290
8291 func (r *OrganizationsLocationsSubscriptionsService) Patch(name string, googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription *GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription) *OrganizationsLocationsSubscriptionsPatchCall {
8292 c := &OrganizationsLocationsSubscriptionsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8293 c.name = name
8294 c.googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription = googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription
8295 return c
8296 }
8297
8298
8299
8300
8301
8302
8303
8304
8305
8306
8307
8308
8309 func (c *OrganizationsLocationsSubscriptionsPatchCall) RequestId(requestId string) *OrganizationsLocationsSubscriptionsPatchCall {
8310 c.urlParams_.Set("requestId", requestId)
8311 return c
8312 }
8313
8314
8315
8316
8317
8318
8319 func (c *OrganizationsLocationsSubscriptionsPatchCall) UpdateMask(updateMask string) *OrganizationsLocationsSubscriptionsPatchCall {
8320 c.urlParams_.Set("updateMask", updateMask)
8321 return c
8322 }
8323
8324
8325
8326
8327 func (c *OrganizationsLocationsSubscriptionsPatchCall) Fields(s ...googleapi.Field) *OrganizationsLocationsSubscriptionsPatchCall {
8328 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8329 return c
8330 }
8331
8332
8333 func (c *OrganizationsLocationsSubscriptionsPatchCall) Context(ctx context.Context) *OrganizationsLocationsSubscriptionsPatchCall {
8334 c.ctx_ = ctx
8335 return c
8336 }
8337
8338
8339
8340 func (c *OrganizationsLocationsSubscriptionsPatchCall) Header() http.Header {
8341 if c.header_ == nil {
8342 c.header_ = make(http.Header)
8343 }
8344 return c.header_
8345 }
8346
8347 func (c *OrganizationsLocationsSubscriptionsPatchCall) doRequest(alt string) (*http.Response, error) {
8348 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8349 var body io.Reader = nil
8350 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpsaasplatformsubscriptionsv1alphasubscription)
8351 if err != nil {
8352 return nil, err
8353 }
8354 c.urlParams_.Set("alt", alt)
8355 c.urlParams_.Set("prettyPrint", "false")
8356 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
8357 urls += "?" + c.urlParams_.Encode()
8358 req, err := http.NewRequest("PATCH", urls, body)
8359 if err != nil {
8360 return nil, err
8361 }
8362 req.Header = reqHeaders
8363 googleapi.Expand(req.URL, map[string]string{
8364 "name": c.name,
8365 })
8366 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8367 }
8368
8369
8370
8371
8372
8373
8374
8375 func (c *OrganizationsLocationsSubscriptionsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription, error) {
8376 gensupport.SetOptions(c.urlParams_, opts...)
8377 res, err := c.doRequest("json")
8378 if res != nil && res.StatusCode == http.StatusNotModified {
8379 if res.Body != nil {
8380 res.Body.Close()
8381 }
8382 return nil, gensupport.WrapError(&googleapi.Error{
8383 Code: res.StatusCode,
8384 Header: res.Header,
8385 })
8386 }
8387 if err != nil {
8388 return nil, err
8389 }
8390 defer googleapi.CloseBody(res)
8391 if err := googleapi.CheckResponse(res); err != nil {
8392 return nil, gensupport.WrapError(err)
8393 }
8394 ret := &GoogleCloudBeyondcorpSaasplatformSubscriptionsV1alphaSubscription{
8395 ServerResponse: googleapi.ServerResponse{
8396 Header: res.Header,
8397 HTTPStatusCode: res.StatusCode,
8398 },
8399 }
8400 target := &ret
8401 if err := gensupport.DecodeResponse(target, res); err != nil {
8402 return nil, err
8403 }
8404 return ret, nil
8405 }
8406
8407 type ProjectsLocationsGetCall struct {
8408 s *Service
8409 name string
8410 urlParams_ gensupport.URLParams
8411 ifNoneMatch_ string
8412 ctx_ context.Context
8413 header_ http.Header
8414 }
8415
8416
8417
8418
8419 func (r *ProjectsLocationsService) Get(name string) *ProjectsLocationsGetCall {
8420 c := &ProjectsLocationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8421 c.name = name
8422 return c
8423 }
8424
8425
8426
8427
8428 func (c *ProjectsLocationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsGetCall {
8429 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8430 return c
8431 }
8432
8433
8434
8435
8436 func (c *ProjectsLocationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsGetCall {
8437 c.ifNoneMatch_ = entityTag
8438 return c
8439 }
8440
8441
8442 func (c *ProjectsLocationsGetCall) Context(ctx context.Context) *ProjectsLocationsGetCall {
8443 c.ctx_ = ctx
8444 return c
8445 }
8446
8447
8448
8449 func (c *ProjectsLocationsGetCall) Header() http.Header {
8450 if c.header_ == nil {
8451 c.header_ = make(http.Header)
8452 }
8453 return c.header_
8454 }
8455
8456 func (c *ProjectsLocationsGetCall) doRequest(alt string) (*http.Response, error) {
8457 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8458 if c.ifNoneMatch_ != "" {
8459 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8460 }
8461 var body io.Reader = nil
8462 c.urlParams_.Set("alt", alt)
8463 c.urlParams_.Set("prettyPrint", "false")
8464 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
8465 urls += "?" + c.urlParams_.Encode()
8466 req, err := http.NewRequest("GET", urls, body)
8467 if err != nil {
8468 return nil, err
8469 }
8470 req.Header = reqHeaders
8471 googleapi.Expand(req.URL, map[string]string{
8472 "name": c.name,
8473 })
8474 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8475 }
8476
8477
8478
8479
8480
8481
8482
8483 func (c *ProjectsLocationsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudLocationLocation, error) {
8484 gensupport.SetOptions(c.urlParams_, opts...)
8485 res, err := c.doRequest("json")
8486 if res != nil && res.StatusCode == http.StatusNotModified {
8487 if res.Body != nil {
8488 res.Body.Close()
8489 }
8490 return nil, gensupport.WrapError(&googleapi.Error{
8491 Code: res.StatusCode,
8492 Header: res.Header,
8493 })
8494 }
8495 if err != nil {
8496 return nil, err
8497 }
8498 defer googleapi.CloseBody(res)
8499 if err := googleapi.CheckResponse(res); err != nil {
8500 return nil, gensupport.WrapError(err)
8501 }
8502 ret := &GoogleCloudLocationLocation{
8503 ServerResponse: googleapi.ServerResponse{
8504 Header: res.Header,
8505 HTTPStatusCode: res.StatusCode,
8506 },
8507 }
8508 target := &ret
8509 if err := gensupport.DecodeResponse(target, res); err != nil {
8510 return nil, err
8511 }
8512 return ret, nil
8513 }
8514
8515 type ProjectsLocationsListCall struct {
8516 s *Service
8517 name string
8518 urlParams_ gensupport.URLParams
8519 ifNoneMatch_ string
8520 ctx_ context.Context
8521 header_ http.Header
8522 }
8523
8524
8525
8526
8527 func (r *ProjectsLocationsService) List(name string) *ProjectsLocationsListCall {
8528 c := &ProjectsLocationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8529 c.name = name
8530 return c
8531 }
8532
8533
8534
8535
8536
8537 func (c *ProjectsLocationsListCall) Filter(filter string) *ProjectsLocationsListCall {
8538 c.urlParams_.Set("filter", filter)
8539 return c
8540 }
8541
8542
8543
8544 func (c *ProjectsLocationsListCall) PageSize(pageSize int64) *ProjectsLocationsListCall {
8545 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
8546 return c
8547 }
8548
8549
8550
8551
8552 func (c *ProjectsLocationsListCall) PageToken(pageToken string) *ProjectsLocationsListCall {
8553 c.urlParams_.Set("pageToken", pageToken)
8554 return c
8555 }
8556
8557
8558
8559
8560 func (c *ProjectsLocationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsListCall {
8561 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8562 return c
8563 }
8564
8565
8566
8567
8568 func (c *ProjectsLocationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsListCall {
8569 c.ifNoneMatch_ = entityTag
8570 return c
8571 }
8572
8573
8574 func (c *ProjectsLocationsListCall) Context(ctx context.Context) *ProjectsLocationsListCall {
8575 c.ctx_ = ctx
8576 return c
8577 }
8578
8579
8580
8581 func (c *ProjectsLocationsListCall) Header() http.Header {
8582 if c.header_ == nil {
8583 c.header_ = make(http.Header)
8584 }
8585 return c.header_
8586 }
8587
8588 func (c *ProjectsLocationsListCall) doRequest(alt string) (*http.Response, error) {
8589 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8590 if c.ifNoneMatch_ != "" {
8591 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8592 }
8593 var body io.Reader = nil
8594 c.urlParams_.Set("alt", alt)
8595 c.urlParams_.Set("prettyPrint", "false")
8596 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}/locations")
8597 urls += "?" + c.urlParams_.Encode()
8598 req, err := http.NewRequest("GET", urls, body)
8599 if err != nil {
8600 return nil, err
8601 }
8602 req.Header = reqHeaders
8603 googleapi.Expand(req.URL, map[string]string{
8604 "name": c.name,
8605 })
8606 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8607 }
8608
8609
8610
8611
8612
8613
8614
8615 func (c *ProjectsLocationsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudLocationListLocationsResponse, error) {
8616 gensupport.SetOptions(c.urlParams_, opts...)
8617 res, err := c.doRequest("json")
8618 if res != nil && res.StatusCode == http.StatusNotModified {
8619 if res.Body != nil {
8620 res.Body.Close()
8621 }
8622 return nil, gensupport.WrapError(&googleapi.Error{
8623 Code: res.StatusCode,
8624 Header: res.Header,
8625 })
8626 }
8627 if err != nil {
8628 return nil, err
8629 }
8630 defer googleapi.CloseBody(res)
8631 if err := googleapi.CheckResponse(res); err != nil {
8632 return nil, gensupport.WrapError(err)
8633 }
8634 ret := &GoogleCloudLocationListLocationsResponse{
8635 ServerResponse: googleapi.ServerResponse{
8636 Header: res.Header,
8637 HTTPStatusCode: res.StatusCode,
8638 },
8639 }
8640 target := &ret
8641 if err := gensupport.DecodeResponse(target, res); err != nil {
8642 return nil, err
8643 }
8644 return ret, nil
8645 }
8646
8647
8648
8649
8650 func (c *ProjectsLocationsListCall) Pages(ctx context.Context, f func(*GoogleCloudLocationListLocationsResponse) error) error {
8651 c.ctx_ = ctx
8652 defer c.PageToken(c.urlParams_.Get("pageToken"))
8653 for {
8654 x, err := c.Do()
8655 if err != nil {
8656 return err
8657 }
8658 if err := f(x); err != nil {
8659 return err
8660 }
8661 if x.NextPageToken == "" {
8662 return nil
8663 }
8664 c.PageToken(x.NextPageToken)
8665 }
8666 }
8667
8668 type ProjectsLocationsAppConnectionsCreateCall struct {
8669 s *Service
8670 parent string
8671 googlecloudbeyondcorpappconnectionsv1alphaappconnection *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection
8672 urlParams_ gensupport.URLParams
8673 ctx_ context.Context
8674 header_ http.Header
8675 }
8676
8677
8678
8679
8680
8681 func (r *ProjectsLocationsAppConnectionsService) Create(parent string, googlecloudbeyondcorpappconnectionsv1alphaappconnection *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection) *ProjectsLocationsAppConnectionsCreateCall {
8682 c := &ProjectsLocationsAppConnectionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8683 c.parent = parent
8684 c.googlecloudbeyondcorpappconnectionsv1alphaappconnection = googlecloudbeyondcorpappconnectionsv1alphaappconnection
8685 return c
8686 }
8687
8688
8689
8690
8691 func (c *ProjectsLocationsAppConnectionsCreateCall) AppConnectionId(appConnectionId string) *ProjectsLocationsAppConnectionsCreateCall {
8692 c.urlParams_.Set("appConnectionId", appConnectionId)
8693 return c
8694 }
8695
8696
8697
8698
8699
8700
8701
8702
8703
8704
8705
8706
8707 func (c *ProjectsLocationsAppConnectionsCreateCall) RequestId(requestId string) *ProjectsLocationsAppConnectionsCreateCall {
8708 c.urlParams_.Set("requestId", requestId)
8709 return c
8710 }
8711
8712
8713
8714
8715 func (c *ProjectsLocationsAppConnectionsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsAppConnectionsCreateCall {
8716 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
8717 return c
8718 }
8719
8720
8721
8722
8723 func (c *ProjectsLocationsAppConnectionsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsCreateCall {
8724 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8725 return c
8726 }
8727
8728
8729 func (c *ProjectsLocationsAppConnectionsCreateCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsCreateCall {
8730 c.ctx_ = ctx
8731 return c
8732 }
8733
8734
8735
8736 func (c *ProjectsLocationsAppConnectionsCreateCall) Header() http.Header {
8737 if c.header_ == nil {
8738 c.header_ = make(http.Header)
8739 }
8740 return c.header_
8741 }
8742
8743 func (c *ProjectsLocationsAppConnectionsCreateCall) doRequest(alt string) (*http.Response, error) {
8744 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8745 var body io.Reader = nil
8746 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpappconnectionsv1alphaappconnection)
8747 if err != nil {
8748 return nil, err
8749 }
8750 c.urlParams_.Set("alt", alt)
8751 c.urlParams_.Set("prettyPrint", "false")
8752 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/appConnections")
8753 urls += "?" + c.urlParams_.Encode()
8754 req, err := http.NewRequest("POST", urls, body)
8755 if err != nil {
8756 return nil, err
8757 }
8758 req.Header = reqHeaders
8759 googleapi.Expand(req.URL, map[string]string{
8760 "parent": c.parent,
8761 })
8762 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8763 }
8764
8765
8766
8767
8768
8769
8770
8771 func (c *ProjectsLocationsAppConnectionsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
8772 gensupport.SetOptions(c.urlParams_, opts...)
8773 res, err := c.doRequest("json")
8774 if res != nil && res.StatusCode == http.StatusNotModified {
8775 if res.Body != nil {
8776 res.Body.Close()
8777 }
8778 return nil, gensupport.WrapError(&googleapi.Error{
8779 Code: res.StatusCode,
8780 Header: res.Header,
8781 })
8782 }
8783 if err != nil {
8784 return nil, err
8785 }
8786 defer googleapi.CloseBody(res)
8787 if err := googleapi.CheckResponse(res); err != nil {
8788 return nil, gensupport.WrapError(err)
8789 }
8790 ret := &GoogleLongrunningOperation{
8791 ServerResponse: googleapi.ServerResponse{
8792 Header: res.Header,
8793 HTTPStatusCode: res.StatusCode,
8794 },
8795 }
8796 target := &ret
8797 if err := gensupport.DecodeResponse(target, res); err != nil {
8798 return nil, err
8799 }
8800 return ret, nil
8801 }
8802
8803 type ProjectsLocationsAppConnectionsDeleteCall struct {
8804 s *Service
8805 name string
8806 urlParams_ gensupport.URLParams
8807 ctx_ context.Context
8808 header_ http.Header
8809 }
8810
8811
8812
8813
8814
8815
8816 func (r *ProjectsLocationsAppConnectionsService) Delete(name string) *ProjectsLocationsAppConnectionsDeleteCall {
8817 c := &ProjectsLocationsAppConnectionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8818 c.name = name
8819 return c
8820 }
8821
8822
8823
8824
8825
8826
8827
8828
8829
8830
8831
8832
8833 func (c *ProjectsLocationsAppConnectionsDeleteCall) RequestId(requestId string) *ProjectsLocationsAppConnectionsDeleteCall {
8834 c.urlParams_.Set("requestId", requestId)
8835 return c
8836 }
8837
8838
8839
8840
8841 func (c *ProjectsLocationsAppConnectionsDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsAppConnectionsDeleteCall {
8842 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
8843 return c
8844 }
8845
8846
8847
8848
8849 func (c *ProjectsLocationsAppConnectionsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsDeleteCall {
8850 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8851 return c
8852 }
8853
8854
8855 func (c *ProjectsLocationsAppConnectionsDeleteCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsDeleteCall {
8856 c.ctx_ = ctx
8857 return c
8858 }
8859
8860
8861
8862 func (c *ProjectsLocationsAppConnectionsDeleteCall) Header() http.Header {
8863 if c.header_ == nil {
8864 c.header_ = make(http.Header)
8865 }
8866 return c.header_
8867 }
8868
8869 func (c *ProjectsLocationsAppConnectionsDeleteCall) doRequest(alt string) (*http.Response, error) {
8870 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8871 var body io.Reader = nil
8872 c.urlParams_.Set("alt", alt)
8873 c.urlParams_.Set("prettyPrint", "false")
8874 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
8875 urls += "?" + c.urlParams_.Encode()
8876 req, err := http.NewRequest("DELETE", urls, body)
8877 if err != nil {
8878 return nil, err
8879 }
8880 req.Header = reqHeaders
8881 googleapi.Expand(req.URL, map[string]string{
8882 "name": c.name,
8883 })
8884 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8885 }
8886
8887
8888
8889
8890
8891
8892
8893 func (c *ProjectsLocationsAppConnectionsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
8894 gensupport.SetOptions(c.urlParams_, opts...)
8895 res, err := c.doRequest("json")
8896 if res != nil && res.StatusCode == http.StatusNotModified {
8897 if res.Body != nil {
8898 res.Body.Close()
8899 }
8900 return nil, gensupport.WrapError(&googleapi.Error{
8901 Code: res.StatusCode,
8902 Header: res.Header,
8903 })
8904 }
8905 if err != nil {
8906 return nil, err
8907 }
8908 defer googleapi.CloseBody(res)
8909 if err := googleapi.CheckResponse(res); err != nil {
8910 return nil, gensupport.WrapError(err)
8911 }
8912 ret := &GoogleLongrunningOperation{
8913 ServerResponse: googleapi.ServerResponse{
8914 Header: res.Header,
8915 HTTPStatusCode: res.StatusCode,
8916 },
8917 }
8918 target := &ret
8919 if err := gensupport.DecodeResponse(target, res); err != nil {
8920 return nil, err
8921 }
8922 return ret, nil
8923 }
8924
8925 type ProjectsLocationsAppConnectionsGetCall struct {
8926 s *Service
8927 name string
8928 urlParams_ gensupport.URLParams
8929 ifNoneMatch_ string
8930 ctx_ context.Context
8931 header_ http.Header
8932 }
8933
8934
8935
8936
8937
8938
8939 func (r *ProjectsLocationsAppConnectionsService) Get(name string) *ProjectsLocationsAppConnectionsGetCall {
8940 c := &ProjectsLocationsAppConnectionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8941 c.name = name
8942 return c
8943 }
8944
8945
8946
8947
8948 func (c *ProjectsLocationsAppConnectionsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsGetCall {
8949 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8950 return c
8951 }
8952
8953
8954
8955
8956 func (c *ProjectsLocationsAppConnectionsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppConnectionsGetCall {
8957 c.ifNoneMatch_ = entityTag
8958 return c
8959 }
8960
8961
8962 func (c *ProjectsLocationsAppConnectionsGetCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsGetCall {
8963 c.ctx_ = ctx
8964 return c
8965 }
8966
8967
8968
8969 func (c *ProjectsLocationsAppConnectionsGetCall) Header() http.Header {
8970 if c.header_ == nil {
8971 c.header_ = make(http.Header)
8972 }
8973 return c.header_
8974 }
8975
8976 func (c *ProjectsLocationsAppConnectionsGetCall) doRequest(alt string) (*http.Response, error) {
8977 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8978 if c.ifNoneMatch_ != "" {
8979 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8980 }
8981 var body io.Reader = nil
8982 c.urlParams_.Set("alt", alt)
8983 c.urlParams_.Set("prettyPrint", "false")
8984 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
8985 urls += "?" + c.urlParams_.Encode()
8986 req, err := http.NewRequest("GET", urls, body)
8987 if err != nil {
8988 return nil, err
8989 }
8990 req.Header = reqHeaders
8991 googleapi.Expand(req.URL, map[string]string{
8992 "name": c.name,
8993 })
8994 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8995 }
8996
8997
8998
8999
9000
9001
9002
9003 func (c *ProjectsLocationsAppConnectionsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection, error) {
9004 gensupport.SetOptions(c.urlParams_, opts...)
9005 res, err := c.doRequest("json")
9006 if res != nil && res.StatusCode == http.StatusNotModified {
9007 if res.Body != nil {
9008 res.Body.Close()
9009 }
9010 return nil, gensupport.WrapError(&googleapi.Error{
9011 Code: res.StatusCode,
9012 Header: res.Header,
9013 })
9014 }
9015 if err != nil {
9016 return nil, err
9017 }
9018 defer googleapi.CloseBody(res)
9019 if err := googleapi.CheckResponse(res); err != nil {
9020 return nil, gensupport.WrapError(err)
9021 }
9022 ret := &GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection{
9023 ServerResponse: googleapi.ServerResponse{
9024 Header: res.Header,
9025 HTTPStatusCode: res.StatusCode,
9026 },
9027 }
9028 target := &ret
9029 if err := gensupport.DecodeResponse(target, res); err != nil {
9030 return nil, err
9031 }
9032 return ret, nil
9033 }
9034
9035 type ProjectsLocationsAppConnectionsGetIamPolicyCall struct {
9036 s *Service
9037 resource string
9038 urlParams_ gensupport.URLParams
9039 ifNoneMatch_ string
9040 ctx_ context.Context
9041 header_ http.Header
9042 }
9043
9044
9045
9046
9047
9048
9049
9050 func (r *ProjectsLocationsAppConnectionsService) GetIamPolicy(resource string) *ProjectsLocationsAppConnectionsGetIamPolicyCall {
9051 c := &ProjectsLocationsAppConnectionsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9052 c.resource = resource
9053 return c
9054 }
9055
9056
9057
9058
9059
9060
9061
9062
9063
9064
9065
9066
9067
9068 func (c *ProjectsLocationsAppConnectionsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsAppConnectionsGetIamPolicyCall {
9069 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
9070 return c
9071 }
9072
9073
9074
9075
9076 func (c *ProjectsLocationsAppConnectionsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsGetIamPolicyCall {
9077 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9078 return c
9079 }
9080
9081
9082
9083
9084 func (c *ProjectsLocationsAppConnectionsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppConnectionsGetIamPolicyCall {
9085 c.ifNoneMatch_ = entityTag
9086 return c
9087 }
9088
9089
9090 func (c *ProjectsLocationsAppConnectionsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsGetIamPolicyCall {
9091 c.ctx_ = ctx
9092 return c
9093 }
9094
9095
9096
9097 func (c *ProjectsLocationsAppConnectionsGetIamPolicyCall) Header() http.Header {
9098 if c.header_ == nil {
9099 c.header_ = make(http.Header)
9100 }
9101 return c.header_
9102 }
9103
9104 func (c *ProjectsLocationsAppConnectionsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
9105 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9106 if c.ifNoneMatch_ != "" {
9107 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9108 }
9109 var body io.Reader = nil
9110 c.urlParams_.Set("alt", alt)
9111 c.urlParams_.Set("prettyPrint", "false")
9112 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
9113 urls += "?" + c.urlParams_.Encode()
9114 req, err := http.NewRequest("GET", urls, body)
9115 if err != nil {
9116 return nil, err
9117 }
9118 req.Header = reqHeaders
9119 googleapi.Expand(req.URL, map[string]string{
9120 "resource": c.resource,
9121 })
9122 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9123 }
9124
9125
9126
9127
9128
9129
9130
9131 func (c *ProjectsLocationsAppConnectionsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
9132 gensupport.SetOptions(c.urlParams_, opts...)
9133 res, err := c.doRequest("json")
9134 if res != nil && res.StatusCode == http.StatusNotModified {
9135 if res.Body != nil {
9136 res.Body.Close()
9137 }
9138 return nil, gensupport.WrapError(&googleapi.Error{
9139 Code: res.StatusCode,
9140 Header: res.Header,
9141 })
9142 }
9143 if err != nil {
9144 return nil, err
9145 }
9146 defer googleapi.CloseBody(res)
9147 if err := googleapi.CheckResponse(res); err != nil {
9148 return nil, gensupport.WrapError(err)
9149 }
9150 ret := &GoogleIamV1Policy{
9151 ServerResponse: googleapi.ServerResponse{
9152 Header: res.Header,
9153 HTTPStatusCode: res.StatusCode,
9154 },
9155 }
9156 target := &ret
9157 if err := gensupport.DecodeResponse(target, res); err != nil {
9158 return nil, err
9159 }
9160 return ret, nil
9161 }
9162
9163 type ProjectsLocationsAppConnectionsListCall struct {
9164 s *Service
9165 parent string
9166 urlParams_ gensupport.URLParams
9167 ifNoneMatch_ string
9168 ctx_ context.Context
9169 header_ http.Header
9170 }
9171
9172
9173
9174
9175
9176 func (r *ProjectsLocationsAppConnectionsService) List(parent string) *ProjectsLocationsAppConnectionsListCall {
9177 c := &ProjectsLocationsAppConnectionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9178 c.parent = parent
9179 return c
9180 }
9181
9182
9183
9184 func (c *ProjectsLocationsAppConnectionsListCall) Filter(filter string) *ProjectsLocationsAppConnectionsListCall {
9185 c.urlParams_.Set("filter", filter)
9186 return c
9187 }
9188
9189
9190
9191
9192
9193 func (c *ProjectsLocationsAppConnectionsListCall) OrderBy(orderBy string) *ProjectsLocationsAppConnectionsListCall {
9194 c.urlParams_.Set("orderBy", orderBy)
9195 return c
9196 }
9197
9198
9199
9200
9201
9202
9203 func (c *ProjectsLocationsAppConnectionsListCall) PageSize(pageSize int64) *ProjectsLocationsAppConnectionsListCall {
9204 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9205 return c
9206 }
9207
9208
9209
9210 func (c *ProjectsLocationsAppConnectionsListCall) PageToken(pageToken string) *ProjectsLocationsAppConnectionsListCall {
9211 c.urlParams_.Set("pageToken", pageToken)
9212 return c
9213 }
9214
9215
9216
9217
9218 func (c *ProjectsLocationsAppConnectionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsListCall {
9219 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9220 return c
9221 }
9222
9223
9224
9225
9226 func (c *ProjectsLocationsAppConnectionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppConnectionsListCall {
9227 c.ifNoneMatch_ = entityTag
9228 return c
9229 }
9230
9231
9232 func (c *ProjectsLocationsAppConnectionsListCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsListCall {
9233 c.ctx_ = ctx
9234 return c
9235 }
9236
9237
9238
9239 func (c *ProjectsLocationsAppConnectionsListCall) Header() http.Header {
9240 if c.header_ == nil {
9241 c.header_ = make(http.Header)
9242 }
9243 return c.header_
9244 }
9245
9246 func (c *ProjectsLocationsAppConnectionsListCall) doRequest(alt string) (*http.Response, error) {
9247 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9248 if c.ifNoneMatch_ != "" {
9249 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9250 }
9251 var body io.Reader = nil
9252 c.urlParams_.Set("alt", alt)
9253 c.urlParams_.Set("prettyPrint", "false")
9254 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/appConnections")
9255 urls += "?" + c.urlParams_.Encode()
9256 req, err := http.NewRequest("GET", urls, body)
9257 if err != nil {
9258 return nil, err
9259 }
9260 req.Header = reqHeaders
9261 googleapi.Expand(req.URL, map[string]string{
9262 "parent": c.parent,
9263 })
9264 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9265 }
9266
9267
9268
9269
9270
9271
9272
9273 func (c *ProjectsLocationsAppConnectionsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpAppconnectionsV1alphaListAppConnectionsResponse, error) {
9274 gensupport.SetOptions(c.urlParams_, opts...)
9275 res, err := c.doRequest("json")
9276 if res != nil && res.StatusCode == http.StatusNotModified {
9277 if res.Body != nil {
9278 res.Body.Close()
9279 }
9280 return nil, gensupport.WrapError(&googleapi.Error{
9281 Code: res.StatusCode,
9282 Header: res.Header,
9283 })
9284 }
9285 if err != nil {
9286 return nil, err
9287 }
9288 defer googleapi.CloseBody(res)
9289 if err := googleapi.CheckResponse(res); err != nil {
9290 return nil, gensupport.WrapError(err)
9291 }
9292 ret := &GoogleCloudBeyondcorpAppconnectionsV1alphaListAppConnectionsResponse{
9293 ServerResponse: googleapi.ServerResponse{
9294 Header: res.Header,
9295 HTTPStatusCode: res.StatusCode,
9296 },
9297 }
9298 target := &ret
9299 if err := gensupport.DecodeResponse(target, res); err != nil {
9300 return nil, err
9301 }
9302 return ret, nil
9303 }
9304
9305
9306
9307
9308 func (c *ProjectsLocationsAppConnectionsListCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpAppconnectionsV1alphaListAppConnectionsResponse) error) error {
9309 c.ctx_ = ctx
9310 defer c.PageToken(c.urlParams_.Get("pageToken"))
9311 for {
9312 x, err := c.Do()
9313 if err != nil {
9314 return err
9315 }
9316 if err := f(x); err != nil {
9317 return err
9318 }
9319 if x.NextPageToken == "" {
9320 return nil
9321 }
9322 c.PageToken(x.NextPageToken)
9323 }
9324 }
9325
9326 type ProjectsLocationsAppConnectionsPatchCall struct {
9327 s *Service
9328 name string
9329 googlecloudbeyondcorpappconnectionsv1alphaappconnection *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection
9330 urlParams_ gensupport.URLParams
9331 ctx_ context.Context
9332 header_ http.Header
9333 }
9334
9335
9336
9337
9338
9339 func (r *ProjectsLocationsAppConnectionsService) Patch(name string, googlecloudbeyondcorpappconnectionsv1alphaappconnection *GoogleCloudBeyondcorpAppconnectionsV1alphaAppConnection) *ProjectsLocationsAppConnectionsPatchCall {
9340 c := &ProjectsLocationsAppConnectionsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9341 c.name = name
9342 c.googlecloudbeyondcorpappconnectionsv1alphaappconnection = googlecloudbeyondcorpappconnectionsv1alphaappconnection
9343 return c
9344 }
9345
9346
9347
9348 func (c *ProjectsLocationsAppConnectionsPatchCall) AllowMissing(allowMissing bool) *ProjectsLocationsAppConnectionsPatchCall {
9349 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
9350 return c
9351 }
9352
9353
9354
9355
9356
9357
9358
9359
9360
9361
9362
9363
9364 func (c *ProjectsLocationsAppConnectionsPatchCall) RequestId(requestId string) *ProjectsLocationsAppConnectionsPatchCall {
9365 c.urlParams_.Set("requestId", requestId)
9366 return c
9367 }
9368
9369
9370
9371
9372
9373
9374 func (c *ProjectsLocationsAppConnectionsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsAppConnectionsPatchCall {
9375 c.urlParams_.Set("updateMask", updateMask)
9376 return c
9377 }
9378
9379
9380
9381
9382 func (c *ProjectsLocationsAppConnectionsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsAppConnectionsPatchCall {
9383 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
9384 return c
9385 }
9386
9387
9388
9389
9390 func (c *ProjectsLocationsAppConnectionsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsPatchCall {
9391 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9392 return c
9393 }
9394
9395
9396 func (c *ProjectsLocationsAppConnectionsPatchCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsPatchCall {
9397 c.ctx_ = ctx
9398 return c
9399 }
9400
9401
9402
9403 func (c *ProjectsLocationsAppConnectionsPatchCall) Header() http.Header {
9404 if c.header_ == nil {
9405 c.header_ = make(http.Header)
9406 }
9407 return c.header_
9408 }
9409
9410 func (c *ProjectsLocationsAppConnectionsPatchCall) doRequest(alt string) (*http.Response, error) {
9411 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9412 var body io.Reader = nil
9413 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpappconnectionsv1alphaappconnection)
9414 if err != nil {
9415 return nil, err
9416 }
9417 c.urlParams_.Set("alt", alt)
9418 c.urlParams_.Set("prettyPrint", "false")
9419 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
9420 urls += "?" + c.urlParams_.Encode()
9421 req, err := http.NewRequest("PATCH", urls, body)
9422 if err != nil {
9423 return nil, err
9424 }
9425 req.Header = reqHeaders
9426 googleapi.Expand(req.URL, map[string]string{
9427 "name": c.name,
9428 })
9429 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9430 }
9431
9432
9433
9434
9435
9436
9437
9438 func (c *ProjectsLocationsAppConnectionsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
9439 gensupport.SetOptions(c.urlParams_, opts...)
9440 res, err := c.doRequest("json")
9441 if res != nil && res.StatusCode == http.StatusNotModified {
9442 if res.Body != nil {
9443 res.Body.Close()
9444 }
9445 return nil, gensupport.WrapError(&googleapi.Error{
9446 Code: res.StatusCode,
9447 Header: res.Header,
9448 })
9449 }
9450 if err != nil {
9451 return nil, err
9452 }
9453 defer googleapi.CloseBody(res)
9454 if err := googleapi.CheckResponse(res); err != nil {
9455 return nil, gensupport.WrapError(err)
9456 }
9457 ret := &GoogleLongrunningOperation{
9458 ServerResponse: googleapi.ServerResponse{
9459 Header: res.Header,
9460 HTTPStatusCode: res.StatusCode,
9461 },
9462 }
9463 target := &ret
9464 if err := gensupport.DecodeResponse(target, res); err != nil {
9465 return nil, err
9466 }
9467 return ret, nil
9468 }
9469
9470 type ProjectsLocationsAppConnectionsResolveCall struct {
9471 s *Service
9472 parent string
9473 urlParams_ gensupport.URLParams
9474 ifNoneMatch_ string
9475 ctx_ context.Context
9476 header_ http.Header
9477 }
9478
9479
9480
9481
9482
9483
9484 func (r *ProjectsLocationsAppConnectionsService) Resolve(parent string) *ProjectsLocationsAppConnectionsResolveCall {
9485 c := &ProjectsLocationsAppConnectionsResolveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9486 c.parent = parent
9487 return c
9488 }
9489
9490
9491
9492
9493
9494
9495 func (c *ProjectsLocationsAppConnectionsResolveCall) AppConnectorId(appConnectorId string) *ProjectsLocationsAppConnectionsResolveCall {
9496 c.urlParams_.Set("appConnectorId", appConnectorId)
9497 return c
9498 }
9499
9500
9501
9502
9503
9504
9505 func (c *ProjectsLocationsAppConnectionsResolveCall) PageSize(pageSize int64) *ProjectsLocationsAppConnectionsResolveCall {
9506 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9507 return c
9508 }
9509
9510
9511
9512 func (c *ProjectsLocationsAppConnectionsResolveCall) PageToken(pageToken string) *ProjectsLocationsAppConnectionsResolveCall {
9513 c.urlParams_.Set("pageToken", pageToken)
9514 return c
9515 }
9516
9517
9518
9519
9520 func (c *ProjectsLocationsAppConnectionsResolveCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsResolveCall {
9521 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9522 return c
9523 }
9524
9525
9526
9527
9528 func (c *ProjectsLocationsAppConnectionsResolveCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppConnectionsResolveCall {
9529 c.ifNoneMatch_ = entityTag
9530 return c
9531 }
9532
9533
9534 func (c *ProjectsLocationsAppConnectionsResolveCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsResolveCall {
9535 c.ctx_ = ctx
9536 return c
9537 }
9538
9539
9540
9541 func (c *ProjectsLocationsAppConnectionsResolveCall) Header() http.Header {
9542 if c.header_ == nil {
9543 c.header_ = make(http.Header)
9544 }
9545 return c.header_
9546 }
9547
9548 func (c *ProjectsLocationsAppConnectionsResolveCall) doRequest(alt string) (*http.Response, error) {
9549 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9550 if c.ifNoneMatch_ != "" {
9551 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9552 }
9553 var body io.Reader = nil
9554 c.urlParams_.Set("alt", alt)
9555 c.urlParams_.Set("prettyPrint", "false")
9556 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/appConnections:resolve")
9557 urls += "?" + c.urlParams_.Encode()
9558 req, err := http.NewRequest("GET", urls, body)
9559 if err != nil {
9560 return nil, err
9561 }
9562 req.Header = reqHeaders
9563 googleapi.Expand(req.URL, map[string]string{
9564 "parent": c.parent,
9565 })
9566 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9567 }
9568
9569
9570
9571
9572
9573
9574
9575 func (c *ProjectsLocationsAppConnectionsResolveCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponse, error) {
9576 gensupport.SetOptions(c.urlParams_, opts...)
9577 res, err := c.doRequest("json")
9578 if res != nil && res.StatusCode == http.StatusNotModified {
9579 if res.Body != nil {
9580 res.Body.Close()
9581 }
9582 return nil, gensupport.WrapError(&googleapi.Error{
9583 Code: res.StatusCode,
9584 Header: res.Header,
9585 })
9586 }
9587 if err != nil {
9588 return nil, err
9589 }
9590 defer googleapi.CloseBody(res)
9591 if err := googleapi.CheckResponse(res); err != nil {
9592 return nil, gensupport.WrapError(err)
9593 }
9594 ret := &GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponse{
9595 ServerResponse: googleapi.ServerResponse{
9596 Header: res.Header,
9597 HTTPStatusCode: res.StatusCode,
9598 },
9599 }
9600 target := &ret
9601 if err := gensupport.DecodeResponse(target, res); err != nil {
9602 return nil, err
9603 }
9604 return ret, nil
9605 }
9606
9607
9608
9609
9610 func (c *ProjectsLocationsAppConnectionsResolveCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpAppconnectionsV1alphaResolveAppConnectionsResponse) error) error {
9611 c.ctx_ = ctx
9612 defer c.PageToken(c.urlParams_.Get("pageToken"))
9613 for {
9614 x, err := c.Do()
9615 if err != nil {
9616 return err
9617 }
9618 if err := f(x); err != nil {
9619 return err
9620 }
9621 if x.NextPageToken == "" {
9622 return nil
9623 }
9624 c.PageToken(x.NextPageToken)
9625 }
9626 }
9627
9628 type ProjectsLocationsAppConnectionsSetIamPolicyCall struct {
9629 s *Service
9630 resource string
9631 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
9632 urlParams_ gensupport.URLParams
9633 ctx_ context.Context
9634 header_ http.Header
9635 }
9636
9637
9638
9639
9640
9641
9642
9643
9644 func (r *ProjectsLocationsAppConnectionsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsAppConnectionsSetIamPolicyCall {
9645 c := &ProjectsLocationsAppConnectionsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9646 c.resource = resource
9647 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
9648 return c
9649 }
9650
9651
9652
9653
9654 func (c *ProjectsLocationsAppConnectionsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsSetIamPolicyCall {
9655 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9656 return c
9657 }
9658
9659
9660 func (c *ProjectsLocationsAppConnectionsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsSetIamPolicyCall {
9661 c.ctx_ = ctx
9662 return c
9663 }
9664
9665
9666
9667 func (c *ProjectsLocationsAppConnectionsSetIamPolicyCall) Header() http.Header {
9668 if c.header_ == nil {
9669 c.header_ = make(http.Header)
9670 }
9671 return c.header_
9672 }
9673
9674 func (c *ProjectsLocationsAppConnectionsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
9675 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9676 var body io.Reader = nil
9677 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
9678 if err != nil {
9679 return nil, err
9680 }
9681 c.urlParams_.Set("alt", alt)
9682 c.urlParams_.Set("prettyPrint", "false")
9683 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
9684 urls += "?" + c.urlParams_.Encode()
9685 req, err := http.NewRequest("POST", urls, body)
9686 if err != nil {
9687 return nil, err
9688 }
9689 req.Header = reqHeaders
9690 googleapi.Expand(req.URL, map[string]string{
9691 "resource": c.resource,
9692 })
9693 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9694 }
9695
9696
9697
9698
9699
9700
9701
9702 func (c *ProjectsLocationsAppConnectionsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
9703 gensupport.SetOptions(c.urlParams_, opts...)
9704 res, err := c.doRequest("json")
9705 if res != nil && res.StatusCode == http.StatusNotModified {
9706 if res.Body != nil {
9707 res.Body.Close()
9708 }
9709 return nil, gensupport.WrapError(&googleapi.Error{
9710 Code: res.StatusCode,
9711 Header: res.Header,
9712 })
9713 }
9714 if err != nil {
9715 return nil, err
9716 }
9717 defer googleapi.CloseBody(res)
9718 if err := googleapi.CheckResponse(res); err != nil {
9719 return nil, gensupport.WrapError(err)
9720 }
9721 ret := &GoogleIamV1Policy{
9722 ServerResponse: googleapi.ServerResponse{
9723 Header: res.Header,
9724 HTTPStatusCode: res.StatusCode,
9725 },
9726 }
9727 target := &ret
9728 if err := gensupport.DecodeResponse(target, res); err != nil {
9729 return nil, err
9730 }
9731 return ret, nil
9732 }
9733
9734 type ProjectsLocationsAppConnectionsTestIamPermissionsCall struct {
9735 s *Service
9736 resource string
9737 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
9738 urlParams_ gensupport.URLParams
9739 ctx_ context.Context
9740 header_ http.Header
9741 }
9742
9743
9744
9745
9746
9747
9748
9749
9750
9751
9752
9753 func (r *ProjectsLocationsAppConnectionsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsAppConnectionsTestIamPermissionsCall {
9754 c := &ProjectsLocationsAppConnectionsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9755 c.resource = resource
9756 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
9757 return c
9758 }
9759
9760
9761
9762
9763 func (c *ProjectsLocationsAppConnectionsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectionsTestIamPermissionsCall {
9764 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9765 return c
9766 }
9767
9768
9769 func (c *ProjectsLocationsAppConnectionsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsAppConnectionsTestIamPermissionsCall {
9770 c.ctx_ = ctx
9771 return c
9772 }
9773
9774
9775
9776 func (c *ProjectsLocationsAppConnectionsTestIamPermissionsCall) Header() http.Header {
9777 if c.header_ == nil {
9778 c.header_ = make(http.Header)
9779 }
9780 return c.header_
9781 }
9782
9783 func (c *ProjectsLocationsAppConnectionsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
9784 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9785 var body io.Reader = nil
9786 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
9787 if err != nil {
9788 return nil, err
9789 }
9790 c.urlParams_.Set("alt", alt)
9791 c.urlParams_.Set("prettyPrint", "false")
9792 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
9793 urls += "?" + c.urlParams_.Encode()
9794 req, err := http.NewRequest("POST", urls, body)
9795 if err != nil {
9796 return nil, err
9797 }
9798 req.Header = reqHeaders
9799 googleapi.Expand(req.URL, map[string]string{
9800 "resource": c.resource,
9801 })
9802 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9803 }
9804
9805
9806
9807
9808
9809
9810
9811 func (c *ProjectsLocationsAppConnectionsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
9812 gensupport.SetOptions(c.urlParams_, opts...)
9813 res, err := c.doRequest("json")
9814 if res != nil && res.StatusCode == http.StatusNotModified {
9815 if res.Body != nil {
9816 res.Body.Close()
9817 }
9818 return nil, gensupport.WrapError(&googleapi.Error{
9819 Code: res.StatusCode,
9820 Header: res.Header,
9821 })
9822 }
9823 if err != nil {
9824 return nil, err
9825 }
9826 defer googleapi.CloseBody(res)
9827 if err := googleapi.CheckResponse(res); err != nil {
9828 return nil, gensupport.WrapError(err)
9829 }
9830 ret := &GoogleIamV1TestIamPermissionsResponse{
9831 ServerResponse: googleapi.ServerResponse{
9832 Header: res.Header,
9833 HTTPStatusCode: res.StatusCode,
9834 },
9835 }
9836 target := &ret
9837 if err := gensupport.DecodeResponse(target, res); err != nil {
9838 return nil, err
9839 }
9840 return ret, nil
9841 }
9842
9843 type ProjectsLocationsAppConnectorsCreateCall struct {
9844 s *Service
9845 parent string
9846 googlecloudbeyondcorpappconnectorsv1alphaappconnector *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector
9847 urlParams_ gensupport.URLParams
9848 ctx_ context.Context
9849 header_ http.Header
9850 }
9851
9852
9853
9854
9855
9856 func (r *ProjectsLocationsAppConnectorsService) Create(parent string, googlecloudbeyondcorpappconnectorsv1alphaappconnector *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector) *ProjectsLocationsAppConnectorsCreateCall {
9857 c := &ProjectsLocationsAppConnectorsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9858 c.parent = parent
9859 c.googlecloudbeyondcorpappconnectorsv1alphaappconnector = googlecloudbeyondcorpappconnectorsv1alphaappconnector
9860 return c
9861 }
9862
9863
9864
9865
9866 func (c *ProjectsLocationsAppConnectorsCreateCall) AppConnectorId(appConnectorId string) *ProjectsLocationsAppConnectorsCreateCall {
9867 c.urlParams_.Set("appConnectorId", appConnectorId)
9868 return c
9869 }
9870
9871
9872
9873
9874
9875
9876
9877
9878
9879
9880
9881
9882 func (c *ProjectsLocationsAppConnectorsCreateCall) RequestId(requestId string) *ProjectsLocationsAppConnectorsCreateCall {
9883 c.urlParams_.Set("requestId", requestId)
9884 return c
9885 }
9886
9887
9888
9889
9890 func (c *ProjectsLocationsAppConnectorsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsAppConnectorsCreateCall {
9891 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
9892 return c
9893 }
9894
9895
9896
9897
9898 func (c *ProjectsLocationsAppConnectorsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsCreateCall {
9899 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9900 return c
9901 }
9902
9903
9904 func (c *ProjectsLocationsAppConnectorsCreateCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsCreateCall {
9905 c.ctx_ = ctx
9906 return c
9907 }
9908
9909
9910
9911 func (c *ProjectsLocationsAppConnectorsCreateCall) Header() http.Header {
9912 if c.header_ == nil {
9913 c.header_ = make(http.Header)
9914 }
9915 return c.header_
9916 }
9917
9918 func (c *ProjectsLocationsAppConnectorsCreateCall) doRequest(alt string) (*http.Response, error) {
9919 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9920 var body io.Reader = nil
9921 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpappconnectorsv1alphaappconnector)
9922 if err != nil {
9923 return nil, err
9924 }
9925 c.urlParams_.Set("alt", alt)
9926 c.urlParams_.Set("prettyPrint", "false")
9927 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/appConnectors")
9928 urls += "?" + c.urlParams_.Encode()
9929 req, err := http.NewRequest("POST", urls, body)
9930 if err != nil {
9931 return nil, err
9932 }
9933 req.Header = reqHeaders
9934 googleapi.Expand(req.URL, map[string]string{
9935 "parent": c.parent,
9936 })
9937 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9938 }
9939
9940
9941
9942
9943
9944
9945
9946 func (c *ProjectsLocationsAppConnectorsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
9947 gensupport.SetOptions(c.urlParams_, opts...)
9948 res, err := c.doRequest("json")
9949 if res != nil && res.StatusCode == http.StatusNotModified {
9950 if res.Body != nil {
9951 res.Body.Close()
9952 }
9953 return nil, gensupport.WrapError(&googleapi.Error{
9954 Code: res.StatusCode,
9955 Header: res.Header,
9956 })
9957 }
9958 if err != nil {
9959 return nil, err
9960 }
9961 defer googleapi.CloseBody(res)
9962 if err := googleapi.CheckResponse(res); err != nil {
9963 return nil, gensupport.WrapError(err)
9964 }
9965 ret := &GoogleLongrunningOperation{
9966 ServerResponse: googleapi.ServerResponse{
9967 Header: res.Header,
9968 HTTPStatusCode: res.StatusCode,
9969 },
9970 }
9971 target := &ret
9972 if err := gensupport.DecodeResponse(target, res); err != nil {
9973 return nil, err
9974 }
9975 return ret, nil
9976 }
9977
9978 type ProjectsLocationsAppConnectorsDeleteCall struct {
9979 s *Service
9980 name string
9981 urlParams_ gensupport.URLParams
9982 ctx_ context.Context
9983 header_ http.Header
9984 }
9985
9986
9987
9988
9989
9990
9991 func (r *ProjectsLocationsAppConnectorsService) Delete(name string) *ProjectsLocationsAppConnectorsDeleteCall {
9992 c := &ProjectsLocationsAppConnectorsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9993 c.name = name
9994 return c
9995 }
9996
9997
9998
9999
10000
10001
10002
10003
10004
10005
10006
10007
10008 func (c *ProjectsLocationsAppConnectorsDeleteCall) RequestId(requestId string) *ProjectsLocationsAppConnectorsDeleteCall {
10009 c.urlParams_.Set("requestId", requestId)
10010 return c
10011 }
10012
10013
10014
10015
10016 func (c *ProjectsLocationsAppConnectorsDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsAppConnectorsDeleteCall {
10017 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
10018 return c
10019 }
10020
10021
10022
10023
10024 func (c *ProjectsLocationsAppConnectorsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsDeleteCall {
10025 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10026 return c
10027 }
10028
10029
10030 func (c *ProjectsLocationsAppConnectorsDeleteCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsDeleteCall {
10031 c.ctx_ = ctx
10032 return c
10033 }
10034
10035
10036
10037 func (c *ProjectsLocationsAppConnectorsDeleteCall) Header() http.Header {
10038 if c.header_ == nil {
10039 c.header_ = make(http.Header)
10040 }
10041 return c.header_
10042 }
10043
10044 func (c *ProjectsLocationsAppConnectorsDeleteCall) doRequest(alt string) (*http.Response, error) {
10045 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10046 var body io.Reader = nil
10047 c.urlParams_.Set("alt", alt)
10048 c.urlParams_.Set("prettyPrint", "false")
10049 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
10050 urls += "?" + c.urlParams_.Encode()
10051 req, err := http.NewRequest("DELETE", urls, body)
10052 if err != nil {
10053 return nil, err
10054 }
10055 req.Header = reqHeaders
10056 googleapi.Expand(req.URL, map[string]string{
10057 "name": c.name,
10058 })
10059 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10060 }
10061
10062
10063
10064
10065
10066
10067
10068 func (c *ProjectsLocationsAppConnectorsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
10069 gensupport.SetOptions(c.urlParams_, opts...)
10070 res, err := c.doRequest("json")
10071 if res != nil && res.StatusCode == http.StatusNotModified {
10072 if res.Body != nil {
10073 res.Body.Close()
10074 }
10075 return nil, gensupport.WrapError(&googleapi.Error{
10076 Code: res.StatusCode,
10077 Header: res.Header,
10078 })
10079 }
10080 if err != nil {
10081 return nil, err
10082 }
10083 defer googleapi.CloseBody(res)
10084 if err := googleapi.CheckResponse(res); err != nil {
10085 return nil, gensupport.WrapError(err)
10086 }
10087 ret := &GoogleLongrunningOperation{
10088 ServerResponse: googleapi.ServerResponse{
10089 Header: res.Header,
10090 HTTPStatusCode: res.StatusCode,
10091 },
10092 }
10093 target := &ret
10094 if err := gensupport.DecodeResponse(target, res); err != nil {
10095 return nil, err
10096 }
10097 return ret, nil
10098 }
10099
10100 type ProjectsLocationsAppConnectorsGetCall struct {
10101 s *Service
10102 name string
10103 urlParams_ gensupport.URLParams
10104 ifNoneMatch_ string
10105 ctx_ context.Context
10106 header_ http.Header
10107 }
10108
10109
10110
10111
10112
10113
10114 func (r *ProjectsLocationsAppConnectorsService) Get(name string) *ProjectsLocationsAppConnectorsGetCall {
10115 c := &ProjectsLocationsAppConnectorsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10116 c.name = name
10117 return c
10118 }
10119
10120
10121
10122
10123 func (c *ProjectsLocationsAppConnectorsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsGetCall {
10124 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10125 return c
10126 }
10127
10128
10129
10130
10131 func (c *ProjectsLocationsAppConnectorsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppConnectorsGetCall {
10132 c.ifNoneMatch_ = entityTag
10133 return c
10134 }
10135
10136
10137 func (c *ProjectsLocationsAppConnectorsGetCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsGetCall {
10138 c.ctx_ = ctx
10139 return c
10140 }
10141
10142
10143
10144 func (c *ProjectsLocationsAppConnectorsGetCall) Header() http.Header {
10145 if c.header_ == nil {
10146 c.header_ = make(http.Header)
10147 }
10148 return c.header_
10149 }
10150
10151 func (c *ProjectsLocationsAppConnectorsGetCall) doRequest(alt string) (*http.Response, error) {
10152 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10153 if c.ifNoneMatch_ != "" {
10154 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10155 }
10156 var body io.Reader = nil
10157 c.urlParams_.Set("alt", alt)
10158 c.urlParams_.Set("prettyPrint", "false")
10159 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
10160 urls += "?" + c.urlParams_.Encode()
10161 req, err := http.NewRequest("GET", urls, body)
10162 if err != nil {
10163 return nil, err
10164 }
10165 req.Header = reqHeaders
10166 googleapi.Expand(req.URL, map[string]string{
10167 "name": c.name,
10168 })
10169 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10170 }
10171
10172
10173
10174
10175
10176
10177
10178 func (c *ProjectsLocationsAppConnectorsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector, error) {
10179 gensupport.SetOptions(c.urlParams_, opts...)
10180 res, err := c.doRequest("json")
10181 if res != nil && res.StatusCode == http.StatusNotModified {
10182 if res.Body != nil {
10183 res.Body.Close()
10184 }
10185 return nil, gensupport.WrapError(&googleapi.Error{
10186 Code: res.StatusCode,
10187 Header: res.Header,
10188 })
10189 }
10190 if err != nil {
10191 return nil, err
10192 }
10193 defer googleapi.CloseBody(res)
10194 if err := googleapi.CheckResponse(res); err != nil {
10195 return nil, gensupport.WrapError(err)
10196 }
10197 ret := &GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector{
10198 ServerResponse: googleapi.ServerResponse{
10199 Header: res.Header,
10200 HTTPStatusCode: res.StatusCode,
10201 },
10202 }
10203 target := &ret
10204 if err := gensupport.DecodeResponse(target, res); err != nil {
10205 return nil, err
10206 }
10207 return ret, nil
10208 }
10209
10210 type ProjectsLocationsAppConnectorsGetIamPolicyCall struct {
10211 s *Service
10212 resource string
10213 urlParams_ gensupport.URLParams
10214 ifNoneMatch_ string
10215 ctx_ context.Context
10216 header_ http.Header
10217 }
10218
10219
10220
10221
10222
10223
10224
10225 func (r *ProjectsLocationsAppConnectorsService) GetIamPolicy(resource string) *ProjectsLocationsAppConnectorsGetIamPolicyCall {
10226 c := &ProjectsLocationsAppConnectorsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10227 c.resource = resource
10228 return c
10229 }
10230
10231
10232
10233
10234
10235
10236
10237
10238
10239
10240
10241
10242
10243 func (c *ProjectsLocationsAppConnectorsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsAppConnectorsGetIamPolicyCall {
10244 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
10245 return c
10246 }
10247
10248
10249
10250
10251 func (c *ProjectsLocationsAppConnectorsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsGetIamPolicyCall {
10252 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10253 return c
10254 }
10255
10256
10257
10258
10259 func (c *ProjectsLocationsAppConnectorsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppConnectorsGetIamPolicyCall {
10260 c.ifNoneMatch_ = entityTag
10261 return c
10262 }
10263
10264
10265 func (c *ProjectsLocationsAppConnectorsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsGetIamPolicyCall {
10266 c.ctx_ = ctx
10267 return c
10268 }
10269
10270
10271
10272 func (c *ProjectsLocationsAppConnectorsGetIamPolicyCall) Header() http.Header {
10273 if c.header_ == nil {
10274 c.header_ = make(http.Header)
10275 }
10276 return c.header_
10277 }
10278
10279 func (c *ProjectsLocationsAppConnectorsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
10280 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10281 if c.ifNoneMatch_ != "" {
10282 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10283 }
10284 var body io.Reader = nil
10285 c.urlParams_.Set("alt", alt)
10286 c.urlParams_.Set("prettyPrint", "false")
10287 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
10288 urls += "?" + c.urlParams_.Encode()
10289 req, err := http.NewRequest("GET", urls, body)
10290 if err != nil {
10291 return nil, err
10292 }
10293 req.Header = reqHeaders
10294 googleapi.Expand(req.URL, map[string]string{
10295 "resource": c.resource,
10296 })
10297 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10298 }
10299
10300
10301
10302
10303
10304
10305
10306 func (c *ProjectsLocationsAppConnectorsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
10307 gensupport.SetOptions(c.urlParams_, opts...)
10308 res, err := c.doRequest("json")
10309 if res != nil && res.StatusCode == http.StatusNotModified {
10310 if res.Body != nil {
10311 res.Body.Close()
10312 }
10313 return nil, gensupport.WrapError(&googleapi.Error{
10314 Code: res.StatusCode,
10315 Header: res.Header,
10316 })
10317 }
10318 if err != nil {
10319 return nil, err
10320 }
10321 defer googleapi.CloseBody(res)
10322 if err := googleapi.CheckResponse(res); err != nil {
10323 return nil, gensupport.WrapError(err)
10324 }
10325 ret := &GoogleIamV1Policy{
10326 ServerResponse: googleapi.ServerResponse{
10327 Header: res.Header,
10328 HTTPStatusCode: res.StatusCode,
10329 },
10330 }
10331 target := &ret
10332 if err := gensupport.DecodeResponse(target, res); err != nil {
10333 return nil, err
10334 }
10335 return ret, nil
10336 }
10337
10338 type ProjectsLocationsAppConnectorsListCall struct {
10339 s *Service
10340 parent string
10341 urlParams_ gensupport.URLParams
10342 ifNoneMatch_ string
10343 ctx_ context.Context
10344 header_ http.Header
10345 }
10346
10347
10348
10349
10350
10351 func (r *ProjectsLocationsAppConnectorsService) List(parent string) *ProjectsLocationsAppConnectorsListCall {
10352 c := &ProjectsLocationsAppConnectorsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10353 c.parent = parent
10354 return c
10355 }
10356
10357
10358
10359 func (c *ProjectsLocationsAppConnectorsListCall) Filter(filter string) *ProjectsLocationsAppConnectorsListCall {
10360 c.urlParams_.Set("filter", filter)
10361 return c
10362 }
10363
10364
10365
10366
10367
10368 func (c *ProjectsLocationsAppConnectorsListCall) OrderBy(orderBy string) *ProjectsLocationsAppConnectorsListCall {
10369 c.urlParams_.Set("orderBy", orderBy)
10370 return c
10371 }
10372
10373
10374
10375
10376
10377
10378 func (c *ProjectsLocationsAppConnectorsListCall) PageSize(pageSize int64) *ProjectsLocationsAppConnectorsListCall {
10379 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
10380 return c
10381 }
10382
10383
10384
10385 func (c *ProjectsLocationsAppConnectorsListCall) PageToken(pageToken string) *ProjectsLocationsAppConnectorsListCall {
10386 c.urlParams_.Set("pageToken", pageToken)
10387 return c
10388 }
10389
10390
10391
10392
10393 func (c *ProjectsLocationsAppConnectorsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsListCall {
10394 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10395 return c
10396 }
10397
10398
10399
10400
10401 func (c *ProjectsLocationsAppConnectorsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppConnectorsListCall {
10402 c.ifNoneMatch_ = entityTag
10403 return c
10404 }
10405
10406
10407 func (c *ProjectsLocationsAppConnectorsListCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsListCall {
10408 c.ctx_ = ctx
10409 return c
10410 }
10411
10412
10413
10414 func (c *ProjectsLocationsAppConnectorsListCall) Header() http.Header {
10415 if c.header_ == nil {
10416 c.header_ = make(http.Header)
10417 }
10418 return c.header_
10419 }
10420
10421 func (c *ProjectsLocationsAppConnectorsListCall) doRequest(alt string) (*http.Response, error) {
10422 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10423 if c.ifNoneMatch_ != "" {
10424 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10425 }
10426 var body io.Reader = nil
10427 c.urlParams_.Set("alt", alt)
10428 c.urlParams_.Set("prettyPrint", "false")
10429 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/appConnectors")
10430 urls += "?" + c.urlParams_.Encode()
10431 req, err := http.NewRequest("GET", urls, body)
10432 if err != nil {
10433 return nil, err
10434 }
10435 req.Header = reqHeaders
10436 googleapi.Expand(req.URL, map[string]string{
10437 "parent": c.parent,
10438 })
10439 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10440 }
10441
10442
10443
10444
10445
10446
10447
10448 func (c *ProjectsLocationsAppConnectorsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpAppconnectorsV1alphaListAppConnectorsResponse, error) {
10449 gensupport.SetOptions(c.urlParams_, opts...)
10450 res, err := c.doRequest("json")
10451 if res != nil && res.StatusCode == http.StatusNotModified {
10452 if res.Body != nil {
10453 res.Body.Close()
10454 }
10455 return nil, gensupport.WrapError(&googleapi.Error{
10456 Code: res.StatusCode,
10457 Header: res.Header,
10458 })
10459 }
10460 if err != nil {
10461 return nil, err
10462 }
10463 defer googleapi.CloseBody(res)
10464 if err := googleapi.CheckResponse(res); err != nil {
10465 return nil, gensupport.WrapError(err)
10466 }
10467 ret := &GoogleCloudBeyondcorpAppconnectorsV1alphaListAppConnectorsResponse{
10468 ServerResponse: googleapi.ServerResponse{
10469 Header: res.Header,
10470 HTTPStatusCode: res.StatusCode,
10471 },
10472 }
10473 target := &ret
10474 if err := gensupport.DecodeResponse(target, res); err != nil {
10475 return nil, err
10476 }
10477 return ret, nil
10478 }
10479
10480
10481
10482
10483 func (c *ProjectsLocationsAppConnectorsListCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpAppconnectorsV1alphaListAppConnectorsResponse) error) error {
10484 c.ctx_ = ctx
10485 defer c.PageToken(c.urlParams_.Get("pageToken"))
10486 for {
10487 x, err := c.Do()
10488 if err != nil {
10489 return err
10490 }
10491 if err := f(x); err != nil {
10492 return err
10493 }
10494 if x.NextPageToken == "" {
10495 return nil
10496 }
10497 c.PageToken(x.NextPageToken)
10498 }
10499 }
10500
10501 type ProjectsLocationsAppConnectorsPatchCall struct {
10502 s *Service
10503 name string
10504 googlecloudbeyondcorpappconnectorsv1alphaappconnector *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector
10505 urlParams_ gensupport.URLParams
10506 ctx_ context.Context
10507 header_ http.Header
10508 }
10509
10510
10511
10512
10513
10514 func (r *ProjectsLocationsAppConnectorsService) Patch(name string, googlecloudbeyondcorpappconnectorsv1alphaappconnector *GoogleCloudBeyondcorpAppconnectorsV1alphaAppConnector) *ProjectsLocationsAppConnectorsPatchCall {
10515 c := &ProjectsLocationsAppConnectorsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10516 c.name = name
10517 c.googlecloudbeyondcorpappconnectorsv1alphaappconnector = googlecloudbeyondcorpappconnectorsv1alphaappconnector
10518 return c
10519 }
10520
10521
10522
10523
10524
10525
10526
10527
10528
10529
10530
10531
10532 func (c *ProjectsLocationsAppConnectorsPatchCall) RequestId(requestId string) *ProjectsLocationsAppConnectorsPatchCall {
10533 c.urlParams_.Set("requestId", requestId)
10534 return c
10535 }
10536
10537
10538
10539
10540
10541 func (c *ProjectsLocationsAppConnectorsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsAppConnectorsPatchCall {
10542 c.urlParams_.Set("updateMask", updateMask)
10543 return c
10544 }
10545
10546
10547
10548
10549 func (c *ProjectsLocationsAppConnectorsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsAppConnectorsPatchCall {
10550 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
10551 return c
10552 }
10553
10554
10555
10556
10557 func (c *ProjectsLocationsAppConnectorsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsPatchCall {
10558 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10559 return c
10560 }
10561
10562
10563 func (c *ProjectsLocationsAppConnectorsPatchCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsPatchCall {
10564 c.ctx_ = ctx
10565 return c
10566 }
10567
10568
10569
10570 func (c *ProjectsLocationsAppConnectorsPatchCall) Header() http.Header {
10571 if c.header_ == nil {
10572 c.header_ = make(http.Header)
10573 }
10574 return c.header_
10575 }
10576
10577 func (c *ProjectsLocationsAppConnectorsPatchCall) doRequest(alt string) (*http.Response, error) {
10578 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10579 var body io.Reader = nil
10580 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpappconnectorsv1alphaappconnector)
10581 if err != nil {
10582 return nil, err
10583 }
10584 c.urlParams_.Set("alt", alt)
10585 c.urlParams_.Set("prettyPrint", "false")
10586 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
10587 urls += "?" + c.urlParams_.Encode()
10588 req, err := http.NewRequest("PATCH", urls, body)
10589 if err != nil {
10590 return nil, err
10591 }
10592 req.Header = reqHeaders
10593 googleapi.Expand(req.URL, map[string]string{
10594 "name": c.name,
10595 })
10596 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10597 }
10598
10599
10600
10601
10602
10603
10604
10605 func (c *ProjectsLocationsAppConnectorsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
10606 gensupport.SetOptions(c.urlParams_, opts...)
10607 res, err := c.doRequest("json")
10608 if res != nil && res.StatusCode == http.StatusNotModified {
10609 if res.Body != nil {
10610 res.Body.Close()
10611 }
10612 return nil, gensupport.WrapError(&googleapi.Error{
10613 Code: res.StatusCode,
10614 Header: res.Header,
10615 })
10616 }
10617 if err != nil {
10618 return nil, err
10619 }
10620 defer googleapi.CloseBody(res)
10621 if err := googleapi.CheckResponse(res); err != nil {
10622 return nil, gensupport.WrapError(err)
10623 }
10624 ret := &GoogleLongrunningOperation{
10625 ServerResponse: googleapi.ServerResponse{
10626 Header: res.Header,
10627 HTTPStatusCode: res.StatusCode,
10628 },
10629 }
10630 target := &ret
10631 if err := gensupport.DecodeResponse(target, res); err != nil {
10632 return nil, err
10633 }
10634 return ret, nil
10635 }
10636
10637 type ProjectsLocationsAppConnectorsReportStatusCall struct {
10638 s *Service
10639 appConnector string
10640 googlecloudbeyondcorpappconnectorsv1alphareportstatusrequest *GoogleCloudBeyondcorpAppconnectorsV1alphaReportStatusRequest
10641 urlParams_ gensupport.URLParams
10642 ctx_ context.Context
10643 header_ http.Header
10644 }
10645
10646
10647
10648
10649
10650 func (r *ProjectsLocationsAppConnectorsService) ReportStatus(appConnector string, googlecloudbeyondcorpappconnectorsv1alphareportstatusrequest *GoogleCloudBeyondcorpAppconnectorsV1alphaReportStatusRequest) *ProjectsLocationsAppConnectorsReportStatusCall {
10651 c := &ProjectsLocationsAppConnectorsReportStatusCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10652 c.appConnector = appConnector
10653 c.googlecloudbeyondcorpappconnectorsv1alphareportstatusrequest = googlecloudbeyondcorpappconnectorsv1alphareportstatusrequest
10654 return c
10655 }
10656
10657
10658
10659
10660 func (c *ProjectsLocationsAppConnectorsReportStatusCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsReportStatusCall {
10661 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10662 return c
10663 }
10664
10665
10666 func (c *ProjectsLocationsAppConnectorsReportStatusCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsReportStatusCall {
10667 c.ctx_ = ctx
10668 return c
10669 }
10670
10671
10672
10673 func (c *ProjectsLocationsAppConnectorsReportStatusCall) Header() http.Header {
10674 if c.header_ == nil {
10675 c.header_ = make(http.Header)
10676 }
10677 return c.header_
10678 }
10679
10680 func (c *ProjectsLocationsAppConnectorsReportStatusCall) doRequest(alt string) (*http.Response, error) {
10681 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10682 var body io.Reader = nil
10683 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpappconnectorsv1alphareportstatusrequest)
10684 if err != nil {
10685 return nil, err
10686 }
10687 c.urlParams_.Set("alt", alt)
10688 c.urlParams_.Set("prettyPrint", "false")
10689 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+appConnector}:reportStatus")
10690 urls += "?" + c.urlParams_.Encode()
10691 req, err := http.NewRequest("POST", urls, body)
10692 if err != nil {
10693 return nil, err
10694 }
10695 req.Header = reqHeaders
10696 googleapi.Expand(req.URL, map[string]string{
10697 "appConnector": c.appConnector,
10698 })
10699 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10700 }
10701
10702
10703
10704
10705
10706
10707
10708 func (c *ProjectsLocationsAppConnectorsReportStatusCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
10709 gensupport.SetOptions(c.urlParams_, opts...)
10710 res, err := c.doRequest("json")
10711 if res != nil && res.StatusCode == http.StatusNotModified {
10712 if res.Body != nil {
10713 res.Body.Close()
10714 }
10715 return nil, gensupport.WrapError(&googleapi.Error{
10716 Code: res.StatusCode,
10717 Header: res.Header,
10718 })
10719 }
10720 if err != nil {
10721 return nil, err
10722 }
10723 defer googleapi.CloseBody(res)
10724 if err := googleapi.CheckResponse(res); err != nil {
10725 return nil, gensupport.WrapError(err)
10726 }
10727 ret := &GoogleLongrunningOperation{
10728 ServerResponse: googleapi.ServerResponse{
10729 Header: res.Header,
10730 HTTPStatusCode: res.StatusCode,
10731 },
10732 }
10733 target := &ret
10734 if err := gensupport.DecodeResponse(target, res); err != nil {
10735 return nil, err
10736 }
10737 return ret, nil
10738 }
10739
10740 type ProjectsLocationsAppConnectorsResolveInstanceConfigCall struct {
10741 s *Service
10742 appConnector string
10743 urlParams_ gensupport.URLParams
10744 ifNoneMatch_ string
10745 ctx_ context.Context
10746 header_ http.Header
10747 }
10748
10749
10750
10751
10752
10753
10754
10755 func (r *ProjectsLocationsAppConnectorsService) ResolveInstanceConfig(appConnector string) *ProjectsLocationsAppConnectorsResolveInstanceConfigCall {
10756 c := &ProjectsLocationsAppConnectorsResolveInstanceConfigCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10757 c.appConnector = appConnector
10758 return c
10759 }
10760
10761
10762
10763
10764 func (c *ProjectsLocationsAppConnectorsResolveInstanceConfigCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsResolveInstanceConfigCall {
10765 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10766 return c
10767 }
10768
10769
10770
10771
10772 func (c *ProjectsLocationsAppConnectorsResolveInstanceConfigCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppConnectorsResolveInstanceConfigCall {
10773 c.ifNoneMatch_ = entityTag
10774 return c
10775 }
10776
10777
10778 func (c *ProjectsLocationsAppConnectorsResolveInstanceConfigCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsResolveInstanceConfigCall {
10779 c.ctx_ = ctx
10780 return c
10781 }
10782
10783
10784
10785 func (c *ProjectsLocationsAppConnectorsResolveInstanceConfigCall) Header() http.Header {
10786 if c.header_ == nil {
10787 c.header_ = make(http.Header)
10788 }
10789 return c.header_
10790 }
10791
10792 func (c *ProjectsLocationsAppConnectorsResolveInstanceConfigCall) doRequest(alt string) (*http.Response, error) {
10793 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10794 if c.ifNoneMatch_ != "" {
10795 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10796 }
10797 var body io.Reader = nil
10798 c.urlParams_.Set("alt", alt)
10799 c.urlParams_.Set("prettyPrint", "false")
10800 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+appConnector}:resolveInstanceConfig")
10801 urls += "?" + c.urlParams_.Encode()
10802 req, err := http.NewRequest("GET", urls, body)
10803 if err != nil {
10804 return nil, err
10805 }
10806 req.Header = reqHeaders
10807 googleapi.Expand(req.URL, map[string]string{
10808 "appConnector": c.appConnector,
10809 })
10810 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10811 }
10812
10813
10814
10815
10816
10817
10818
10819 func (c *ProjectsLocationsAppConnectorsResolveInstanceConfigCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpAppconnectorsV1alphaResolveInstanceConfigResponse, error) {
10820 gensupport.SetOptions(c.urlParams_, opts...)
10821 res, err := c.doRequest("json")
10822 if res != nil && res.StatusCode == http.StatusNotModified {
10823 if res.Body != nil {
10824 res.Body.Close()
10825 }
10826 return nil, gensupport.WrapError(&googleapi.Error{
10827 Code: res.StatusCode,
10828 Header: res.Header,
10829 })
10830 }
10831 if err != nil {
10832 return nil, err
10833 }
10834 defer googleapi.CloseBody(res)
10835 if err := googleapi.CheckResponse(res); err != nil {
10836 return nil, gensupport.WrapError(err)
10837 }
10838 ret := &GoogleCloudBeyondcorpAppconnectorsV1alphaResolveInstanceConfigResponse{
10839 ServerResponse: googleapi.ServerResponse{
10840 Header: res.Header,
10841 HTTPStatusCode: res.StatusCode,
10842 },
10843 }
10844 target := &ret
10845 if err := gensupport.DecodeResponse(target, res); err != nil {
10846 return nil, err
10847 }
10848 return ret, nil
10849 }
10850
10851 type ProjectsLocationsAppConnectorsSetIamPolicyCall struct {
10852 s *Service
10853 resource string
10854 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
10855 urlParams_ gensupport.URLParams
10856 ctx_ context.Context
10857 header_ http.Header
10858 }
10859
10860
10861
10862
10863
10864
10865
10866
10867 func (r *ProjectsLocationsAppConnectorsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsAppConnectorsSetIamPolicyCall {
10868 c := &ProjectsLocationsAppConnectorsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10869 c.resource = resource
10870 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
10871 return c
10872 }
10873
10874
10875
10876
10877 func (c *ProjectsLocationsAppConnectorsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsSetIamPolicyCall {
10878 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10879 return c
10880 }
10881
10882
10883 func (c *ProjectsLocationsAppConnectorsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsSetIamPolicyCall {
10884 c.ctx_ = ctx
10885 return c
10886 }
10887
10888
10889
10890 func (c *ProjectsLocationsAppConnectorsSetIamPolicyCall) Header() http.Header {
10891 if c.header_ == nil {
10892 c.header_ = make(http.Header)
10893 }
10894 return c.header_
10895 }
10896
10897 func (c *ProjectsLocationsAppConnectorsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
10898 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10899 var body io.Reader = nil
10900 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
10901 if err != nil {
10902 return nil, err
10903 }
10904 c.urlParams_.Set("alt", alt)
10905 c.urlParams_.Set("prettyPrint", "false")
10906 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
10907 urls += "?" + c.urlParams_.Encode()
10908 req, err := http.NewRequest("POST", urls, body)
10909 if err != nil {
10910 return nil, err
10911 }
10912 req.Header = reqHeaders
10913 googleapi.Expand(req.URL, map[string]string{
10914 "resource": c.resource,
10915 })
10916 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10917 }
10918
10919
10920
10921
10922
10923
10924
10925 func (c *ProjectsLocationsAppConnectorsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
10926 gensupport.SetOptions(c.urlParams_, opts...)
10927 res, err := c.doRequest("json")
10928 if res != nil && res.StatusCode == http.StatusNotModified {
10929 if res.Body != nil {
10930 res.Body.Close()
10931 }
10932 return nil, gensupport.WrapError(&googleapi.Error{
10933 Code: res.StatusCode,
10934 Header: res.Header,
10935 })
10936 }
10937 if err != nil {
10938 return nil, err
10939 }
10940 defer googleapi.CloseBody(res)
10941 if err := googleapi.CheckResponse(res); err != nil {
10942 return nil, gensupport.WrapError(err)
10943 }
10944 ret := &GoogleIamV1Policy{
10945 ServerResponse: googleapi.ServerResponse{
10946 Header: res.Header,
10947 HTTPStatusCode: res.StatusCode,
10948 },
10949 }
10950 target := &ret
10951 if err := gensupport.DecodeResponse(target, res); err != nil {
10952 return nil, err
10953 }
10954 return ret, nil
10955 }
10956
10957 type ProjectsLocationsAppConnectorsTestIamPermissionsCall struct {
10958 s *Service
10959 resource string
10960 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
10961 urlParams_ gensupport.URLParams
10962 ctx_ context.Context
10963 header_ http.Header
10964 }
10965
10966
10967
10968
10969
10970
10971
10972
10973
10974
10975
10976 func (r *ProjectsLocationsAppConnectorsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsAppConnectorsTestIamPermissionsCall {
10977 c := &ProjectsLocationsAppConnectorsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10978 c.resource = resource
10979 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
10980 return c
10981 }
10982
10983
10984
10985
10986 func (c *ProjectsLocationsAppConnectorsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppConnectorsTestIamPermissionsCall {
10987 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10988 return c
10989 }
10990
10991
10992 func (c *ProjectsLocationsAppConnectorsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsAppConnectorsTestIamPermissionsCall {
10993 c.ctx_ = ctx
10994 return c
10995 }
10996
10997
10998
10999 func (c *ProjectsLocationsAppConnectorsTestIamPermissionsCall) Header() http.Header {
11000 if c.header_ == nil {
11001 c.header_ = make(http.Header)
11002 }
11003 return c.header_
11004 }
11005
11006 func (c *ProjectsLocationsAppConnectorsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
11007 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11008 var body io.Reader = nil
11009 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
11010 if err != nil {
11011 return nil, err
11012 }
11013 c.urlParams_.Set("alt", alt)
11014 c.urlParams_.Set("prettyPrint", "false")
11015 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
11016 urls += "?" + c.urlParams_.Encode()
11017 req, err := http.NewRequest("POST", urls, body)
11018 if err != nil {
11019 return nil, err
11020 }
11021 req.Header = reqHeaders
11022 googleapi.Expand(req.URL, map[string]string{
11023 "resource": c.resource,
11024 })
11025 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11026 }
11027
11028
11029
11030
11031
11032
11033
11034 func (c *ProjectsLocationsAppConnectorsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
11035 gensupport.SetOptions(c.urlParams_, opts...)
11036 res, err := c.doRequest("json")
11037 if res != nil && res.StatusCode == http.StatusNotModified {
11038 if res.Body != nil {
11039 res.Body.Close()
11040 }
11041 return nil, gensupport.WrapError(&googleapi.Error{
11042 Code: res.StatusCode,
11043 Header: res.Header,
11044 })
11045 }
11046 if err != nil {
11047 return nil, err
11048 }
11049 defer googleapi.CloseBody(res)
11050 if err := googleapi.CheckResponse(res); err != nil {
11051 return nil, gensupport.WrapError(err)
11052 }
11053 ret := &GoogleIamV1TestIamPermissionsResponse{
11054 ServerResponse: googleapi.ServerResponse{
11055 Header: res.Header,
11056 HTTPStatusCode: res.StatusCode,
11057 },
11058 }
11059 target := &ret
11060 if err := gensupport.DecodeResponse(target, res); err != nil {
11061 return nil, err
11062 }
11063 return ret, nil
11064 }
11065
11066 type ProjectsLocationsAppGatewaysCreateCall struct {
11067 s *Service
11068 parent string
11069 appgateway *AppGateway
11070 urlParams_ gensupport.URLParams
11071 ctx_ context.Context
11072 header_ http.Header
11073 }
11074
11075
11076
11077
11078
11079 func (r *ProjectsLocationsAppGatewaysService) Create(parent string, appgateway *AppGateway) *ProjectsLocationsAppGatewaysCreateCall {
11080 c := &ProjectsLocationsAppGatewaysCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11081 c.parent = parent
11082 c.appgateway = appgateway
11083 return c
11084 }
11085
11086
11087
11088
11089 func (c *ProjectsLocationsAppGatewaysCreateCall) AppGatewayId(appGatewayId string) *ProjectsLocationsAppGatewaysCreateCall {
11090 c.urlParams_.Set("appGatewayId", appGatewayId)
11091 return c
11092 }
11093
11094
11095
11096
11097
11098
11099
11100
11101
11102
11103
11104
11105 func (c *ProjectsLocationsAppGatewaysCreateCall) RequestId(requestId string) *ProjectsLocationsAppGatewaysCreateCall {
11106 c.urlParams_.Set("requestId", requestId)
11107 return c
11108 }
11109
11110
11111
11112
11113 func (c *ProjectsLocationsAppGatewaysCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsAppGatewaysCreateCall {
11114 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
11115 return c
11116 }
11117
11118
11119
11120
11121 func (c *ProjectsLocationsAppGatewaysCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppGatewaysCreateCall {
11122 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11123 return c
11124 }
11125
11126
11127 func (c *ProjectsLocationsAppGatewaysCreateCall) Context(ctx context.Context) *ProjectsLocationsAppGatewaysCreateCall {
11128 c.ctx_ = ctx
11129 return c
11130 }
11131
11132
11133
11134 func (c *ProjectsLocationsAppGatewaysCreateCall) Header() http.Header {
11135 if c.header_ == nil {
11136 c.header_ = make(http.Header)
11137 }
11138 return c.header_
11139 }
11140
11141 func (c *ProjectsLocationsAppGatewaysCreateCall) doRequest(alt string) (*http.Response, error) {
11142 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11143 var body io.Reader = nil
11144 body, err := googleapi.WithoutDataWrapper.JSONReader(c.appgateway)
11145 if err != nil {
11146 return nil, err
11147 }
11148 c.urlParams_.Set("alt", alt)
11149 c.urlParams_.Set("prettyPrint", "false")
11150 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/appGateways")
11151 urls += "?" + c.urlParams_.Encode()
11152 req, err := http.NewRequest("POST", urls, body)
11153 if err != nil {
11154 return nil, err
11155 }
11156 req.Header = reqHeaders
11157 googleapi.Expand(req.URL, map[string]string{
11158 "parent": c.parent,
11159 })
11160 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11161 }
11162
11163
11164
11165
11166
11167
11168
11169 func (c *ProjectsLocationsAppGatewaysCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
11170 gensupport.SetOptions(c.urlParams_, opts...)
11171 res, err := c.doRequest("json")
11172 if res != nil && res.StatusCode == http.StatusNotModified {
11173 if res.Body != nil {
11174 res.Body.Close()
11175 }
11176 return nil, gensupport.WrapError(&googleapi.Error{
11177 Code: res.StatusCode,
11178 Header: res.Header,
11179 })
11180 }
11181 if err != nil {
11182 return nil, err
11183 }
11184 defer googleapi.CloseBody(res)
11185 if err := googleapi.CheckResponse(res); err != nil {
11186 return nil, gensupport.WrapError(err)
11187 }
11188 ret := &GoogleLongrunningOperation{
11189 ServerResponse: googleapi.ServerResponse{
11190 Header: res.Header,
11191 HTTPStatusCode: res.StatusCode,
11192 },
11193 }
11194 target := &ret
11195 if err := gensupport.DecodeResponse(target, res); err != nil {
11196 return nil, err
11197 }
11198 return ret, nil
11199 }
11200
11201 type ProjectsLocationsAppGatewaysDeleteCall struct {
11202 s *Service
11203 name string
11204 urlParams_ gensupport.URLParams
11205 ctx_ context.Context
11206 header_ http.Header
11207 }
11208
11209
11210
11211
11212
11213
11214 func (r *ProjectsLocationsAppGatewaysService) Delete(name string) *ProjectsLocationsAppGatewaysDeleteCall {
11215 c := &ProjectsLocationsAppGatewaysDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11216 c.name = name
11217 return c
11218 }
11219
11220
11221
11222
11223
11224
11225
11226
11227
11228
11229
11230
11231 func (c *ProjectsLocationsAppGatewaysDeleteCall) RequestId(requestId string) *ProjectsLocationsAppGatewaysDeleteCall {
11232 c.urlParams_.Set("requestId", requestId)
11233 return c
11234 }
11235
11236
11237
11238
11239 func (c *ProjectsLocationsAppGatewaysDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsAppGatewaysDeleteCall {
11240 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
11241 return c
11242 }
11243
11244
11245
11246
11247 func (c *ProjectsLocationsAppGatewaysDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppGatewaysDeleteCall {
11248 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11249 return c
11250 }
11251
11252
11253 func (c *ProjectsLocationsAppGatewaysDeleteCall) Context(ctx context.Context) *ProjectsLocationsAppGatewaysDeleteCall {
11254 c.ctx_ = ctx
11255 return c
11256 }
11257
11258
11259
11260 func (c *ProjectsLocationsAppGatewaysDeleteCall) Header() http.Header {
11261 if c.header_ == nil {
11262 c.header_ = make(http.Header)
11263 }
11264 return c.header_
11265 }
11266
11267 func (c *ProjectsLocationsAppGatewaysDeleteCall) doRequest(alt string) (*http.Response, error) {
11268 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11269 var body io.Reader = nil
11270 c.urlParams_.Set("alt", alt)
11271 c.urlParams_.Set("prettyPrint", "false")
11272 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
11273 urls += "?" + c.urlParams_.Encode()
11274 req, err := http.NewRequest("DELETE", urls, body)
11275 if err != nil {
11276 return nil, err
11277 }
11278 req.Header = reqHeaders
11279 googleapi.Expand(req.URL, map[string]string{
11280 "name": c.name,
11281 })
11282 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11283 }
11284
11285
11286
11287
11288
11289
11290
11291 func (c *ProjectsLocationsAppGatewaysDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
11292 gensupport.SetOptions(c.urlParams_, opts...)
11293 res, err := c.doRequest("json")
11294 if res != nil && res.StatusCode == http.StatusNotModified {
11295 if res.Body != nil {
11296 res.Body.Close()
11297 }
11298 return nil, gensupport.WrapError(&googleapi.Error{
11299 Code: res.StatusCode,
11300 Header: res.Header,
11301 })
11302 }
11303 if err != nil {
11304 return nil, err
11305 }
11306 defer googleapi.CloseBody(res)
11307 if err := googleapi.CheckResponse(res); err != nil {
11308 return nil, gensupport.WrapError(err)
11309 }
11310 ret := &GoogleLongrunningOperation{
11311 ServerResponse: googleapi.ServerResponse{
11312 Header: res.Header,
11313 HTTPStatusCode: res.StatusCode,
11314 },
11315 }
11316 target := &ret
11317 if err := gensupport.DecodeResponse(target, res); err != nil {
11318 return nil, err
11319 }
11320 return ret, nil
11321 }
11322
11323 type ProjectsLocationsAppGatewaysGetCall struct {
11324 s *Service
11325 name string
11326 urlParams_ gensupport.URLParams
11327 ifNoneMatch_ string
11328 ctx_ context.Context
11329 header_ http.Header
11330 }
11331
11332
11333
11334
11335
11336
11337 func (r *ProjectsLocationsAppGatewaysService) Get(name string) *ProjectsLocationsAppGatewaysGetCall {
11338 c := &ProjectsLocationsAppGatewaysGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11339 c.name = name
11340 return c
11341 }
11342
11343
11344
11345
11346 func (c *ProjectsLocationsAppGatewaysGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppGatewaysGetCall {
11347 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11348 return c
11349 }
11350
11351
11352
11353
11354 func (c *ProjectsLocationsAppGatewaysGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppGatewaysGetCall {
11355 c.ifNoneMatch_ = entityTag
11356 return c
11357 }
11358
11359
11360 func (c *ProjectsLocationsAppGatewaysGetCall) Context(ctx context.Context) *ProjectsLocationsAppGatewaysGetCall {
11361 c.ctx_ = ctx
11362 return c
11363 }
11364
11365
11366
11367 func (c *ProjectsLocationsAppGatewaysGetCall) Header() http.Header {
11368 if c.header_ == nil {
11369 c.header_ = make(http.Header)
11370 }
11371 return c.header_
11372 }
11373
11374 func (c *ProjectsLocationsAppGatewaysGetCall) doRequest(alt string) (*http.Response, error) {
11375 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11376 if c.ifNoneMatch_ != "" {
11377 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11378 }
11379 var body io.Reader = nil
11380 c.urlParams_.Set("alt", alt)
11381 c.urlParams_.Set("prettyPrint", "false")
11382 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
11383 urls += "?" + c.urlParams_.Encode()
11384 req, err := http.NewRequest("GET", urls, body)
11385 if err != nil {
11386 return nil, err
11387 }
11388 req.Header = reqHeaders
11389 googleapi.Expand(req.URL, map[string]string{
11390 "name": c.name,
11391 })
11392 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11393 }
11394
11395
11396
11397
11398
11399
11400 func (c *ProjectsLocationsAppGatewaysGetCall) Do(opts ...googleapi.CallOption) (*AppGateway, error) {
11401 gensupport.SetOptions(c.urlParams_, opts...)
11402 res, err := c.doRequest("json")
11403 if res != nil && res.StatusCode == http.StatusNotModified {
11404 if res.Body != nil {
11405 res.Body.Close()
11406 }
11407 return nil, gensupport.WrapError(&googleapi.Error{
11408 Code: res.StatusCode,
11409 Header: res.Header,
11410 })
11411 }
11412 if err != nil {
11413 return nil, err
11414 }
11415 defer googleapi.CloseBody(res)
11416 if err := googleapi.CheckResponse(res); err != nil {
11417 return nil, gensupport.WrapError(err)
11418 }
11419 ret := &AppGateway{
11420 ServerResponse: googleapi.ServerResponse{
11421 Header: res.Header,
11422 HTTPStatusCode: res.StatusCode,
11423 },
11424 }
11425 target := &ret
11426 if err := gensupport.DecodeResponse(target, res); err != nil {
11427 return nil, err
11428 }
11429 return ret, nil
11430 }
11431
11432 type ProjectsLocationsAppGatewaysGetIamPolicyCall struct {
11433 s *Service
11434 resource string
11435 urlParams_ gensupport.URLParams
11436 ifNoneMatch_ string
11437 ctx_ context.Context
11438 header_ http.Header
11439 }
11440
11441
11442
11443
11444
11445
11446
11447 func (r *ProjectsLocationsAppGatewaysService) GetIamPolicy(resource string) *ProjectsLocationsAppGatewaysGetIamPolicyCall {
11448 c := &ProjectsLocationsAppGatewaysGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11449 c.resource = resource
11450 return c
11451 }
11452
11453
11454
11455
11456
11457
11458
11459
11460
11461
11462
11463
11464
11465 func (c *ProjectsLocationsAppGatewaysGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsAppGatewaysGetIamPolicyCall {
11466 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
11467 return c
11468 }
11469
11470
11471
11472
11473 func (c *ProjectsLocationsAppGatewaysGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppGatewaysGetIamPolicyCall {
11474 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11475 return c
11476 }
11477
11478
11479
11480
11481 func (c *ProjectsLocationsAppGatewaysGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppGatewaysGetIamPolicyCall {
11482 c.ifNoneMatch_ = entityTag
11483 return c
11484 }
11485
11486
11487 func (c *ProjectsLocationsAppGatewaysGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsAppGatewaysGetIamPolicyCall {
11488 c.ctx_ = ctx
11489 return c
11490 }
11491
11492
11493
11494 func (c *ProjectsLocationsAppGatewaysGetIamPolicyCall) Header() http.Header {
11495 if c.header_ == nil {
11496 c.header_ = make(http.Header)
11497 }
11498 return c.header_
11499 }
11500
11501 func (c *ProjectsLocationsAppGatewaysGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
11502 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11503 if c.ifNoneMatch_ != "" {
11504 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11505 }
11506 var body io.Reader = nil
11507 c.urlParams_.Set("alt", alt)
11508 c.urlParams_.Set("prettyPrint", "false")
11509 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
11510 urls += "?" + c.urlParams_.Encode()
11511 req, err := http.NewRequest("GET", urls, body)
11512 if err != nil {
11513 return nil, err
11514 }
11515 req.Header = reqHeaders
11516 googleapi.Expand(req.URL, map[string]string{
11517 "resource": c.resource,
11518 })
11519 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11520 }
11521
11522
11523
11524
11525
11526
11527
11528 func (c *ProjectsLocationsAppGatewaysGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
11529 gensupport.SetOptions(c.urlParams_, opts...)
11530 res, err := c.doRequest("json")
11531 if res != nil && res.StatusCode == http.StatusNotModified {
11532 if res.Body != nil {
11533 res.Body.Close()
11534 }
11535 return nil, gensupport.WrapError(&googleapi.Error{
11536 Code: res.StatusCode,
11537 Header: res.Header,
11538 })
11539 }
11540 if err != nil {
11541 return nil, err
11542 }
11543 defer googleapi.CloseBody(res)
11544 if err := googleapi.CheckResponse(res); err != nil {
11545 return nil, gensupport.WrapError(err)
11546 }
11547 ret := &GoogleIamV1Policy{
11548 ServerResponse: googleapi.ServerResponse{
11549 Header: res.Header,
11550 HTTPStatusCode: res.StatusCode,
11551 },
11552 }
11553 target := &ret
11554 if err := gensupport.DecodeResponse(target, res); err != nil {
11555 return nil, err
11556 }
11557 return ret, nil
11558 }
11559
11560 type ProjectsLocationsAppGatewaysListCall struct {
11561 s *Service
11562 parent string
11563 urlParams_ gensupport.URLParams
11564 ifNoneMatch_ string
11565 ctx_ context.Context
11566 header_ http.Header
11567 }
11568
11569
11570
11571
11572
11573 func (r *ProjectsLocationsAppGatewaysService) List(parent string) *ProjectsLocationsAppGatewaysListCall {
11574 c := &ProjectsLocationsAppGatewaysListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11575 c.parent = parent
11576 return c
11577 }
11578
11579
11580
11581 func (c *ProjectsLocationsAppGatewaysListCall) Filter(filter string) *ProjectsLocationsAppGatewaysListCall {
11582 c.urlParams_.Set("filter", filter)
11583 return c
11584 }
11585
11586
11587
11588
11589
11590 func (c *ProjectsLocationsAppGatewaysListCall) OrderBy(orderBy string) *ProjectsLocationsAppGatewaysListCall {
11591 c.urlParams_.Set("orderBy", orderBy)
11592 return c
11593 }
11594
11595
11596
11597
11598
11599
11600 func (c *ProjectsLocationsAppGatewaysListCall) PageSize(pageSize int64) *ProjectsLocationsAppGatewaysListCall {
11601 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
11602 return c
11603 }
11604
11605
11606
11607 func (c *ProjectsLocationsAppGatewaysListCall) PageToken(pageToken string) *ProjectsLocationsAppGatewaysListCall {
11608 c.urlParams_.Set("pageToken", pageToken)
11609 return c
11610 }
11611
11612
11613
11614
11615 func (c *ProjectsLocationsAppGatewaysListCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppGatewaysListCall {
11616 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11617 return c
11618 }
11619
11620
11621
11622
11623 func (c *ProjectsLocationsAppGatewaysListCall) IfNoneMatch(entityTag string) *ProjectsLocationsAppGatewaysListCall {
11624 c.ifNoneMatch_ = entityTag
11625 return c
11626 }
11627
11628
11629 func (c *ProjectsLocationsAppGatewaysListCall) Context(ctx context.Context) *ProjectsLocationsAppGatewaysListCall {
11630 c.ctx_ = ctx
11631 return c
11632 }
11633
11634
11635
11636 func (c *ProjectsLocationsAppGatewaysListCall) Header() http.Header {
11637 if c.header_ == nil {
11638 c.header_ = make(http.Header)
11639 }
11640 return c.header_
11641 }
11642
11643 func (c *ProjectsLocationsAppGatewaysListCall) doRequest(alt string) (*http.Response, error) {
11644 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11645 if c.ifNoneMatch_ != "" {
11646 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11647 }
11648 var body io.Reader = nil
11649 c.urlParams_.Set("alt", alt)
11650 c.urlParams_.Set("prettyPrint", "false")
11651 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/appGateways")
11652 urls += "?" + c.urlParams_.Encode()
11653 req, err := http.NewRequest("GET", urls, body)
11654 if err != nil {
11655 return nil, err
11656 }
11657 req.Header = reqHeaders
11658 googleapi.Expand(req.URL, map[string]string{
11659 "parent": c.parent,
11660 })
11661 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11662 }
11663
11664
11665
11666
11667
11668
11669
11670 func (c *ProjectsLocationsAppGatewaysListCall) Do(opts ...googleapi.CallOption) (*ListAppGatewaysResponse, error) {
11671 gensupport.SetOptions(c.urlParams_, opts...)
11672 res, err := c.doRequest("json")
11673 if res != nil && res.StatusCode == http.StatusNotModified {
11674 if res.Body != nil {
11675 res.Body.Close()
11676 }
11677 return nil, gensupport.WrapError(&googleapi.Error{
11678 Code: res.StatusCode,
11679 Header: res.Header,
11680 })
11681 }
11682 if err != nil {
11683 return nil, err
11684 }
11685 defer googleapi.CloseBody(res)
11686 if err := googleapi.CheckResponse(res); err != nil {
11687 return nil, gensupport.WrapError(err)
11688 }
11689 ret := &ListAppGatewaysResponse{
11690 ServerResponse: googleapi.ServerResponse{
11691 Header: res.Header,
11692 HTTPStatusCode: res.StatusCode,
11693 },
11694 }
11695 target := &ret
11696 if err := gensupport.DecodeResponse(target, res); err != nil {
11697 return nil, err
11698 }
11699 return ret, nil
11700 }
11701
11702
11703
11704
11705 func (c *ProjectsLocationsAppGatewaysListCall) Pages(ctx context.Context, f func(*ListAppGatewaysResponse) error) error {
11706 c.ctx_ = ctx
11707 defer c.PageToken(c.urlParams_.Get("pageToken"))
11708 for {
11709 x, err := c.Do()
11710 if err != nil {
11711 return err
11712 }
11713 if err := f(x); err != nil {
11714 return err
11715 }
11716 if x.NextPageToken == "" {
11717 return nil
11718 }
11719 c.PageToken(x.NextPageToken)
11720 }
11721 }
11722
11723 type ProjectsLocationsAppGatewaysSetIamPolicyCall struct {
11724 s *Service
11725 resource string
11726 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
11727 urlParams_ gensupport.URLParams
11728 ctx_ context.Context
11729 header_ http.Header
11730 }
11731
11732
11733
11734
11735
11736
11737
11738
11739 func (r *ProjectsLocationsAppGatewaysService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsAppGatewaysSetIamPolicyCall {
11740 c := &ProjectsLocationsAppGatewaysSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11741 c.resource = resource
11742 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
11743 return c
11744 }
11745
11746
11747
11748
11749 func (c *ProjectsLocationsAppGatewaysSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppGatewaysSetIamPolicyCall {
11750 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11751 return c
11752 }
11753
11754
11755 func (c *ProjectsLocationsAppGatewaysSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsAppGatewaysSetIamPolicyCall {
11756 c.ctx_ = ctx
11757 return c
11758 }
11759
11760
11761
11762 func (c *ProjectsLocationsAppGatewaysSetIamPolicyCall) Header() http.Header {
11763 if c.header_ == nil {
11764 c.header_ = make(http.Header)
11765 }
11766 return c.header_
11767 }
11768
11769 func (c *ProjectsLocationsAppGatewaysSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
11770 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11771 var body io.Reader = nil
11772 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
11773 if err != nil {
11774 return nil, err
11775 }
11776 c.urlParams_.Set("alt", alt)
11777 c.urlParams_.Set("prettyPrint", "false")
11778 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
11779 urls += "?" + c.urlParams_.Encode()
11780 req, err := http.NewRequest("POST", urls, body)
11781 if err != nil {
11782 return nil, err
11783 }
11784 req.Header = reqHeaders
11785 googleapi.Expand(req.URL, map[string]string{
11786 "resource": c.resource,
11787 })
11788 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11789 }
11790
11791
11792
11793
11794
11795
11796
11797 func (c *ProjectsLocationsAppGatewaysSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
11798 gensupport.SetOptions(c.urlParams_, opts...)
11799 res, err := c.doRequest("json")
11800 if res != nil && res.StatusCode == http.StatusNotModified {
11801 if res.Body != nil {
11802 res.Body.Close()
11803 }
11804 return nil, gensupport.WrapError(&googleapi.Error{
11805 Code: res.StatusCode,
11806 Header: res.Header,
11807 })
11808 }
11809 if err != nil {
11810 return nil, err
11811 }
11812 defer googleapi.CloseBody(res)
11813 if err := googleapi.CheckResponse(res); err != nil {
11814 return nil, gensupport.WrapError(err)
11815 }
11816 ret := &GoogleIamV1Policy{
11817 ServerResponse: googleapi.ServerResponse{
11818 Header: res.Header,
11819 HTTPStatusCode: res.StatusCode,
11820 },
11821 }
11822 target := &ret
11823 if err := gensupport.DecodeResponse(target, res); err != nil {
11824 return nil, err
11825 }
11826 return ret, nil
11827 }
11828
11829 type ProjectsLocationsAppGatewaysTestIamPermissionsCall struct {
11830 s *Service
11831 resource string
11832 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
11833 urlParams_ gensupport.URLParams
11834 ctx_ context.Context
11835 header_ http.Header
11836 }
11837
11838
11839
11840
11841
11842
11843
11844
11845
11846
11847
11848 func (r *ProjectsLocationsAppGatewaysService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsAppGatewaysTestIamPermissionsCall {
11849 c := &ProjectsLocationsAppGatewaysTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11850 c.resource = resource
11851 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
11852 return c
11853 }
11854
11855
11856
11857
11858 func (c *ProjectsLocationsAppGatewaysTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsAppGatewaysTestIamPermissionsCall {
11859 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11860 return c
11861 }
11862
11863
11864 func (c *ProjectsLocationsAppGatewaysTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsAppGatewaysTestIamPermissionsCall {
11865 c.ctx_ = ctx
11866 return c
11867 }
11868
11869
11870
11871 func (c *ProjectsLocationsAppGatewaysTestIamPermissionsCall) Header() http.Header {
11872 if c.header_ == nil {
11873 c.header_ = make(http.Header)
11874 }
11875 return c.header_
11876 }
11877
11878 func (c *ProjectsLocationsAppGatewaysTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
11879 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11880 var body io.Reader = nil
11881 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
11882 if err != nil {
11883 return nil, err
11884 }
11885 c.urlParams_.Set("alt", alt)
11886 c.urlParams_.Set("prettyPrint", "false")
11887 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
11888 urls += "?" + c.urlParams_.Encode()
11889 req, err := http.NewRequest("POST", urls, body)
11890 if err != nil {
11891 return nil, err
11892 }
11893 req.Header = reqHeaders
11894 googleapi.Expand(req.URL, map[string]string{
11895 "resource": c.resource,
11896 })
11897 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11898 }
11899
11900
11901
11902
11903
11904
11905
11906 func (c *ProjectsLocationsAppGatewaysTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
11907 gensupport.SetOptions(c.urlParams_, opts...)
11908 res, err := c.doRequest("json")
11909 if res != nil && res.StatusCode == http.StatusNotModified {
11910 if res.Body != nil {
11911 res.Body.Close()
11912 }
11913 return nil, gensupport.WrapError(&googleapi.Error{
11914 Code: res.StatusCode,
11915 Header: res.Header,
11916 })
11917 }
11918 if err != nil {
11919 return nil, err
11920 }
11921 defer googleapi.CloseBody(res)
11922 if err := googleapi.CheckResponse(res); err != nil {
11923 return nil, gensupport.WrapError(err)
11924 }
11925 ret := &GoogleIamV1TestIamPermissionsResponse{
11926 ServerResponse: googleapi.ServerResponse{
11927 Header: res.Header,
11928 HTTPStatusCode: res.StatusCode,
11929 },
11930 }
11931 target := &ret
11932 if err := gensupport.DecodeResponse(target, res); err != nil {
11933 return nil, err
11934 }
11935 return ret, nil
11936 }
11937
11938 type ProjectsLocationsApplicationDomainsGetIamPolicyCall struct {
11939 s *Service
11940 resource string
11941 urlParams_ gensupport.URLParams
11942 ifNoneMatch_ string
11943 ctx_ context.Context
11944 header_ http.Header
11945 }
11946
11947
11948
11949
11950
11951
11952
11953 func (r *ProjectsLocationsApplicationDomainsService) GetIamPolicy(resource string) *ProjectsLocationsApplicationDomainsGetIamPolicyCall {
11954 c := &ProjectsLocationsApplicationDomainsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11955 c.resource = resource
11956 return c
11957 }
11958
11959
11960
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971 func (c *ProjectsLocationsApplicationDomainsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsApplicationDomainsGetIamPolicyCall {
11972 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
11973 return c
11974 }
11975
11976
11977
11978
11979 func (c *ProjectsLocationsApplicationDomainsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsApplicationDomainsGetIamPolicyCall {
11980 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11981 return c
11982 }
11983
11984
11985
11986
11987 func (c *ProjectsLocationsApplicationDomainsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsApplicationDomainsGetIamPolicyCall {
11988 c.ifNoneMatch_ = entityTag
11989 return c
11990 }
11991
11992
11993 func (c *ProjectsLocationsApplicationDomainsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsApplicationDomainsGetIamPolicyCall {
11994 c.ctx_ = ctx
11995 return c
11996 }
11997
11998
11999
12000 func (c *ProjectsLocationsApplicationDomainsGetIamPolicyCall) Header() http.Header {
12001 if c.header_ == nil {
12002 c.header_ = make(http.Header)
12003 }
12004 return c.header_
12005 }
12006
12007 func (c *ProjectsLocationsApplicationDomainsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12008 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12009 if c.ifNoneMatch_ != "" {
12010 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12011 }
12012 var body io.Reader = nil
12013 c.urlParams_.Set("alt", alt)
12014 c.urlParams_.Set("prettyPrint", "false")
12015 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
12016 urls += "?" + c.urlParams_.Encode()
12017 req, err := http.NewRequest("GET", urls, body)
12018 if err != nil {
12019 return nil, err
12020 }
12021 req.Header = reqHeaders
12022 googleapi.Expand(req.URL, map[string]string{
12023 "resource": c.resource,
12024 })
12025 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12026 }
12027
12028
12029
12030
12031
12032
12033
12034 func (c *ProjectsLocationsApplicationDomainsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
12035 gensupport.SetOptions(c.urlParams_, opts...)
12036 res, err := c.doRequest("json")
12037 if res != nil && res.StatusCode == http.StatusNotModified {
12038 if res.Body != nil {
12039 res.Body.Close()
12040 }
12041 return nil, gensupport.WrapError(&googleapi.Error{
12042 Code: res.StatusCode,
12043 Header: res.Header,
12044 })
12045 }
12046 if err != nil {
12047 return nil, err
12048 }
12049 defer googleapi.CloseBody(res)
12050 if err := googleapi.CheckResponse(res); err != nil {
12051 return nil, gensupport.WrapError(err)
12052 }
12053 ret := &GoogleIamV1Policy{
12054 ServerResponse: googleapi.ServerResponse{
12055 Header: res.Header,
12056 HTTPStatusCode: res.StatusCode,
12057 },
12058 }
12059 target := &ret
12060 if err := gensupport.DecodeResponse(target, res); err != nil {
12061 return nil, err
12062 }
12063 return ret, nil
12064 }
12065
12066 type ProjectsLocationsApplicationDomainsSetIamPolicyCall struct {
12067 s *Service
12068 resource string
12069 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
12070 urlParams_ gensupport.URLParams
12071 ctx_ context.Context
12072 header_ http.Header
12073 }
12074
12075
12076
12077
12078
12079
12080
12081
12082 func (r *ProjectsLocationsApplicationDomainsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsApplicationDomainsSetIamPolicyCall {
12083 c := &ProjectsLocationsApplicationDomainsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12084 c.resource = resource
12085 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
12086 return c
12087 }
12088
12089
12090
12091
12092 func (c *ProjectsLocationsApplicationDomainsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsApplicationDomainsSetIamPolicyCall {
12093 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12094 return c
12095 }
12096
12097
12098 func (c *ProjectsLocationsApplicationDomainsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsApplicationDomainsSetIamPolicyCall {
12099 c.ctx_ = ctx
12100 return c
12101 }
12102
12103
12104
12105 func (c *ProjectsLocationsApplicationDomainsSetIamPolicyCall) Header() http.Header {
12106 if c.header_ == nil {
12107 c.header_ = make(http.Header)
12108 }
12109 return c.header_
12110 }
12111
12112 func (c *ProjectsLocationsApplicationDomainsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12113 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12114 var body io.Reader = nil
12115 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
12116 if err != nil {
12117 return nil, err
12118 }
12119 c.urlParams_.Set("alt", alt)
12120 c.urlParams_.Set("prettyPrint", "false")
12121 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
12122 urls += "?" + c.urlParams_.Encode()
12123 req, err := http.NewRequest("POST", urls, body)
12124 if err != nil {
12125 return nil, err
12126 }
12127 req.Header = reqHeaders
12128 googleapi.Expand(req.URL, map[string]string{
12129 "resource": c.resource,
12130 })
12131 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12132 }
12133
12134
12135
12136
12137
12138
12139
12140 func (c *ProjectsLocationsApplicationDomainsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
12141 gensupport.SetOptions(c.urlParams_, opts...)
12142 res, err := c.doRequest("json")
12143 if res != nil && res.StatusCode == http.StatusNotModified {
12144 if res.Body != nil {
12145 res.Body.Close()
12146 }
12147 return nil, gensupport.WrapError(&googleapi.Error{
12148 Code: res.StatusCode,
12149 Header: res.Header,
12150 })
12151 }
12152 if err != nil {
12153 return nil, err
12154 }
12155 defer googleapi.CloseBody(res)
12156 if err := googleapi.CheckResponse(res); err != nil {
12157 return nil, gensupport.WrapError(err)
12158 }
12159 ret := &GoogleIamV1Policy{
12160 ServerResponse: googleapi.ServerResponse{
12161 Header: res.Header,
12162 HTTPStatusCode: res.StatusCode,
12163 },
12164 }
12165 target := &ret
12166 if err := gensupport.DecodeResponse(target, res); err != nil {
12167 return nil, err
12168 }
12169 return ret, nil
12170 }
12171
12172 type ProjectsLocationsApplicationDomainsTestIamPermissionsCall struct {
12173 s *Service
12174 resource string
12175 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
12176 urlParams_ gensupport.URLParams
12177 ctx_ context.Context
12178 header_ http.Header
12179 }
12180
12181
12182
12183
12184
12185
12186
12187
12188
12189
12190
12191 func (r *ProjectsLocationsApplicationDomainsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsApplicationDomainsTestIamPermissionsCall {
12192 c := &ProjectsLocationsApplicationDomainsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12193 c.resource = resource
12194 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
12195 return c
12196 }
12197
12198
12199
12200
12201 func (c *ProjectsLocationsApplicationDomainsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsApplicationDomainsTestIamPermissionsCall {
12202 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12203 return c
12204 }
12205
12206
12207 func (c *ProjectsLocationsApplicationDomainsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsApplicationDomainsTestIamPermissionsCall {
12208 c.ctx_ = ctx
12209 return c
12210 }
12211
12212
12213
12214 func (c *ProjectsLocationsApplicationDomainsTestIamPermissionsCall) Header() http.Header {
12215 if c.header_ == nil {
12216 c.header_ = make(http.Header)
12217 }
12218 return c.header_
12219 }
12220
12221 func (c *ProjectsLocationsApplicationDomainsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
12222 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12223 var body io.Reader = nil
12224 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
12225 if err != nil {
12226 return nil, err
12227 }
12228 c.urlParams_.Set("alt", alt)
12229 c.urlParams_.Set("prettyPrint", "false")
12230 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
12231 urls += "?" + c.urlParams_.Encode()
12232 req, err := http.NewRequest("POST", urls, body)
12233 if err != nil {
12234 return nil, err
12235 }
12236 req.Header = reqHeaders
12237 googleapi.Expand(req.URL, map[string]string{
12238 "resource": c.resource,
12239 })
12240 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12241 }
12242
12243
12244
12245
12246
12247
12248
12249 func (c *ProjectsLocationsApplicationDomainsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
12250 gensupport.SetOptions(c.urlParams_, opts...)
12251 res, err := c.doRequest("json")
12252 if res != nil && res.StatusCode == http.StatusNotModified {
12253 if res.Body != nil {
12254 res.Body.Close()
12255 }
12256 return nil, gensupport.WrapError(&googleapi.Error{
12257 Code: res.StatusCode,
12258 Header: res.Header,
12259 })
12260 }
12261 if err != nil {
12262 return nil, err
12263 }
12264 defer googleapi.CloseBody(res)
12265 if err := googleapi.CheckResponse(res); err != nil {
12266 return nil, gensupport.WrapError(err)
12267 }
12268 ret := &GoogleIamV1TestIamPermissionsResponse{
12269 ServerResponse: googleapi.ServerResponse{
12270 Header: res.Header,
12271 HTTPStatusCode: res.StatusCode,
12272 },
12273 }
12274 target := &ret
12275 if err := gensupport.DecodeResponse(target, res); err != nil {
12276 return nil, err
12277 }
12278 return ret, nil
12279 }
12280
12281 type ProjectsLocationsApplicationsGetIamPolicyCall struct {
12282 s *Service
12283 resource string
12284 urlParams_ gensupport.URLParams
12285 ifNoneMatch_ string
12286 ctx_ context.Context
12287 header_ http.Header
12288 }
12289
12290
12291
12292
12293
12294
12295
12296 func (r *ProjectsLocationsApplicationsService) GetIamPolicy(resource string) *ProjectsLocationsApplicationsGetIamPolicyCall {
12297 c := &ProjectsLocationsApplicationsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12298 c.resource = resource
12299 return c
12300 }
12301
12302
12303
12304
12305
12306
12307
12308
12309
12310
12311
12312
12313
12314 func (c *ProjectsLocationsApplicationsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsApplicationsGetIamPolicyCall {
12315 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
12316 return c
12317 }
12318
12319
12320
12321
12322 func (c *ProjectsLocationsApplicationsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsApplicationsGetIamPolicyCall {
12323 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12324 return c
12325 }
12326
12327
12328
12329
12330 func (c *ProjectsLocationsApplicationsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsApplicationsGetIamPolicyCall {
12331 c.ifNoneMatch_ = entityTag
12332 return c
12333 }
12334
12335
12336 func (c *ProjectsLocationsApplicationsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsApplicationsGetIamPolicyCall {
12337 c.ctx_ = ctx
12338 return c
12339 }
12340
12341
12342
12343 func (c *ProjectsLocationsApplicationsGetIamPolicyCall) Header() http.Header {
12344 if c.header_ == nil {
12345 c.header_ = make(http.Header)
12346 }
12347 return c.header_
12348 }
12349
12350 func (c *ProjectsLocationsApplicationsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12351 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12352 if c.ifNoneMatch_ != "" {
12353 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12354 }
12355 var body io.Reader = nil
12356 c.urlParams_.Set("alt", alt)
12357 c.urlParams_.Set("prettyPrint", "false")
12358 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
12359 urls += "?" + c.urlParams_.Encode()
12360 req, err := http.NewRequest("GET", urls, body)
12361 if err != nil {
12362 return nil, err
12363 }
12364 req.Header = reqHeaders
12365 googleapi.Expand(req.URL, map[string]string{
12366 "resource": c.resource,
12367 })
12368 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12369 }
12370
12371
12372
12373
12374
12375
12376
12377 func (c *ProjectsLocationsApplicationsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
12378 gensupport.SetOptions(c.urlParams_, opts...)
12379 res, err := c.doRequest("json")
12380 if res != nil && res.StatusCode == http.StatusNotModified {
12381 if res.Body != nil {
12382 res.Body.Close()
12383 }
12384 return nil, gensupport.WrapError(&googleapi.Error{
12385 Code: res.StatusCode,
12386 Header: res.Header,
12387 })
12388 }
12389 if err != nil {
12390 return nil, err
12391 }
12392 defer googleapi.CloseBody(res)
12393 if err := googleapi.CheckResponse(res); err != nil {
12394 return nil, gensupport.WrapError(err)
12395 }
12396 ret := &GoogleIamV1Policy{
12397 ServerResponse: googleapi.ServerResponse{
12398 Header: res.Header,
12399 HTTPStatusCode: res.StatusCode,
12400 },
12401 }
12402 target := &ret
12403 if err := gensupport.DecodeResponse(target, res); err != nil {
12404 return nil, err
12405 }
12406 return ret, nil
12407 }
12408
12409 type ProjectsLocationsApplicationsSetIamPolicyCall struct {
12410 s *Service
12411 resource string
12412 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
12413 urlParams_ gensupport.URLParams
12414 ctx_ context.Context
12415 header_ http.Header
12416 }
12417
12418
12419
12420
12421
12422
12423
12424
12425 func (r *ProjectsLocationsApplicationsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsApplicationsSetIamPolicyCall {
12426 c := &ProjectsLocationsApplicationsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12427 c.resource = resource
12428 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
12429 return c
12430 }
12431
12432
12433
12434
12435 func (c *ProjectsLocationsApplicationsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsApplicationsSetIamPolicyCall {
12436 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12437 return c
12438 }
12439
12440
12441 func (c *ProjectsLocationsApplicationsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsApplicationsSetIamPolicyCall {
12442 c.ctx_ = ctx
12443 return c
12444 }
12445
12446
12447
12448 func (c *ProjectsLocationsApplicationsSetIamPolicyCall) Header() http.Header {
12449 if c.header_ == nil {
12450 c.header_ = make(http.Header)
12451 }
12452 return c.header_
12453 }
12454
12455 func (c *ProjectsLocationsApplicationsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12456 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12457 var body io.Reader = nil
12458 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
12459 if err != nil {
12460 return nil, err
12461 }
12462 c.urlParams_.Set("alt", alt)
12463 c.urlParams_.Set("prettyPrint", "false")
12464 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
12465 urls += "?" + c.urlParams_.Encode()
12466 req, err := http.NewRequest("POST", urls, body)
12467 if err != nil {
12468 return nil, err
12469 }
12470 req.Header = reqHeaders
12471 googleapi.Expand(req.URL, map[string]string{
12472 "resource": c.resource,
12473 })
12474 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12475 }
12476
12477
12478
12479
12480
12481
12482
12483 func (c *ProjectsLocationsApplicationsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
12484 gensupport.SetOptions(c.urlParams_, opts...)
12485 res, err := c.doRequest("json")
12486 if res != nil && res.StatusCode == http.StatusNotModified {
12487 if res.Body != nil {
12488 res.Body.Close()
12489 }
12490 return nil, gensupport.WrapError(&googleapi.Error{
12491 Code: res.StatusCode,
12492 Header: res.Header,
12493 })
12494 }
12495 if err != nil {
12496 return nil, err
12497 }
12498 defer googleapi.CloseBody(res)
12499 if err := googleapi.CheckResponse(res); err != nil {
12500 return nil, gensupport.WrapError(err)
12501 }
12502 ret := &GoogleIamV1Policy{
12503 ServerResponse: googleapi.ServerResponse{
12504 Header: res.Header,
12505 HTTPStatusCode: res.StatusCode,
12506 },
12507 }
12508 target := &ret
12509 if err := gensupport.DecodeResponse(target, res); err != nil {
12510 return nil, err
12511 }
12512 return ret, nil
12513 }
12514
12515 type ProjectsLocationsApplicationsTestIamPermissionsCall struct {
12516 s *Service
12517 resource string
12518 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
12519 urlParams_ gensupport.URLParams
12520 ctx_ context.Context
12521 header_ http.Header
12522 }
12523
12524
12525
12526
12527
12528
12529
12530
12531
12532
12533
12534 func (r *ProjectsLocationsApplicationsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsApplicationsTestIamPermissionsCall {
12535 c := &ProjectsLocationsApplicationsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12536 c.resource = resource
12537 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
12538 return c
12539 }
12540
12541
12542
12543
12544 func (c *ProjectsLocationsApplicationsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsApplicationsTestIamPermissionsCall {
12545 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12546 return c
12547 }
12548
12549
12550 func (c *ProjectsLocationsApplicationsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsApplicationsTestIamPermissionsCall {
12551 c.ctx_ = ctx
12552 return c
12553 }
12554
12555
12556
12557 func (c *ProjectsLocationsApplicationsTestIamPermissionsCall) Header() http.Header {
12558 if c.header_ == nil {
12559 c.header_ = make(http.Header)
12560 }
12561 return c.header_
12562 }
12563
12564 func (c *ProjectsLocationsApplicationsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
12565 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12566 var body io.Reader = nil
12567 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
12568 if err != nil {
12569 return nil, err
12570 }
12571 c.urlParams_.Set("alt", alt)
12572 c.urlParams_.Set("prettyPrint", "false")
12573 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
12574 urls += "?" + c.urlParams_.Encode()
12575 req, err := http.NewRequest("POST", urls, body)
12576 if err != nil {
12577 return nil, err
12578 }
12579 req.Header = reqHeaders
12580 googleapi.Expand(req.URL, map[string]string{
12581 "resource": c.resource,
12582 })
12583 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12584 }
12585
12586
12587
12588
12589
12590
12591
12592 func (c *ProjectsLocationsApplicationsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
12593 gensupport.SetOptions(c.urlParams_, opts...)
12594 res, err := c.doRequest("json")
12595 if res != nil && res.StatusCode == http.StatusNotModified {
12596 if res.Body != nil {
12597 res.Body.Close()
12598 }
12599 return nil, gensupport.WrapError(&googleapi.Error{
12600 Code: res.StatusCode,
12601 Header: res.Header,
12602 })
12603 }
12604 if err != nil {
12605 return nil, err
12606 }
12607 defer googleapi.CloseBody(res)
12608 if err := googleapi.CheckResponse(res); err != nil {
12609 return nil, gensupport.WrapError(err)
12610 }
12611 ret := &GoogleIamV1TestIamPermissionsResponse{
12612 ServerResponse: googleapi.ServerResponse{
12613 Header: res.Header,
12614 HTTPStatusCode: res.StatusCode,
12615 },
12616 }
12617 target := &ret
12618 if err := gensupport.DecodeResponse(target, res); err != nil {
12619 return nil, err
12620 }
12621 return ret, nil
12622 }
12623
12624 type ProjectsLocationsClientConnectorServicesGetIamPolicyCall struct {
12625 s *Service
12626 resource string
12627 urlParams_ gensupport.URLParams
12628 ifNoneMatch_ string
12629 ctx_ context.Context
12630 header_ http.Header
12631 }
12632
12633
12634
12635
12636
12637
12638
12639 func (r *ProjectsLocationsClientConnectorServicesService) GetIamPolicy(resource string) *ProjectsLocationsClientConnectorServicesGetIamPolicyCall {
12640 c := &ProjectsLocationsClientConnectorServicesGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12641 c.resource = resource
12642 return c
12643 }
12644
12645
12646
12647
12648
12649
12650
12651
12652
12653
12654
12655
12656
12657 func (c *ProjectsLocationsClientConnectorServicesGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsClientConnectorServicesGetIamPolicyCall {
12658 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
12659 return c
12660 }
12661
12662
12663
12664
12665 func (c *ProjectsLocationsClientConnectorServicesGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsClientConnectorServicesGetIamPolicyCall {
12666 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12667 return c
12668 }
12669
12670
12671
12672
12673 func (c *ProjectsLocationsClientConnectorServicesGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsClientConnectorServicesGetIamPolicyCall {
12674 c.ifNoneMatch_ = entityTag
12675 return c
12676 }
12677
12678
12679 func (c *ProjectsLocationsClientConnectorServicesGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsClientConnectorServicesGetIamPolicyCall {
12680 c.ctx_ = ctx
12681 return c
12682 }
12683
12684
12685
12686 func (c *ProjectsLocationsClientConnectorServicesGetIamPolicyCall) Header() http.Header {
12687 if c.header_ == nil {
12688 c.header_ = make(http.Header)
12689 }
12690 return c.header_
12691 }
12692
12693 func (c *ProjectsLocationsClientConnectorServicesGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12694 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12695 if c.ifNoneMatch_ != "" {
12696 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12697 }
12698 var body io.Reader = nil
12699 c.urlParams_.Set("alt", alt)
12700 c.urlParams_.Set("prettyPrint", "false")
12701 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
12702 urls += "?" + c.urlParams_.Encode()
12703 req, err := http.NewRequest("GET", urls, body)
12704 if err != nil {
12705 return nil, err
12706 }
12707 req.Header = reqHeaders
12708 googleapi.Expand(req.URL, map[string]string{
12709 "resource": c.resource,
12710 })
12711 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12712 }
12713
12714
12715
12716
12717
12718
12719
12720 func (c *ProjectsLocationsClientConnectorServicesGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
12721 gensupport.SetOptions(c.urlParams_, opts...)
12722 res, err := c.doRequest("json")
12723 if res != nil && res.StatusCode == http.StatusNotModified {
12724 if res.Body != nil {
12725 res.Body.Close()
12726 }
12727 return nil, gensupport.WrapError(&googleapi.Error{
12728 Code: res.StatusCode,
12729 Header: res.Header,
12730 })
12731 }
12732 if err != nil {
12733 return nil, err
12734 }
12735 defer googleapi.CloseBody(res)
12736 if err := googleapi.CheckResponse(res); err != nil {
12737 return nil, gensupport.WrapError(err)
12738 }
12739 ret := &GoogleIamV1Policy{
12740 ServerResponse: googleapi.ServerResponse{
12741 Header: res.Header,
12742 HTTPStatusCode: res.StatusCode,
12743 },
12744 }
12745 target := &ret
12746 if err := gensupport.DecodeResponse(target, res); err != nil {
12747 return nil, err
12748 }
12749 return ret, nil
12750 }
12751
12752 type ProjectsLocationsClientConnectorServicesSetIamPolicyCall struct {
12753 s *Service
12754 resource string
12755 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
12756 urlParams_ gensupport.URLParams
12757 ctx_ context.Context
12758 header_ http.Header
12759 }
12760
12761
12762
12763
12764
12765
12766
12767
12768 func (r *ProjectsLocationsClientConnectorServicesService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsClientConnectorServicesSetIamPolicyCall {
12769 c := &ProjectsLocationsClientConnectorServicesSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12770 c.resource = resource
12771 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
12772 return c
12773 }
12774
12775
12776
12777
12778 func (c *ProjectsLocationsClientConnectorServicesSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsClientConnectorServicesSetIamPolicyCall {
12779 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12780 return c
12781 }
12782
12783
12784 func (c *ProjectsLocationsClientConnectorServicesSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsClientConnectorServicesSetIamPolicyCall {
12785 c.ctx_ = ctx
12786 return c
12787 }
12788
12789
12790
12791 func (c *ProjectsLocationsClientConnectorServicesSetIamPolicyCall) Header() http.Header {
12792 if c.header_ == nil {
12793 c.header_ = make(http.Header)
12794 }
12795 return c.header_
12796 }
12797
12798 func (c *ProjectsLocationsClientConnectorServicesSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12799 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12800 var body io.Reader = nil
12801 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
12802 if err != nil {
12803 return nil, err
12804 }
12805 c.urlParams_.Set("alt", alt)
12806 c.urlParams_.Set("prettyPrint", "false")
12807 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
12808 urls += "?" + c.urlParams_.Encode()
12809 req, err := http.NewRequest("POST", urls, body)
12810 if err != nil {
12811 return nil, err
12812 }
12813 req.Header = reqHeaders
12814 googleapi.Expand(req.URL, map[string]string{
12815 "resource": c.resource,
12816 })
12817 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12818 }
12819
12820
12821
12822
12823
12824
12825
12826 func (c *ProjectsLocationsClientConnectorServicesSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
12827 gensupport.SetOptions(c.urlParams_, opts...)
12828 res, err := c.doRequest("json")
12829 if res != nil && res.StatusCode == http.StatusNotModified {
12830 if res.Body != nil {
12831 res.Body.Close()
12832 }
12833 return nil, gensupport.WrapError(&googleapi.Error{
12834 Code: res.StatusCode,
12835 Header: res.Header,
12836 })
12837 }
12838 if err != nil {
12839 return nil, err
12840 }
12841 defer googleapi.CloseBody(res)
12842 if err := googleapi.CheckResponse(res); err != nil {
12843 return nil, gensupport.WrapError(err)
12844 }
12845 ret := &GoogleIamV1Policy{
12846 ServerResponse: googleapi.ServerResponse{
12847 Header: res.Header,
12848 HTTPStatusCode: res.StatusCode,
12849 },
12850 }
12851 target := &ret
12852 if err := gensupport.DecodeResponse(target, res); err != nil {
12853 return nil, err
12854 }
12855 return ret, nil
12856 }
12857
12858 type ProjectsLocationsClientConnectorServicesTestIamPermissionsCall struct {
12859 s *Service
12860 resource string
12861 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
12862 urlParams_ gensupport.URLParams
12863 ctx_ context.Context
12864 header_ http.Header
12865 }
12866
12867
12868
12869
12870
12871
12872
12873
12874
12875
12876
12877 func (r *ProjectsLocationsClientConnectorServicesService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsClientConnectorServicesTestIamPermissionsCall {
12878 c := &ProjectsLocationsClientConnectorServicesTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12879 c.resource = resource
12880 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
12881 return c
12882 }
12883
12884
12885
12886
12887 func (c *ProjectsLocationsClientConnectorServicesTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsClientConnectorServicesTestIamPermissionsCall {
12888 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12889 return c
12890 }
12891
12892
12893 func (c *ProjectsLocationsClientConnectorServicesTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsClientConnectorServicesTestIamPermissionsCall {
12894 c.ctx_ = ctx
12895 return c
12896 }
12897
12898
12899
12900 func (c *ProjectsLocationsClientConnectorServicesTestIamPermissionsCall) Header() http.Header {
12901 if c.header_ == nil {
12902 c.header_ = make(http.Header)
12903 }
12904 return c.header_
12905 }
12906
12907 func (c *ProjectsLocationsClientConnectorServicesTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
12908 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12909 var body io.Reader = nil
12910 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
12911 if err != nil {
12912 return nil, err
12913 }
12914 c.urlParams_.Set("alt", alt)
12915 c.urlParams_.Set("prettyPrint", "false")
12916 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
12917 urls += "?" + c.urlParams_.Encode()
12918 req, err := http.NewRequest("POST", urls, body)
12919 if err != nil {
12920 return nil, err
12921 }
12922 req.Header = reqHeaders
12923 googleapi.Expand(req.URL, map[string]string{
12924 "resource": c.resource,
12925 })
12926 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12927 }
12928
12929
12930
12931
12932
12933
12934
12935 func (c *ProjectsLocationsClientConnectorServicesTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
12936 gensupport.SetOptions(c.urlParams_, opts...)
12937 res, err := c.doRequest("json")
12938 if res != nil && res.StatusCode == http.StatusNotModified {
12939 if res.Body != nil {
12940 res.Body.Close()
12941 }
12942 return nil, gensupport.WrapError(&googleapi.Error{
12943 Code: res.StatusCode,
12944 Header: res.Header,
12945 })
12946 }
12947 if err != nil {
12948 return nil, err
12949 }
12950 defer googleapi.CloseBody(res)
12951 if err := googleapi.CheckResponse(res); err != nil {
12952 return nil, gensupport.WrapError(err)
12953 }
12954 ret := &GoogleIamV1TestIamPermissionsResponse{
12955 ServerResponse: googleapi.ServerResponse{
12956 Header: res.Header,
12957 HTTPStatusCode: res.StatusCode,
12958 },
12959 }
12960 target := &ret
12961 if err := gensupport.DecodeResponse(target, res); err != nil {
12962 return nil, err
12963 }
12964 return ret, nil
12965 }
12966
12967 type ProjectsLocationsClientGatewaysGetIamPolicyCall struct {
12968 s *Service
12969 resource string
12970 urlParams_ gensupport.URLParams
12971 ifNoneMatch_ string
12972 ctx_ context.Context
12973 header_ http.Header
12974 }
12975
12976
12977
12978
12979
12980
12981
12982 func (r *ProjectsLocationsClientGatewaysService) GetIamPolicy(resource string) *ProjectsLocationsClientGatewaysGetIamPolicyCall {
12983 c := &ProjectsLocationsClientGatewaysGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12984 c.resource = resource
12985 return c
12986 }
12987
12988
12989
12990
12991
12992
12993
12994
12995
12996
12997
12998
12999
13000 func (c *ProjectsLocationsClientGatewaysGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsClientGatewaysGetIamPolicyCall {
13001 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
13002 return c
13003 }
13004
13005
13006
13007
13008 func (c *ProjectsLocationsClientGatewaysGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsClientGatewaysGetIamPolicyCall {
13009 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13010 return c
13011 }
13012
13013
13014
13015
13016 func (c *ProjectsLocationsClientGatewaysGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsClientGatewaysGetIamPolicyCall {
13017 c.ifNoneMatch_ = entityTag
13018 return c
13019 }
13020
13021
13022 func (c *ProjectsLocationsClientGatewaysGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsClientGatewaysGetIamPolicyCall {
13023 c.ctx_ = ctx
13024 return c
13025 }
13026
13027
13028
13029 func (c *ProjectsLocationsClientGatewaysGetIamPolicyCall) Header() http.Header {
13030 if c.header_ == nil {
13031 c.header_ = make(http.Header)
13032 }
13033 return c.header_
13034 }
13035
13036 func (c *ProjectsLocationsClientGatewaysGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
13037 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13038 if c.ifNoneMatch_ != "" {
13039 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13040 }
13041 var body io.Reader = nil
13042 c.urlParams_.Set("alt", alt)
13043 c.urlParams_.Set("prettyPrint", "false")
13044 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
13045 urls += "?" + c.urlParams_.Encode()
13046 req, err := http.NewRequest("GET", urls, body)
13047 if err != nil {
13048 return nil, err
13049 }
13050 req.Header = reqHeaders
13051 googleapi.Expand(req.URL, map[string]string{
13052 "resource": c.resource,
13053 })
13054 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13055 }
13056
13057
13058
13059
13060
13061
13062
13063 func (c *ProjectsLocationsClientGatewaysGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
13064 gensupport.SetOptions(c.urlParams_, opts...)
13065 res, err := c.doRequest("json")
13066 if res != nil && res.StatusCode == http.StatusNotModified {
13067 if res.Body != nil {
13068 res.Body.Close()
13069 }
13070 return nil, gensupport.WrapError(&googleapi.Error{
13071 Code: res.StatusCode,
13072 Header: res.Header,
13073 })
13074 }
13075 if err != nil {
13076 return nil, err
13077 }
13078 defer googleapi.CloseBody(res)
13079 if err := googleapi.CheckResponse(res); err != nil {
13080 return nil, gensupport.WrapError(err)
13081 }
13082 ret := &GoogleIamV1Policy{
13083 ServerResponse: googleapi.ServerResponse{
13084 Header: res.Header,
13085 HTTPStatusCode: res.StatusCode,
13086 },
13087 }
13088 target := &ret
13089 if err := gensupport.DecodeResponse(target, res); err != nil {
13090 return nil, err
13091 }
13092 return ret, nil
13093 }
13094
13095 type ProjectsLocationsClientGatewaysSetIamPolicyCall struct {
13096 s *Service
13097 resource string
13098 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
13099 urlParams_ gensupport.URLParams
13100 ctx_ context.Context
13101 header_ http.Header
13102 }
13103
13104
13105
13106
13107
13108
13109
13110
13111 func (r *ProjectsLocationsClientGatewaysService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsClientGatewaysSetIamPolicyCall {
13112 c := &ProjectsLocationsClientGatewaysSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13113 c.resource = resource
13114 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
13115 return c
13116 }
13117
13118
13119
13120
13121 func (c *ProjectsLocationsClientGatewaysSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsClientGatewaysSetIamPolicyCall {
13122 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13123 return c
13124 }
13125
13126
13127 func (c *ProjectsLocationsClientGatewaysSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsClientGatewaysSetIamPolicyCall {
13128 c.ctx_ = ctx
13129 return c
13130 }
13131
13132
13133
13134 func (c *ProjectsLocationsClientGatewaysSetIamPolicyCall) Header() http.Header {
13135 if c.header_ == nil {
13136 c.header_ = make(http.Header)
13137 }
13138 return c.header_
13139 }
13140
13141 func (c *ProjectsLocationsClientGatewaysSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
13142 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13143 var body io.Reader = nil
13144 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
13145 if err != nil {
13146 return nil, err
13147 }
13148 c.urlParams_.Set("alt", alt)
13149 c.urlParams_.Set("prettyPrint", "false")
13150 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
13151 urls += "?" + c.urlParams_.Encode()
13152 req, err := http.NewRequest("POST", urls, body)
13153 if err != nil {
13154 return nil, err
13155 }
13156 req.Header = reqHeaders
13157 googleapi.Expand(req.URL, map[string]string{
13158 "resource": c.resource,
13159 })
13160 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13161 }
13162
13163
13164
13165
13166
13167
13168
13169 func (c *ProjectsLocationsClientGatewaysSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
13170 gensupport.SetOptions(c.urlParams_, opts...)
13171 res, err := c.doRequest("json")
13172 if res != nil && res.StatusCode == http.StatusNotModified {
13173 if res.Body != nil {
13174 res.Body.Close()
13175 }
13176 return nil, gensupport.WrapError(&googleapi.Error{
13177 Code: res.StatusCode,
13178 Header: res.Header,
13179 })
13180 }
13181 if err != nil {
13182 return nil, err
13183 }
13184 defer googleapi.CloseBody(res)
13185 if err := googleapi.CheckResponse(res); err != nil {
13186 return nil, gensupport.WrapError(err)
13187 }
13188 ret := &GoogleIamV1Policy{
13189 ServerResponse: googleapi.ServerResponse{
13190 Header: res.Header,
13191 HTTPStatusCode: res.StatusCode,
13192 },
13193 }
13194 target := &ret
13195 if err := gensupport.DecodeResponse(target, res); err != nil {
13196 return nil, err
13197 }
13198 return ret, nil
13199 }
13200
13201 type ProjectsLocationsClientGatewaysTestIamPermissionsCall struct {
13202 s *Service
13203 resource string
13204 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
13205 urlParams_ gensupport.URLParams
13206 ctx_ context.Context
13207 header_ http.Header
13208 }
13209
13210
13211
13212
13213
13214
13215
13216
13217
13218
13219
13220 func (r *ProjectsLocationsClientGatewaysService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsClientGatewaysTestIamPermissionsCall {
13221 c := &ProjectsLocationsClientGatewaysTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13222 c.resource = resource
13223 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
13224 return c
13225 }
13226
13227
13228
13229
13230 func (c *ProjectsLocationsClientGatewaysTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsClientGatewaysTestIamPermissionsCall {
13231 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13232 return c
13233 }
13234
13235
13236 func (c *ProjectsLocationsClientGatewaysTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsClientGatewaysTestIamPermissionsCall {
13237 c.ctx_ = ctx
13238 return c
13239 }
13240
13241
13242
13243 func (c *ProjectsLocationsClientGatewaysTestIamPermissionsCall) Header() http.Header {
13244 if c.header_ == nil {
13245 c.header_ = make(http.Header)
13246 }
13247 return c.header_
13248 }
13249
13250 func (c *ProjectsLocationsClientGatewaysTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
13251 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13252 var body io.Reader = nil
13253 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
13254 if err != nil {
13255 return nil, err
13256 }
13257 c.urlParams_.Set("alt", alt)
13258 c.urlParams_.Set("prettyPrint", "false")
13259 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
13260 urls += "?" + c.urlParams_.Encode()
13261 req, err := http.NewRequest("POST", urls, body)
13262 if err != nil {
13263 return nil, err
13264 }
13265 req.Header = reqHeaders
13266 googleapi.Expand(req.URL, map[string]string{
13267 "resource": c.resource,
13268 })
13269 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13270 }
13271
13272
13273
13274
13275
13276
13277
13278 func (c *ProjectsLocationsClientGatewaysTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
13279 gensupport.SetOptions(c.urlParams_, opts...)
13280 res, err := c.doRequest("json")
13281 if res != nil && res.StatusCode == http.StatusNotModified {
13282 if res.Body != nil {
13283 res.Body.Close()
13284 }
13285 return nil, gensupport.WrapError(&googleapi.Error{
13286 Code: res.StatusCode,
13287 Header: res.Header,
13288 })
13289 }
13290 if err != nil {
13291 return nil, err
13292 }
13293 defer googleapi.CloseBody(res)
13294 if err := googleapi.CheckResponse(res); err != nil {
13295 return nil, gensupport.WrapError(err)
13296 }
13297 ret := &GoogleIamV1TestIamPermissionsResponse{
13298 ServerResponse: googleapi.ServerResponse{
13299 Header: res.Header,
13300 HTTPStatusCode: res.StatusCode,
13301 },
13302 }
13303 target := &ret
13304 if err := gensupport.DecodeResponse(target, res); err != nil {
13305 return nil, err
13306 }
13307 return ret, nil
13308 }
13309
13310 type ProjectsLocationsConnectionsCreateCall struct {
13311 s *Service
13312 parent string
13313 connection *Connection
13314 urlParams_ gensupport.URLParams
13315 ctx_ context.Context
13316 header_ http.Header
13317 }
13318
13319
13320
13321
13322
13323 func (r *ProjectsLocationsConnectionsService) Create(parent string, connection *Connection) *ProjectsLocationsConnectionsCreateCall {
13324 c := &ProjectsLocationsConnectionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13325 c.parent = parent
13326 c.connection = connection
13327 return c
13328 }
13329
13330
13331
13332
13333 func (c *ProjectsLocationsConnectionsCreateCall) ConnectionId(connectionId string) *ProjectsLocationsConnectionsCreateCall {
13334 c.urlParams_.Set("connectionId", connectionId)
13335 return c
13336 }
13337
13338
13339
13340
13341
13342
13343
13344
13345
13346
13347
13348
13349 func (c *ProjectsLocationsConnectionsCreateCall) RequestId(requestId string) *ProjectsLocationsConnectionsCreateCall {
13350 c.urlParams_.Set("requestId", requestId)
13351 return c
13352 }
13353
13354
13355
13356
13357 func (c *ProjectsLocationsConnectionsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsConnectionsCreateCall {
13358 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
13359 return c
13360 }
13361
13362
13363
13364
13365 func (c *ProjectsLocationsConnectionsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsCreateCall {
13366 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13367 return c
13368 }
13369
13370
13371 func (c *ProjectsLocationsConnectionsCreateCall) Context(ctx context.Context) *ProjectsLocationsConnectionsCreateCall {
13372 c.ctx_ = ctx
13373 return c
13374 }
13375
13376
13377
13378 func (c *ProjectsLocationsConnectionsCreateCall) Header() http.Header {
13379 if c.header_ == nil {
13380 c.header_ = make(http.Header)
13381 }
13382 return c.header_
13383 }
13384
13385 func (c *ProjectsLocationsConnectionsCreateCall) doRequest(alt string) (*http.Response, error) {
13386 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13387 var body io.Reader = nil
13388 body, err := googleapi.WithoutDataWrapper.JSONReader(c.connection)
13389 if err != nil {
13390 return nil, err
13391 }
13392 c.urlParams_.Set("alt", alt)
13393 c.urlParams_.Set("prettyPrint", "false")
13394 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/connections")
13395 urls += "?" + c.urlParams_.Encode()
13396 req, err := http.NewRequest("POST", urls, body)
13397 if err != nil {
13398 return nil, err
13399 }
13400 req.Header = reqHeaders
13401 googleapi.Expand(req.URL, map[string]string{
13402 "parent": c.parent,
13403 })
13404 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13405 }
13406
13407
13408
13409
13410
13411
13412
13413 func (c *ProjectsLocationsConnectionsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
13414 gensupport.SetOptions(c.urlParams_, opts...)
13415 res, err := c.doRequest("json")
13416 if res != nil && res.StatusCode == http.StatusNotModified {
13417 if res.Body != nil {
13418 res.Body.Close()
13419 }
13420 return nil, gensupport.WrapError(&googleapi.Error{
13421 Code: res.StatusCode,
13422 Header: res.Header,
13423 })
13424 }
13425 if err != nil {
13426 return nil, err
13427 }
13428 defer googleapi.CloseBody(res)
13429 if err := googleapi.CheckResponse(res); err != nil {
13430 return nil, gensupport.WrapError(err)
13431 }
13432 ret := &GoogleLongrunningOperation{
13433 ServerResponse: googleapi.ServerResponse{
13434 Header: res.Header,
13435 HTTPStatusCode: res.StatusCode,
13436 },
13437 }
13438 target := &ret
13439 if err := gensupport.DecodeResponse(target, res); err != nil {
13440 return nil, err
13441 }
13442 return ret, nil
13443 }
13444
13445 type ProjectsLocationsConnectionsDeleteCall struct {
13446 s *Service
13447 name string
13448 urlParams_ gensupport.URLParams
13449 ctx_ context.Context
13450 header_ http.Header
13451 }
13452
13453
13454
13455
13456
13457 func (r *ProjectsLocationsConnectionsService) Delete(name string) *ProjectsLocationsConnectionsDeleteCall {
13458 c := &ProjectsLocationsConnectionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13459 c.name = name
13460 return c
13461 }
13462
13463
13464
13465
13466
13467
13468
13469
13470
13471
13472
13473
13474 func (c *ProjectsLocationsConnectionsDeleteCall) RequestId(requestId string) *ProjectsLocationsConnectionsDeleteCall {
13475 c.urlParams_.Set("requestId", requestId)
13476 return c
13477 }
13478
13479
13480
13481
13482 func (c *ProjectsLocationsConnectionsDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsConnectionsDeleteCall {
13483 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
13484 return c
13485 }
13486
13487
13488
13489
13490 func (c *ProjectsLocationsConnectionsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsDeleteCall {
13491 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13492 return c
13493 }
13494
13495
13496 func (c *ProjectsLocationsConnectionsDeleteCall) Context(ctx context.Context) *ProjectsLocationsConnectionsDeleteCall {
13497 c.ctx_ = ctx
13498 return c
13499 }
13500
13501
13502
13503 func (c *ProjectsLocationsConnectionsDeleteCall) Header() http.Header {
13504 if c.header_ == nil {
13505 c.header_ = make(http.Header)
13506 }
13507 return c.header_
13508 }
13509
13510 func (c *ProjectsLocationsConnectionsDeleteCall) doRequest(alt string) (*http.Response, error) {
13511 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13512 var body io.Reader = nil
13513 c.urlParams_.Set("alt", alt)
13514 c.urlParams_.Set("prettyPrint", "false")
13515 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
13516 urls += "?" + c.urlParams_.Encode()
13517 req, err := http.NewRequest("DELETE", urls, body)
13518 if err != nil {
13519 return nil, err
13520 }
13521 req.Header = reqHeaders
13522 googleapi.Expand(req.URL, map[string]string{
13523 "name": c.name,
13524 })
13525 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13526 }
13527
13528
13529
13530
13531
13532
13533
13534 func (c *ProjectsLocationsConnectionsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
13535 gensupport.SetOptions(c.urlParams_, opts...)
13536 res, err := c.doRequest("json")
13537 if res != nil && res.StatusCode == http.StatusNotModified {
13538 if res.Body != nil {
13539 res.Body.Close()
13540 }
13541 return nil, gensupport.WrapError(&googleapi.Error{
13542 Code: res.StatusCode,
13543 Header: res.Header,
13544 })
13545 }
13546 if err != nil {
13547 return nil, err
13548 }
13549 defer googleapi.CloseBody(res)
13550 if err := googleapi.CheckResponse(res); err != nil {
13551 return nil, gensupport.WrapError(err)
13552 }
13553 ret := &GoogleLongrunningOperation{
13554 ServerResponse: googleapi.ServerResponse{
13555 Header: res.Header,
13556 HTTPStatusCode: res.StatusCode,
13557 },
13558 }
13559 target := &ret
13560 if err := gensupport.DecodeResponse(target, res); err != nil {
13561 return nil, err
13562 }
13563 return ret, nil
13564 }
13565
13566 type ProjectsLocationsConnectionsGetCall struct {
13567 s *Service
13568 name string
13569 urlParams_ gensupport.URLParams
13570 ifNoneMatch_ string
13571 ctx_ context.Context
13572 header_ http.Header
13573 }
13574
13575
13576
13577
13578
13579 func (r *ProjectsLocationsConnectionsService) Get(name string) *ProjectsLocationsConnectionsGetCall {
13580 c := &ProjectsLocationsConnectionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13581 c.name = name
13582 return c
13583 }
13584
13585
13586
13587
13588 func (c *ProjectsLocationsConnectionsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsGetCall {
13589 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13590 return c
13591 }
13592
13593
13594
13595
13596 func (c *ProjectsLocationsConnectionsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectionsGetCall {
13597 c.ifNoneMatch_ = entityTag
13598 return c
13599 }
13600
13601
13602 func (c *ProjectsLocationsConnectionsGetCall) Context(ctx context.Context) *ProjectsLocationsConnectionsGetCall {
13603 c.ctx_ = ctx
13604 return c
13605 }
13606
13607
13608
13609 func (c *ProjectsLocationsConnectionsGetCall) Header() http.Header {
13610 if c.header_ == nil {
13611 c.header_ = make(http.Header)
13612 }
13613 return c.header_
13614 }
13615
13616 func (c *ProjectsLocationsConnectionsGetCall) doRequest(alt string) (*http.Response, error) {
13617 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13618 if c.ifNoneMatch_ != "" {
13619 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13620 }
13621 var body io.Reader = nil
13622 c.urlParams_.Set("alt", alt)
13623 c.urlParams_.Set("prettyPrint", "false")
13624 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
13625 urls += "?" + c.urlParams_.Encode()
13626 req, err := http.NewRequest("GET", urls, body)
13627 if err != nil {
13628 return nil, err
13629 }
13630 req.Header = reqHeaders
13631 googleapi.Expand(req.URL, map[string]string{
13632 "name": c.name,
13633 })
13634 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13635 }
13636
13637
13638
13639
13640
13641
13642 func (c *ProjectsLocationsConnectionsGetCall) Do(opts ...googleapi.CallOption) (*Connection, error) {
13643 gensupport.SetOptions(c.urlParams_, opts...)
13644 res, err := c.doRequest("json")
13645 if res != nil && res.StatusCode == http.StatusNotModified {
13646 if res.Body != nil {
13647 res.Body.Close()
13648 }
13649 return nil, gensupport.WrapError(&googleapi.Error{
13650 Code: res.StatusCode,
13651 Header: res.Header,
13652 })
13653 }
13654 if err != nil {
13655 return nil, err
13656 }
13657 defer googleapi.CloseBody(res)
13658 if err := googleapi.CheckResponse(res); err != nil {
13659 return nil, gensupport.WrapError(err)
13660 }
13661 ret := &Connection{
13662 ServerResponse: googleapi.ServerResponse{
13663 Header: res.Header,
13664 HTTPStatusCode: res.StatusCode,
13665 },
13666 }
13667 target := &ret
13668 if err := gensupport.DecodeResponse(target, res); err != nil {
13669 return nil, err
13670 }
13671 return ret, nil
13672 }
13673
13674 type ProjectsLocationsConnectionsGetIamPolicyCall struct {
13675 s *Service
13676 resource string
13677 urlParams_ gensupport.URLParams
13678 ifNoneMatch_ string
13679 ctx_ context.Context
13680 header_ http.Header
13681 }
13682
13683
13684
13685
13686
13687
13688
13689 func (r *ProjectsLocationsConnectionsService) GetIamPolicy(resource string) *ProjectsLocationsConnectionsGetIamPolicyCall {
13690 c := &ProjectsLocationsConnectionsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13691 c.resource = resource
13692 return c
13693 }
13694
13695
13696
13697
13698
13699
13700
13701
13702
13703
13704
13705
13706
13707 func (c *ProjectsLocationsConnectionsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsConnectionsGetIamPolicyCall {
13708 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
13709 return c
13710 }
13711
13712
13713
13714
13715 func (c *ProjectsLocationsConnectionsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsGetIamPolicyCall {
13716 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13717 return c
13718 }
13719
13720
13721
13722
13723 func (c *ProjectsLocationsConnectionsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectionsGetIamPolicyCall {
13724 c.ifNoneMatch_ = entityTag
13725 return c
13726 }
13727
13728
13729 func (c *ProjectsLocationsConnectionsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsConnectionsGetIamPolicyCall {
13730 c.ctx_ = ctx
13731 return c
13732 }
13733
13734
13735
13736 func (c *ProjectsLocationsConnectionsGetIamPolicyCall) Header() http.Header {
13737 if c.header_ == nil {
13738 c.header_ = make(http.Header)
13739 }
13740 return c.header_
13741 }
13742
13743 func (c *ProjectsLocationsConnectionsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
13744 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13745 if c.ifNoneMatch_ != "" {
13746 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13747 }
13748 var body io.Reader = nil
13749 c.urlParams_.Set("alt", alt)
13750 c.urlParams_.Set("prettyPrint", "false")
13751 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
13752 urls += "?" + c.urlParams_.Encode()
13753 req, err := http.NewRequest("GET", urls, body)
13754 if err != nil {
13755 return nil, err
13756 }
13757 req.Header = reqHeaders
13758 googleapi.Expand(req.URL, map[string]string{
13759 "resource": c.resource,
13760 })
13761 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13762 }
13763
13764
13765
13766
13767
13768
13769
13770 func (c *ProjectsLocationsConnectionsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
13771 gensupport.SetOptions(c.urlParams_, opts...)
13772 res, err := c.doRequest("json")
13773 if res != nil && res.StatusCode == http.StatusNotModified {
13774 if res.Body != nil {
13775 res.Body.Close()
13776 }
13777 return nil, gensupport.WrapError(&googleapi.Error{
13778 Code: res.StatusCode,
13779 Header: res.Header,
13780 })
13781 }
13782 if err != nil {
13783 return nil, err
13784 }
13785 defer googleapi.CloseBody(res)
13786 if err := googleapi.CheckResponse(res); err != nil {
13787 return nil, gensupport.WrapError(err)
13788 }
13789 ret := &GoogleIamV1Policy{
13790 ServerResponse: googleapi.ServerResponse{
13791 Header: res.Header,
13792 HTTPStatusCode: res.StatusCode,
13793 },
13794 }
13795 target := &ret
13796 if err := gensupport.DecodeResponse(target, res); err != nil {
13797 return nil, err
13798 }
13799 return ret, nil
13800 }
13801
13802 type ProjectsLocationsConnectionsListCall struct {
13803 s *Service
13804 parent string
13805 urlParams_ gensupport.URLParams
13806 ifNoneMatch_ string
13807 ctx_ context.Context
13808 header_ http.Header
13809 }
13810
13811
13812
13813
13814
13815 func (r *ProjectsLocationsConnectionsService) List(parent string) *ProjectsLocationsConnectionsListCall {
13816 c := &ProjectsLocationsConnectionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13817 c.parent = parent
13818 return c
13819 }
13820
13821
13822
13823 func (c *ProjectsLocationsConnectionsListCall) Filter(filter string) *ProjectsLocationsConnectionsListCall {
13824 c.urlParams_.Set("filter", filter)
13825 return c
13826 }
13827
13828
13829
13830
13831
13832 func (c *ProjectsLocationsConnectionsListCall) OrderBy(orderBy string) *ProjectsLocationsConnectionsListCall {
13833 c.urlParams_.Set("orderBy", orderBy)
13834 return c
13835 }
13836
13837
13838
13839
13840
13841
13842 func (c *ProjectsLocationsConnectionsListCall) PageSize(pageSize int64) *ProjectsLocationsConnectionsListCall {
13843 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
13844 return c
13845 }
13846
13847
13848
13849 func (c *ProjectsLocationsConnectionsListCall) PageToken(pageToken string) *ProjectsLocationsConnectionsListCall {
13850 c.urlParams_.Set("pageToken", pageToken)
13851 return c
13852 }
13853
13854
13855
13856
13857 func (c *ProjectsLocationsConnectionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsListCall {
13858 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13859 return c
13860 }
13861
13862
13863
13864
13865 func (c *ProjectsLocationsConnectionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectionsListCall {
13866 c.ifNoneMatch_ = entityTag
13867 return c
13868 }
13869
13870
13871 func (c *ProjectsLocationsConnectionsListCall) Context(ctx context.Context) *ProjectsLocationsConnectionsListCall {
13872 c.ctx_ = ctx
13873 return c
13874 }
13875
13876
13877
13878 func (c *ProjectsLocationsConnectionsListCall) Header() http.Header {
13879 if c.header_ == nil {
13880 c.header_ = make(http.Header)
13881 }
13882 return c.header_
13883 }
13884
13885 func (c *ProjectsLocationsConnectionsListCall) doRequest(alt string) (*http.Response, error) {
13886 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13887 if c.ifNoneMatch_ != "" {
13888 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13889 }
13890 var body io.Reader = nil
13891 c.urlParams_.Set("alt", alt)
13892 c.urlParams_.Set("prettyPrint", "false")
13893 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/connections")
13894 urls += "?" + c.urlParams_.Encode()
13895 req, err := http.NewRequest("GET", urls, body)
13896 if err != nil {
13897 return nil, err
13898 }
13899 req.Header = reqHeaders
13900 googleapi.Expand(req.URL, map[string]string{
13901 "parent": c.parent,
13902 })
13903 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13904 }
13905
13906
13907
13908
13909
13910
13911
13912 func (c *ProjectsLocationsConnectionsListCall) Do(opts ...googleapi.CallOption) (*ListConnectionsResponse, error) {
13913 gensupport.SetOptions(c.urlParams_, opts...)
13914 res, err := c.doRequest("json")
13915 if res != nil && res.StatusCode == http.StatusNotModified {
13916 if res.Body != nil {
13917 res.Body.Close()
13918 }
13919 return nil, gensupport.WrapError(&googleapi.Error{
13920 Code: res.StatusCode,
13921 Header: res.Header,
13922 })
13923 }
13924 if err != nil {
13925 return nil, err
13926 }
13927 defer googleapi.CloseBody(res)
13928 if err := googleapi.CheckResponse(res); err != nil {
13929 return nil, gensupport.WrapError(err)
13930 }
13931 ret := &ListConnectionsResponse{
13932 ServerResponse: googleapi.ServerResponse{
13933 Header: res.Header,
13934 HTTPStatusCode: res.StatusCode,
13935 },
13936 }
13937 target := &ret
13938 if err := gensupport.DecodeResponse(target, res); err != nil {
13939 return nil, err
13940 }
13941 return ret, nil
13942 }
13943
13944
13945
13946
13947 func (c *ProjectsLocationsConnectionsListCall) Pages(ctx context.Context, f func(*ListConnectionsResponse) error) error {
13948 c.ctx_ = ctx
13949 defer c.PageToken(c.urlParams_.Get("pageToken"))
13950 for {
13951 x, err := c.Do()
13952 if err != nil {
13953 return err
13954 }
13955 if err := f(x); err != nil {
13956 return err
13957 }
13958 if x.NextPageToken == "" {
13959 return nil
13960 }
13961 c.PageToken(x.NextPageToken)
13962 }
13963 }
13964
13965 type ProjectsLocationsConnectionsPatchCall struct {
13966 s *Service
13967 name string
13968 connection *Connection
13969 urlParams_ gensupport.URLParams
13970 ctx_ context.Context
13971 header_ http.Header
13972 }
13973
13974
13975
13976
13977
13978 func (r *ProjectsLocationsConnectionsService) Patch(name string, connection *Connection) *ProjectsLocationsConnectionsPatchCall {
13979 c := &ProjectsLocationsConnectionsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13980 c.name = name
13981 c.connection = connection
13982 return c
13983 }
13984
13985
13986
13987 func (c *ProjectsLocationsConnectionsPatchCall) AllowMissing(allowMissing bool) *ProjectsLocationsConnectionsPatchCall {
13988 c.urlParams_.Set("allowMissing", fmt.Sprint(allowMissing))
13989 return c
13990 }
13991
13992
13993
13994
13995
13996
13997
13998
13999
14000
14001
14002
14003 func (c *ProjectsLocationsConnectionsPatchCall) RequestId(requestId string) *ProjectsLocationsConnectionsPatchCall {
14004 c.urlParams_.Set("requestId", requestId)
14005 return c
14006 }
14007
14008
14009
14010
14011
14012
14013 func (c *ProjectsLocationsConnectionsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsConnectionsPatchCall {
14014 c.urlParams_.Set("updateMask", updateMask)
14015 return c
14016 }
14017
14018
14019
14020
14021 func (c *ProjectsLocationsConnectionsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsConnectionsPatchCall {
14022 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
14023 return c
14024 }
14025
14026
14027
14028
14029 func (c *ProjectsLocationsConnectionsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsPatchCall {
14030 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14031 return c
14032 }
14033
14034
14035 func (c *ProjectsLocationsConnectionsPatchCall) Context(ctx context.Context) *ProjectsLocationsConnectionsPatchCall {
14036 c.ctx_ = ctx
14037 return c
14038 }
14039
14040
14041
14042 func (c *ProjectsLocationsConnectionsPatchCall) Header() http.Header {
14043 if c.header_ == nil {
14044 c.header_ = make(http.Header)
14045 }
14046 return c.header_
14047 }
14048
14049 func (c *ProjectsLocationsConnectionsPatchCall) doRequest(alt string) (*http.Response, error) {
14050 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14051 var body io.Reader = nil
14052 body, err := googleapi.WithoutDataWrapper.JSONReader(c.connection)
14053 if err != nil {
14054 return nil, err
14055 }
14056 c.urlParams_.Set("alt", alt)
14057 c.urlParams_.Set("prettyPrint", "false")
14058 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
14059 urls += "?" + c.urlParams_.Encode()
14060 req, err := http.NewRequest("PATCH", urls, body)
14061 if err != nil {
14062 return nil, err
14063 }
14064 req.Header = reqHeaders
14065 googleapi.Expand(req.URL, map[string]string{
14066 "name": c.name,
14067 })
14068 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14069 }
14070
14071
14072
14073
14074
14075
14076
14077 func (c *ProjectsLocationsConnectionsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
14078 gensupport.SetOptions(c.urlParams_, opts...)
14079 res, err := c.doRequest("json")
14080 if res != nil && res.StatusCode == http.StatusNotModified {
14081 if res.Body != nil {
14082 res.Body.Close()
14083 }
14084 return nil, gensupport.WrapError(&googleapi.Error{
14085 Code: res.StatusCode,
14086 Header: res.Header,
14087 })
14088 }
14089 if err != nil {
14090 return nil, err
14091 }
14092 defer googleapi.CloseBody(res)
14093 if err := googleapi.CheckResponse(res); err != nil {
14094 return nil, gensupport.WrapError(err)
14095 }
14096 ret := &GoogleLongrunningOperation{
14097 ServerResponse: googleapi.ServerResponse{
14098 Header: res.Header,
14099 HTTPStatusCode: res.StatusCode,
14100 },
14101 }
14102 target := &ret
14103 if err := gensupport.DecodeResponse(target, res); err != nil {
14104 return nil, err
14105 }
14106 return ret, nil
14107 }
14108
14109 type ProjectsLocationsConnectionsResolveCall struct {
14110 s *Service
14111 parent string
14112 urlParams_ gensupport.URLParams
14113 ifNoneMatch_ string
14114 ctx_ context.Context
14115 header_ http.Header
14116 }
14117
14118
14119
14120
14121
14122
14123 func (r *ProjectsLocationsConnectionsService) Resolve(parent string) *ProjectsLocationsConnectionsResolveCall {
14124 c := &ProjectsLocationsConnectionsResolveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14125 c.parent = parent
14126 return c
14127 }
14128
14129
14130
14131
14132
14133 func (c *ProjectsLocationsConnectionsResolveCall) ConnectorId(connectorId string) *ProjectsLocationsConnectionsResolveCall {
14134 c.urlParams_.Set("connectorId", connectorId)
14135 return c
14136 }
14137
14138
14139
14140
14141
14142
14143 func (c *ProjectsLocationsConnectionsResolveCall) PageSize(pageSize int64) *ProjectsLocationsConnectionsResolveCall {
14144 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
14145 return c
14146 }
14147
14148
14149
14150 func (c *ProjectsLocationsConnectionsResolveCall) PageToken(pageToken string) *ProjectsLocationsConnectionsResolveCall {
14151 c.urlParams_.Set("pageToken", pageToken)
14152 return c
14153 }
14154
14155
14156
14157
14158 func (c *ProjectsLocationsConnectionsResolveCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsResolveCall {
14159 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14160 return c
14161 }
14162
14163
14164
14165
14166 func (c *ProjectsLocationsConnectionsResolveCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectionsResolveCall {
14167 c.ifNoneMatch_ = entityTag
14168 return c
14169 }
14170
14171
14172 func (c *ProjectsLocationsConnectionsResolveCall) Context(ctx context.Context) *ProjectsLocationsConnectionsResolveCall {
14173 c.ctx_ = ctx
14174 return c
14175 }
14176
14177
14178
14179 func (c *ProjectsLocationsConnectionsResolveCall) Header() http.Header {
14180 if c.header_ == nil {
14181 c.header_ = make(http.Header)
14182 }
14183 return c.header_
14184 }
14185
14186 func (c *ProjectsLocationsConnectionsResolveCall) doRequest(alt string) (*http.Response, error) {
14187 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14188 if c.ifNoneMatch_ != "" {
14189 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14190 }
14191 var body io.Reader = nil
14192 c.urlParams_.Set("alt", alt)
14193 c.urlParams_.Set("prettyPrint", "false")
14194 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/connections:resolve")
14195 urls += "?" + c.urlParams_.Encode()
14196 req, err := http.NewRequest("GET", urls, body)
14197 if err != nil {
14198 return nil, err
14199 }
14200 req.Header = reqHeaders
14201 googleapi.Expand(req.URL, map[string]string{
14202 "parent": c.parent,
14203 })
14204 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14205 }
14206
14207
14208
14209
14210
14211
14212
14213 func (c *ProjectsLocationsConnectionsResolveCall) Do(opts ...googleapi.CallOption) (*ResolveConnectionsResponse, error) {
14214 gensupport.SetOptions(c.urlParams_, opts...)
14215 res, err := c.doRequest("json")
14216 if res != nil && res.StatusCode == http.StatusNotModified {
14217 if res.Body != nil {
14218 res.Body.Close()
14219 }
14220 return nil, gensupport.WrapError(&googleapi.Error{
14221 Code: res.StatusCode,
14222 Header: res.Header,
14223 })
14224 }
14225 if err != nil {
14226 return nil, err
14227 }
14228 defer googleapi.CloseBody(res)
14229 if err := googleapi.CheckResponse(res); err != nil {
14230 return nil, gensupport.WrapError(err)
14231 }
14232 ret := &ResolveConnectionsResponse{
14233 ServerResponse: googleapi.ServerResponse{
14234 Header: res.Header,
14235 HTTPStatusCode: res.StatusCode,
14236 },
14237 }
14238 target := &ret
14239 if err := gensupport.DecodeResponse(target, res); err != nil {
14240 return nil, err
14241 }
14242 return ret, nil
14243 }
14244
14245
14246
14247
14248 func (c *ProjectsLocationsConnectionsResolveCall) Pages(ctx context.Context, f func(*ResolveConnectionsResponse) error) error {
14249 c.ctx_ = ctx
14250 defer c.PageToken(c.urlParams_.Get("pageToken"))
14251 for {
14252 x, err := c.Do()
14253 if err != nil {
14254 return err
14255 }
14256 if err := f(x); err != nil {
14257 return err
14258 }
14259 if x.NextPageToken == "" {
14260 return nil
14261 }
14262 c.PageToken(x.NextPageToken)
14263 }
14264 }
14265
14266 type ProjectsLocationsConnectionsSetIamPolicyCall struct {
14267 s *Service
14268 resource string
14269 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
14270 urlParams_ gensupport.URLParams
14271 ctx_ context.Context
14272 header_ http.Header
14273 }
14274
14275
14276
14277
14278
14279
14280
14281
14282 func (r *ProjectsLocationsConnectionsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsConnectionsSetIamPolicyCall {
14283 c := &ProjectsLocationsConnectionsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14284 c.resource = resource
14285 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
14286 return c
14287 }
14288
14289
14290
14291
14292 func (c *ProjectsLocationsConnectionsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsSetIamPolicyCall {
14293 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14294 return c
14295 }
14296
14297
14298 func (c *ProjectsLocationsConnectionsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsConnectionsSetIamPolicyCall {
14299 c.ctx_ = ctx
14300 return c
14301 }
14302
14303
14304
14305 func (c *ProjectsLocationsConnectionsSetIamPolicyCall) Header() http.Header {
14306 if c.header_ == nil {
14307 c.header_ = make(http.Header)
14308 }
14309 return c.header_
14310 }
14311
14312 func (c *ProjectsLocationsConnectionsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
14313 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14314 var body io.Reader = nil
14315 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
14316 if err != nil {
14317 return nil, err
14318 }
14319 c.urlParams_.Set("alt", alt)
14320 c.urlParams_.Set("prettyPrint", "false")
14321 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
14322 urls += "?" + c.urlParams_.Encode()
14323 req, err := http.NewRequest("POST", urls, body)
14324 if err != nil {
14325 return nil, err
14326 }
14327 req.Header = reqHeaders
14328 googleapi.Expand(req.URL, map[string]string{
14329 "resource": c.resource,
14330 })
14331 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14332 }
14333
14334
14335
14336
14337
14338
14339
14340 func (c *ProjectsLocationsConnectionsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
14341 gensupport.SetOptions(c.urlParams_, opts...)
14342 res, err := c.doRequest("json")
14343 if res != nil && res.StatusCode == http.StatusNotModified {
14344 if res.Body != nil {
14345 res.Body.Close()
14346 }
14347 return nil, gensupport.WrapError(&googleapi.Error{
14348 Code: res.StatusCode,
14349 Header: res.Header,
14350 })
14351 }
14352 if err != nil {
14353 return nil, err
14354 }
14355 defer googleapi.CloseBody(res)
14356 if err := googleapi.CheckResponse(res); err != nil {
14357 return nil, gensupport.WrapError(err)
14358 }
14359 ret := &GoogleIamV1Policy{
14360 ServerResponse: googleapi.ServerResponse{
14361 Header: res.Header,
14362 HTTPStatusCode: res.StatusCode,
14363 },
14364 }
14365 target := &ret
14366 if err := gensupport.DecodeResponse(target, res); err != nil {
14367 return nil, err
14368 }
14369 return ret, nil
14370 }
14371
14372 type ProjectsLocationsConnectionsTestIamPermissionsCall struct {
14373 s *Service
14374 resource string
14375 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
14376 urlParams_ gensupport.URLParams
14377 ctx_ context.Context
14378 header_ http.Header
14379 }
14380
14381
14382
14383
14384
14385
14386
14387
14388
14389
14390
14391 func (r *ProjectsLocationsConnectionsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsConnectionsTestIamPermissionsCall {
14392 c := &ProjectsLocationsConnectionsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14393 c.resource = resource
14394 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
14395 return c
14396 }
14397
14398
14399
14400
14401 func (c *ProjectsLocationsConnectionsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectionsTestIamPermissionsCall {
14402 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14403 return c
14404 }
14405
14406
14407 func (c *ProjectsLocationsConnectionsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsConnectionsTestIamPermissionsCall {
14408 c.ctx_ = ctx
14409 return c
14410 }
14411
14412
14413
14414 func (c *ProjectsLocationsConnectionsTestIamPermissionsCall) Header() http.Header {
14415 if c.header_ == nil {
14416 c.header_ = make(http.Header)
14417 }
14418 return c.header_
14419 }
14420
14421 func (c *ProjectsLocationsConnectionsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
14422 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14423 var body io.Reader = nil
14424 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
14425 if err != nil {
14426 return nil, err
14427 }
14428 c.urlParams_.Set("alt", alt)
14429 c.urlParams_.Set("prettyPrint", "false")
14430 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
14431 urls += "?" + c.urlParams_.Encode()
14432 req, err := http.NewRequest("POST", urls, body)
14433 if err != nil {
14434 return nil, err
14435 }
14436 req.Header = reqHeaders
14437 googleapi.Expand(req.URL, map[string]string{
14438 "resource": c.resource,
14439 })
14440 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14441 }
14442
14443
14444
14445
14446
14447
14448
14449 func (c *ProjectsLocationsConnectionsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
14450 gensupport.SetOptions(c.urlParams_, opts...)
14451 res, err := c.doRequest("json")
14452 if res != nil && res.StatusCode == http.StatusNotModified {
14453 if res.Body != nil {
14454 res.Body.Close()
14455 }
14456 return nil, gensupport.WrapError(&googleapi.Error{
14457 Code: res.StatusCode,
14458 Header: res.Header,
14459 })
14460 }
14461 if err != nil {
14462 return nil, err
14463 }
14464 defer googleapi.CloseBody(res)
14465 if err := googleapi.CheckResponse(res); err != nil {
14466 return nil, gensupport.WrapError(err)
14467 }
14468 ret := &GoogleIamV1TestIamPermissionsResponse{
14469 ServerResponse: googleapi.ServerResponse{
14470 Header: res.Header,
14471 HTTPStatusCode: res.StatusCode,
14472 },
14473 }
14474 target := &ret
14475 if err := gensupport.DecodeResponse(target, res); err != nil {
14476 return nil, err
14477 }
14478 return ret, nil
14479 }
14480
14481 type ProjectsLocationsConnectorsCreateCall struct {
14482 s *Service
14483 parent string
14484 connector *Connector
14485 urlParams_ gensupport.URLParams
14486 ctx_ context.Context
14487 header_ http.Header
14488 }
14489
14490
14491
14492
14493
14494 func (r *ProjectsLocationsConnectorsService) Create(parent string, connector *Connector) *ProjectsLocationsConnectorsCreateCall {
14495 c := &ProjectsLocationsConnectorsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14496 c.parent = parent
14497 c.connector = connector
14498 return c
14499 }
14500
14501
14502
14503
14504 func (c *ProjectsLocationsConnectorsCreateCall) ConnectorId(connectorId string) *ProjectsLocationsConnectorsCreateCall {
14505 c.urlParams_.Set("connectorId", connectorId)
14506 return c
14507 }
14508
14509
14510
14511
14512
14513
14514
14515
14516
14517
14518
14519
14520 func (c *ProjectsLocationsConnectorsCreateCall) RequestId(requestId string) *ProjectsLocationsConnectorsCreateCall {
14521 c.urlParams_.Set("requestId", requestId)
14522 return c
14523 }
14524
14525
14526
14527
14528 func (c *ProjectsLocationsConnectorsCreateCall) ValidateOnly(validateOnly bool) *ProjectsLocationsConnectorsCreateCall {
14529 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
14530 return c
14531 }
14532
14533
14534
14535
14536 func (c *ProjectsLocationsConnectorsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsCreateCall {
14537 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14538 return c
14539 }
14540
14541
14542 func (c *ProjectsLocationsConnectorsCreateCall) Context(ctx context.Context) *ProjectsLocationsConnectorsCreateCall {
14543 c.ctx_ = ctx
14544 return c
14545 }
14546
14547
14548
14549 func (c *ProjectsLocationsConnectorsCreateCall) Header() http.Header {
14550 if c.header_ == nil {
14551 c.header_ = make(http.Header)
14552 }
14553 return c.header_
14554 }
14555
14556 func (c *ProjectsLocationsConnectorsCreateCall) doRequest(alt string) (*http.Response, error) {
14557 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14558 var body io.Reader = nil
14559 body, err := googleapi.WithoutDataWrapper.JSONReader(c.connector)
14560 if err != nil {
14561 return nil, err
14562 }
14563 c.urlParams_.Set("alt", alt)
14564 c.urlParams_.Set("prettyPrint", "false")
14565 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/connectors")
14566 urls += "?" + c.urlParams_.Encode()
14567 req, err := http.NewRequest("POST", urls, body)
14568 if err != nil {
14569 return nil, err
14570 }
14571 req.Header = reqHeaders
14572 googleapi.Expand(req.URL, map[string]string{
14573 "parent": c.parent,
14574 })
14575 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14576 }
14577
14578
14579
14580
14581
14582
14583
14584 func (c *ProjectsLocationsConnectorsCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
14585 gensupport.SetOptions(c.urlParams_, opts...)
14586 res, err := c.doRequest("json")
14587 if res != nil && res.StatusCode == http.StatusNotModified {
14588 if res.Body != nil {
14589 res.Body.Close()
14590 }
14591 return nil, gensupport.WrapError(&googleapi.Error{
14592 Code: res.StatusCode,
14593 Header: res.Header,
14594 })
14595 }
14596 if err != nil {
14597 return nil, err
14598 }
14599 defer googleapi.CloseBody(res)
14600 if err := googleapi.CheckResponse(res); err != nil {
14601 return nil, gensupport.WrapError(err)
14602 }
14603 ret := &GoogleLongrunningOperation{
14604 ServerResponse: googleapi.ServerResponse{
14605 Header: res.Header,
14606 HTTPStatusCode: res.StatusCode,
14607 },
14608 }
14609 target := &ret
14610 if err := gensupport.DecodeResponse(target, res); err != nil {
14611 return nil, err
14612 }
14613 return ret, nil
14614 }
14615
14616 type ProjectsLocationsConnectorsDeleteCall struct {
14617 s *Service
14618 name string
14619 urlParams_ gensupport.URLParams
14620 ctx_ context.Context
14621 header_ http.Header
14622 }
14623
14624
14625
14626
14627
14628 func (r *ProjectsLocationsConnectorsService) Delete(name string) *ProjectsLocationsConnectorsDeleteCall {
14629 c := &ProjectsLocationsConnectorsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14630 c.name = name
14631 return c
14632 }
14633
14634
14635
14636
14637
14638
14639
14640
14641
14642
14643
14644
14645 func (c *ProjectsLocationsConnectorsDeleteCall) RequestId(requestId string) *ProjectsLocationsConnectorsDeleteCall {
14646 c.urlParams_.Set("requestId", requestId)
14647 return c
14648 }
14649
14650
14651
14652
14653 func (c *ProjectsLocationsConnectorsDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsConnectorsDeleteCall {
14654 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
14655 return c
14656 }
14657
14658
14659
14660
14661 func (c *ProjectsLocationsConnectorsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsDeleteCall {
14662 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14663 return c
14664 }
14665
14666
14667 func (c *ProjectsLocationsConnectorsDeleteCall) Context(ctx context.Context) *ProjectsLocationsConnectorsDeleteCall {
14668 c.ctx_ = ctx
14669 return c
14670 }
14671
14672
14673
14674 func (c *ProjectsLocationsConnectorsDeleteCall) Header() http.Header {
14675 if c.header_ == nil {
14676 c.header_ = make(http.Header)
14677 }
14678 return c.header_
14679 }
14680
14681 func (c *ProjectsLocationsConnectorsDeleteCall) doRequest(alt string) (*http.Response, error) {
14682 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14683 var body io.Reader = nil
14684 c.urlParams_.Set("alt", alt)
14685 c.urlParams_.Set("prettyPrint", "false")
14686 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
14687 urls += "?" + c.urlParams_.Encode()
14688 req, err := http.NewRequest("DELETE", urls, body)
14689 if err != nil {
14690 return nil, err
14691 }
14692 req.Header = reqHeaders
14693 googleapi.Expand(req.URL, map[string]string{
14694 "name": c.name,
14695 })
14696 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14697 }
14698
14699
14700
14701
14702
14703
14704
14705 func (c *ProjectsLocationsConnectorsDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
14706 gensupport.SetOptions(c.urlParams_, opts...)
14707 res, err := c.doRequest("json")
14708 if res != nil && res.StatusCode == http.StatusNotModified {
14709 if res.Body != nil {
14710 res.Body.Close()
14711 }
14712 return nil, gensupport.WrapError(&googleapi.Error{
14713 Code: res.StatusCode,
14714 Header: res.Header,
14715 })
14716 }
14717 if err != nil {
14718 return nil, err
14719 }
14720 defer googleapi.CloseBody(res)
14721 if err := googleapi.CheckResponse(res); err != nil {
14722 return nil, gensupport.WrapError(err)
14723 }
14724 ret := &GoogleLongrunningOperation{
14725 ServerResponse: googleapi.ServerResponse{
14726 Header: res.Header,
14727 HTTPStatusCode: res.StatusCode,
14728 },
14729 }
14730 target := &ret
14731 if err := gensupport.DecodeResponse(target, res); err != nil {
14732 return nil, err
14733 }
14734 return ret, nil
14735 }
14736
14737 type ProjectsLocationsConnectorsGetCall struct {
14738 s *Service
14739 name string
14740 urlParams_ gensupport.URLParams
14741 ifNoneMatch_ string
14742 ctx_ context.Context
14743 header_ http.Header
14744 }
14745
14746
14747
14748
14749
14750 func (r *ProjectsLocationsConnectorsService) Get(name string) *ProjectsLocationsConnectorsGetCall {
14751 c := &ProjectsLocationsConnectorsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14752 c.name = name
14753 return c
14754 }
14755
14756
14757
14758
14759 func (c *ProjectsLocationsConnectorsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsGetCall {
14760 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14761 return c
14762 }
14763
14764
14765
14766
14767 func (c *ProjectsLocationsConnectorsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectorsGetCall {
14768 c.ifNoneMatch_ = entityTag
14769 return c
14770 }
14771
14772
14773 func (c *ProjectsLocationsConnectorsGetCall) Context(ctx context.Context) *ProjectsLocationsConnectorsGetCall {
14774 c.ctx_ = ctx
14775 return c
14776 }
14777
14778
14779
14780 func (c *ProjectsLocationsConnectorsGetCall) Header() http.Header {
14781 if c.header_ == nil {
14782 c.header_ = make(http.Header)
14783 }
14784 return c.header_
14785 }
14786
14787 func (c *ProjectsLocationsConnectorsGetCall) doRequest(alt string) (*http.Response, error) {
14788 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14789 if c.ifNoneMatch_ != "" {
14790 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14791 }
14792 var body io.Reader = nil
14793 c.urlParams_.Set("alt", alt)
14794 c.urlParams_.Set("prettyPrint", "false")
14795 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
14796 urls += "?" + c.urlParams_.Encode()
14797 req, err := http.NewRequest("GET", urls, body)
14798 if err != nil {
14799 return nil, err
14800 }
14801 req.Header = reqHeaders
14802 googleapi.Expand(req.URL, map[string]string{
14803 "name": c.name,
14804 })
14805 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14806 }
14807
14808
14809
14810
14811
14812
14813 func (c *ProjectsLocationsConnectorsGetCall) Do(opts ...googleapi.CallOption) (*Connector, error) {
14814 gensupport.SetOptions(c.urlParams_, opts...)
14815 res, err := c.doRequest("json")
14816 if res != nil && res.StatusCode == http.StatusNotModified {
14817 if res.Body != nil {
14818 res.Body.Close()
14819 }
14820 return nil, gensupport.WrapError(&googleapi.Error{
14821 Code: res.StatusCode,
14822 Header: res.Header,
14823 })
14824 }
14825 if err != nil {
14826 return nil, err
14827 }
14828 defer googleapi.CloseBody(res)
14829 if err := googleapi.CheckResponse(res); err != nil {
14830 return nil, gensupport.WrapError(err)
14831 }
14832 ret := &Connector{
14833 ServerResponse: googleapi.ServerResponse{
14834 Header: res.Header,
14835 HTTPStatusCode: res.StatusCode,
14836 },
14837 }
14838 target := &ret
14839 if err := gensupport.DecodeResponse(target, res); err != nil {
14840 return nil, err
14841 }
14842 return ret, nil
14843 }
14844
14845 type ProjectsLocationsConnectorsGetIamPolicyCall struct {
14846 s *Service
14847 resource string
14848 urlParams_ gensupport.URLParams
14849 ifNoneMatch_ string
14850 ctx_ context.Context
14851 header_ http.Header
14852 }
14853
14854
14855
14856
14857
14858
14859
14860 func (r *ProjectsLocationsConnectorsService) GetIamPolicy(resource string) *ProjectsLocationsConnectorsGetIamPolicyCall {
14861 c := &ProjectsLocationsConnectorsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14862 c.resource = resource
14863 return c
14864 }
14865
14866
14867
14868
14869
14870
14871
14872
14873
14874
14875
14876
14877
14878 func (c *ProjectsLocationsConnectorsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsConnectorsGetIamPolicyCall {
14879 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
14880 return c
14881 }
14882
14883
14884
14885
14886 func (c *ProjectsLocationsConnectorsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsGetIamPolicyCall {
14887 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14888 return c
14889 }
14890
14891
14892
14893
14894 func (c *ProjectsLocationsConnectorsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectorsGetIamPolicyCall {
14895 c.ifNoneMatch_ = entityTag
14896 return c
14897 }
14898
14899
14900 func (c *ProjectsLocationsConnectorsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsConnectorsGetIamPolicyCall {
14901 c.ctx_ = ctx
14902 return c
14903 }
14904
14905
14906
14907 func (c *ProjectsLocationsConnectorsGetIamPolicyCall) Header() http.Header {
14908 if c.header_ == nil {
14909 c.header_ = make(http.Header)
14910 }
14911 return c.header_
14912 }
14913
14914 func (c *ProjectsLocationsConnectorsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
14915 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14916 if c.ifNoneMatch_ != "" {
14917 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14918 }
14919 var body io.Reader = nil
14920 c.urlParams_.Set("alt", alt)
14921 c.urlParams_.Set("prettyPrint", "false")
14922 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
14923 urls += "?" + c.urlParams_.Encode()
14924 req, err := http.NewRequest("GET", urls, body)
14925 if err != nil {
14926 return nil, err
14927 }
14928 req.Header = reqHeaders
14929 googleapi.Expand(req.URL, map[string]string{
14930 "resource": c.resource,
14931 })
14932 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14933 }
14934
14935
14936
14937
14938
14939
14940
14941 func (c *ProjectsLocationsConnectorsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
14942 gensupport.SetOptions(c.urlParams_, opts...)
14943 res, err := c.doRequest("json")
14944 if res != nil && res.StatusCode == http.StatusNotModified {
14945 if res.Body != nil {
14946 res.Body.Close()
14947 }
14948 return nil, gensupport.WrapError(&googleapi.Error{
14949 Code: res.StatusCode,
14950 Header: res.Header,
14951 })
14952 }
14953 if err != nil {
14954 return nil, err
14955 }
14956 defer googleapi.CloseBody(res)
14957 if err := googleapi.CheckResponse(res); err != nil {
14958 return nil, gensupport.WrapError(err)
14959 }
14960 ret := &GoogleIamV1Policy{
14961 ServerResponse: googleapi.ServerResponse{
14962 Header: res.Header,
14963 HTTPStatusCode: res.StatusCode,
14964 },
14965 }
14966 target := &ret
14967 if err := gensupport.DecodeResponse(target, res); err != nil {
14968 return nil, err
14969 }
14970 return ret, nil
14971 }
14972
14973 type ProjectsLocationsConnectorsListCall struct {
14974 s *Service
14975 parent string
14976 urlParams_ gensupport.URLParams
14977 ifNoneMatch_ string
14978 ctx_ context.Context
14979 header_ http.Header
14980 }
14981
14982
14983
14984
14985
14986 func (r *ProjectsLocationsConnectorsService) List(parent string) *ProjectsLocationsConnectorsListCall {
14987 c := &ProjectsLocationsConnectorsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14988 c.parent = parent
14989 return c
14990 }
14991
14992
14993
14994 func (c *ProjectsLocationsConnectorsListCall) Filter(filter string) *ProjectsLocationsConnectorsListCall {
14995 c.urlParams_.Set("filter", filter)
14996 return c
14997 }
14998
14999
15000
15001
15002
15003 func (c *ProjectsLocationsConnectorsListCall) OrderBy(orderBy string) *ProjectsLocationsConnectorsListCall {
15004 c.urlParams_.Set("orderBy", orderBy)
15005 return c
15006 }
15007
15008
15009
15010
15011
15012
15013 func (c *ProjectsLocationsConnectorsListCall) PageSize(pageSize int64) *ProjectsLocationsConnectorsListCall {
15014 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
15015 return c
15016 }
15017
15018
15019
15020 func (c *ProjectsLocationsConnectorsListCall) PageToken(pageToken string) *ProjectsLocationsConnectorsListCall {
15021 c.urlParams_.Set("pageToken", pageToken)
15022 return c
15023 }
15024
15025
15026
15027
15028 func (c *ProjectsLocationsConnectorsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsListCall {
15029 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15030 return c
15031 }
15032
15033
15034
15035
15036 func (c *ProjectsLocationsConnectorsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectorsListCall {
15037 c.ifNoneMatch_ = entityTag
15038 return c
15039 }
15040
15041
15042 func (c *ProjectsLocationsConnectorsListCall) Context(ctx context.Context) *ProjectsLocationsConnectorsListCall {
15043 c.ctx_ = ctx
15044 return c
15045 }
15046
15047
15048
15049 func (c *ProjectsLocationsConnectorsListCall) Header() http.Header {
15050 if c.header_ == nil {
15051 c.header_ = make(http.Header)
15052 }
15053 return c.header_
15054 }
15055
15056 func (c *ProjectsLocationsConnectorsListCall) doRequest(alt string) (*http.Response, error) {
15057 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15058 if c.ifNoneMatch_ != "" {
15059 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15060 }
15061 var body io.Reader = nil
15062 c.urlParams_.Set("alt", alt)
15063 c.urlParams_.Set("prettyPrint", "false")
15064 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/connectors")
15065 urls += "?" + c.urlParams_.Encode()
15066 req, err := http.NewRequest("GET", urls, body)
15067 if err != nil {
15068 return nil, err
15069 }
15070 req.Header = reqHeaders
15071 googleapi.Expand(req.URL, map[string]string{
15072 "parent": c.parent,
15073 })
15074 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15075 }
15076
15077
15078
15079
15080
15081
15082
15083 func (c *ProjectsLocationsConnectorsListCall) Do(opts ...googleapi.CallOption) (*ListConnectorsResponse, error) {
15084 gensupport.SetOptions(c.urlParams_, opts...)
15085 res, err := c.doRequest("json")
15086 if res != nil && res.StatusCode == http.StatusNotModified {
15087 if res.Body != nil {
15088 res.Body.Close()
15089 }
15090 return nil, gensupport.WrapError(&googleapi.Error{
15091 Code: res.StatusCode,
15092 Header: res.Header,
15093 })
15094 }
15095 if err != nil {
15096 return nil, err
15097 }
15098 defer googleapi.CloseBody(res)
15099 if err := googleapi.CheckResponse(res); err != nil {
15100 return nil, gensupport.WrapError(err)
15101 }
15102 ret := &ListConnectorsResponse{
15103 ServerResponse: googleapi.ServerResponse{
15104 Header: res.Header,
15105 HTTPStatusCode: res.StatusCode,
15106 },
15107 }
15108 target := &ret
15109 if err := gensupport.DecodeResponse(target, res); err != nil {
15110 return nil, err
15111 }
15112 return ret, nil
15113 }
15114
15115
15116
15117
15118 func (c *ProjectsLocationsConnectorsListCall) Pages(ctx context.Context, f func(*ListConnectorsResponse) error) error {
15119 c.ctx_ = ctx
15120 defer c.PageToken(c.urlParams_.Get("pageToken"))
15121 for {
15122 x, err := c.Do()
15123 if err != nil {
15124 return err
15125 }
15126 if err := f(x); err != nil {
15127 return err
15128 }
15129 if x.NextPageToken == "" {
15130 return nil
15131 }
15132 c.PageToken(x.NextPageToken)
15133 }
15134 }
15135
15136 type ProjectsLocationsConnectorsPatchCall struct {
15137 s *Service
15138 name string
15139 connector *Connector
15140 urlParams_ gensupport.URLParams
15141 ctx_ context.Context
15142 header_ http.Header
15143 }
15144
15145
15146
15147
15148
15149 func (r *ProjectsLocationsConnectorsService) Patch(name string, connector *Connector) *ProjectsLocationsConnectorsPatchCall {
15150 c := &ProjectsLocationsConnectorsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15151 c.name = name
15152 c.connector = connector
15153 return c
15154 }
15155
15156
15157
15158
15159
15160
15161
15162
15163
15164
15165
15166
15167 func (c *ProjectsLocationsConnectorsPatchCall) RequestId(requestId string) *ProjectsLocationsConnectorsPatchCall {
15168 c.urlParams_.Set("requestId", requestId)
15169 return c
15170 }
15171
15172
15173
15174
15175
15176 func (c *ProjectsLocationsConnectorsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsConnectorsPatchCall {
15177 c.urlParams_.Set("updateMask", updateMask)
15178 return c
15179 }
15180
15181
15182
15183
15184 func (c *ProjectsLocationsConnectorsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsConnectorsPatchCall {
15185 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
15186 return c
15187 }
15188
15189
15190
15191
15192 func (c *ProjectsLocationsConnectorsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsPatchCall {
15193 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15194 return c
15195 }
15196
15197
15198 func (c *ProjectsLocationsConnectorsPatchCall) Context(ctx context.Context) *ProjectsLocationsConnectorsPatchCall {
15199 c.ctx_ = ctx
15200 return c
15201 }
15202
15203
15204
15205 func (c *ProjectsLocationsConnectorsPatchCall) Header() http.Header {
15206 if c.header_ == nil {
15207 c.header_ = make(http.Header)
15208 }
15209 return c.header_
15210 }
15211
15212 func (c *ProjectsLocationsConnectorsPatchCall) doRequest(alt string) (*http.Response, error) {
15213 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15214 var body io.Reader = nil
15215 body, err := googleapi.WithoutDataWrapper.JSONReader(c.connector)
15216 if err != nil {
15217 return nil, err
15218 }
15219 c.urlParams_.Set("alt", alt)
15220 c.urlParams_.Set("prettyPrint", "false")
15221 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
15222 urls += "?" + c.urlParams_.Encode()
15223 req, err := http.NewRequest("PATCH", urls, body)
15224 if err != nil {
15225 return nil, err
15226 }
15227 req.Header = reqHeaders
15228 googleapi.Expand(req.URL, map[string]string{
15229 "name": c.name,
15230 })
15231 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15232 }
15233
15234
15235
15236
15237
15238
15239
15240 func (c *ProjectsLocationsConnectorsPatchCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
15241 gensupport.SetOptions(c.urlParams_, opts...)
15242 res, err := c.doRequest("json")
15243 if res != nil && res.StatusCode == http.StatusNotModified {
15244 if res.Body != nil {
15245 res.Body.Close()
15246 }
15247 return nil, gensupport.WrapError(&googleapi.Error{
15248 Code: res.StatusCode,
15249 Header: res.Header,
15250 })
15251 }
15252 if err != nil {
15253 return nil, err
15254 }
15255 defer googleapi.CloseBody(res)
15256 if err := googleapi.CheckResponse(res); err != nil {
15257 return nil, gensupport.WrapError(err)
15258 }
15259 ret := &GoogleLongrunningOperation{
15260 ServerResponse: googleapi.ServerResponse{
15261 Header: res.Header,
15262 HTTPStatusCode: res.StatusCode,
15263 },
15264 }
15265 target := &ret
15266 if err := gensupport.DecodeResponse(target, res); err != nil {
15267 return nil, err
15268 }
15269 return ret, nil
15270 }
15271
15272 type ProjectsLocationsConnectorsReportStatusCall struct {
15273 s *Service
15274 connector string
15275 reportstatusrequest *ReportStatusRequest
15276 urlParams_ gensupport.URLParams
15277 ctx_ context.Context
15278 header_ http.Header
15279 }
15280
15281
15282
15283
15284
15285 func (r *ProjectsLocationsConnectorsService) ReportStatus(connector string, reportstatusrequest *ReportStatusRequest) *ProjectsLocationsConnectorsReportStatusCall {
15286 c := &ProjectsLocationsConnectorsReportStatusCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15287 c.connector = connector
15288 c.reportstatusrequest = reportstatusrequest
15289 return c
15290 }
15291
15292
15293
15294
15295 func (c *ProjectsLocationsConnectorsReportStatusCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsReportStatusCall {
15296 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15297 return c
15298 }
15299
15300
15301 func (c *ProjectsLocationsConnectorsReportStatusCall) Context(ctx context.Context) *ProjectsLocationsConnectorsReportStatusCall {
15302 c.ctx_ = ctx
15303 return c
15304 }
15305
15306
15307
15308 func (c *ProjectsLocationsConnectorsReportStatusCall) Header() http.Header {
15309 if c.header_ == nil {
15310 c.header_ = make(http.Header)
15311 }
15312 return c.header_
15313 }
15314
15315 func (c *ProjectsLocationsConnectorsReportStatusCall) doRequest(alt string) (*http.Response, error) {
15316 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15317 var body io.Reader = nil
15318 body, err := googleapi.WithoutDataWrapper.JSONReader(c.reportstatusrequest)
15319 if err != nil {
15320 return nil, err
15321 }
15322 c.urlParams_.Set("alt", alt)
15323 c.urlParams_.Set("prettyPrint", "false")
15324 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+connector}:reportStatus")
15325 urls += "?" + c.urlParams_.Encode()
15326 req, err := http.NewRequest("POST", urls, body)
15327 if err != nil {
15328 return nil, err
15329 }
15330 req.Header = reqHeaders
15331 googleapi.Expand(req.URL, map[string]string{
15332 "connector": c.connector,
15333 })
15334 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15335 }
15336
15337
15338
15339
15340
15341
15342
15343 func (c *ProjectsLocationsConnectorsReportStatusCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
15344 gensupport.SetOptions(c.urlParams_, opts...)
15345 res, err := c.doRequest("json")
15346 if res != nil && res.StatusCode == http.StatusNotModified {
15347 if res.Body != nil {
15348 res.Body.Close()
15349 }
15350 return nil, gensupport.WrapError(&googleapi.Error{
15351 Code: res.StatusCode,
15352 Header: res.Header,
15353 })
15354 }
15355 if err != nil {
15356 return nil, err
15357 }
15358 defer googleapi.CloseBody(res)
15359 if err := googleapi.CheckResponse(res); err != nil {
15360 return nil, gensupport.WrapError(err)
15361 }
15362 ret := &GoogleLongrunningOperation{
15363 ServerResponse: googleapi.ServerResponse{
15364 Header: res.Header,
15365 HTTPStatusCode: res.StatusCode,
15366 },
15367 }
15368 target := &ret
15369 if err := gensupport.DecodeResponse(target, res); err != nil {
15370 return nil, err
15371 }
15372 return ret, nil
15373 }
15374
15375 type ProjectsLocationsConnectorsResolveInstanceConfigCall struct {
15376 s *Service
15377 connector string
15378 urlParams_ gensupport.URLParams
15379 ifNoneMatch_ string
15380 ctx_ context.Context
15381 header_ http.Header
15382 }
15383
15384
15385
15386
15387
15388
15389 func (r *ProjectsLocationsConnectorsService) ResolveInstanceConfig(connector string) *ProjectsLocationsConnectorsResolveInstanceConfigCall {
15390 c := &ProjectsLocationsConnectorsResolveInstanceConfigCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15391 c.connector = connector
15392 return c
15393 }
15394
15395
15396
15397
15398 func (c *ProjectsLocationsConnectorsResolveInstanceConfigCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsResolveInstanceConfigCall {
15399 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15400 return c
15401 }
15402
15403
15404
15405
15406 func (c *ProjectsLocationsConnectorsResolveInstanceConfigCall) IfNoneMatch(entityTag string) *ProjectsLocationsConnectorsResolveInstanceConfigCall {
15407 c.ifNoneMatch_ = entityTag
15408 return c
15409 }
15410
15411
15412 func (c *ProjectsLocationsConnectorsResolveInstanceConfigCall) Context(ctx context.Context) *ProjectsLocationsConnectorsResolveInstanceConfigCall {
15413 c.ctx_ = ctx
15414 return c
15415 }
15416
15417
15418
15419 func (c *ProjectsLocationsConnectorsResolveInstanceConfigCall) Header() http.Header {
15420 if c.header_ == nil {
15421 c.header_ = make(http.Header)
15422 }
15423 return c.header_
15424 }
15425
15426 func (c *ProjectsLocationsConnectorsResolveInstanceConfigCall) doRequest(alt string) (*http.Response, error) {
15427 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15428 if c.ifNoneMatch_ != "" {
15429 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15430 }
15431 var body io.Reader = nil
15432 c.urlParams_.Set("alt", alt)
15433 c.urlParams_.Set("prettyPrint", "false")
15434 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+connector}:resolveInstanceConfig")
15435 urls += "?" + c.urlParams_.Encode()
15436 req, err := http.NewRequest("GET", urls, body)
15437 if err != nil {
15438 return nil, err
15439 }
15440 req.Header = reqHeaders
15441 googleapi.Expand(req.URL, map[string]string{
15442 "connector": c.connector,
15443 })
15444 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15445 }
15446
15447
15448
15449
15450
15451
15452
15453 func (c *ProjectsLocationsConnectorsResolveInstanceConfigCall) Do(opts ...googleapi.CallOption) (*ResolveInstanceConfigResponse, error) {
15454 gensupport.SetOptions(c.urlParams_, opts...)
15455 res, err := c.doRequest("json")
15456 if res != nil && res.StatusCode == http.StatusNotModified {
15457 if res.Body != nil {
15458 res.Body.Close()
15459 }
15460 return nil, gensupport.WrapError(&googleapi.Error{
15461 Code: res.StatusCode,
15462 Header: res.Header,
15463 })
15464 }
15465 if err != nil {
15466 return nil, err
15467 }
15468 defer googleapi.CloseBody(res)
15469 if err := googleapi.CheckResponse(res); err != nil {
15470 return nil, gensupport.WrapError(err)
15471 }
15472 ret := &ResolveInstanceConfigResponse{
15473 ServerResponse: googleapi.ServerResponse{
15474 Header: res.Header,
15475 HTTPStatusCode: res.StatusCode,
15476 },
15477 }
15478 target := &ret
15479 if err := gensupport.DecodeResponse(target, res); err != nil {
15480 return nil, err
15481 }
15482 return ret, nil
15483 }
15484
15485 type ProjectsLocationsConnectorsSetIamPolicyCall struct {
15486 s *Service
15487 resource string
15488 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
15489 urlParams_ gensupport.URLParams
15490 ctx_ context.Context
15491 header_ http.Header
15492 }
15493
15494
15495
15496
15497
15498
15499
15500
15501 func (r *ProjectsLocationsConnectorsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsConnectorsSetIamPolicyCall {
15502 c := &ProjectsLocationsConnectorsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15503 c.resource = resource
15504 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
15505 return c
15506 }
15507
15508
15509
15510
15511 func (c *ProjectsLocationsConnectorsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsSetIamPolicyCall {
15512 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15513 return c
15514 }
15515
15516
15517 func (c *ProjectsLocationsConnectorsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsConnectorsSetIamPolicyCall {
15518 c.ctx_ = ctx
15519 return c
15520 }
15521
15522
15523
15524 func (c *ProjectsLocationsConnectorsSetIamPolicyCall) Header() http.Header {
15525 if c.header_ == nil {
15526 c.header_ = make(http.Header)
15527 }
15528 return c.header_
15529 }
15530
15531 func (c *ProjectsLocationsConnectorsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
15532 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15533 var body io.Reader = nil
15534 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
15535 if err != nil {
15536 return nil, err
15537 }
15538 c.urlParams_.Set("alt", alt)
15539 c.urlParams_.Set("prettyPrint", "false")
15540 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
15541 urls += "?" + c.urlParams_.Encode()
15542 req, err := http.NewRequest("POST", urls, body)
15543 if err != nil {
15544 return nil, err
15545 }
15546 req.Header = reqHeaders
15547 googleapi.Expand(req.URL, map[string]string{
15548 "resource": c.resource,
15549 })
15550 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15551 }
15552
15553
15554
15555
15556
15557
15558
15559 func (c *ProjectsLocationsConnectorsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
15560 gensupport.SetOptions(c.urlParams_, opts...)
15561 res, err := c.doRequest("json")
15562 if res != nil && res.StatusCode == http.StatusNotModified {
15563 if res.Body != nil {
15564 res.Body.Close()
15565 }
15566 return nil, gensupport.WrapError(&googleapi.Error{
15567 Code: res.StatusCode,
15568 Header: res.Header,
15569 })
15570 }
15571 if err != nil {
15572 return nil, err
15573 }
15574 defer googleapi.CloseBody(res)
15575 if err := googleapi.CheckResponse(res); err != nil {
15576 return nil, gensupport.WrapError(err)
15577 }
15578 ret := &GoogleIamV1Policy{
15579 ServerResponse: googleapi.ServerResponse{
15580 Header: res.Header,
15581 HTTPStatusCode: res.StatusCode,
15582 },
15583 }
15584 target := &ret
15585 if err := gensupport.DecodeResponse(target, res); err != nil {
15586 return nil, err
15587 }
15588 return ret, nil
15589 }
15590
15591 type ProjectsLocationsConnectorsTestIamPermissionsCall struct {
15592 s *Service
15593 resource string
15594 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
15595 urlParams_ gensupport.URLParams
15596 ctx_ context.Context
15597 header_ http.Header
15598 }
15599
15600
15601
15602
15603
15604
15605
15606
15607
15608
15609
15610 func (r *ProjectsLocationsConnectorsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsConnectorsTestIamPermissionsCall {
15611 c := &ProjectsLocationsConnectorsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15612 c.resource = resource
15613 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
15614 return c
15615 }
15616
15617
15618
15619
15620 func (c *ProjectsLocationsConnectorsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsConnectorsTestIamPermissionsCall {
15621 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15622 return c
15623 }
15624
15625
15626 func (c *ProjectsLocationsConnectorsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsConnectorsTestIamPermissionsCall {
15627 c.ctx_ = ctx
15628 return c
15629 }
15630
15631
15632
15633 func (c *ProjectsLocationsConnectorsTestIamPermissionsCall) Header() http.Header {
15634 if c.header_ == nil {
15635 c.header_ = make(http.Header)
15636 }
15637 return c.header_
15638 }
15639
15640 func (c *ProjectsLocationsConnectorsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
15641 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15642 var body io.Reader = nil
15643 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
15644 if err != nil {
15645 return nil, err
15646 }
15647 c.urlParams_.Set("alt", alt)
15648 c.urlParams_.Set("prettyPrint", "false")
15649 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
15650 urls += "?" + c.urlParams_.Encode()
15651 req, err := http.NewRequest("POST", urls, body)
15652 if err != nil {
15653 return nil, err
15654 }
15655 req.Header = reqHeaders
15656 googleapi.Expand(req.URL, map[string]string{
15657 "resource": c.resource,
15658 })
15659 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15660 }
15661
15662
15663
15664
15665
15666
15667
15668 func (c *ProjectsLocationsConnectorsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
15669 gensupport.SetOptions(c.urlParams_, opts...)
15670 res, err := c.doRequest("json")
15671 if res != nil && res.StatusCode == http.StatusNotModified {
15672 if res.Body != nil {
15673 res.Body.Close()
15674 }
15675 return nil, gensupport.WrapError(&googleapi.Error{
15676 Code: res.StatusCode,
15677 Header: res.Header,
15678 })
15679 }
15680 if err != nil {
15681 return nil, err
15682 }
15683 defer googleapi.CloseBody(res)
15684 if err := googleapi.CheckResponse(res); err != nil {
15685 return nil, gensupport.WrapError(err)
15686 }
15687 ret := &GoogleIamV1TestIamPermissionsResponse{
15688 ServerResponse: googleapi.ServerResponse{
15689 Header: res.Header,
15690 HTTPStatusCode: res.StatusCode,
15691 },
15692 }
15693 target := &ret
15694 if err := gensupport.DecodeResponse(target, res); err != nil {
15695 return nil, err
15696 }
15697 return ret, nil
15698 }
15699
15700 type ProjectsLocationsInsightsConfiguredInsightCall struct {
15701 s *Service
15702 insight string
15703 urlParams_ gensupport.URLParams
15704 ifNoneMatch_ string
15705 ctx_ context.Context
15706 header_ http.Header
15707 }
15708
15709
15710
15711
15712
15713
15714
15715
15716
15717
15718 func (r *ProjectsLocationsInsightsService) ConfiguredInsight(insight string) *ProjectsLocationsInsightsConfiguredInsightCall {
15719 c := &ProjectsLocationsInsightsConfiguredInsightCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15720 c.insight = insight
15721 return c
15722 }
15723
15724
15725
15726
15727
15728
15729
15730
15731
15732
15733
15734
15735
15736
15737
15738 func (c *ProjectsLocationsInsightsConfiguredInsightCall) Aggregation(aggregation string) *ProjectsLocationsInsightsConfiguredInsightCall {
15739 c.urlParams_.Set("aggregation", aggregation)
15740 return c
15741 }
15742
15743
15744
15745
15746
15747
15748
15749
15750
15751
15752
15753 func (c *ProjectsLocationsInsightsConfiguredInsightCall) CustomGroupingFieldFilter(customGroupingFieldFilter string) *ProjectsLocationsInsightsConfiguredInsightCall {
15754 c.urlParams_.Set("customGrouping.fieldFilter", customGroupingFieldFilter)
15755 return c
15756 }
15757
15758
15759
15760
15761
15762 func (c *ProjectsLocationsInsightsConfiguredInsightCall) CustomGroupingGroupFields(customGroupingGroupFields ...string) *ProjectsLocationsInsightsConfiguredInsightCall {
15763 c.urlParams_.SetMulti("customGrouping.groupFields", append([]string{}, customGroupingGroupFields...))
15764 return c
15765 }
15766
15767
15768
15769 func (c *ProjectsLocationsInsightsConfiguredInsightCall) EndTime(endTime string) *ProjectsLocationsInsightsConfiguredInsightCall {
15770 c.urlParams_.Set("endTime", endTime)
15771 return c
15772 }
15773
15774
15775
15776
15777
15778
15779
15780
15781
15782
15783 func (c *ProjectsLocationsInsightsConfiguredInsightCall) FieldFilter(fieldFilter string) *ProjectsLocationsInsightsConfiguredInsightCall {
15784 c.urlParams_.Set("fieldFilter", fieldFilter)
15785 return c
15786 }
15787
15788
15789
15790
15791 func (c *ProjectsLocationsInsightsConfiguredInsightCall) Group(group string) *ProjectsLocationsInsightsConfiguredInsightCall {
15792 c.urlParams_.Set("group", group)
15793 return c
15794 }
15795
15796
15797
15798
15799 func (c *ProjectsLocationsInsightsConfiguredInsightCall) PageSize(pageSize int64) *ProjectsLocationsInsightsConfiguredInsightCall {
15800 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
15801 return c
15802 }
15803
15804
15805
15806 func (c *ProjectsLocationsInsightsConfiguredInsightCall) PageToken(pageToken string) *ProjectsLocationsInsightsConfiguredInsightCall {
15807 c.urlParams_.Set("pageToken", pageToken)
15808 return c
15809 }
15810
15811
15812
15813 func (c *ProjectsLocationsInsightsConfiguredInsightCall) StartTime(startTime string) *ProjectsLocationsInsightsConfiguredInsightCall {
15814 c.urlParams_.Set("startTime", startTime)
15815 return c
15816 }
15817
15818
15819
15820
15821 func (c *ProjectsLocationsInsightsConfiguredInsightCall) Fields(s ...googleapi.Field) *ProjectsLocationsInsightsConfiguredInsightCall {
15822 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15823 return c
15824 }
15825
15826
15827
15828
15829 func (c *ProjectsLocationsInsightsConfiguredInsightCall) IfNoneMatch(entityTag string) *ProjectsLocationsInsightsConfiguredInsightCall {
15830 c.ifNoneMatch_ = entityTag
15831 return c
15832 }
15833
15834
15835 func (c *ProjectsLocationsInsightsConfiguredInsightCall) Context(ctx context.Context) *ProjectsLocationsInsightsConfiguredInsightCall {
15836 c.ctx_ = ctx
15837 return c
15838 }
15839
15840
15841
15842 func (c *ProjectsLocationsInsightsConfiguredInsightCall) Header() http.Header {
15843 if c.header_ == nil {
15844 c.header_ = make(http.Header)
15845 }
15846 return c.header_
15847 }
15848
15849 func (c *ProjectsLocationsInsightsConfiguredInsightCall) doRequest(alt string) (*http.Response, error) {
15850 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15851 if c.ifNoneMatch_ != "" {
15852 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15853 }
15854 var body io.Reader = nil
15855 c.urlParams_.Set("alt", alt)
15856 c.urlParams_.Set("prettyPrint", "false")
15857 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+insight}:configuredInsight")
15858 urls += "?" + c.urlParams_.Encode()
15859 req, err := http.NewRequest("GET", urls, body)
15860 if err != nil {
15861 return nil, err
15862 }
15863 req.Header = reqHeaders
15864 googleapi.Expand(req.URL, map[string]string{
15865 "insight": c.insight,
15866 })
15867 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15868 }
15869
15870
15871
15872
15873
15874
15875
15876 func (c *ProjectsLocationsInsightsConfiguredInsightCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse, error) {
15877 gensupport.SetOptions(c.urlParams_, opts...)
15878 res, err := c.doRequest("json")
15879 if res != nil && res.StatusCode == http.StatusNotModified {
15880 if res.Body != nil {
15881 res.Body.Close()
15882 }
15883 return nil, gensupport.WrapError(&googleapi.Error{
15884 Code: res.StatusCode,
15885 Header: res.Header,
15886 })
15887 }
15888 if err != nil {
15889 return nil, err
15890 }
15891 defer googleapi.CloseBody(res)
15892 if err := googleapi.CheckResponse(res); err != nil {
15893 return nil, gensupport.WrapError(err)
15894 }
15895 ret := &GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse{
15896 ServerResponse: googleapi.ServerResponse{
15897 Header: res.Header,
15898 HTTPStatusCode: res.StatusCode,
15899 },
15900 }
15901 target := &ret
15902 if err := gensupport.DecodeResponse(target, res); err != nil {
15903 return nil, err
15904 }
15905 return ret, nil
15906 }
15907
15908
15909
15910
15911 func (c *ProjectsLocationsInsightsConfiguredInsightCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaConfiguredInsightResponse) error) error {
15912 c.ctx_ = ctx
15913 defer c.PageToken(c.urlParams_.Get("pageToken"))
15914 for {
15915 x, err := c.Do()
15916 if err != nil {
15917 return err
15918 }
15919 if err := f(x); err != nil {
15920 return err
15921 }
15922 if x.NextPageToken == "" {
15923 return nil
15924 }
15925 c.PageToken(x.NextPageToken)
15926 }
15927 }
15928
15929 type ProjectsLocationsInsightsGetCall struct {
15930 s *Service
15931 name string
15932 urlParams_ gensupport.URLParams
15933 ifNoneMatch_ string
15934 ctx_ context.Context
15935 header_ http.Header
15936 }
15937
15938
15939
15940
15941
15942
15943
15944
15945
15946
15947
15948
15949
15950 func (r *ProjectsLocationsInsightsService) Get(name string) *ProjectsLocationsInsightsGetCall {
15951 c := &ProjectsLocationsInsightsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15952 c.name = name
15953 return c
15954 }
15955
15956
15957
15958
15959
15960
15961
15962
15963
15964
15965
15966
15967
15968
15969
15970 func (c *ProjectsLocationsInsightsGetCall) View(view string) *ProjectsLocationsInsightsGetCall {
15971 c.urlParams_.Set("view", view)
15972 return c
15973 }
15974
15975
15976
15977
15978 func (c *ProjectsLocationsInsightsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsInsightsGetCall {
15979 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15980 return c
15981 }
15982
15983
15984
15985
15986 func (c *ProjectsLocationsInsightsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsInsightsGetCall {
15987 c.ifNoneMatch_ = entityTag
15988 return c
15989 }
15990
15991
15992 func (c *ProjectsLocationsInsightsGetCall) Context(ctx context.Context) *ProjectsLocationsInsightsGetCall {
15993 c.ctx_ = ctx
15994 return c
15995 }
15996
15997
15998
15999 func (c *ProjectsLocationsInsightsGetCall) Header() http.Header {
16000 if c.header_ == nil {
16001 c.header_ = make(http.Header)
16002 }
16003 return c.header_
16004 }
16005
16006 func (c *ProjectsLocationsInsightsGetCall) doRequest(alt string) (*http.Response, error) {
16007 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16008 if c.ifNoneMatch_ != "" {
16009 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16010 }
16011 var body io.Reader = nil
16012 c.urlParams_.Set("alt", alt)
16013 c.urlParams_.Set("prettyPrint", "false")
16014 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16015 urls += "?" + c.urlParams_.Encode()
16016 req, err := http.NewRequest("GET", urls, body)
16017 if err != nil {
16018 return nil, err
16019 }
16020 req.Header = reqHeaders
16021 googleapi.Expand(req.URL, map[string]string{
16022 "name": c.name,
16023 })
16024 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16025 }
16026
16027
16028
16029
16030
16031
16032
16033 func (c *ProjectsLocationsInsightsGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsight, error) {
16034 gensupport.SetOptions(c.urlParams_, opts...)
16035 res, err := c.doRequest("json")
16036 if res != nil && res.StatusCode == http.StatusNotModified {
16037 if res.Body != nil {
16038 res.Body.Close()
16039 }
16040 return nil, gensupport.WrapError(&googleapi.Error{
16041 Code: res.StatusCode,
16042 Header: res.Header,
16043 })
16044 }
16045 if err != nil {
16046 return nil, err
16047 }
16048 defer googleapi.CloseBody(res)
16049 if err := googleapi.CheckResponse(res); err != nil {
16050 return nil, gensupport.WrapError(err)
16051 }
16052 ret := &GoogleCloudBeyondcorpSaasplatformInsightsV1alphaInsight{
16053 ServerResponse: googleapi.ServerResponse{
16054 Header: res.Header,
16055 HTTPStatusCode: res.StatusCode,
16056 },
16057 }
16058 target := &ret
16059 if err := gensupport.DecodeResponse(target, res); err != nil {
16060 return nil, err
16061 }
16062 return ret, nil
16063 }
16064
16065 type ProjectsLocationsInsightsListCall struct {
16066 s *Service
16067 parent string
16068 urlParams_ gensupport.URLParams
16069 ifNoneMatch_ string
16070 ctx_ context.Context
16071 header_ http.Header
16072 }
16073
16074
16075
16076
16077
16078
16079
16080
16081 func (r *ProjectsLocationsInsightsService) List(parent string) *ProjectsLocationsInsightsListCall {
16082 c := &ProjectsLocationsInsightsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16083 c.parent = parent
16084 return c
16085 }
16086
16087
16088
16089
16090
16091
16092
16093
16094
16095
16096
16097
16098 func (c *ProjectsLocationsInsightsListCall) Filter(filter string) *ProjectsLocationsInsightsListCall {
16099 c.urlParams_.Set("filter", filter)
16100 return c
16101 }
16102
16103
16104
16105 func (c *ProjectsLocationsInsightsListCall) OrderBy(orderBy string) *ProjectsLocationsInsightsListCall {
16106 c.urlParams_.Set("orderBy", orderBy)
16107 return c
16108 }
16109
16110
16111
16112
16113 func (c *ProjectsLocationsInsightsListCall) PageSize(pageSize int64) *ProjectsLocationsInsightsListCall {
16114 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
16115 return c
16116 }
16117
16118
16119
16120 func (c *ProjectsLocationsInsightsListCall) PageToken(pageToken string) *ProjectsLocationsInsightsListCall {
16121 c.urlParams_.Set("pageToken", pageToken)
16122 return c
16123 }
16124
16125
16126
16127
16128
16129
16130
16131
16132
16133
16134
16135
16136
16137
16138
16139 func (c *ProjectsLocationsInsightsListCall) View(view string) *ProjectsLocationsInsightsListCall {
16140 c.urlParams_.Set("view", view)
16141 return c
16142 }
16143
16144
16145
16146
16147 func (c *ProjectsLocationsInsightsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsInsightsListCall {
16148 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16149 return c
16150 }
16151
16152
16153
16154
16155 func (c *ProjectsLocationsInsightsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsInsightsListCall {
16156 c.ifNoneMatch_ = entityTag
16157 return c
16158 }
16159
16160
16161 func (c *ProjectsLocationsInsightsListCall) Context(ctx context.Context) *ProjectsLocationsInsightsListCall {
16162 c.ctx_ = ctx
16163 return c
16164 }
16165
16166
16167
16168 func (c *ProjectsLocationsInsightsListCall) Header() http.Header {
16169 if c.header_ == nil {
16170 c.header_ = make(http.Header)
16171 }
16172 return c.header_
16173 }
16174
16175 func (c *ProjectsLocationsInsightsListCall) doRequest(alt string) (*http.Response, error) {
16176 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16177 if c.ifNoneMatch_ != "" {
16178 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16179 }
16180 var body io.Reader = nil
16181 c.urlParams_.Set("alt", alt)
16182 c.urlParams_.Set("prettyPrint", "false")
16183 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/insights")
16184 urls += "?" + c.urlParams_.Encode()
16185 req, err := http.NewRequest("GET", urls, body)
16186 if err != nil {
16187 return nil, err
16188 }
16189 req.Header = reqHeaders
16190 googleapi.Expand(req.URL, map[string]string{
16191 "parent": c.parent,
16192 })
16193 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16194 }
16195
16196
16197
16198
16199
16200
16201
16202 func (c *ProjectsLocationsInsightsListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse, error) {
16203 gensupport.SetOptions(c.urlParams_, opts...)
16204 res, err := c.doRequest("json")
16205 if res != nil && res.StatusCode == http.StatusNotModified {
16206 if res.Body != nil {
16207 res.Body.Close()
16208 }
16209 return nil, gensupport.WrapError(&googleapi.Error{
16210 Code: res.StatusCode,
16211 Header: res.Header,
16212 })
16213 }
16214 if err != nil {
16215 return nil, err
16216 }
16217 defer googleapi.CloseBody(res)
16218 if err := googleapi.CheckResponse(res); err != nil {
16219 return nil, gensupport.WrapError(err)
16220 }
16221 ret := &GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse{
16222 ServerResponse: googleapi.ServerResponse{
16223 Header: res.Header,
16224 HTTPStatusCode: res.StatusCode,
16225 },
16226 }
16227 target := &ret
16228 if err := gensupport.DecodeResponse(target, res); err != nil {
16229 return nil, err
16230 }
16231 return ret, nil
16232 }
16233
16234
16235
16236
16237 func (c *ProjectsLocationsInsightsListCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpSaasplatformInsightsV1alphaListInsightsResponse) error) error {
16238 c.ctx_ = ctx
16239 defer c.PageToken(c.urlParams_.Get("pageToken"))
16240 for {
16241 x, err := c.Do()
16242 if err != nil {
16243 return err
16244 }
16245 if err := f(x); err != nil {
16246 return err
16247 }
16248 if x.NextPageToken == "" {
16249 return nil
16250 }
16251 c.PageToken(x.NextPageToken)
16252 }
16253 }
16254
16255 type ProjectsLocationsNetConnectionsGetIamPolicyCall struct {
16256 s *Service
16257 resource string
16258 urlParams_ gensupport.URLParams
16259 ifNoneMatch_ string
16260 ctx_ context.Context
16261 header_ http.Header
16262 }
16263
16264
16265
16266
16267
16268
16269
16270 func (r *ProjectsLocationsNetConnectionsService) GetIamPolicy(resource string) *ProjectsLocationsNetConnectionsGetIamPolicyCall {
16271 c := &ProjectsLocationsNetConnectionsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16272 c.resource = resource
16273 return c
16274 }
16275
16276
16277
16278
16279
16280
16281
16282
16283
16284
16285
16286
16287
16288 func (c *ProjectsLocationsNetConnectionsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsNetConnectionsGetIamPolicyCall {
16289 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
16290 return c
16291 }
16292
16293
16294
16295
16296 func (c *ProjectsLocationsNetConnectionsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsNetConnectionsGetIamPolicyCall {
16297 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16298 return c
16299 }
16300
16301
16302
16303
16304 func (c *ProjectsLocationsNetConnectionsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsNetConnectionsGetIamPolicyCall {
16305 c.ifNoneMatch_ = entityTag
16306 return c
16307 }
16308
16309
16310 func (c *ProjectsLocationsNetConnectionsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsNetConnectionsGetIamPolicyCall {
16311 c.ctx_ = ctx
16312 return c
16313 }
16314
16315
16316
16317 func (c *ProjectsLocationsNetConnectionsGetIamPolicyCall) Header() http.Header {
16318 if c.header_ == nil {
16319 c.header_ = make(http.Header)
16320 }
16321 return c.header_
16322 }
16323
16324 func (c *ProjectsLocationsNetConnectionsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
16325 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16326 if c.ifNoneMatch_ != "" {
16327 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16328 }
16329 var body io.Reader = nil
16330 c.urlParams_.Set("alt", alt)
16331 c.urlParams_.Set("prettyPrint", "false")
16332 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:getIamPolicy")
16333 urls += "?" + c.urlParams_.Encode()
16334 req, err := http.NewRequest("GET", urls, body)
16335 if err != nil {
16336 return nil, err
16337 }
16338 req.Header = reqHeaders
16339 googleapi.Expand(req.URL, map[string]string{
16340 "resource": c.resource,
16341 })
16342 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16343 }
16344
16345
16346
16347
16348
16349
16350
16351 func (c *ProjectsLocationsNetConnectionsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
16352 gensupport.SetOptions(c.urlParams_, opts...)
16353 res, err := c.doRequest("json")
16354 if res != nil && res.StatusCode == http.StatusNotModified {
16355 if res.Body != nil {
16356 res.Body.Close()
16357 }
16358 return nil, gensupport.WrapError(&googleapi.Error{
16359 Code: res.StatusCode,
16360 Header: res.Header,
16361 })
16362 }
16363 if err != nil {
16364 return nil, err
16365 }
16366 defer googleapi.CloseBody(res)
16367 if err := googleapi.CheckResponse(res); err != nil {
16368 return nil, gensupport.WrapError(err)
16369 }
16370 ret := &GoogleIamV1Policy{
16371 ServerResponse: googleapi.ServerResponse{
16372 Header: res.Header,
16373 HTTPStatusCode: res.StatusCode,
16374 },
16375 }
16376 target := &ret
16377 if err := gensupport.DecodeResponse(target, res); err != nil {
16378 return nil, err
16379 }
16380 return ret, nil
16381 }
16382
16383 type ProjectsLocationsNetConnectionsSetIamPolicyCall struct {
16384 s *Service
16385 resource string
16386 googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest
16387 urlParams_ gensupport.URLParams
16388 ctx_ context.Context
16389 header_ http.Header
16390 }
16391
16392
16393
16394
16395
16396
16397
16398
16399 func (r *ProjectsLocationsNetConnectionsService) SetIamPolicy(resource string, googleiamv1setiampolicyrequest *GoogleIamV1SetIamPolicyRequest) *ProjectsLocationsNetConnectionsSetIamPolicyCall {
16400 c := &ProjectsLocationsNetConnectionsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16401 c.resource = resource
16402 c.googleiamv1setiampolicyrequest = googleiamv1setiampolicyrequest
16403 return c
16404 }
16405
16406
16407
16408
16409 func (c *ProjectsLocationsNetConnectionsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsNetConnectionsSetIamPolicyCall {
16410 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16411 return c
16412 }
16413
16414
16415 func (c *ProjectsLocationsNetConnectionsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsNetConnectionsSetIamPolicyCall {
16416 c.ctx_ = ctx
16417 return c
16418 }
16419
16420
16421
16422 func (c *ProjectsLocationsNetConnectionsSetIamPolicyCall) Header() http.Header {
16423 if c.header_ == nil {
16424 c.header_ = make(http.Header)
16425 }
16426 return c.header_
16427 }
16428
16429 func (c *ProjectsLocationsNetConnectionsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
16430 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16431 var body io.Reader = nil
16432 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1setiampolicyrequest)
16433 if err != nil {
16434 return nil, err
16435 }
16436 c.urlParams_.Set("alt", alt)
16437 c.urlParams_.Set("prettyPrint", "false")
16438 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:setIamPolicy")
16439 urls += "?" + c.urlParams_.Encode()
16440 req, err := http.NewRequest("POST", urls, body)
16441 if err != nil {
16442 return nil, err
16443 }
16444 req.Header = reqHeaders
16445 googleapi.Expand(req.URL, map[string]string{
16446 "resource": c.resource,
16447 })
16448 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16449 }
16450
16451
16452
16453
16454
16455
16456
16457 func (c *ProjectsLocationsNetConnectionsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1Policy, error) {
16458 gensupport.SetOptions(c.urlParams_, opts...)
16459 res, err := c.doRequest("json")
16460 if res != nil && res.StatusCode == http.StatusNotModified {
16461 if res.Body != nil {
16462 res.Body.Close()
16463 }
16464 return nil, gensupport.WrapError(&googleapi.Error{
16465 Code: res.StatusCode,
16466 Header: res.Header,
16467 })
16468 }
16469 if err != nil {
16470 return nil, err
16471 }
16472 defer googleapi.CloseBody(res)
16473 if err := googleapi.CheckResponse(res); err != nil {
16474 return nil, gensupport.WrapError(err)
16475 }
16476 ret := &GoogleIamV1Policy{
16477 ServerResponse: googleapi.ServerResponse{
16478 Header: res.Header,
16479 HTTPStatusCode: res.StatusCode,
16480 },
16481 }
16482 target := &ret
16483 if err := gensupport.DecodeResponse(target, res); err != nil {
16484 return nil, err
16485 }
16486 return ret, nil
16487 }
16488
16489 type ProjectsLocationsNetConnectionsTestIamPermissionsCall struct {
16490 s *Service
16491 resource string
16492 googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest
16493 urlParams_ gensupport.URLParams
16494 ctx_ context.Context
16495 header_ http.Header
16496 }
16497
16498
16499
16500
16501
16502
16503
16504
16505
16506
16507
16508 func (r *ProjectsLocationsNetConnectionsService) TestIamPermissions(resource string, googleiamv1testiampermissionsrequest *GoogleIamV1TestIamPermissionsRequest) *ProjectsLocationsNetConnectionsTestIamPermissionsCall {
16509 c := &ProjectsLocationsNetConnectionsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16510 c.resource = resource
16511 c.googleiamv1testiampermissionsrequest = googleiamv1testiampermissionsrequest
16512 return c
16513 }
16514
16515
16516
16517
16518 func (c *ProjectsLocationsNetConnectionsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsNetConnectionsTestIamPermissionsCall {
16519 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16520 return c
16521 }
16522
16523
16524 func (c *ProjectsLocationsNetConnectionsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsNetConnectionsTestIamPermissionsCall {
16525 c.ctx_ = ctx
16526 return c
16527 }
16528
16529
16530
16531 func (c *ProjectsLocationsNetConnectionsTestIamPermissionsCall) Header() http.Header {
16532 if c.header_ == nil {
16533 c.header_ = make(http.Header)
16534 }
16535 return c.header_
16536 }
16537
16538 func (c *ProjectsLocationsNetConnectionsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
16539 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16540 var body io.Reader = nil
16541 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googleiamv1testiampermissionsrequest)
16542 if err != nil {
16543 return nil, err
16544 }
16545 c.urlParams_.Set("alt", alt)
16546 c.urlParams_.Set("prettyPrint", "false")
16547 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+resource}:testIamPermissions")
16548 urls += "?" + c.urlParams_.Encode()
16549 req, err := http.NewRequest("POST", urls, body)
16550 if err != nil {
16551 return nil, err
16552 }
16553 req.Header = reqHeaders
16554 googleapi.Expand(req.URL, map[string]string{
16555 "resource": c.resource,
16556 })
16557 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16558 }
16559
16560
16561
16562
16563
16564
16565
16566 func (c *ProjectsLocationsNetConnectionsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*GoogleIamV1TestIamPermissionsResponse, error) {
16567 gensupport.SetOptions(c.urlParams_, opts...)
16568 res, err := c.doRequest("json")
16569 if res != nil && res.StatusCode == http.StatusNotModified {
16570 if res.Body != nil {
16571 res.Body.Close()
16572 }
16573 return nil, gensupport.WrapError(&googleapi.Error{
16574 Code: res.StatusCode,
16575 Header: res.Header,
16576 })
16577 }
16578 if err != nil {
16579 return nil, err
16580 }
16581 defer googleapi.CloseBody(res)
16582 if err := googleapi.CheckResponse(res); err != nil {
16583 return nil, gensupport.WrapError(err)
16584 }
16585 ret := &GoogleIamV1TestIamPermissionsResponse{
16586 ServerResponse: googleapi.ServerResponse{
16587 Header: res.Header,
16588 HTTPStatusCode: res.StatusCode,
16589 },
16590 }
16591 target := &ret
16592 if err := gensupport.DecodeResponse(target, res); err != nil {
16593 return nil, err
16594 }
16595 return ret, nil
16596 }
16597
16598 type ProjectsLocationsOperationsCancelCall struct {
16599 s *Service
16600 name string
16601 googlelongrunningcanceloperationrequest *GoogleLongrunningCancelOperationRequest
16602 urlParams_ gensupport.URLParams
16603 ctx_ context.Context
16604 header_ http.Header
16605 }
16606
16607
16608
16609
16610
16611
16612
16613
16614
16615
16616
16617
16618 func (r *ProjectsLocationsOperationsService) Cancel(name string, googlelongrunningcanceloperationrequest *GoogleLongrunningCancelOperationRequest) *ProjectsLocationsOperationsCancelCall {
16619 c := &ProjectsLocationsOperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16620 c.name = name
16621 c.googlelongrunningcanceloperationrequest = googlelongrunningcanceloperationrequest
16622 return c
16623 }
16624
16625
16626
16627
16628 func (c *ProjectsLocationsOperationsCancelCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsCancelCall {
16629 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16630 return c
16631 }
16632
16633
16634 func (c *ProjectsLocationsOperationsCancelCall) Context(ctx context.Context) *ProjectsLocationsOperationsCancelCall {
16635 c.ctx_ = ctx
16636 return c
16637 }
16638
16639
16640
16641 func (c *ProjectsLocationsOperationsCancelCall) Header() http.Header {
16642 if c.header_ == nil {
16643 c.header_ = make(http.Header)
16644 }
16645 return c.header_
16646 }
16647
16648 func (c *ProjectsLocationsOperationsCancelCall) doRequest(alt string) (*http.Response, error) {
16649 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16650 var body io.Reader = nil
16651 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlelongrunningcanceloperationrequest)
16652 if err != nil {
16653 return nil, err
16654 }
16655 c.urlParams_.Set("alt", alt)
16656 c.urlParams_.Set("prettyPrint", "false")
16657 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}:cancel")
16658 urls += "?" + c.urlParams_.Encode()
16659 req, err := http.NewRequest("POST", urls, body)
16660 if err != nil {
16661 return nil, err
16662 }
16663 req.Header = reqHeaders
16664 googleapi.Expand(req.URL, map[string]string{
16665 "name": c.name,
16666 })
16667 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16668 }
16669
16670
16671
16672
16673
16674
16675 func (c *ProjectsLocationsOperationsCancelCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
16676 gensupport.SetOptions(c.urlParams_, opts...)
16677 res, err := c.doRequest("json")
16678 if res != nil && res.StatusCode == http.StatusNotModified {
16679 if res.Body != nil {
16680 res.Body.Close()
16681 }
16682 return nil, gensupport.WrapError(&googleapi.Error{
16683 Code: res.StatusCode,
16684 Header: res.Header,
16685 })
16686 }
16687 if err != nil {
16688 return nil, err
16689 }
16690 defer googleapi.CloseBody(res)
16691 if err := googleapi.CheckResponse(res); err != nil {
16692 return nil, gensupport.WrapError(err)
16693 }
16694 ret := &Empty{
16695 ServerResponse: googleapi.ServerResponse{
16696 Header: res.Header,
16697 HTTPStatusCode: res.StatusCode,
16698 },
16699 }
16700 target := &ret
16701 if err := gensupport.DecodeResponse(target, res); err != nil {
16702 return nil, err
16703 }
16704 return ret, nil
16705 }
16706
16707 type ProjectsLocationsOperationsDeleteCall struct {
16708 s *Service
16709 name string
16710 urlParams_ gensupport.URLParams
16711 ctx_ context.Context
16712 header_ http.Header
16713 }
16714
16715
16716
16717
16718
16719
16720
16721 func (r *ProjectsLocationsOperationsService) Delete(name string) *ProjectsLocationsOperationsDeleteCall {
16722 c := &ProjectsLocationsOperationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16723 c.name = name
16724 return c
16725 }
16726
16727
16728
16729
16730 func (c *ProjectsLocationsOperationsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsDeleteCall {
16731 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16732 return c
16733 }
16734
16735
16736 func (c *ProjectsLocationsOperationsDeleteCall) Context(ctx context.Context) *ProjectsLocationsOperationsDeleteCall {
16737 c.ctx_ = ctx
16738 return c
16739 }
16740
16741
16742
16743 func (c *ProjectsLocationsOperationsDeleteCall) Header() http.Header {
16744 if c.header_ == nil {
16745 c.header_ = make(http.Header)
16746 }
16747 return c.header_
16748 }
16749
16750 func (c *ProjectsLocationsOperationsDeleteCall) doRequest(alt string) (*http.Response, error) {
16751 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16752 var body io.Reader = nil
16753 c.urlParams_.Set("alt", alt)
16754 c.urlParams_.Set("prettyPrint", "false")
16755 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16756 urls += "?" + c.urlParams_.Encode()
16757 req, err := http.NewRequest("DELETE", urls, body)
16758 if err != nil {
16759 return nil, err
16760 }
16761 req.Header = reqHeaders
16762 googleapi.Expand(req.URL, map[string]string{
16763 "name": c.name,
16764 })
16765 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16766 }
16767
16768
16769
16770
16771
16772
16773 func (c *ProjectsLocationsOperationsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
16774 gensupport.SetOptions(c.urlParams_, opts...)
16775 res, err := c.doRequest("json")
16776 if res != nil && res.StatusCode == http.StatusNotModified {
16777 if res.Body != nil {
16778 res.Body.Close()
16779 }
16780 return nil, gensupport.WrapError(&googleapi.Error{
16781 Code: res.StatusCode,
16782 Header: res.Header,
16783 })
16784 }
16785 if err != nil {
16786 return nil, err
16787 }
16788 defer googleapi.CloseBody(res)
16789 if err := googleapi.CheckResponse(res); err != nil {
16790 return nil, gensupport.WrapError(err)
16791 }
16792 ret := &Empty{
16793 ServerResponse: googleapi.ServerResponse{
16794 Header: res.Header,
16795 HTTPStatusCode: res.StatusCode,
16796 },
16797 }
16798 target := &ret
16799 if err := gensupport.DecodeResponse(target, res); err != nil {
16800 return nil, err
16801 }
16802 return ret, nil
16803 }
16804
16805 type ProjectsLocationsOperationsGetCall struct {
16806 s *Service
16807 name string
16808 urlParams_ gensupport.URLParams
16809 ifNoneMatch_ string
16810 ctx_ context.Context
16811 header_ http.Header
16812 }
16813
16814
16815
16816
16817
16818
16819 func (r *ProjectsLocationsOperationsService) Get(name string) *ProjectsLocationsOperationsGetCall {
16820 c := &ProjectsLocationsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16821 c.name = name
16822 return c
16823 }
16824
16825
16826
16827
16828 func (c *ProjectsLocationsOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsGetCall {
16829 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16830 return c
16831 }
16832
16833
16834
16835
16836 func (c *ProjectsLocationsOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsOperationsGetCall {
16837 c.ifNoneMatch_ = entityTag
16838 return c
16839 }
16840
16841
16842 func (c *ProjectsLocationsOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsOperationsGetCall {
16843 c.ctx_ = ctx
16844 return c
16845 }
16846
16847
16848
16849 func (c *ProjectsLocationsOperationsGetCall) Header() http.Header {
16850 if c.header_ == nil {
16851 c.header_ = make(http.Header)
16852 }
16853 return c.header_
16854 }
16855
16856 func (c *ProjectsLocationsOperationsGetCall) doRequest(alt string) (*http.Response, error) {
16857 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16858 if c.ifNoneMatch_ != "" {
16859 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16860 }
16861 var body io.Reader = nil
16862 c.urlParams_.Set("alt", alt)
16863 c.urlParams_.Set("prettyPrint", "false")
16864 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
16865 urls += "?" + c.urlParams_.Encode()
16866 req, err := http.NewRequest("GET", urls, body)
16867 if err != nil {
16868 return nil, err
16869 }
16870 req.Header = reqHeaders
16871 googleapi.Expand(req.URL, map[string]string{
16872 "name": c.name,
16873 })
16874 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16875 }
16876
16877
16878
16879
16880
16881
16882
16883 func (c *ProjectsLocationsOperationsGetCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
16884 gensupport.SetOptions(c.urlParams_, opts...)
16885 res, err := c.doRequest("json")
16886 if res != nil && res.StatusCode == http.StatusNotModified {
16887 if res.Body != nil {
16888 res.Body.Close()
16889 }
16890 return nil, gensupport.WrapError(&googleapi.Error{
16891 Code: res.StatusCode,
16892 Header: res.Header,
16893 })
16894 }
16895 if err != nil {
16896 return nil, err
16897 }
16898 defer googleapi.CloseBody(res)
16899 if err := googleapi.CheckResponse(res); err != nil {
16900 return nil, gensupport.WrapError(err)
16901 }
16902 ret := &GoogleLongrunningOperation{
16903 ServerResponse: googleapi.ServerResponse{
16904 Header: res.Header,
16905 HTTPStatusCode: res.StatusCode,
16906 },
16907 }
16908 target := &ret
16909 if err := gensupport.DecodeResponse(target, res); err != nil {
16910 return nil, err
16911 }
16912 return ret, nil
16913 }
16914
16915 type ProjectsLocationsOperationsListCall struct {
16916 s *Service
16917 name string
16918 urlParams_ gensupport.URLParams
16919 ifNoneMatch_ string
16920 ctx_ context.Context
16921 header_ http.Header
16922 }
16923
16924
16925
16926
16927
16928 func (r *ProjectsLocationsOperationsService) List(name string) *ProjectsLocationsOperationsListCall {
16929 c := &ProjectsLocationsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16930 c.name = name
16931 return c
16932 }
16933
16934
16935 func (c *ProjectsLocationsOperationsListCall) Filter(filter string) *ProjectsLocationsOperationsListCall {
16936 c.urlParams_.Set("filter", filter)
16937 return c
16938 }
16939
16940
16941
16942 func (c *ProjectsLocationsOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsOperationsListCall {
16943 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
16944 return c
16945 }
16946
16947
16948
16949 func (c *ProjectsLocationsOperationsListCall) PageToken(pageToken string) *ProjectsLocationsOperationsListCall {
16950 c.urlParams_.Set("pageToken", pageToken)
16951 return c
16952 }
16953
16954
16955
16956
16957 func (c *ProjectsLocationsOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsOperationsListCall {
16958 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16959 return c
16960 }
16961
16962
16963
16964
16965 func (c *ProjectsLocationsOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsOperationsListCall {
16966 c.ifNoneMatch_ = entityTag
16967 return c
16968 }
16969
16970
16971 func (c *ProjectsLocationsOperationsListCall) Context(ctx context.Context) *ProjectsLocationsOperationsListCall {
16972 c.ctx_ = ctx
16973 return c
16974 }
16975
16976
16977
16978 func (c *ProjectsLocationsOperationsListCall) Header() http.Header {
16979 if c.header_ == nil {
16980 c.header_ = make(http.Header)
16981 }
16982 return c.header_
16983 }
16984
16985 func (c *ProjectsLocationsOperationsListCall) doRequest(alt string) (*http.Response, error) {
16986 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16987 if c.ifNoneMatch_ != "" {
16988 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16989 }
16990 var body io.Reader = nil
16991 c.urlParams_.Set("alt", alt)
16992 c.urlParams_.Set("prettyPrint", "false")
16993 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}/operations")
16994 urls += "?" + c.urlParams_.Encode()
16995 req, err := http.NewRequest("GET", urls, body)
16996 if err != nil {
16997 return nil, err
16998 }
16999 req.Header = reqHeaders
17000 googleapi.Expand(req.URL, map[string]string{
17001 "name": c.name,
17002 })
17003 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17004 }
17005
17006
17007
17008
17009
17010
17011
17012 func (c *ProjectsLocationsOperationsListCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningListOperationsResponse, error) {
17013 gensupport.SetOptions(c.urlParams_, opts...)
17014 res, err := c.doRequest("json")
17015 if res != nil && res.StatusCode == http.StatusNotModified {
17016 if res.Body != nil {
17017 res.Body.Close()
17018 }
17019 return nil, gensupport.WrapError(&googleapi.Error{
17020 Code: res.StatusCode,
17021 Header: res.Header,
17022 })
17023 }
17024 if err != nil {
17025 return nil, err
17026 }
17027 defer googleapi.CloseBody(res)
17028 if err := googleapi.CheckResponse(res); err != nil {
17029 return nil, gensupport.WrapError(err)
17030 }
17031 ret := &GoogleLongrunningListOperationsResponse{
17032 ServerResponse: googleapi.ServerResponse{
17033 Header: res.Header,
17034 HTTPStatusCode: res.StatusCode,
17035 },
17036 }
17037 target := &ret
17038 if err := gensupport.DecodeResponse(target, res); err != nil {
17039 return nil, err
17040 }
17041 return ret, nil
17042 }
17043
17044
17045
17046
17047 func (c *ProjectsLocationsOperationsListCall) Pages(ctx context.Context, f func(*GoogleLongrunningListOperationsResponse) error) error {
17048 c.ctx_ = ctx
17049 defer c.PageToken(c.urlParams_.Get("pageToken"))
17050 for {
17051 x, err := c.Do()
17052 if err != nil {
17053 return err
17054 }
17055 if err := f(x); err != nil {
17056 return err
17057 }
17058 if x.NextPageToken == "" {
17059 return nil
17060 }
17061 c.PageToken(x.NextPageToken)
17062 }
17063 }
17064
17065 type ProjectsLocationsSecurityGatewaysCreateCall struct {
17066 s *Service
17067 parent string
17068 googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway *GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway
17069 urlParams_ gensupport.URLParams
17070 ctx_ context.Context
17071 header_ http.Header
17072 }
17073
17074
17075
17076
17077
17078 func (r *ProjectsLocationsSecurityGatewaysService) Create(parent string, googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway *GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway) *ProjectsLocationsSecurityGatewaysCreateCall {
17079 c := &ProjectsLocationsSecurityGatewaysCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17080 c.parent = parent
17081 c.googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway = googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway
17082 return c
17083 }
17084
17085
17086
17087
17088
17089
17090 func (c *ProjectsLocationsSecurityGatewaysCreateCall) RequestId(requestId string) *ProjectsLocationsSecurityGatewaysCreateCall {
17091 c.urlParams_.Set("requestId", requestId)
17092 return c
17093 }
17094
17095
17096
17097
17098
17099 func (c *ProjectsLocationsSecurityGatewaysCreateCall) SecurityGatewayId(securityGatewayId string) *ProjectsLocationsSecurityGatewaysCreateCall {
17100 c.urlParams_.Set("securityGatewayId", securityGatewayId)
17101 return c
17102 }
17103
17104
17105
17106
17107 func (c *ProjectsLocationsSecurityGatewaysCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsSecurityGatewaysCreateCall {
17108 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17109 return c
17110 }
17111
17112
17113 func (c *ProjectsLocationsSecurityGatewaysCreateCall) Context(ctx context.Context) *ProjectsLocationsSecurityGatewaysCreateCall {
17114 c.ctx_ = ctx
17115 return c
17116 }
17117
17118
17119
17120 func (c *ProjectsLocationsSecurityGatewaysCreateCall) Header() http.Header {
17121 if c.header_ == nil {
17122 c.header_ = make(http.Header)
17123 }
17124 return c.header_
17125 }
17126
17127 func (c *ProjectsLocationsSecurityGatewaysCreateCall) doRequest(alt string) (*http.Response, error) {
17128 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17129 var body io.Reader = nil
17130 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway)
17131 if err != nil {
17132 return nil, err
17133 }
17134 c.urlParams_.Set("alt", alt)
17135 c.urlParams_.Set("prettyPrint", "false")
17136 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/securityGateways")
17137 urls += "?" + c.urlParams_.Encode()
17138 req, err := http.NewRequest("POST", urls, body)
17139 if err != nil {
17140 return nil, err
17141 }
17142 req.Header = reqHeaders
17143 googleapi.Expand(req.URL, map[string]string{
17144 "parent": c.parent,
17145 })
17146 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17147 }
17148
17149
17150
17151
17152
17153
17154
17155 func (c *ProjectsLocationsSecurityGatewaysCreateCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
17156 gensupport.SetOptions(c.urlParams_, opts...)
17157 res, err := c.doRequest("json")
17158 if res != nil && res.StatusCode == http.StatusNotModified {
17159 if res.Body != nil {
17160 res.Body.Close()
17161 }
17162 return nil, gensupport.WrapError(&googleapi.Error{
17163 Code: res.StatusCode,
17164 Header: res.Header,
17165 })
17166 }
17167 if err != nil {
17168 return nil, err
17169 }
17170 defer googleapi.CloseBody(res)
17171 if err := googleapi.CheckResponse(res); err != nil {
17172 return nil, gensupport.WrapError(err)
17173 }
17174 ret := &GoogleLongrunningOperation{
17175 ServerResponse: googleapi.ServerResponse{
17176 Header: res.Header,
17177 HTTPStatusCode: res.StatusCode,
17178 },
17179 }
17180 target := &ret
17181 if err := gensupport.DecodeResponse(target, res); err != nil {
17182 return nil, err
17183 }
17184 return ret, nil
17185 }
17186
17187 type ProjectsLocationsSecurityGatewaysDeleteCall struct {
17188 s *Service
17189 name string
17190 urlParams_ gensupport.URLParams
17191 ctx_ context.Context
17192 header_ http.Header
17193 }
17194
17195
17196
17197
17198
17199
17200 func (r *ProjectsLocationsSecurityGatewaysService) Delete(name string) *ProjectsLocationsSecurityGatewaysDeleteCall {
17201 c := &ProjectsLocationsSecurityGatewaysDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17202 c.name = name
17203 return c
17204 }
17205
17206
17207
17208
17209
17210
17211
17212
17213
17214
17215
17216
17217 func (c *ProjectsLocationsSecurityGatewaysDeleteCall) RequestId(requestId string) *ProjectsLocationsSecurityGatewaysDeleteCall {
17218 c.urlParams_.Set("requestId", requestId)
17219 return c
17220 }
17221
17222
17223
17224
17225 func (c *ProjectsLocationsSecurityGatewaysDeleteCall) ValidateOnly(validateOnly bool) *ProjectsLocationsSecurityGatewaysDeleteCall {
17226 c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
17227 return c
17228 }
17229
17230
17231
17232
17233 func (c *ProjectsLocationsSecurityGatewaysDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsSecurityGatewaysDeleteCall {
17234 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17235 return c
17236 }
17237
17238
17239 func (c *ProjectsLocationsSecurityGatewaysDeleteCall) Context(ctx context.Context) *ProjectsLocationsSecurityGatewaysDeleteCall {
17240 c.ctx_ = ctx
17241 return c
17242 }
17243
17244
17245
17246 func (c *ProjectsLocationsSecurityGatewaysDeleteCall) Header() http.Header {
17247 if c.header_ == nil {
17248 c.header_ = make(http.Header)
17249 }
17250 return c.header_
17251 }
17252
17253 func (c *ProjectsLocationsSecurityGatewaysDeleteCall) doRequest(alt string) (*http.Response, error) {
17254 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17255 var body io.Reader = nil
17256 c.urlParams_.Set("alt", alt)
17257 c.urlParams_.Set("prettyPrint", "false")
17258 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
17259 urls += "?" + c.urlParams_.Encode()
17260 req, err := http.NewRequest("DELETE", urls, body)
17261 if err != nil {
17262 return nil, err
17263 }
17264 req.Header = reqHeaders
17265 googleapi.Expand(req.URL, map[string]string{
17266 "name": c.name,
17267 })
17268 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17269 }
17270
17271
17272
17273
17274
17275
17276
17277 func (c *ProjectsLocationsSecurityGatewaysDeleteCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
17278 gensupport.SetOptions(c.urlParams_, opts...)
17279 res, err := c.doRequest("json")
17280 if res != nil && res.StatusCode == http.StatusNotModified {
17281 if res.Body != nil {
17282 res.Body.Close()
17283 }
17284 return nil, gensupport.WrapError(&googleapi.Error{
17285 Code: res.StatusCode,
17286 Header: res.Header,
17287 })
17288 }
17289 if err != nil {
17290 return nil, err
17291 }
17292 defer googleapi.CloseBody(res)
17293 if err := googleapi.CheckResponse(res); err != nil {
17294 return nil, gensupport.WrapError(err)
17295 }
17296 ret := &GoogleLongrunningOperation{
17297 ServerResponse: googleapi.ServerResponse{
17298 Header: res.Header,
17299 HTTPStatusCode: res.StatusCode,
17300 },
17301 }
17302 target := &ret
17303 if err := gensupport.DecodeResponse(target, res); err != nil {
17304 return nil, err
17305 }
17306 return ret, nil
17307 }
17308
17309 type ProjectsLocationsSecurityGatewaysGetCall struct {
17310 s *Service
17311 name string
17312 urlParams_ gensupport.URLParams
17313 ifNoneMatch_ string
17314 ctx_ context.Context
17315 header_ http.Header
17316 }
17317
17318
17319
17320
17321
17322
17323 func (r *ProjectsLocationsSecurityGatewaysService) Get(name string) *ProjectsLocationsSecurityGatewaysGetCall {
17324 c := &ProjectsLocationsSecurityGatewaysGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17325 c.name = name
17326 return c
17327 }
17328
17329
17330
17331
17332 func (c *ProjectsLocationsSecurityGatewaysGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsSecurityGatewaysGetCall {
17333 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17334 return c
17335 }
17336
17337
17338
17339
17340 func (c *ProjectsLocationsSecurityGatewaysGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsSecurityGatewaysGetCall {
17341 c.ifNoneMatch_ = entityTag
17342 return c
17343 }
17344
17345
17346 func (c *ProjectsLocationsSecurityGatewaysGetCall) Context(ctx context.Context) *ProjectsLocationsSecurityGatewaysGetCall {
17347 c.ctx_ = ctx
17348 return c
17349 }
17350
17351
17352
17353 func (c *ProjectsLocationsSecurityGatewaysGetCall) Header() http.Header {
17354 if c.header_ == nil {
17355 c.header_ = make(http.Header)
17356 }
17357 return c.header_
17358 }
17359
17360 func (c *ProjectsLocationsSecurityGatewaysGetCall) doRequest(alt string) (*http.Response, error) {
17361 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17362 if c.ifNoneMatch_ != "" {
17363 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17364 }
17365 var body io.Reader = nil
17366 c.urlParams_.Set("alt", alt)
17367 c.urlParams_.Set("prettyPrint", "false")
17368 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
17369 urls += "?" + c.urlParams_.Encode()
17370 req, err := http.NewRequest("GET", urls, body)
17371 if err != nil {
17372 return nil, err
17373 }
17374 req.Header = reqHeaders
17375 googleapi.Expand(req.URL, map[string]string{
17376 "name": c.name,
17377 })
17378 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17379 }
17380
17381
17382
17383
17384
17385
17386
17387 func (c *ProjectsLocationsSecurityGatewaysGetCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway, error) {
17388 gensupport.SetOptions(c.urlParams_, opts...)
17389 res, err := c.doRequest("json")
17390 if res != nil && res.StatusCode == http.StatusNotModified {
17391 if res.Body != nil {
17392 res.Body.Close()
17393 }
17394 return nil, gensupport.WrapError(&googleapi.Error{
17395 Code: res.StatusCode,
17396 Header: res.Header,
17397 })
17398 }
17399 if err != nil {
17400 return nil, err
17401 }
17402 defer googleapi.CloseBody(res)
17403 if err := googleapi.CheckResponse(res); err != nil {
17404 return nil, gensupport.WrapError(err)
17405 }
17406 ret := &GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway{
17407 ServerResponse: googleapi.ServerResponse{
17408 Header: res.Header,
17409 HTTPStatusCode: res.StatusCode,
17410 },
17411 }
17412 target := &ret
17413 if err := gensupport.DecodeResponse(target, res); err != nil {
17414 return nil, err
17415 }
17416 return ret, nil
17417 }
17418
17419 type ProjectsLocationsSecurityGatewaysListCall struct {
17420 s *Service
17421 parent string
17422 urlParams_ gensupport.URLParams
17423 ifNoneMatch_ string
17424 ctx_ context.Context
17425 header_ http.Header
17426 }
17427
17428
17429
17430
17431
17432 func (r *ProjectsLocationsSecurityGatewaysService) List(parent string) *ProjectsLocationsSecurityGatewaysListCall {
17433 c := &ProjectsLocationsSecurityGatewaysListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17434 c.parent = parent
17435 return c
17436 }
17437
17438
17439
17440
17441
17442
17443 func (c *ProjectsLocationsSecurityGatewaysListCall) Filter(filter string) *ProjectsLocationsSecurityGatewaysListCall {
17444 c.urlParams_.Set("filter", filter)
17445 return c
17446 }
17447
17448
17449
17450
17451
17452 func (c *ProjectsLocationsSecurityGatewaysListCall) OrderBy(orderBy string) *ProjectsLocationsSecurityGatewaysListCall {
17453 c.urlParams_.Set("orderBy", orderBy)
17454 return c
17455 }
17456
17457
17458
17459
17460
17461
17462 func (c *ProjectsLocationsSecurityGatewaysListCall) PageSize(pageSize int64) *ProjectsLocationsSecurityGatewaysListCall {
17463 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
17464 return c
17465 }
17466
17467
17468
17469 func (c *ProjectsLocationsSecurityGatewaysListCall) PageToken(pageToken string) *ProjectsLocationsSecurityGatewaysListCall {
17470 c.urlParams_.Set("pageToken", pageToken)
17471 return c
17472 }
17473
17474
17475
17476
17477 func (c *ProjectsLocationsSecurityGatewaysListCall) Fields(s ...googleapi.Field) *ProjectsLocationsSecurityGatewaysListCall {
17478 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17479 return c
17480 }
17481
17482
17483
17484
17485 func (c *ProjectsLocationsSecurityGatewaysListCall) IfNoneMatch(entityTag string) *ProjectsLocationsSecurityGatewaysListCall {
17486 c.ifNoneMatch_ = entityTag
17487 return c
17488 }
17489
17490
17491 func (c *ProjectsLocationsSecurityGatewaysListCall) Context(ctx context.Context) *ProjectsLocationsSecurityGatewaysListCall {
17492 c.ctx_ = ctx
17493 return c
17494 }
17495
17496
17497
17498 func (c *ProjectsLocationsSecurityGatewaysListCall) Header() http.Header {
17499 if c.header_ == nil {
17500 c.header_ = make(http.Header)
17501 }
17502 return c.header_
17503 }
17504
17505 func (c *ProjectsLocationsSecurityGatewaysListCall) doRequest(alt string) (*http.Response, error) {
17506 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17507 if c.ifNoneMatch_ != "" {
17508 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17509 }
17510 var body io.Reader = nil
17511 c.urlParams_.Set("alt", alt)
17512 c.urlParams_.Set("prettyPrint", "false")
17513 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+parent}/securityGateways")
17514 urls += "?" + c.urlParams_.Encode()
17515 req, err := http.NewRequest("GET", urls, body)
17516 if err != nil {
17517 return nil, err
17518 }
17519 req.Header = reqHeaders
17520 googleapi.Expand(req.URL, map[string]string{
17521 "parent": c.parent,
17522 })
17523 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17524 }
17525
17526
17527
17528
17529
17530
17531
17532 func (c *ProjectsLocationsSecurityGatewaysListCall) Do(opts ...googleapi.CallOption) (*GoogleCloudBeyondcorpSecuritygatewaysV1alphaListSecurityGatewaysResponse, error) {
17533 gensupport.SetOptions(c.urlParams_, opts...)
17534 res, err := c.doRequest("json")
17535 if res != nil && res.StatusCode == http.StatusNotModified {
17536 if res.Body != nil {
17537 res.Body.Close()
17538 }
17539 return nil, gensupport.WrapError(&googleapi.Error{
17540 Code: res.StatusCode,
17541 Header: res.Header,
17542 })
17543 }
17544 if err != nil {
17545 return nil, err
17546 }
17547 defer googleapi.CloseBody(res)
17548 if err := googleapi.CheckResponse(res); err != nil {
17549 return nil, gensupport.WrapError(err)
17550 }
17551 ret := &GoogleCloudBeyondcorpSecuritygatewaysV1alphaListSecurityGatewaysResponse{
17552 ServerResponse: googleapi.ServerResponse{
17553 Header: res.Header,
17554 HTTPStatusCode: res.StatusCode,
17555 },
17556 }
17557 target := &ret
17558 if err := gensupport.DecodeResponse(target, res); err != nil {
17559 return nil, err
17560 }
17561 return ret, nil
17562 }
17563
17564
17565
17566
17567 func (c *ProjectsLocationsSecurityGatewaysListCall) Pages(ctx context.Context, f func(*GoogleCloudBeyondcorpSecuritygatewaysV1alphaListSecurityGatewaysResponse) error) error {
17568 c.ctx_ = ctx
17569 defer c.PageToken(c.urlParams_.Get("pageToken"))
17570 for {
17571 x, err := c.Do()
17572 if err != nil {
17573 return err
17574 }
17575 if err := f(x); err != nil {
17576 return err
17577 }
17578 if x.NextPageToken == "" {
17579 return nil
17580 }
17581 c.PageToken(x.NextPageToken)
17582 }
17583 }
17584
17585 type ProjectsLocationsSecurityGatewaysPatchCall struct {
17586 s *Service
17587 name string
17588 googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway *GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway
17589 urlParams_ gensupport.URLParams
17590 ctx_ context.Context
17591 header_ http.Header
17592 }
17593
17594
17595
17596
17597 func (r *ProjectsLocationsSecurityGatewaysService) Patch(name string, googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway *GoogleCloudBeyondcorpSecuritygatewaysV1alphaSecurityGateway) *ProjectsLocationsSecurityGatewaysPatchCall {
17598 c := &ProjectsLocationsSecurityGatewaysPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17599 c.name = name
17600 c.googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway = googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway
17601 return c
17602 }
17603
17604
17605
17606
17607
17608
17609
17610
17611
17612
17613
17614
17615 func (c *ProjectsLocationsSecurityGatewaysPatchCall) RequestId(requestId string) *ProjectsLocationsSecurityGatewaysPatchCall {
17616 c.urlParams_.Set("requestId", requestId)
17617 return c
17618 }
17619
17620
17621
17622 func (c *ProjectsLocationsSecurityGatewaysPatchCall) UpdateMask(updateMask string) *ProjectsLocationsSecurityGatewaysPatchCall {
17623 c.urlParams_.Set("updateMask", updateMask)
17624 return c
17625 }
17626
17627
17628
17629
17630 func (c *ProjectsLocationsSecurityGatewaysPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsSecurityGatewaysPatchCall {
17631 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17632 return c
17633 }
17634
17635
17636 func (c *ProjectsLocationsSecurityGatewaysPatchCall) Context(ctx context.Context) *ProjectsLocationsSecurityGatewaysPatchCall {
17637 c.ctx_ = ctx
17638 return c
17639 }
17640
17641
17642
17643 func (c *ProjectsLocationsSecurityGatewaysPatchCall) Header() http.Header {
17644 if c.header_ == nil {
17645 c.header_ = make(http.Header)
17646 }
17647 return c.header_
17648 }
17649
17650 func (c *ProjectsLocationsSecurityGatewaysPatchCall) doRequest(alt string) (*http.Response, error) {
17651 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17652 var body io.Reader = nil
17653 body, err := googleapi.WithoutDataWrapper.JSONReader(c.googlecloudbeyondcorpsecuritygatewaysv1alphasecuritygateway)
17654 if err != nil {
17655 return nil, err
17656 }
17657 c.urlParams_.Set("alt", alt)
17658 c.urlParams_.Set("prettyPrint", "false")
17659 urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/{+name}")
17660 urls += "?" + c.urlParams_.Encode()
17661 req, err := http.NewRequest("PATCH", urls, body)
17662 if err != nil {
17663 return nil, err
17664 }
17665 req.Header = reqHeaders
17666 googleapi.Expand(req.URL, map[string]string{
17667 "name": c.name,
17668 })
17669 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17670 }
17671
17672
17673
17674
17675
17676
17677
17678 func (c *ProjectsLocationsSecurityGatewaysPatchCall) Do(opts ...googleapi.CallOption) (*GoogleLongrunningOperation, error) {
17679 gensupport.SetOptions(c.urlParams_, opts...)
17680 res, err := c.doRequest("json")
17681 if res != nil && res.StatusCode == http.StatusNotModified {
17682 if res.Body != nil {
17683 res.Body.Close()
17684 }
17685 return nil, gensupport.WrapError(&googleapi.Error{
17686 Code: res.StatusCode,
17687 Header: res.Header,
17688 })
17689 }
17690 if err != nil {
17691 return nil, err
17692 }
17693 defer googleapi.CloseBody(res)
17694 if err := googleapi.CheckResponse(res); err != nil {
17695 return nil, gensupport.WrapError(err)
17696 }
17697 ret := &GoogleLongrunningOperation{
17698 ServerResponse: googleapi.ServerResponse{
17699 Header: res.Header,
17700 HTTPStatusCode: res.StatusCode,
17701 },
17702 }
17703 target := &ret
17704 if err := gensupport.DecodeResponse(target, res); err != nil {
17705 return nil, err
17706 }
17707 return ret, nil
17708 }
17709
View as plain text