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