1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56 package healthcare
57
58 import (
59 "bytes"
60 "context"
61 "encoding/json"
62 "errors"
63 "fmt"
64 "io"
65 "net/http"
66 "net/url"
67 "strconv"
68 "strings"
69
70 googleapi "google.golang.org/api/googleapi"
71 internal "google.golang.org/api/internal"
72 gensupport "google.golang.org/api/internal/gensupport"
73 option "google.golang.org/api/option"
74 internaloption "google.golang.org/api/option/internaloption"
75 htransport "google.golang.org/api/transport/http"
76 )
77
78
79
80 var _ = bytes.NewBuffer
81 var _ = strconv.Itoa
82 var _ = fmt.Sprintf
83 var _ = json.NewDecoder
84 var _ = io.Copy
85 var _ = url.Parse
86 var _ = gensupport.MarshalJSON
87 var _ = googleapi.Version
88 var _ = errors.New
89 var _ = strings.Replace
90 var _ = context.Canceled
91 var _ = internaloption.WithDefaultEndpoint
92 var _ = internal.Version
93
94 const apiId = "healthcare:v1"
95 const apiName = "healthcare"
96 const apiVersion = "v1"
97 const basePath = "https://healthcare.googleapis.com/"
98 const basePathTemplate = "https://healthcare.UNIVERSE_DOMAIN/"
99 const mtlsBasePath = "https://healthcare.mtls.googleapis.com/"
100
101
102 const (
103
104 CloudHealthcareScope = "https://www.googleapis.com/auth/cloud-healthcare"
105
106
107
108 CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
109 )
110
111
112 func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
113 scopesOption := internaloption.WithDefaultScopes(
114 "https://www.googleapis.com/auth/cloud-healthcare",
115 "https://www.googleapis.com/auth/cloud-platform",
116 )
117
118 opts = append([]option.ClientOption{scopesOption}, opts...)
119 opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
120 opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate))
121 opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
122 opts = append(opts, internaloption.EnableNewAuthLibrary())
123 client, endpoint, err := htransport.NewClient(ctx, opts...)
124 if err != nil {
125 return nil, err
126 }
127 s, err := New(client)
128 if err != nil {
129 return nil, err
130 }
131 if endpoint != "" {
132 s.BasePath = endpoint
133 }
134 return s, nil
135 }
136
137
138
139
140
141
142 func New(client *http.Client) (*Service, error) {
143 if client == nil {
144 return nil, errors.New("client is nil")
145 }
146 s := &Service{client: client, BasePath: basePath}
147 s.Projects = NewProjectsService(s)
148 return s, nil
149 }
150
151 type Service struct {
152 client *http.Client
153 BasePath string
154 UserAgent string
155
156 Projects *ProjectsService
157 }
158
159 func (s *Service) userAgent() string {
160 if s.UserAgent == "" {
161 return googleapi.UserAgent
162 }
163 return googleapi.UserAgent + " " + s.UserAgent
164 }
165
166 func NewProjectsService(s *Service) *ProjectsService {
167 rs := &ProjectsService{s: s}
168 rs.Locations = NewProjectsLocationsService(s)
169 return rs
170 }
171
172 type ProjectsService struct {
173 s *Service
174
175 Locations *ProjectsLocationsService
176 }
177
178 func NewProjectsLocationsService(s *Service) *ProjectsLocationsService {
179 rs := &ProjectsLocationsService{s: s}
180 rs.Datasets = NewProjectsLocationsDatasetsService(s)
181 rs.Services = NewProjectsLocationsServicesService(s)
182 return rs
183 }
184
185 type ProjectsLocationsService struct {
186 s *Service
187
188 Datasets *ProjectsLocationsDatasetsService
189
190 Services *ProjectsLocationsServicesService
191 }
192
193 func NewProjectsLocationsDatasetsService(s *Service) *ProjectsLocationsDatasetsService {
194 rs := &ProjectsLocationsDatasetsService{s: s}
195 rs.ConsentStores = NewProjectsLocationsDatasetsConsentStoresService(s)
196 rs.DataMapperWorkspaces = NewProjectsLocationsDatasetsDataMapperWorkspacesService(s)
197 rs.DicomStores = NewProjectsLocationsDatasetsDicomStoresService(s)
198 rs.FhirStores = NewProjectsLocationsDatasetsFhirStoresService(s)
199 rs.Hl7V2Stores = NewProjectsLocationsDatasetsHl7V2StoresService(s)
200 rs.Operations = NewProjectsLocationsDatasetsOperationsService(s)
201 return rs
202 }
203
204 type ProjectsLocationsDatasetsService struct {
205 s *Service
206
207 ConsentStores *ProjectsLocationsDatasetsConsentStoresService
208
209 DataMapperWorkspaces *ProjectsLocationsDatasetsDataMapperWorkspacesService
210
211 DicomStores *ProjectsLocationsDatasetsDicomStoresService
212
213 FhirStores *ProjectsLocationsDatasetsFhirStoresService
214
215 Hl7V2Stores *ProjectsLocationsDatasetsHl7V2StoresService
216
217 Operations *ProjectsLocationsDatasetsOperationsService
218 }
219
220 func NewProjectsLocationsDatasetsConsentStoresService(s *Service) *ProjectsLocationsDatasetsConsentStoresService {
221 rs := &ProjectsLocationsDatasetsConsentStoresService{s: s}
222 rs.AttributeDefinitions = NewProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService(s)
223 rs.ConsentArtifacts = NewProjectsLocationsDatasetsConsentStoresConsentArtifactsService(s)
224 rs.Consents = NewProjectsLocationsDatasetsConsentStoresConsentsService(s)
225 rs.UserDataMappings = NewProjectsLocationsDatasetsConsentStoresUserDataMappingsService(s)
226 return rs
227 }
228
229 type ProjectsLocationsDatasetsConsentStoresService struct {
230 s *Service
231
232 AttributeDefinitions *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService
233
234 ConsentArtifacts *ProjectsLocationsDatasetsConsentStoresConsentArtifactsService
235
236 Consents *ProjectsLocationsDatasetsConsentStoresConsentsService
237
238 UserDataMappings *ProjectsLocationsDatasetsConsentStoresUserDataMappingsService
239 }
240
241 func NewProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService(s *Service) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService {
242 rs := &ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService{s: s}
243 return rs
244 }
245
246 type ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService struct {
247 s *Service
248 }
249
250 func NewProjectsLocationsDatasetsConsentStoresConsentArtifactsService(s *Service) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsService {
251 rs := &ProjectsLocationsDatasetsConsentStoresConsentArtifactsService{s: s}
252 return rs
253 }
254
255 type ProjectsLocationsDatasetsConsentStoresConsentArtifactsService struct {
256 s *Service
257 }
258
259 func NewProjectsLocationsDatasetsConsentStoresConsentsService(s *Service) *ProjectsLocationsDatasetsConsentStoresConsentsService {
260 rs := &ProjectsLocationsDatasetsConsentStoresConsentsService{s: s}
261 return rs
262 }
263
264 type ProjectsLocationsDatasetsConsentStoresConsentsService struct {
265 s *Service
266 }
267
268 func NewProjectsLocationsDatasetsConsentStoresUserDataMappingsService(s *Service) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsService {
269 rs := &ProjectsLocationsDatasetsConsentStoresUserDataMappingsService{s: s}
270 return rs
271 }
272
273 type ProjectsLocationsDatasetsConsentStoresUserDataMappingsService struct {
274 s *Service
275 }
276
277 func NewProjectsLocationsDatasetsDataMapperWorkspacesService(s *Service) *ProjectsLocationsDatasetsDataMapperWorkspacesService {
278 rs := &ProjectsLocationsDatasetsDataMapperWorkspacesService{s: s}
279 return rs
280 }
281
282 type ProjectsLocationsDatasetsDataMapperWorkspacesService struct {
283 s *Service
284 }
285
286 func NewProjectsLocationsDatasetsDicomStoresService(s *Service) *ProjectsLocationsDatasetsDicomStoresService {
287 rs := &ProjectsLocationsDatasetsDicomStoresService{s: s}
288 rs.DicomWeb = NewProjectsLocationsDatasetsDicomStoresDicomWebService(s)
289 rs.Studies = NewProjectsLocationsDatasetsDicomStoresStudiesService(s)
290 return rs
291 }
292
293 type ProjectsLocationsDatasetsDicomStoresService struct {
294 s *Service
295
296 DicomWeb *ProjectsLocationsDatasetsDicomStoresDicomWebService
297
298 Studies *ProjectsLocationsDatasetsDicomStoresStudiesService
299 }
300
301 func NewProjectsLocationsDatasetsDicomStoresDicomWebService(s *Service) *ProjectsLocationsDatasetsDicomStoresDicomWebService {
302 rs := &ProjectsLocationsDatasetsDicomStoresDicomWebService{s: s}
303 rs.Studies = NewProjectsLocationsDatasetsDicomStoresDicomWebStudiesService(s)
304 return rs
305 }
306
307 type ProjectsLocationsDatasetsDicomStoresDicomWebService struct {
308 s *Service
309
310 Studies *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesService
311 }
312
313 func NewProjectsLocationsDatasetsDicomStoresDicomWebStudiesService(s *Service) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesService {
314 rs := &ProjectsLocationsDatasetsDicomStoresDicomWebStudiesService{s: s}
315 rs.Series = NewProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesService(s)
316 return rs
317 }
318
319 type ProjectsLocationsDatasetsDicomStoresDicomWebStudiesService struct {
320 s *Service
321
322 Series *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesService
323 }
324
325 func NewProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesService(s *Service) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesService {
326 rs := &ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesService{s: s}
327 return rs
328 }
329
330 type ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesService struct {
331 s *Service
332 }
333
334 func NewProjectsLocationsDatasetsDicomStoresStudiesService(s *Service) *ProjectsLocationsDatasetsDicomStoresStudiesService {
335 rs := &ProjectsLocationsDatasetsDicomStoresStudiesService{s: s}
336 rs.Series = NewProjectsLocationsDatasetsDicomStoresStudiesSeriesService(s)
337 return rs
338 }
339
340 type ProjectsLocationsDatasetsDicomStoresStudiesService struct {
341 s *Service
342
343 Series *ProjectsLocationsDatasetsDicomStoresStudiesSeriesService
344 }
345
346 func NewProjectsLocationsDatasetsDicomStoresStudiesSeriesService(s *Service) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesService {
347 rs := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesService{s: s}
348 rs.Instances = NewProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService(s)
349 return rs
350 }
351
352 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesService struct {
353 s *Service
354
355 Instances *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService
356 }
357
358 func NewProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService(s *Service) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService {
359 rs := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService{s: s}
360 rs.Frames = NewProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService(s)
361 return rs
362 }
363
364 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService struct {
365 s *Service
366
367 Frames *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService
368 }
369
370 func NewProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService(s *Service) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService {
371 rs := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService{s: s}
372 return rs
373 }
374
375 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService struct {
376 s *Service
377 }
378
379 func NewProjectsLocationsDatasetsFhirStoresService(s *Service) *ProjectsLocationsDatasetsFhirStoresService {
380 rs := &ProjectsLocationsDatasetsFhirStoresService{s: s}
381 rs.Fhir = NewProjectsLocationsDatasetsFhirStoresFhirService(s)
382 return rs
383 }
384
385 type ProjectsLocationsDatasetsFhirStoresService struct {
386 s *Service
387
388 Fhir *ProjectsLocationsDatasetsFhirStoresFhirService
389 }
390
391 func NewProjectsLocationsDatasetsFhirStoresFhirService(s *Service) *ProjectsLocationsDatasetsFhirStoresFhirService {
392 rs := &ProjectsLocationsDatasetsFhirStoresFhirService{s: s}
393 return rs
394 }
395
396 type ProjectsLocationsDatasetsFhirStoresFhirService struct {
397 s *Service
398 }
399
400 func NewProjectsLocationsDatasetsHl7V2StoresService(s *Service) *ProjectsLocationsDatasetsHl7V2StoresService {
401 rs := &ProjectsLocationsDatasetsHl7V2StoresService{s: s}
402 rs.Messages = NewProjectsLocationsDatasetsHl7V2StoresMessagesService(s)
403 return rs
404 }
405
406 type ProjectsLocationsDatasetsHl7V2StoresService struct {
407 s *Service
408
409 Messages *ProjectsLocationsDatasetsHl7V2StoresMessagesService
410 }
411
412 func NewProjectsLocationsDatasetsHl7V2StoresMessagesService(s *Service) *ProjectsLocationsDatasetsHl7V2StoresMessagesService {
413 rs := &ProjectsLocationsDatasetsHl7V2StoresMessagesService{s: s}
414 return rs
415 }
416
417 type ProjectsLocationsDatasetsHl7V2StoresMessagesService struct {
418 s *Service
419 }
420
421 func NewProjectsLocationsDatasetsOperationsService(s *Service) *ProjectsLocationsDatasetsOperationsService {
422 rs := &ProjectsLocationsDatasetsOperationsService{s: s}
423 return rs
424 }
425
426 type ProjectsLocationsDatasetsOperationsService struct {
427 s *Service
428 }
429
430 func NewProjectsLocationsServicesService(s *Service) *ProjectsLocationsServicesService {
431 rs := &ProjectsLocationsServicesService{s: s}
432 rs.Nlp = NewProjectsLocationsServicesNlpService(s)
433 return rs
434 }
435
436 type ProjectsLocationsServicesService struct {
437 s *Service
438
439 Nlp *ProjectsLocationsServicesNlpService
440 }
441
442 func NewProjectsLocationsServicesNlpService(s *Service) *ProjectsLocationsServicesNlpService {
443 rs := &ProjectsLocationsServicesNlpService{s: s}
444 return rs
445 }
446
447 type ProjectsLocationsServicesNlpService struct {
448 s *Service
449 }
450
451
452
453
454
455
456 type ActivateConsentRequest struct {
457
458
459
460
461
462 ConsentArtifact string `json:"consentArtifact,omitempty"`
463
464 ExpireTime string `json:"expireTime,omitempty"`
465
466 Ttl string `json:"ttl,omitempty"`
467
468
469
470
471
472 ForceSendFields []string `json:"-"`
473
474
475
476
477 NullFields []string `json:"-"`
478 }
479
480 func (s *ActivateConsentRequest) MarshalJSON() ([]byte, error) {
481 type NoMethod ActivateConsentRequest
482 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
483 }
484
485
486
487 type AnalyzeEntitiesRequest struct {
488
489
490
491
492
493
494
495 AlternativeOutputFormat string `json:"alternativeOutputFormat,omitempty"`
496
497 DocumentContent string `json:"documentContent,omitempty"`
498
499
500
501
502
503
504
505 LicensedVocabularies []string `json:"licensedVocabularies,omitempty"`
506
507
508
509
510
511 ForceSendFields []string `json:"-"`
512
513
514
515
516 NullFields []string `json:"-"`
517 }
518
519 func (s *AnalyzeEntitiesRequest) MarshalJSON() ([]byte, error) {
520 type NoMethod AnalyzeEntitiesRequest
521 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
522 }
523
524
525
526 type AnalyzeEntitiesResponse struct {
527
528
529
530 Entities []*Entity `json:"entities,omitempty"`
531
532
533 EntityMentions []*EntityMention `json:"entityMentions,omitempty"`
534
535
536
537 FhirBundle string `json:"fhirBundle,omitempty"`
538
539
540 Relationships []*EntityMentionRelationship `json:"relationships,omitempty"`
541
542
543 googleapi.ServerResponse `json:"-"`
544
545
546
547
548
549 ForceSendFields []string `json:"-"`
550
551
552
553
554 NullFields []string `json:"-"`
555 }
556
557 func (s *AnalyzeEntitiesResponse) MarshalJSON() ([]byte, error) {
558 type NoMethod AnalyzeEntitiesResponse
559 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
560 }
561
562
563 type ArchiveUserDataMappingRequest struct {
564 }
565
566
567 type ArchiveUserDataMappingResponse struct {
568
569 googleapi.ServerResponse `json:"-"`
570 }
571
572
573
574
575 type Attribute struct {
576
577
578 AttributeDefinitionId string `json:"attributeDefinitionId,omitempty"`
579
580
581
582
583
584 Values []string `json:"values,omitempty"`
585
586
587
588
589
590 ForceSendFields []string `json:"-"`
591
592
593
594
595 NullFields []string `json:"-"`
596 }
597
598 func (s *Attribute) MarshalJSON() ([]byte, error) {
599 type NoMethod Attribute
600 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
601 }
602
603
604 type AttributeDefinition struct {
605
606
607
608 AllowedValues []string `json:"allowedValues,omitempty"`
609
610
611
612
613
614
615
616
617
618
619 Category string `json:"category,omitempty"`
620
621
622 ConsentDefaultValues []string `json:"consentDefaultValues,omitempty"`
623
624
625
626
627 DataMappingDefaultValue string `json:"dataMappingDefaultValue,omitempty"`
628
629 Description string `json:"description,omitempty"`
630
631
632
633
634 Name string `json:"name,omitempty"`
635
636
637 googleapi.ServerResponse `json:"-"`
638
639
640
641
642
643 ForceSendFields []string `json:"-"`
644
645
646
647
648 NullFields []string `json:"-"`
649 }
650
651 func (s *AttributeDefinition) MarshalJSON() ([]byte, error) {
652 type NoMethod AttributeDefinition
653 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
654 }
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672 type AuditConfig struct {
673
674 AuditLogConfigs []*AuditLogConfig `json:"auditLogConfigs,omitempty"`
675
676
677
678 Service string `json:"service,omitempty"`
679
680
681
682
683
684 ForceSendFields []string `json:"-"`
685
686
687
688
689 NullFields []string `json:"-"`
690 }
691
692 func (s *AuditConfig) MarshalJSON() ([]byte, error) {
693 type NoMethod AuditConfig
694 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
695 }
696
697
698
699
700
701
702 type AuditLogConfig struct {
703
704
705 ExemptedMembers []string `json:"exemptedMembers,omitempty"`
706
707
708
709
710
711
712
713 LogType string `json:"logType,omitempty"`
714
715
716
717
718
719 ForceSendFields []string `json:"-"`
720
721
722
723
724 NullFields []string `json:"-"`
725 }
726
727 func (s *AuditLogConfig) MarshalJSON() ([]byte, error) {
728 type NoMethod AuditLogConfig
729 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
730 }
731
732
733 type Binding struct {
734
735
736
737
738
739
740
741
742 Condition *Expr `json:"condition,omitempty"`
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
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
799
800
801
802
803
804
805 Members []string `json:"members,omitempty"`
806
807
808
809
810
811
812 Role string `json:"role,omitempty"`
813
814
815
816
817
818 ForceSendFields []string `json:"-"`
819
820
821
822
823 NullFields []string `json:"-"`
824 }
825
826 func (s *Binding) MarshalJSON() ([]byte, error) {
827 type NoMethod Binding
828 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
829 }
830
831
832 type CancelOperationRequest struct {
833 }
834
835
836
837 type CharacterMaskConfig struct {
838
839
840 MaskingCharacter string `json:"maskingCharacter,omitempty"`
841
842
843
844
845
846 ForceSendFields []string `json:"-"`
847
848
849
850
851 NullFields []string `json:"-"`
852 }
853
854 func (s *CharacterMaskConfig) MarshalJSON() ([]byte, error) {
855 type NoMethod CharacterMaskConfig
856 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
857 }
858
859
860
861 type CheckDataAccessRequest struct {
862
863
864
865
866
867
868
869 ConsentList *ConsentList `json:"consentList,omitempty"`
870
871
872
873 DataId string `json:"dataId,omitempty"`
874
875
876 RequestAttributes map[string]string `json:"requestAttributes,omitempty"`
877
878
879
880
881
882
883
884
885
886
887
888
889 ResponseView string `json:"responseView,omitempty"`
890
891
892
893
894
895 ForceSendFields []string `json:"-"`
896
897
898
899
900 NullFields []string `json:"-"`
901 }
902
903 func (s *CheckDataAccessRequest) MarshalJSON() ([]byte, error) {
904 type NoMethod CheckDataAccessRequest
905 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
906 }
907
908
909
910 type CheckDataAccessResponse struct {
911
912
913 ConsentDetails map[string]ConsentEvaluation `json:"consentDetails,omitempty"`
914
915 Consented bool `json:"consented,omitempty"`
916
917
918 googleapi.ServerResponse `json:"-"`
919
920
921
922
923
924 ForceSendFields []string `json:"-"`
925
926
927
928
929 NullFields []string `json:"-"`
930 }
931
932 func (s *CheckDataAccessResponse) MarshalJSON() ([]byte, error) {
933 type NoMethod CheckDataAccessResponse
934 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
935 }
936
937
938 type Consent struct {
939
940
941
942
943 ConsentArtifact string `json:"consentArtifact,omitempty"`
944
945 ExpireTime string `json:"expireTime,omitempty"`
946
947
948
949
950
951
952
953
954
955 Metadata map[string]string `json:"metadata,omitempty"`
956
957
958
959
960 Name string `json:"name,omitempty"`
961
962
963 Policies []*GoogleCloudHealthcareV1ConsentPolicy `json:"policies,omitempty"`
964
965
966 RevisionCreateTime string `json:"revisionCreateTime,omitempty"`
967
968
969
970 RevisionId string `json:"revisionId,omitempty"`
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986 State string `json:"state,omitempty"`
987
988 Ttl string `json:"ttl,omitempty"`
989
990 UserId string `json:"userId,omitempty"`
991
992
993 googleapi.ServerResponse `json:"-"`
994
995
996
997
998
999 ForceSendFields []string `json:"-"`
1000
1001
1002
1003
1004 NullFields []string `json:"-"`
1005 }
1006
1007 func (s *Consent) MarshalJSON() ([]byte, error) {
1008 type NoMethod Consent
1009 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1010 }
1011
1012
1013 type ConsentArtifact struct {
1014
1015
1016 ConsentContentScreenshots []*Image `json:"consentContentScreenshots,omitempty"`
1017
1018
1019 ConsentContentVersion string `json:"consentContentVersion,omitempty"`
1020
1021 GuardianSignature *Signature `json:"guardianSignature,omitempty"`
1022
1023
1024 Metadata map[string]string `json:"metadata,omitempty"`
1025
1026
1027
1028
1029 Name string `json:"name,omitempty"`
1030
1031 UserId string `json:"userId,omitempty"`
1032
1033 UserSignature *Signature `json:"userSignature,omitempty"`
1034
1035 WitnessSignature *Signature `json:"witnessSignature,omitempty"`
1036
1037
1038 googleapi.ServerResponse `json:"-"`
1039
1040
1041
1042
1043
1044 ForceSendFields []string `json:"-"`
1045
1046
1047
1048
1049 NullFields []string `json:"-"`
1050 }
1051
1052 func (s *ConsentArtifact) MarshalJSON() ([]byte, error) {
1053 type NoMethod ConsentArtifact
1054 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1055 }
1056
1057
1058 type ConsentEvaluation struct {
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076 EvaluationResult string `json:"evaluationResult,omitempty"`
1077
1078
1079
1080
1081
1082 ForceSendFields []string `json:"-"`
1083
1084
1085
1086
1087 NullFields []string `json:"-"`
1088 }
1089
1090 func (s *ConsentEvaluation) MarshalJSON() ([]byte, error) {
1091 type NoMethod ConsentEvaluation
1092 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1093 }
1094
1095
1096 type ConsentList struct {
1097
1098
1099
1100
1101 Consents []string `json:"consents,omitempty"`
1102
1103
1104
1105
1106
1107 ForceSendFields []string `json:"-"`
1108
1109
1110
1111
1112 NullFields []string `json:"-"`
1113 }
1114
1115 func (s *ConsentList) MarshalJSON() ([]byte, error) {
1116 type NoMethod ConsentList
1117 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1118 }
1119
1120
1121 type ConsentStore struct {
1122
1123
1124
1125 DefaultConsentTtl string `json:"defaultConsentTtl,omitempty"`
1126
1127
1128 EnableConsentCreateOnUpdate bool `json:"enableConsentCreateOnUpdate,omitempty"`
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138 Labels map[string]string `json:"labels,omitempty"`
1139
1140
1141
1142 Name string `json:"name,omitempty"`
1143
1144
1145 googleapi.ServerResponse `json:"-"`
1146
1147
1148
1149
1150
1151 ForceSendFields []string `json:"-"`
1152
1153
1154
1155
1156 NullFields []string `json:"-"`
1157 }
1158
1159 func (s *ConsentStore) MarshalJSON() ([]byte, error) {
1160 type NoMethod ConsentStore
1161 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1162 }
1163
1164
1165 type CreateMessageRequest struct {
1166
1167 Message *Message `json:"message,omitempty"`
1168
1169
1170
1171
1172
1173 ForceSendFields []string `json:"-"`
1174
1175
1176
1177
1178 NullFields []string `json:"-"`
1179 }
1180
1181 func (s *CreateMessageRequest) MarshalJSON() ([]byte, error) {
1182 type NoMethod CreateMessageRequest
1183 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1184 }
1185
1186
1187
1188
1189
1190 type CryptoHashConfig struct {
1191
1192
1193
1194
1195 CryptoKey string `json:"cryptoKey,omitempty"`
1196
1197 KmsWrapped *KmsWrappedCryptoKey `json:"kmsWrapped,omitempty"`
1198
1199
1200
1201
1202
1203 ForceSendFields []string `json:"-"`
1204
1205
1206
1207
1208 NullFields []string `json:"-"`
1209 }
1210
1211 func (s *CryptoHashConfig) MarshalJSON() ([]byte, error) {
1212 type NoMethod CryptoHashConfig
1213 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1214 }
1215
1216
1217
1218
1219
1220 type Dataset struct {
1221
1222
1223 Name string `json:"name,omitempty"`
1224
1225
1226
1227
1228 TimeZone string `json:"timeZone,omitempty"`
1229
1230
1231 googleapi.ServerResponse `json:"-"`
1232
1233
1234
1235
1236
1237 ForceSendFields []string `json:"-"`
1238
1239
1240
1241
1242 NullFields []string `json:"-"`
1243 }
1244
1245 func (s *Dataset) MarshalJSON() ([]byte, error) {
1246 type NoMethod Dataset
1247 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1248 }
1249
1250
1251
1252 type DateShiftConfig struct {
1253
1254
1255
1256
1257
1258
1259 CryptoKey string `json:"cryptoKey,omitempty"`
1260
1261
1262
1263
1264 KmsWrapped *KmsWrappedCryptoKey `json:"kmsWrapped,omitempty"`
1265
1266
1267
1268
1269
1270 ForceSendFields []string `json:"-"`
1271
1272
1273
1274
1275 NullFields []string `json:"-"`
1276 }
1277
1278 func (s *DateShiftConfig) MarshalJSON() ([]byte, error) {
1279 type NoMethod DateShiftConfig
1280 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1281 }
1282
1283
1284
1285 type DeidentifiedStoreDestination struct {
1286
1287
1288 Config *DeidentifyConfig `json:"config,omitempty"`
1289
1290
1291
1292 Store string `json:"store,omitempty"`
1293
1294
1295
1296
1297
1298 ForceSendFields []string `json:"-"`
1299
1300
1301
1302
1303 NullFields []string `json:"-"`
1304 }
1305
1306 func (s *DeidentifiedStoreDestination) MarshalJSON() ([]byte, error) {
1307 type NoMethod DeidentifiedStoreDestination
1308 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1309 }
1310
1311
1312
1313
1314
1315 type DeidentifyConfig struct {
1316
1317 Dicom *DicomConfig `json:"dicom,omitempty"`
1318
1319 Fhir *FhirConfig `json:"fhir,omitempty"`
1320
1321
1322 Image *ImageConfig `json:"image,omitempty"`
1323
1324
1325 Text *TextConfig `json:"text,omitempty"`
1326
1327
1328
1329
1330
1331
1332 UseRegionalDataProcessing bool `json:"useRegionalDataProcessing,omitempty"`
1333
1334
1335
1336
1337
1338 ForceSendFields []string `json:"-"`
1339
1340
1341
1342
1343 NullFields []string `json:"-"`
1344 }
1345
1346 func (s *DeidentifyConfig) MarshalJSON() ([]byte, error) {
1347 type NoMethod DeidentifyConfig
1348 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1349 }
1350
1351
1352
1353 type DeidentifyDatasetRequest struct {
1354
1355
1356 Config *DeidentifyConfig `json:"config,omitempty"`
1357
1358
1359
1360
1361 DestinationDataset string `json:"destinationDataset,omitempty"`
1362
1363
1364
1365
1366
1367
1368 GcsConfigUri string `json:"gcsConfigUri,omitempty"`
1369
1370
1371
1372
1373
1374 ForceSendFields []string `json:"-"`
1375
1376
1377
1378
1379 NullFields []string `json:"-"`
1380 }
1381
1382 func (s *DeidentifyDatasetRequest) MarshalJSON() ([]byte, error) {
1383 type NoMethod DeidentifyDatasetRequest
1384 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1385 }
1386
1387
1388
1389 type DeidentifyDicomStoreRequest struct {
1390
1391
1392 Config *DeidentifyConfig `json:"config,omitempty"`
1393
1394
1395
1396
1397
1398
1399
1400
1401 DestinationStore string `json:"destinationStore,omitempty"`
1402
1403 FilterConfig *DicomFilterConfig `json:"filterConfig,omitempty"`
1404
1405
1406
1407
1408
1409
1410 GcsConfigUri string `json:"gcsConfigUri,omitempty"`
1411
1412
1413
1414
1415
1416 ForceSendFields []string `json:"-"`
1417
1418
1419
1420
1421 NullFields []string `json:"-"`
1422 }
1423
1424 func (s *DeidentifyDicomStoreRequest) MarshalJSON() ([]byte, error) {
1425 type NoMethod DeidentifyDicomStoreRequest
1426 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1427 }
1428
1429
1430
1431 type DeidentifyFhirStoreRequest struct {
1432
1433
1434 Config *DeidentifyConfig `json:"config,omitempty"`
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444 DestinationStore string `json:"destinationStore,omitempty"`
1445
1446
1447
1448
1449
1450
1451 GcsConfigUri string `json:"gcsConfigUri,omitempty"`
1452
1453
1454 ResourceFilter *FhirFilter `json:"resourceFilter,omitempty"`
1455
1456
1457 SkipModifiedResources bool `json:"skipModifiedResources,omitempty"`
1458
1459
1460
1461
1462
1463 ForceSendFields []string `json:"-"`
1464
1465
1466
1467
1468 NullFields []string `json:"-"`
1469 }
1470
1471 func (s *DeidentifyFhirStoreRequest) MarshalJSON() ([]byte, error) {
1472 type NoMethod DeidentifyFhirStoreRequest
1473 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1474 }
1475
1476
1477 type DeidentifySummary struct {
1478 }
1479
1480
1481
1482 type DicomConfig struct {
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500 FilterProfile string `json:"filterProfile,omitempty"`
1501
1502 KeepList *TagFilterList `json:"keepList,omitempty"`
1503
1504 RemoveList *TagFilterList `json:"removeList,omitempty"`
1505
1506
1507
1508
1509
1510
1511
1512
1513 SkipIdRedaction bool `json:"skipIdRedaction,omitempty"`
1514
1515
1516
1517
1518
1519 ForceSendFields []string `json:"-"`
1520
1521
1522
1523
1524 NullFields []string `json:"-"`
1525 }
1526
1527 func (s *DicomConfig) MarshalJSON() ([]byte, error) {
1528 type NoMethod DicomConfig
1529 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1530 }
1531
1532
1533 type DicomFilterConfig struct {
1534
1535
1536
1537
1538
1539
1540
1541 ResourcePathsGcsUri string `json:"resourcePathsGcsUri,omitempty"`
1542
1543
1544
1545
1546
1547 ForceSendFields []string `json:"-"`
1548
1549
1550
1551
1552 NullFields []string `json:"-"`
1553 }
1554
1555 func (s *DicomFilterConfig) MarshalJSON() ([]byte, error) {
1556 type NoMethod DicomFilterConfig
1557 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1558 }
1559
1560
1561 type DicomStore struct {
1562
1563
1564
1565
1566
1567
1568
1569
1570 Labels map[string]string `json:"labels,omitempty"`
1571
1572
1573
1574 Name string `json:"name,omitempty"`
1575
1576
1577 NotificationConfig *NotificationConfig `json:"notificationConfig,omitempty"`
1578
1579
1580
1581
1582
1583
1584 StreamConfigs []*GoogleCloudHealthcareV1DicomStreamConfig `json:"streamConfigs,omitempty"`
1585
1586
1587 googleapi.ServerResponse `json:"-"`
1588
1589
1590
1591
1592
1593 ForceSendFields []string `json:"-"`
1594
1595
1596
1597
1598 NullFields []string `json:"-"`
1599 }
1600
1601 func (s *DicomStore) MarshalJSON() ([]byte, error) {
1602 type NoMethod DicomStore
1603 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1604 }
1605
1606
1607
1608 type DicomStoreMetrics struct {
1609
1610
1611 BlobStorageSizeBytes int64 `json:"blobStorageSizeBytes,omitempty,string"`
1612
1613 InstanceCount int64 `json:"instanceCount,omitempty,string"`
1614
1615
1616
1617 Name string `json:"name,omitempty"`
1618
1619 SeriesCount int64 `json:"seriesCount,omitempty,string"`
1620
1621
1622 StructuredStorageSizeBytes int64 `json:"structuredStorageSizeBytes,omitempty,string"`
1623
1624 StudyCount int64 `json:"studyCount,omitempty,string"`
1625
1626
1627 googleapi.ServerResponse `json:"-"`
1628
1629
1630
1631
1632
1633 ForceSendFields []string `json:"-"`
1634
1635
1636
1637
1638 NullFields []string `json:"-"`
1639 }
1640
1641 func (s *DicomStoreMetrics) MarshalJSON() ([]byte, error) {
1642 type NoMethod DicomStoreMetrics
1643 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1644 }
1645
1646
1647
1648
1649
1650 type Empty struct {
1651
1652 googleapi.ServerResponse `json:"-"`
1653 }
1654
1655
1656 type Entity struct {
1657
1658
1659 EntityId string `json:"entityId,omitempty"`
1660
1661
1662
1663 PreferredTerm string `json:"preferredTerm,omitempty"`
1664
1665
1666
1667
1668
1669
1670 VocabularyCodes []string `json:"vocabularyCodes,omitempty"`
1671
1672
1673
1674
1675
1676 ForceSendFields []string `json:"-"`
1677
1678
1679
1680
1681 NullFields []string `json:"-"`
1682 }
1683
1684 func (s *Entity) MarshalJSON() ([]byte, error) {
1685 type NoMethod Entity
1686 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1687 }
1688
1689
1690 type EntityMention struct {
1691
1692
1693
1694 CertaintyAssessment *Feature `json:"certaintyAssessment,omitempty"`
1695
1696
1697 Confidence float64 `json:"confidence,omitempty"`
1698
1699
1700 LinkedEntities []*LinkedEntity `json:"linkedEntities,omitempty"`
1701
1702
1703 MentionId string `json:"mentionId,omitempty"`
1704
1705
1706 Subject *Feature `json:"subject,omitempty"`
1707
1708
1709
1710 TemporalAssessment *Feature `json:"temporalAssessment,omitempty"`
1711
1712 Text *TextSpan `json:"text,omitempty"`
1713
1714
1715
1716
1717
1718
1719
1720
1721 Type string `json:"type,omitempty"`
1722
1723
1724
1725
1726
1727 ForceSendFields []string `json:"-"`
1728
1729
1730
1731
1732 NullFields []string `json:"-"`
1733 }
1734
1735 func (s *EntityMention) MarshalJSON() ([]byte, error) {
1736 type NoMethod EntityMention
1737 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1738 }
1739
1740 func (s *EntityMention) UnmarshalJSON(data []byte) error {
1741 type NoMethod EntityMention
1742 var s1 struct {
1743 Confidence gensupport.JSONFloat64 `json:"confidence"`
1744 *NoMethod
1745 }
1746 s1.NoMethod = (*NoMethod)(s)
1747 if err := json.Unmarshal(data, &s1); err != nil {
1748 return err
1749 }
1750 s.Confidence = float64(s1.Confidence)
1751 return nil
1752 }
1753
1754
1755
1756 type EntityMentionRelationship struct {
1757
1758
1759 Confidence float64 `json:"confidence,omitempty"`
1760
1761 ObjectId string `json:"objectId,omitempty"`
1762
1763 SubjectId string `json:"subjectId,omitempty"`
1764
1765
1766
1767
1768
1769 ForceSendFields []string `json:"-"`
1770
1771
1772
1773
1774 NullFields []string `json:"-"`
1775 }
1776
1777 func (s *EntityMentionRelationship) MarshalJSON() ([]byte, error) {
1778 type NoMethod EntityMentionRelationship
1779 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1780 }
1781
1782 func (s *EntityMentionRelationship) UnmarshalJSON(data []byte) error {
1783 type NoMethod EntityMentionRelationship
1784 var s1 struct {
1785 Confidence gensupport.JSONFloat64 `json:"confidence"`
1786 *NoMethod
1787 }
1788 s1.NoMethod = (*NoMethod)(s)
1789 if err := json.Unmarshal(data, &s1); err != nil {
1790 return err
1791 }
1792 s.Confidence = float64(s1.Confidence)
1793 return nil
1794 }
1795
1796
1797
1798
1799
1800 type EvaluateUserConsentsRequest struct {
1801
1802
1803
1804
1805
1806
1807 ConsentList *ConsentList `json:"consentList,omitempty"`
1808
1809
1810 PageSize int64 `json:"pageSize,omitempty"`
1811
1812
1813 PageToken string `json:"pageToken,omitempty"`
1814
1815
1816 RequestAttributes map[string]string `json:"requestAttributes,omitempty"`
1817
1818
1819
1820 ResourceAttributes map[string]string `json:"resourceAttributes,omitempty"`
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833 ResponseView string `json:"responseView,omitempty"`
1834
1835 UserId string `json:"userId,omitempty"`
1836
1837
1838
1839
1840
1841 ForceSendFields []string `json:"-"`
1842
1843
1844
1845
1846 NullFields []string `json:"-"`
1847 }
1848
1849 func (s *EvaluateUserConsentsRequest) MarshalJSON() ([]byte, error) {
1850 type NoMethod EvaluateUserConsentsRequest
1851 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1852 }
1853
1854 type EvaluateUserConsentsResponse struct {
1855
1856
1857
1858 NextPageToken string `json:"nextPageToken,omitempty"`
1859
1860 Results []*Result `json:"results,omitempty"`
1861
1862
1863 googleapi.ServerResponse `json:"-"`
1864
1865
1866
1867
1868
1869 ForceSendFields []string `json:"-"`
1870
1871
1872
1873
1874 NullFields []string `json:"-"`
1875 }
1876
1877 func (s *EvaluateUserConsentsResponse) MarshalJSON() ([]byte, error) {
1878 type NoMethod EvaluateUserConsentsResponse
1879 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1880 }
1881
1882
1883
1884
1885
1886
1887 type ExportDicomDataRequest struct {
1888
1889
1890
1891
1892
1893 BigqueryDestination *GoogleCloudHealthcareV1DicomBigQueryDestination `json:"bigqueryDestination,omitempty"`
1894
1895
1896
1897 GcsDestination *GoogleCloudHealthcareV1DicomGcsDestination `json:"gcsDestination,omitempty"`
1898
1899
1900
1901
1902
1903 ForceSendFields []string `json:"-"`
1904
1905
1906
1907
1908 NullFields []string `json:"-"`
1909 }
1910
1911 func (s *ExportDicomDataRequest) MarshalJSON() ([]byte, error) {
1912 type NoMethod ExportDicomDataRequest
1913 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1914 }
1915
1916
1917
1918 type ExportDicomDataResponse struct {
1919 }
1920
1921
1922 type ExportMessagesRequest struct {
1923
1924
1925
1926
1927
1928
1929 EndTime string `json:"endTime,omitempty"`
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969 Filter string `json:"filter,omitempty"`
1970
1971 GcsDestination *GcsDestination `json:"gcsDestination,omitempty"`
1972
1973 PubsubDestination *PubsubDestination `json:"pubsubDestination,omitempty"`
1974
1975
1976
1977
1978
1979
1980 StartTime string `json:"startTime,omitempty"`
1981
1982
1983
1984
1985
1986 ForceSendFields []string `json:"-"`
1987
1988
1989
1990
1991 NullFields []string `json:"-"`
1992 }
1993
1994 func (s *ExportMessagesRequest) MarshalJSON() ([]byte, error) {
1995 type NoMethod ExportMessagesRequest
1996 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
1997 }
1998
1999
2000
2001 type ExportMessagesResponse struct {
2002 }
2003
2004
2005 type ExportResourcesRequest struct {
2006
2007
2008
2009
2010 Since string `json:"_since,omitempty"`
2011
2012
2013 Type string `json:"_type,omitempty"`
2014
2015
2016
2017
2018
2019 BigqueryDestination *GoogleCloudHealthcareV1FhirBigQueryDestination `json:"bigqueryDestination,omitempty"`
2020
2021
2022
2023
2024
2025 GcsDestination *GoogleCloudHealthcareV1FhirGcsDestination `json:"gcsDestination,omitempty"`
2026
2027
2028
2029
2030
2031 ForceSendFields []string `json:"-"`
2032
2033
2034
2035
2036 NullFields []string `json:"-"`
2037 }
2038
2039 func (s *ExportResourcesRequest) MarshalJSON() ([]byte, error) {
2040 type NoMethod ExportResourcesRequest
2041 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2042 }
2043
2044
2045
2046
2047 type ExportResourcesResponse struct {
2048 }
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066 type Expr struct {
2067
2068
2069 Description string `json:"description,omitempty"`
2070
2071
2072 Expression string `json:"expression,omitempty"`
2073
2074
2075 Location string `json:"location,omitempty"`
2076
2077
2078
2079 Title string `json:"title,omitempty"`
2080
2081
2082
2083
2084
2085 ForceSendFields []string `json:"-"`
2086
2087
2088
2089
2090 NullFields []string `json:"-"`
2091 }
2092
2093 func (s *Expr) MarshalJSON() ([]byte, error) {
2094 type NoMethod Expr
2095 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2096 }
2097
2098
2099 type Feature struct {
2100
2101
2102 Confidence float64 `json:"confidence,omitempty"`
2103
2104
2105 Value string `json:"value,omitempty"`
2106
2107
2108
2109
2110
2111 ForceSendFields []string `json:"-"`
2112
2113
2114
2115
2116 NullFields []string `json:"-"`
2117 }
2118
2119 func (s *Feature) MarshalJSON() ([]byte, error) {
2120 type NoMethod Feature
2121 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2122 }
2123
2124 func (s *Feature) UnmarshalJSON(data []byte) error {
2125 type NoMethod Feature
2126 var s1 struct {
2127 Confidence gensupport.JSONFloat64 `json:"confidence"`
2128 *NoMethod
2129 }
2130 s1.NoMethod = (*NoMethod)(s)
2131 if err := json.Unmarshal(data, &s1); err != nil {
2132 return err
2133 }
2134 s.Confidence = float64(s1.Confidence)
2135 return nil
2136 }
2137
2138
2139 type FhirConfig struct {
2140
2141
2142
2143
2144 DefaultKeepExtensions bool `json:"defaultKeepExtensions,omitempty"`
2145
2146
2147
2148
2149 FieldMetadataList []*FieldMetadata `json:"fieldMetadataList,omitempty"`
2150
2151
2152
2153
2154
2155 ForceSendFields []string `json:"-"`
2156
2157
2158
2159
2160 NullFields []string `json:"-"`
2161 }
2162
2163 func (s *FhirConfig) MarshalJSON() ([]byte, error) {
2164 type NoMethod FhirConfig
2165 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2166 }
2167
2168
2169 type FhirFilter struct {
2170
2171
2172 Resources *Resources `json:"resources,omitempty"`
2173
2174
2175
2176
2177
2178 ForceSendFields []string `json:"-"`
2179
2180
2181
2182
2183 NullFields []string `json:"-"`
2184 }
2185
2186 func (s *FhirFilter) MarshalJSON() ([]byte, error) {
2187 type NoMethod FhirFilter
2188 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2189 }
2190
2191
2192 type FhirNotificationConfig struct {
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209 PubsubTopic string `json:"pubsubTopic,omitempty"`
2210
2211 SendFullResource bool `json:"sendFullResource,omitempty"`
2212
2213
2214
2215
2216
2217
2218
2219 SendPreviousResourceOnDelete bool `json:"sendPreviousResourceOnDelete,omitempty"`
2220
2221
2222
2223
2224
2225 ForceSendFields []string `json:"-"`
2226
2227
2228
2229
2230 NullFields []string `json:"-"`
2231 }
2232
2233 func (s *FhirNotificationConfig) MarshalJSON() ([]byte, error) {
2234 type NoMethod FhirNotificationConfig
2235 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2236 }
2237
2238
2239 type FhirStore struct {
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254 ComplexDataTypeReferenceParsing string `json:"complexDataTypeReferenceParsing,omitempty"`
2255
2256
2257
2258
2259
2260
2261
2262 DefaultSearchHandlingStrict bool `json:"defaultSearchHandlingStrict,omitempty"`
2263
2264
2265
2266
2267
2268
2269
2270
2271 DisableReferentialIntegrity bool `json:"disableReferentialIntegrity,omitempty"`
2272
2273
2274
2275
2276
2277
2278
2279 DisableResourceVersioning bool `json:"disableResourceVersioning,omitempty"`
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290 EnableUpdateCreate bool `json:"enableUpdateCreate,omitempty"`
2291
2292
2293
2294
2295
2296
2297
2298
2299 Labels map[string]string `json:"labels,omitempty"`
2300
2301
2302
2303 Name string `json:"name,omitempty"`
2304
2305
2306
2307
2308
2309 NotificationConfig *NotificationConfig `json:"notificationConfig,omitempty"`
2310
2311
2312 NotificationConfigs []*FhirNotificationConfig `json:"notificationConfigs,omitempty"`
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325 StreamConfigs []*StreamConfig `json:"streamConfigs,omitempty"`
2326
2327
2328 ValidationConfig *ValidationConfig `json:"validationConfig,omitempty"`
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342 Version string `json:"version,omitempty"`
2343
2344
2345 googleapi.ServerResponse `json:"-"`
2346
2347
2348
2349
2350
2351
2352 ForceSendFields []string `json:"-"`
2353
2354
2355
2356
2357 NullFields []string `json:"-"`
2358 }
2359
2360 func (s *FhirStore) MarshalJSON() ([]byte, error) {
2361 type NoMethod FhirStore
2362 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2363 }
2364
2365
2366
2367 type FhirStoreMetric struct {
2368
2369 Count int64 `json:"count,omitempty,string"`
2370
2371 ResourceType string `json:"resourceType,omitempty"`
2372
2373
2374 StructuredStorageSizeBytes int64 `json:"structuredStorageSizeBytes,omitempty,string"`
2375
2376
2377
2378
2379
2380 ForceSendFields []string `json:"-"`
2381
2382
2383
2384
2385 NullFields []string `json:"-"`
2386 }
2387
2388 func (s *FhirStoreMetric) MarshalJSON() ([]byte, error) {
2389 type NoMethod FhirStoreMetric
2390 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2391 }
2392
2393
2394 type FhirStoreMetrics struct {
2395
2396 Metrics []*FhirStoreMetric `json:"metrics,omitempty"`
2397
2398
2399 Name string `json:"name,omitempty"`
2400
2401
2402 googleapi.ServerResponse `json:"-"`
2403
2404
2405
2406
2407
2408 ForceSendFields []string `json:"-"`
2409
2410
2411
2412
2413 NullFields []string `json:"-"`
2414 }
2415
2416 func (s *FhirStoreMetrics) MarshalJSON() ([]byte, error) {
2417 type NoMethod FhirStoreMetrics
2418 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2419 }
2420
2421
2422 type Field struct {
2423
2424
2425 MaxOccurs int64 `json:"maxOccurs,omitempty"`
2426
2427 MinOccurs int64 `json:"minOccurs,omitempty"`
2428
2429 Name string `json:"name,omitempty"`
2430
2431
2432 Table string `json:"table,omitempty"`
2433
2434
2435 Type string `json:"type,omitempty"`
2436
2437
2438
2439
2440
2441 ForceSendFields []string `json:"-"`
2442
2443
2444
2445
2446 NullFields []string `json:"-"`
2447 }
2448
2449 func (s *Field) MarshalJSON() ([]byte, error) {
2450 type NoMethod Field
2451 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2452 }
2453
2454
2455
2456 type FieldMetadata struct {
2457
2458
2459
2460
2461
2462
2463
2464 Action string `json:"action,omitempty"`
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474 Paths []string `json:"paths,omitempty"`
2475
2476
2477
2478
2479
2480 ForceSendFields []string `json:"-"`
2481
2482
2483
2484
2485 NullFields []string `json:"-"`
2486 }
2487
2488 func (s *FieldMetadata) MarshalJSON() ([]byte, error) {
2489 type NoMethod FieldMetadata
2490 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2491 }
2492
2493
2494
2495
2496 type GcsDestination struct {
2497
2498
2499
2500
2501
2502
2503
2504 ContentStructure string `json:"contentStructure,omitempty"`
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518 MessageView string `json:"messageView,omitempty"`
2519
2520
2521
2522
2523 UriPrefix string `json:"uriPrefix,omitempty"`
2524
2525
2526
2527
2528
2529 ForceSendFields []string `json:"-"`
2530
2531
2532
2533
2534 NullFields []string `json:"-"`
2535 }
2536
2537 func (s *GcsDestination) MarshalJSON() ([]byte, error) {
2538 type NoMethod GcsDestination
2539 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2540 }
2541
2542
2543
2544 type GcsSource struct {
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557 Uri string `json:"uri,omitempty"`
2558
2559
2560
2561
2562
2563 ForceSendFields []string `json:"-"`
2564
2565
2566
2567
2568 NullFields []string `json:"-"`
2569 }
2570
2571 func (s *GcsSource) MarshalJSON() ([]byte, error) {
2572 type NoMethod GcsSource
2573 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2574 }
2575
2576
2577
2578 type GoogleCloudHealthcareV1ConsentGcsDestination struct {
2579
2580
2581
2582
2583
2584 UriPrefix string `json:"uriPrefix,omitempty"`
2585
2586
2587
2588
2589
2590 ForceSendFields []string `json:"-"`
2591
2592
2593
2594
2595 NullFields []string `json:"-"`
2596 }
2597
2598 func (s *GoogleCloudHealthcareV1ConsentGcsDestination) MarshalJSON() ([]byte, error) {
2599 type NoMethod GoogleCloudHealthcareV1ConsentGcsDestination
2600 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2601 }
2602
2603
2604
2605 type GoogleCloudHealthcareV1ConsentPolicy struct {
2606
2607
2608
2609
2610 AuthorizationRule *Expr `json:"authorizationRule,omitempty"`
2611
2612
2613
2614 ResourceAttributes []*Attribute `json:"resourceAttributes,omitempty"`
2615
2616
2617
2618
2619
2620 ForceSendFields []string `json:"-"`
2621
2622
2623
2624
2625 NullFields []string `json:"-"`
2626 }
2627
2628 func (s *GoogleCloudHealthcareV1ConsentPolicy) MarshalJSON() ([]byte, error) {
2629 type NoMethod GoogleCloudHealthcareV1ConsentPolicy
2630 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2631 }
2632
2633
2634
2635 type GoogleCloudHealthcareV1DeidentifyDeidentifyDicomStoreSummary struct {
2636 }
2637
2638
2639
2640 type GoogleCloudHealthcareV1DeidentifyDeidentifyFhirStoreSummary struct {
2641 }
2642
2643
2644
2645 type GoogleCloudHealthcareV1DicomBigQueryDestination struct {
2646
2647
2648
2649
2650 Force bool `json:"force,omitempty"`
2651
2652
2653 TableUri string `json:"tableUri,omitempty"`
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665 WriteDisposition string `json:"writeDisposition,omitempty"`
2666
2667
2668
2669
2670
2671 ForceSendFields []string `json:"-"`
2672
2673
2674
2675
2676 NullFields []string `json:"-"`
2677 }
2678
2679 func (s *GoogleCloudHealthcareV1DicomBigQueryDestination) MarshalJSON() ([]byte, error) {
2680 type NoMethod GoogleCloudHealthcareV1DicomBigQueryDestination
2681 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2682 }
2683
2684
2685
2686 type GoogleCloudHealthcareV1DicomGcsDestination struct {
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709 MimeType string `json:"mimeType,omitempty"`
2710
2711
2712
2713
2714
2715
2716 UriPrefix string `json:"uriPrefix,omitempty"`
2717
2718
2719
2720
2721
2722 ForceSendFields []string `json:"-"`
2723
2724
2725
2726
2727 NullFields []string `json:"-"`
2728 }
2729
2730 func (s *GoogleCloudHealthcareV1DicomGcsDestination) MarshalJSON() ([]byte, error) {
2731 type NoMethod GoogleCloudHealthcareV1DicomGcsDestination
2732 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2733 }
2734
2735
2736
2737 type GoogleCloudHealthcareV1DicomGcsSource struct {
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750 Uri string `json:"uri,omitempty"`
2751
2752
2753
2754
2755
2756 ForceSendFields []string `json:"-"`
2757
2758
2759
2760
2761 NullFields []string `json:"-"`
2762 }
2763
2764 func (s *GoogleCloudHealthcareV1DicomGcsSource) MarshalJSON() ([]byte, error) {
2765 type NoMethod GoogleCloudHealthcareV1DicomGcsSource
2766 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2767 }
2768
2769
2770
2771 type GoogleCloudHealthcareV1DicomStreamConfig struct {
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793 BigqueryDestination *GoogleCloudHealthcareV1DicomBigQueryDestination `json:"bigqueryDestination,omitempty"`
2794
2795
2796
2797
2798
2799 ForceSendFields []string `json:"-"`
2800
2801
2802
2803
2804 NullFields []string `json:"-"`
2805 }
2806
2807 func (s *GoogleCloudHealthcareV1DicomStreamConfig) MarshalJSON() ([]byte, error) {
2808 type NoMethod GoogleCloudHealthcareV1DicomStreamConfig
2809 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2810 }
2811
2812
2813
2814 type GoogleCloudHealthcareV1FhirBigQueryDestination struct {
2815
2816
2817 DatasetUri string `json:"datasetUri,omitempty"`
2818
2819
2820
2821
2822
2823
2824 Force bool `json:"force,omitempty"`
2825
2826 SchemaConfig *SchemaConfig `json:"schemaConfig,omitempty"`
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838 WriteDisposition string `json:"writeDisposition,omitempty"`
2839
2840
2841
2842
2843
2844 ForceSendFields []string `json:"-"`
2845
2846
2847
2848
2849 NullFields []string `json:"-"`
2850 }
2851
2852 func (s *GoogleCloudHealthcareV1FhirBigQueryDestination) MarshalJSON() ([]byte, error) {
2853 type NoMethod GoogleCloudHealthcareV1FhirBigQueryDestination
2854 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2855 }
2856
2857
2858
2859 type GoogleCloudHealthcareV1FhirGcsDestination struct {
2860
2861
2862
2863
2864
2865 UriPrefix string `json:"uriPrefix,omitempty"`
2866
2867
2868
2869
2870
2871 ForceSendFields []string `json:"-"`
2872
2873
2874
2875
2876 NullFields []string `json:"-"`
2877 }
2878
2879 func (s *GoogleCloudHealthcareV1FhirGcsDestination) MarshalJSON() ([]byte, error) {
2880 type NoMethod GoogleCloudHealthcareV1FhirGcsDestination
2881 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2882 }
2883
2884
2885
2886 type GoogleCloudHealthcareV1FhirGcsSource struct {
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899 Uri string `json:"uri,omitempty"`
2900
2901
2902
2903
2904
2905 ForceSendFields []string `json:"-"`
2906
2907
2908
2909
2910 NullFields []string `json:"-"`
2911 }
2912
2913 func (s *GoogleCloudHealthcareV1FhirGcsSource) MarshalJSON() ([]byte, error) {
2914 type NoMethod GoogleCloudHealthcareV1FhirGcsSource
2915 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2916 }
2917
2918
2919 type GroupOrSegment struct {
2920 Group *SchemaGroup `json:"group,omitempty"`
2921 Segment *SchemaSegment `json:"segment,omitempty"`
2922
2923
2924
2925
2926
2927 ForceSendFields []string `json:"-"`
2928
2929
2930
2931
2932 NullFields []string `json:"-"`
2933 }
2934
2935 func (s *GroupOrSegment) MarshalJSON() ([]byte, error) {
2936 type NoMethod GroupOrSegment
2937 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2938 }
2939
2940
2941
2942
2943 type Hl7SchemaConfig struct {
2944
2945
2946 MessageSchemaConfigs map[string]SchemaGroup `json:"messageSchemaConfigs,omitempty"`
2947
2948
2949 Version []*VersionSource `json:"version,omitempty"`
2950
2951
2952
2953
2954
2955 ForceSendFields []string `json:"-"`
2956
2957
2958
2959
2960 NullFields []string `json:"-"`
2961 }
2962
2963 func (s *Hl7SchemaConfig) MarshalJSON() ([]byte, error) {
2964 type NoMethod Hl7SchemaConfig
2965 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2966 }
2967
2968
2969
2970 type Hl7TypesConfig struct {
2971
2972 Type []*Type `json:"type,omitempty"`
2973
2974
2975 Version []*VersionSource `json:"version,omitempty"`
2976
2977
2978
2979
2980
2981 ForceSendFields []string `json:"-"`
2982
2983
2984
2985
2986 NullFields []string `json:"-"`
2987 }
2988
2989 func (s *Hl7TypesConfig) MarshalJSON() ([]byte, error) {
2990 type NoMethod Hl7TypesConfig
2991 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
2992 }
2993
2994
2995
2996 type Hl7V2NotificationConfig struct {
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037 Filter string `json:"filter,omitempty"`
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053 PubsubTopic string `json:"pubsubTopic,omitempty"`
3054
3055
3056
3057
3058
3059 ForceSendFields []string `json:"-"`
3060
3061
3062
3063
3064 NullFields []string `json:"-"`
3065 }
3066
3067 func (s *Hl7V2NotificationConfig) MarshalJSON() ([]byte, error) {
3068 type NoMethod Hl7V2NotificationConfig
3069 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3070 }
3071
3072
3073 type Hl7V2Store struct {
3074
3075
3076
3077
3078
3079
3080
3081
3082 Labels map[string]string `json:"labels,omitempty"`
3083
3084
3085
3086 Name string `json:"name,omitempty"`
3087
3088
3089
3090
3091 NotificationConfigs []*Hl7V2NotificationConfig `json:"notificationConfigs,omitempty"`
3092
3093
3094 ParserConfig *ParserConfig `json:"parserConfig,omitempty"`
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104 RejectDuplicateMessage bool `json:"rejectDuplicateMessage,omitempty"`
3105
3106
3107 googleapi.ServerResponse `json:"-"`
3108
3109
3110
3111
3112
3113 ForceSendFields []string `json:"-"`
3114
3115
3116
3117
3118 NullFields []string `json:"-"`
3119 }
3120
3121 func (s *Hl7V2Store) MarshalJSON() ([]byte, error) {
3122 type NoMethod Hl7V2Store
3123 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3124 }
3125
3126
3127
3128 type Hl7V2StoreMetric struct {
3129
3130
3131 Count int64 `json:"count,omitempty,string"`
3132
3133
3134 MessageType string `json:"messageType,omitempty"`
3135
3136
3137 StructuredStorageSizeBytes int64 `json:"structuredStorageSizeBytes,omitempty,string"`
3138
3139
3140
3141
3142
3143 ForceSendFields []string `json:"-"`
3144
3145
3146
3147
3148 NullFields []string `json:"-"`
3149 }
3150
3151 func (s *Hl7V2StoreMetric) MarshalJSON() ([]byte, error) {
3152 type NoMethod Hl7V2StoreMetric
3153 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3154 }
3155
3156
3157 type Hl7V2StoreMetrics struct {
3158
3159 Metrics []*Hl7V2StoreMetric `json:"metrics,omitempty"`
3160
3161
3162 Name string `json:"name,omitempty"`
3163
3164
3165 googleapi.ServerResponse `json:"-"`
3166
3167
3168
3169
3170
3171 ForceSendFields []string `json:"-"`
3172
3173
3174
3175
3176 NullFields []string `json:"-"`
3177 }
3178
3179 func (s *Hl7V2StoreMetrics) MarshalJSON() ([]byte, error) {
3180 type NoMethod Hl7V2StoreMetrics
3181 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3182 }
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201 type HttpBody struct {
3202
3203
3204 ContentType string `json:"contentType,omitempty"`
3205
3206 Data string `json:"data,omitempty"`
3207
3208
3209 Extensions []googleapi.RawMessage `json:"extensions,omitempty"`
3210
3211
3212 googleapi.ServerResponse `json:"-"`
3213
3214
3215
3216
3217
3218 ForceSendFields []string `json:"-"`
3219
3220
3221
3222
3223 NullFields []string `json:"-"`
3224 }
3225
3226 func (s *HttpBody) MarshalJSON() ([]byte, error) {
3227 type NoMethod HttpBody
3228 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3229 }
3230
3231
3232 type Image struct {
3233
3234
3235
3236
3237
3238
3239
3240 GcsUri string `json:"gcsUri,omitempty"`
3241
3242
3243
3244 RawBytes string `json:"rawBytes,omitempty"`
3245
3246
3247
3248
3249
3250 ForceSendFields []string `json:"-"`
3251
3252
3253
3254
3255 NullFields []string `json:"-"`
3256 }
3257
3258 func (s *Image) MarshalJSON() ([]byte, error) {
3259 type NoMethod Image
3260 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3261 }
3262
3263
3264 type ImageConfig struct {
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276 TextRedactionMode string `json:"textRedactionMode,omitempty"`
3277
3278
3279
3280
3281
3282 ForceSendFields []string `json:"-"`
3283
3284
3285
3286
3287 NullFields []string `json:"-"`
3288 }
3289
3290 func (s *ImageConfig) MarshalJSON() ([]byte, error) {
3291 type NoMethod ImageConfig
3292 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3293 }
3294
3295
3296
3297
3298
3299 type ImportDicomDataRequest struct {
3300
3301
3302
3303 GcsSource *GoogleCloudHealthcareV1DicomGcsSource `json:"gcsSource,omitempty"`
3304
3305
3306
3307
3308
3309 ForceSendFields []string `json:"-"`
3310
3311
3312
3313
3314 NullFields []string `json:"-"`
3315 }
3316
3317 func (s *ImportDicomDataRequest) MarshalJSON() ([]byte, error) {
3318 type NoMethod ImportDicomDataRequest
3319 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3320 }
3321
3322
3323
3324 type ImportDicomDataResponse struct {
3325 }
3326
3327
3328 type ImportMessagesRequest struct {
3329
3330
3331
3332 GcsSource *GcsSource `json:"gcsSource,omitempty"`
3333
3334
3335
3336
3337
3338 ForceSendFields []string `json:"-"`
3339
3340
3341
3342
3343 NullFields []string `json:"-"`
3344 }
3345
3346 func (s *ImportMessagesRequest) MarshalJSON() ([]byte, error) {
3347 type NoMethod ImportMessagesRequest
3348 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3349 }
3350
3351
3352
3353
3354 type ImportMessagesResponse struct {
3355 }
3356
3357
3358 type ImportResourcesRequest struct {
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373 ContentStructure string `json:"contentStructure,omitempty"`
3374
3375
3376
3377
3378 GcsSource *GoogleCloudHealthcareV1FhirGcsSource `json:"gcsSource,omitempty"`
3379
3380
3381
3382
3383
3384 ForceSendFields []string `json:"-"`
3385
3386
3387
3388
3389 NullFields []string `json:"-"`
3390 }
3391
3392 func (s *ImportResourcesRequest) MarshalJSON() ([]byte, error) {
3393 type NoMethod ImportResourcesRequest
3394 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3395 }
3396
3397
3398
3399
3400 type ImportResourcesResponse struct {
3401 }
3402
3403
3404
3405 type InfoTypeTransformation struct {
3406
3407 CharacterMaskConfig *CharacterMaskConfig `json:"characterMaskConfig,omitempty"`
3408
3409 CryptoHashConfig *CryptoHashConfig `json:"cryptoHashConfig,omitempty"`
3410
3411 DateShiftConfig *DateShiftConfig `json:"dateShiftConfig,omitempty"`
3412
3413
3414 InfoTypes []string `json:"infoTypes,omitempty"`
3415
3416 RedactConfig *RedactConfig `json:"redactConfig,omitempty"`
3417
3418 ReplaceWithInfoTypeConfig *ReplaceWithInfoTypeConfig `json:"replaceWithInfoTypeConfig,omitempty"`
3419
3420
3421
3422
3423
3424 ForceSendFields []string `json:"-"`
3425
3426
3427
3428
3429 NullFields []string `json:"-"`
3430 }
3431
3432 func (s *InfoTypeTransformation) MarshalJSON() ([]byte, error) {
3433 type NoMethod InfoTypeTransformation
3434 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3435 }
3436
3437
3438 type IngestMessageRequest struct {
3439
3440 Message *Message `json:"message,omitempty"`
3441
3442
3443
3444
3445
3446 ForceSendFields []string `json:"-"`
3447
3448
3449
3450
3451 NullFields []string `json:"-"`
3452 }
3453
3454 func (s *IngestMessageRequest) MarshalJSON() ([]byte, error) {
3455 type NoMethod IngestMessageRequest
3456 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3457 }
3458
3459
3460
3461 type IngestMessageResponse struct {
3462
3463 Hl7Ack string `json:"hl7Ack,omitempty"`
3464
3465 Message *Message `json:"message,omitempty"`
3466
3467
3468 googleapi.ServerResponse `json:"-"`
3469
3470
3471
3472
3473
3474 ForceSendFields []string `json:"-"`
3475
3476
3477
3478
3479 NullFields []string `json:"-"`
3480 }
3481
3482 func (s *IngestMessageResponse) MarshalJSON() ([]byte, error) {
3483 type NoMethod IngestMessageResponse
3484 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3485 }
3486
3487
3488
3489
3490
3491
3492
3493 type KmsWrappedCryptoKey struct {
3494
3495
3496
3497
3498 CryptoKey string `json:"cryptoKey,omitempty"`
3499
3500 WrappedKey string `json:"wrappedKey,omitempty"`
3501
3502
3503
3504
3505
3506 ForceSendFields []string `json:"-"`
3507
3508
3509
3510
3511 NullFields []string `json:"-"`
3512 }
3513
3514 func (s *KmsWrappedCryptoKey) MarshalJSON() ([]byte, error) {
3515 type NoMethod KmsWrappedCryptoKey
3516 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3517 }
3518
3519
3520
3521 type LinkedEntity struct {
3522
3523
3524
3525
3526
3527 EntityId string `json:"entityId,omitempty"`
3528
3529
3530
3531
3532
3533 ForceSendFields []string `json:"-"`
3534
3535
3536
3537
3538 NullFields []string `json:"-"`
3539 }
3540
3541 func (s *LinkedEntity) MarshalJSON() ([]byte, error) {
3542 type NoMethod LinkedEntity
3543 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3544 }
3545
3546 type ListAttributeDefinitionsResponse struct {
3547
3548
3549
3550 AttributeDefinitions []*AttributeDefinition `json:"attributeDefinitions,omitempty"`
3551
3552
3553 NextPageToken string `json:"nextPageToken,omitempty"`
3554
3555
3556 googleapi.ServerResponse `json:"-"`
3557
3558
3559
3560
3561
3562 ForceSendFields []string `json:"-"`
3563
3564
3565
3566
3567 NullFields []string `json:"-"`
3568 }
3569
3570 func (s *ListAttributeDefinitionsResponse) MarshalJSON() ([]byte, error) {
3571 type NoMethod ListAttributeDefinitionsResponse
3572 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3573 }
3574
3575 type ListConsentArtifactsResponse struct {
3576
3577
3578
3579 ConsentArtifacts []*ConsentArtifact `json:"consentArtifacts,omitempty"`
3580
3581
3582 NextPageToken string `json:"nextPageToken,omitempty"`
3583
3584
3585 googleapi.ServerResponse `json:"-"`
3586
3587
3588
3589
3590
3591 ForceSendFields []string `json:"-"`
3592
3593
3594
3595
3596 NullFields []string `json:"-"`
3597 }
3598
3599 func (s *ListConsentArtifactsResponse) MarshalJSON() ([]byte, error) {
3600 type NoMethod ListConsentArtifactsResponse
3601 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3602 }
3603
3604 type ListConsentRevisionsResponse struct {
3605
3606
3607
3608 Consents []*Consent `json:"consents,omitempty"`
3609
3610
3611 NextPageToken string `json:"nextPageToken,omitempty"`
3612
3613
3614 googleapi.ServerResponse `json:"-"`
3615
3616
3617
3618
3619
3620 ForceSendFields []string `json:"-"`
3621
3622
3623
3624
3625 NullFields []string `json:"-"`
3626 }
3627
3628 func (s *ListConsentRevisionsResponse) MarshalJSON() ([]byte, error) {
3629 type NoMethod ListConsentRevisionsResponse
3630 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3631 }
3632
3633 type ListConsentStoresResponse struct {
3634
3635
3636
3637 ConsentStores []*ConsentStore `json:"consentStores,omitempty"`
3638
3639
3640 NextPageToken string `json:"nextPageToken,omitempty"`
3641
3642
3643 googleapi.ServerResponse `json:"-"`
3644
3645
3646
3647
3648
3649 ForceSendFields []string `json:"-"`
3650
3651
3652
3653
3654 NullFields []string `json:"-"`
3655 }
3656
3657 func (s *ListConsentStoresResponse) MarshalJSON() ([]byte, error) {
3658 type NoMethod ListConsentStoresResponse
3659 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3660 }
3661
3662 type ListConsentsResponse struct {
3663
3664
3665 Consents []*Consent `json:"consents,omitempty"`
3666
3667
3668 NextPageToken string `json:"nextPageToken,omitempty"`
3669
3670
3671 googleapi.ServerResponse `json:"-"`
3672
3673
3674
3675
3676
3677 ForceSendFields []string `json:"-"`
3678
3679
3680
3681
3682 NullFields []string `json:"-"`
3683 }
3684
3685 func (s *ListConsentsResponse) MarshalJSON() ([]byte, error) {
3686 type NoMethod ListConsentsResponse
3687 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3688 }
3689
3690
3691 type ListDatasetsResponse struct {
3692
3693 Datasets []*Dataset `json:"datasets,omitempty"`
3694
3695
3696 NextPageToken string `json:"nextPageToken,omitempty"`
3697
3698
3699 googleapi.ServerResponse `json:"-"`
3700
3701
3702
3703
3704
3705 ForceSendFields []string `json:"-"`
3706
3707
3708
3709
3710 NullFields []string `json:"-"`
3711 }
3712
3713 func (s *ListDatasetsResponse) MarshalJSON() ([]byte, error) {
3714 type NoMethod ListDatasetsResponse
3715 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3716 }
3717
3718
3719 type ListDicomStoresResponse struct {
3720
3721
3722 DicomStores []*DicomStore `json:"dicomStores,omitempty"`
3723
3724
3725 NextPageToken string `json:"nextPageToken,omitempty"`
3726
3727
3728 googleapi.ServerResponse `json:"-"`
3729
3730
3731
3732
3733
3734 ForceSendFields []string `json:"-"`
3735
3736
3737
3738
3739 NullFields []string `json:"-"`
3740 }
3741
3742 func (s *ListDicomStoresResponse) MarshalJSON() ([]byte, error) {
3743 type NoMethod ListDicomStoresResponse
3744 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3745 }
3746
3747
3748 type ListFhirStoresResponse struct {
3749
3750
3751 FhirStores []*FhirStore `json:"fhirStores,omitempty"`
3752
3753
3754 NextPageToken string `json:"nextPageToken,omitempty"`
3755
3756
3757 googleapi.ServerResponse `json:"-"`
3758
3759
3760
3761
3762
3763 ForceSendFields []string `json:"-"`
3764
3765
3766
3767
3768 NullFields []string `json:"-"`
3769 }
3770
3771 func (s *ListFhirStoresResponse) MarshalJSON() ([]byte, error) {
3772 type NoMethod ListFhirStoresResponse
3773 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3774 }
3775
3776
3777 type ListHl7V2StoresResponse struct {
3778
3779
3780 Hl7V2Stores []*Hl7V2Store `json:"hl7V2Stores,omitempty"`
3781
3782
3783 NextPageToken string `json:"nextPageToken,omitempty"`
3784
3785
3786 googleapi.ServerResponse `json:"-"`
3787
3788
3789
3790
3791
3792 ForceSendFields []string `json:"-"`
3793
3794
3795
3796
3797 NullFields []string `json:"-"`
3798 }
3799
3800 func (s *ListHl7V2StoresResponse) MarshalJSON() ([]byte, error) {
3801 type NoMethod ListHl7V2StoresResponse
3802 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3803 }
3804
3805
3806 type ListLocationsResponse struct {
3807
3808
3809 Locations []*Location `json:"locations,omitempty"`
3810
3811 NextPageToken string `json:"nextPageToken,omitempty"`
3812
3813
3814 googleapi.ServerResponse `json:"-"`
3815
3816
3817
3818
3819
3820 ForceSendFields []string `json:"-"`
3821
3822
3823
3824
3825 NullFields []string `json:"-"`
3826 }
3827
3828 func (s *ListLocationsResponse) MarshalJSON() ([]byte, error) {
3829 type NoMethod ListLocationsResponse
3830 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3831 }
3832
3833
3834 type ListMessagesResponse struct {
3835
3836
3837 Hl7V2Messages []*Message `json:"hl7V2Messages,omitempty"`
3838
3839
3840 NextPageToken string `json:"nextPageToken,omitempty"`
3841
3842
3843 googleapi.ServerResponse `json:"-"`
3844
3845
3846
3847
3848
3849 ForceSendFields []string `json:"-"`
3850
3851
3852
3853
3854 NullFields []string `json:"-"`
3855 }
3856
3857 func (s *ListMessagesResponse) MarshalJSON() ([]byte, error) {
3858 type NoMethod ListMessagesResponse
3859 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3860 }
3861
3862
3863 type ListOperationsResponse struct {
3864
3865 NextPageToken string `json:"nextPageToken,omitempty"`
3866
3867
3868 Operations []*Operation `json:"operations,omitempty"`
3869
3870
3871 googleapi.ServerResponse `json:"-"`
3872
3873
3874
3875
3876
3877 ForceSendFields []string `json:"-"`
3878
3879
3880
3881
3882 NullFields []string `json:"-"`
3883 }
3884
3885 func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) {
3886 type NoMethod ListOperationsResponse
3887 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3888 }
3889
3890 type ListUserDataMappingsResponse struct {
3891
3892
3893 NextPageToken string `json:"nextPageToken,omitempty"`
3894
3895
3896
3897 UserDataMappings []*UserDataMapping `json:"userDataMappings,omitempty"`
3898
3899
3900 googleapi.ServerResponse `json:"-"`
3901
3902
3903
3904
3905
3906 ForceSendFields []string `json:"-"`
3907
3908
3909
3910
3911 NullFields []string `json:"-"`
3912 }
3913
3914 func (s *ListUserDataMappingsResponse) MarshalJSON() ([]byte, error) {
3915 type NoMethod ListUserDataMappingsResponse
3916 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3917 }
3918
3919
3920 type Location struct {
3921
3922
3923 DisplayName string `json:"displayName,omitempty"`
3924
3925
3926 Labels map[string]string `json:"labels,omitempty"`
3927
3928 LocationId string `json:"locationId,omitempty"`
3929
3930
3931 Metadata googleapi.RawMessage `json:"metadata,omitempty"`
3932
3933
3934
3935 Name string `json:"name,omitempty"`
3936
3937
3938 googleapi.ServerResponse `json:"-"`
3939
3940
3941
3942
3943
3944 ForceSendFields []string `json:"-"`
3945
3946
3947
3948
3949 NullFields []string `json:"-"`
3950 }
3951
3952 func (s *Location) MarshalJSON() ([]byte, error) {
3953 type NoMethod Location
3954 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
3955 }
3956
3957
3958
3959
3960 type Message struct {
3961
3962
3963 CreateTime string `json:"createTime,omitempty"`
3964
3965 Data string `json:"data,omitempty"`
3966
3967
3968
3969
3970
3971
3972
3973
3974 Labels map[string]string `json:"labels,omitempty"`
3975
3976 MessageType string `json:"messageType,omitempty"`
3977
3978
3979
3980 Name string `json:"name,omitempty"`
3981
3982 ParsedData *ParsedData `json:"parsedData,omitempty"`
3983
3984
3985 PatientIds []*PatientId `json:"patientIds,omitempty"`
3986
3987
3988 SchematizedData *SchematizedData `json:"schematizedData,omitempty"`
3989
3990 SendFacility string `json:"sendFacility,omitempty"`
3991
3992 SendTime string `json:"sendTime,omitempty"`
3993
3994
3995 googleapi.ServerResponse `json:"-"`
3996
3997
3998
3999
4000
4001 ForceSendFields []string `json:"-"`
4002
4003
4004
4005
4006 NullFields []string `json:"-"`
4007 }
4008
4009 func (s *Message) MarshalJSON() ([]byte, error) {
4010 type NoMethod Message
4011 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4012 }
4013
4014
4015
4016 type NotificationConfig struct {
4017
4018
4019
4020
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034 PubsubTopic string `json:"pubsubTopic,omitempty"`
4035
4036
4037 SendForBulkImport bool `json:"sendForBulkImport,omitempty"`
4038
4039
4040
4041
4042
4043 ForceSendFields []string `json:"-"`
4044
4045
4046
4047
4048 NullFields []string `json:"-"`
4049 }
4050
4051 func (s *NotificationConfig) MarshalJSON() ([]byte, error) {
4052 type NoMethod NotificationConfig
4053 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4054 }
4055
4056
4057
4058 type Operation struct {
4059
4060
4061
4062 Done bool `json:"done,omitempty"`
4063
4064 Error *Status `json:"error,omitempty"`
4065
4066
4067
4068
4069 Metadata googleapi.RawMessage `json:"metadata,omitempty"`
4070
4071
4072
4073 Name string `json:"name,omitempty"`
4074
4075
4076
4077
4078
4079
4080
4081 Response googleapi.RawMessage `json:"response,omitempty"`
4082
4083
4084 googleapi.ServerResponse `json:"-"`
4085
4086
4087
4088
4089
4090 ForceSendFields []string `json:"-"`
4091
4092
4093
4094
4095 NullFields []string `json:"-"`
4096 }
4097
4098 func (s *Operation) MarshalJSON() ([]byte, error) {
4099 type NoMethod Operation
4100 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4101 }
4102
4103
4104
4105
4106 type OperationMetadata struct {
4107
4108 ApiMethodName string `json:"apiMethodName,omitempty"`
4109
4110 CancelRequested bool `json:"cancelRequested,omitempty"`
4111 Counter *ProgressCounter `json:"counter,omitempty"`
4112
4113 CreateTime string `json:"createTime,omitempty"`
4114
4115 EndTime string `json:"endTime,omitempty"`
4116
4117
4118
4119 LogsUrl string `json:"logsUrl,omitempty"`
4120
4121
4122
4123
4124
4125 ForceSendFields []string `json:"-"`
4126
4127
4128
4129
4130 NullFields []string `json:"-"`
4131 }
4132
4133 func (s *OperationMetadata) MarshalJSON() ([]byte, error) {
4134 type NoMethod OperationMetadata
4135 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4136 }
4137
4138
4139 type ParsedData struct {
4140 Segments []*Segment `json:"segments,omitempty"`
4141
4142
4143
4144
4145
4146 ForceSendFields []string `json:"-"`
4147
4148
4149
4150
4151 NullFields []string `json:"-"`
4152 }
4153
4154 func (s *ParsedData) MarshalJSON() ([]byte, error) {
4155 type NoMethod ParsedData
4156 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4157 }
4158
4159
4160
4161 type ParserConfig struct {
4162
4163 AllowNullHeader bool `json:"allowNullHeader,omitempty"`
4164
4165
4166 Schema *SchemaPackage `json:"schema,omitempty"`
4167
4168
4169
4170 SegmentTerminator string `json:"segmentTerminator,omitempty"`
4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189 Version string `json:"version,omitempty"`
4190
4191
4192
4193
4194
4195 ForceSendFields []string `json:"-"`
4196
4197
4198
4199
4200 NullFields []string `json:"-"`
4201 }
4202
4203 func (s *ParserConfig) MarshalJSON() ([]byte, error) {
4204 type NoMethod ParserConfig
4205 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4206 }
4207
4208
4209 type PatientId struct {
4210
4211 Type string `json:"type,omitempty"`
4212
4213 Value string `json:"value,omitempty"`
4214
4215
4216
4217
4218
4219 ForceSendFields []string `json:"-"`
4220
4221
4222
4223
4224 NullFields []string `json:"-"`
4225 }
4226
4227 func (s *PatientId) MarshalJSON() ([]byte, error) {
4228 type NoMethod PatientId
4229 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4230 }
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
4242
4243
4244
4245
4246
4247
4248
4249
4250
4251
4252
4253
4254
4255
4256
4257
4258
4259
4260
4261
4262 type Policy struct {
4263
4264 AuditConfigs []*AuditConfig `json:"auditConfigs,omitempty"`
4265
4266
4267
4268
4269
4270
4271
4272
4273
4274 Bindings []*Binding `json:"bindings,omitempty"`
4275
4276
4277
4278
4279
4280
4281
4282
4283
4284
4285
4286 Etag string `json:"etag,omitempty"`
4287
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297
4298
4299
4300
4301
4302 Version int64 `json:"version,omitempty"`
4303
4304
4305 googleapi.ServerResponse `json:"-"`
4306
4307
4308
4309
4310
4311 ForceSendFields []string `json:"-"`
4312
4313
4314
4315
4316 NullFields []string `json:"-"`
4317 }
4318
4319 func (s *Policy) MarshalJSON() ([]byte, error) {
4320 type NoMethod Policy
4321 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4322 }
4323
4324
4325
4326 type ProgressCounter struct {
4327
4328 Failure int64 `json:"failure,omitempty,string"`
4329
4330 Pending int64 `json:"pending,omitempty,string"`
4331
4332 Success int64 `json:"success,omitempty,string"`
4333
4334
4335
4336
4337
4338 ForceSendFields []string `json:"-"`
4339
4340
4341
4342
4343 NullFields []string `json:"-"`
4344 }
4345
4346 func (s *ProgressCounter) MarshalJSON() ([]byte, error) {
4347 type NoMethod ProgressCounter
4348 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4349 }
4350
4351
4352
4353
4354 type PubsubDestination struct {
4355
4356
4357
4358
4359
4360
4361
4362
4363
4364
4365
4366 PubsubTopic string `json:"pubsubTopic,omitempty"`
4367
4368
4369
4370
4371
4372 ForceSendFields []string `json:"-"`
4373
4374
4375
4376
4377 NullFields []string `json:"-"`
4378 }
4379
4380 func (s *PubsubDestination) MarshalJSON() ([]byte, error) {
4381 type NoMethod PubsubDestination
4382 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4383 }
4384
4385
4386
4387
4388
4389
4390
4391
4392 type QueryAccessibleDataRequest struct {
4393
4394
4395
4396 GcsDestination *GoogleCloudHealthcareV1ConsentGcsDestination `json:"gcsDestination,omitempty"`
4397
4398
4399 RequestAttributes map[string]string `json:"requestAttributes,omitempty"`
4400
4401
4402
4403 ResourceAttributes map[string]string `json:"resourceAttributes,omitempty"`
4404
4405
4406
4407
4408
4409 ForceSendFields []string `json:"-"`
4410
4411
4412
4413
4414 NullFields []string `json:"-"`
4415 }
4416
4417 func (s *QueryAccessibleDataRequest) MarshalJSON() ([]byte, error) {
4418 type NoMethod QueryAccessibleDataRequest
4419 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4420 }
4421
4422
4423
4424
4425 type QueryAccessibleDataResponse struct {
4426
4427
4428 GcsUris []string `json:"gcsUris,omitempty"`
4429
4430
4431
4432
4433
4434 ForceSendFields []string `json:"-"`
4435
4436
4437
4438
4439 NullFields []string `json:"-"`
4440 }
4441
4442 func (s *QueryAccessibleDataResponse) MarshalJSON() ([]byte, error) {
4443 type NoMethod QueryAccessibleDataResponse
4444 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4445 }
4446
4447
4448
4449 type RedactConfig struct {
4450 }
4451
4452
4453
4454
4455
4456 type RejectConsentRequest struct {
4457
4458
4459
4460
4461
4462
4463 ConsentArtifact string `json:"consentArtifact,omitempty"`
4464
4465
4466
4467
4468
4469 ForceSendFields []string `json:"-"`
4470
4471
4472
4473
4474 NullFields []string `json:"-"`
4475 }
4476
4477 func (s *RejectConsentRequest) MarshalJSON() ([]byte, error) {
4478 type NoMethod RejectConsentRequest
4479 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4480 }
4481
4482
4483
4484
4485
4486 type ReplaceWithInfoTypeConfig struct {
4487 }
4488
4489
4490 type Resources struct {
4491
4492 Resources []string `json:"resources,omitempty"`
4493
4494
4495
4496
4497
4498 ForceSendFields []string `json:"-"`
4499
4500
4501
4502
4503 NullFields []string `json:"-"`
4504 }
4505
4506 func (s *Resources) MarshalJSON() ([]byte, error) {
4507 type NoMethod Resources
4508 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4509 }
4510
4511
4512 type Result struct {
4513
4514
4515 ConsentDetails map[string]ConsentEvaluation `json:"consentDetails,omitempty"`
4516
4517 Consented bool `json:"consented,omitempty"`
4518
4519 DataId string `json:"dataId,omitempty"`
4520
4521
4522
4523
4524
4525 ForceSendFields []string `json:"-"`
4526
4527
4528
4529
4530 NullFields []string `json:"-"`
4531 }
4532
4533 func (s *Result) MarshalJSON() ([]byte, error) {
4534 type NoMethod Result
4535 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4536 }
4537
4538
4539
4540
4541
4542 type RevokeConsentRequest struct {
4543
4544
4545
4546
4547 ConsentArtifact string `json:"consentArtifact,omitempty"`
4548
4549
4550
4551
4552
4553 ForceSendFields []string `json:"-"`
4554
4555
4556
4557
4558 NullFields []string `json:"-"`
4559 }
4560
4561 func (s *RevokeConsentRequest) MarshalJSON() ([]byte, error) {
4562 type NoMethod RevokeConsentRequest
4563 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4564 }
4565
4566 type RollbackFhirResourceFilteringFields struct {
4567
4568
4569
4570
4571
4572
4573
4574 MetadataFilter string `json:"metadataFilter,omitempty"`
4575
4576 OperationIds googleapi.Uint64s `json:"operationIds,omitempty"`
4577
4578
4579
4580
4581
4582 ForceSendFields []string `json:"-"`
4583
4584
4585
4586
4587 NullFields []string `json:"-"`
4588 }
4589
4590 func (s *RollbackFhirResourceFilteringFields) MarshalJSON() ([]byte, error) {
4591 type NoMethod RollbackFhirResourceFilteringFields
4592 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4593 }
4594
4595 type RollbackFhirResourcesRequest struct {
4596
4597
4598
4599
4600
4601
4602
4603
4604
4605 ChangeType string `json:"changeType,omitempty"`
4606
4607 ExcludeRollbacks bool `json:"excludeRollbacks,omitempty"`
4608
4609 FilteringFields *RollbackFhirResourceFilteringFields `json:"filteringFields,omitempty"`
4610
4611
4612 Force bool `json:"force,omitempty"`
4613
4614
4615 InputGcsObject string `json:"inputGcsObject,omitempty"`
4616
4617 ResultGcsBucket string `json:"resultGcsBucket,omitempty"`
4618
4619 RollbackTime string `json:"rollbackTime,omitempty"`
4620
4621 Type []string `json:"type,omitempty"`
4622
4623
4624
4625
4626
4627 ForceSendFields []string `json:"-"`
4628
4629
4630
4631
4632 NullFields []string `json:"-"`
4633 }
4634
4635 func (s *RollbackFhirResourcesRequest) MarshalJSON() ([]byte, error) {
4636 type NoMethod RollbackFhirResourcesRequest
4637 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4638 }
4639
4640
4641
4642 type RollbackFhirResourcesResponse struct {
4643
4644
4645
4646 FhirStore string `json:"fhirStore,omitempty"`
4647
4648
4649
4650
4651
4652 ForceSendFields []string `json:"-"`
4653
4654
4655
4656
4657 NullFields []string `json:"-"`
4658 }
4659
4660 func (s *RollbackFhirResourcesResponse) MarshalJSON() ([]byte, error) {
4661 type NoMethod RollbackFhirResourcesResponse
4662 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4663 }
4664
4665
4666
4667 type SchemaConfig struct {
4668
4669
4670 LastUpdatedPartitionConfig *TimePartitioning `json:"lastUpdatedPartitionConfig,omitempty"`
4671
4672
4673
4674
4675
4676
4677 RecursiveStructureDepth int64 `json:"recursiveStructureDepth,omitempty,string"`
4678
4679
4680
4681
4682
4683
4684
4685
4686
4687
4688
4689
4690
4691
4692
4693
4694
4695
4696
4697
4698
4699
4700 SchemaType string `json:"schemaType,omitempty"`
4701
4702
4703
4704
4705
4706 ForceSendFields []string `json:"-"`
4707
4708
4709
4710
4711 NullFields []string `json:"-"`
4712 }
4713
4714 func (s *SchemaConfig) MarshalJSON() ([]byte, error) {
4715 type NoMethod SchemaConfig
4716 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4717 }
4718
4719
4720 type SchemaGroup struct {
4721
4722
4723 Choice bool `json:"choice,omitempty"`
4724
4725
4726 MaxOccurs int64 `json:"maxOccurs,omitempty"`
4727
4728 Members []*GroupOrSegment `json:"members,omitempty"`
4729
4730 MinOccurs int64 `json:"minOccurs,omitempty"`
4731
4732 Name string `json:"name,omitempty"`
4733
4734
4735
4736
4737
4738 ForceSendFields []string `json:"-"`
4739
4740
4741
4742
4743 NullFields []string `json:"-"`
4744 }
4745
4746 func (s *SchemaGroup) MarshalJSON() ([]byte, error) {
4747 type NoMethod SchemaGroup
4748 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4749 }
4750
4751
4752
4753 type SchemaPackage struct {
4754
4755
4756
4757 IgnoreMinOccurs bool `json:"ignoreMinOccurs,omitempty"`
4758
4759
4760
4761
4762 Schemas []*Hl7SchemaConfig `json:"schemas,omitempty"`
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773 SchematizedParsingType string `json:"schematizedParsingType,omitempty"`
4774
4775
4776
4777
4778 Types []*Hl7TypesConfig `json:"types,omitempty"`
4779
4780
4781
4782
4783
4784
4785
4786
4787
4788
4789
4790 UnexpectedSegmentHandling string `json:"unexpectedSegmentHandling,omitempty"`
4791
4792
4793
4794
4795
4796 ForceSendFields []string `json:"-"`
4797
4798
4799
4800
4801 NullFields []string `json:"-"`
4802 }
4803
4804 func (s *SchemaPackage) MarshalJSON() ([]byte, error) {
4805 type NoMethod SchemaPackage
4806 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4807 }
4808
4809
4810 type SchemaSegment struct {
4811
4812
4813 MaxOccurs int64 `json:"maxOccurs,omitempty"`
4814
4815
4816 MinOccurs int64 `json:"minOccurs,omitempty"`
4817
4818 Type string `json:"type,omitempty"`
4819
4820
4821
4822
4823
4824 ForceSendFields []string `json:"-"`
4825
4826
4827
4828
4829 NullFields []string `json:"-"`
4830 }
4831
4832 func (s *SchemaSegment) MarshalJSON() ([]byte, error) {
4833 type NoMethod SchemaSegment
4834 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4835 }
4836
4837
4838
4839 type SchematizedData struct {
4840
4841 Data string `json:"data,omitempty"`
4842
4843 Error string `json:"error,omitempty"`
4844
4845
4846
4847
4848
4849 ForceSendFields []string `json:"-"`
4850
4851
4852
4853
4854 NullFields []string `json:"-"`
4855 }
4856
4857 func (s *SchematizedData) MarshalJSON() ([]byte, error) {
4858 type NoMethod SchematizedData
4859 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4860 }
4861
4862
4863
4864 type SearchResourcesRequest struct {
4865
4866
4867
4868
4869
4870 ResourceType string `json:"resourceType,omitempty"`
4871
4872
4873
4874
4875
4876 ForceSendFields []string `json:"-"`
4877
4878
4879
4880
4881 NullFields []string `json:"-"`
4882 }
4883
4884 func (s *SearchResourcesRequest) MarshalJSON() ([]byte, error) {
4885 type NoMethod SearchResourcesRequest
4886 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4887 }
4888
4889
4890 type Segment struct {
4891
4892
4893
4894
4895
4896
4897
4898
4899
4900 Fields map[string]string `json:"fields,omitempty"`
4901
4902
4903 SegmentId string `json:"segmentId,omitempty"`
4904
4905
4906 SetId string `json:"setId,omitempty"`
4907
4908
4909
4910
4911
4912 ForceSendFields []string `json:"-"`
4913
4914
4915
4916
4917 NullFields []string `json:"-"`
4918 }
4919
4920 func (s *Segment) MarshalJSON() ([]byte, error) {
4921 type NoMethod Segment
4922 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4923 }
4924
4925
4926 type SeriesMetrics struct {
4927
4928
4929 BlobStorageSizeBytes int64 `json:"blobStorageSizeBytes,omitempty,string"`
4930
4931 InstanceCount int64 `json:"instanceCount,omitempty,string"`
4932
4933
4934
4935 Series string `json:"series,omitempty"`
4936
4937
4938 StructuredStorageSizeBytes int64 `json:"structuredStorageSizeBytes,omitempty,string"`
4939
4940
4941 googleapi.ServerResponse `json:"-"`
4942
4943
4944
4945
4946
4947 ForceSendFields []string `json:"-"`
4948
4949
4950
4951
4952 NullFields []string `json:"-"`
4953 }
4954
4955 func (s *SeriesMetrics) MarshalJSON() ([]byte, error) {
4956 type NoMethod SeriesMetrics
4957 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4958 }
4959
4960
4961 type SetIamPolicyRequest struct {
4962
4963
4964
4965
4966 Policy *Policy `json:"policy,omitempty"`
4967
4968
4969
4970 UpdateMask string `json:"updateMask,omitempty"`
4971
4972
4973
4974
4975
4976 ForceSendFields []string `json:"-"`
4977
4978
4979
4980
4981 NullFields []string `json:"-"`
4982 }
4983
4984 func (s *SetIamPolicyRequest) MarshalJSON() ([]byte, error) {
4985 type NoMethod SetIamPolicyRequest
4986 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
4987 }
4988
4989
4990 type Signature struct {
4991
4992 Image *Image `json:"image,omitempty"`
4993
4994
4995 Metadata map[string]string `json:"metadata,omitempty"`
4996
4997 SignatureTime string `json:"signatureTime,omitempty"`
4998
4999 UserId string `json:"userId,omitempty"`
5000
5001
5002
5003
5004
5005 ForceSendFields []string `json:"-"`
5006
5007
5008
5009
5010 NullFields []string `json:"-"`
5011 }
5012
5013 func (s *Signature) MarshalJSON() ([]byte, error) {
5014 type NoMethod Signature
5015 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5016 }
5017
5018
5019
5020
5021
5022
5023
5024 type Status struct {
5025
5026 Code int64 `json:"code,omitempty"`
5027
5028
5029 Details []googleapi.RawMessage `json:"details,omitempty"`
5030
5031
5032
5033 Message string `json:"message,omitempty"`
5034
5035
5036
5037
5038
5039 ForceSendFields []string `json:"-"`
5040
5041
5042
5043
5044 NullFields []string `json:"-"`
5045 }
5046
5047 func (s *Status) MarshalJSON() ([]byte, error) {
5048 type NoMethod Status
5049 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5050 }
5051
5052
5053 type StreamConfig struct {
5054
5055
5056
5057
5058
5059
5060
5061
5062
5063
5064
5065
5066
5067
5068
5069
5070
5071
5072
5073
5074
5075
5076
5077
5078
5079
5080
5081
5082
5083
5084 BigqueryDestination *GoogleCloudHealthcareV1FhirBigQueryDestination `json:"bigqueryDestination,omitempty"`
5085
5086
5087
5088
5089
5090
5091
5092
5093
5094
5095
5096
5097
5098
5099
5100
5101
5102 DeidentifiedStoreDestination *DeidentifiedStoreDestination `json:"deidentifiedStoreDestination,omitempty"`
5103
5104
5105
5106
5107 ResourceTypes []string `json:"resourceTypes,omitempty"`
5108
5109
5110
5111
5112
5113 ForceSendFields []string `json:"-"`
5114
5115
5116
5117
5118 NullFields []string `json:"-"`
5119 }
5120
5121 func (s *StreamConfig) MarshalJSON() ([]byte, error) {
5122 type NoMethod StreamConfig
5123 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5124 }
5125
5126
5127 type StudyMetrics struct {
5128
5129
5130 BlobStorageSizeBytes int64 `json:"blobStorageSizeBytes,omitempty,string"`
5131
5132 InstanceCount int64 `json:"instanceCount,omitempty,string"`
5133
5134 SeriesCount int64 `json:"seriesCount,omitempty,string"`
5135
5136
5137 StructuredStorageSizeBytes int64 `json:"structuredStorageSizeBytes,omitempty,string"`
5138
5139
5140
5141 Study string `json:"study,omitempty"`
5142
5143
5144 googleapi.ServerResponse `json:"-"`
5145
5146
5147
5148
5149
5150 ForceSendFields []string `json:"-"`
5151
5152
5153
5154
5155 NullFields []string `json:"-"`
5156 }
5157
5158 func (s *StudyMetrics) MarshalJSON() ([]byte, error) {
5159 type NoMethod StudyMetrics
5160 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5161 }
5162
5163
5164 type TagFilterList struct {
5165
5166
5167
5168
5169
5170 Tags []string `json:"tags,omitempty"`
5171
5172
5173
5174
5175
5176 ForceSendFields []string `json:"-"`
5177
5178
5179
5180
5181 NullFields []string `json:"-"`
5182 }
5183
5184 func (s *TagFilterList) MarshalJSON() ([]byte, error) {
5185 type NoMethod TagFilterList
5186 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5187 }
5188
5189
5190 type TestIamPermissionsRequest struct {
5191
5192
5193
5194
5195 Permissions []string `json:"permissions,omitempty"`
5196
5197
5198
5199
5200
5201 ForceSendFields []string `json:"-"`
5202
5203
5204
5205
5206 NullFields []string `json:"-"`
5207 }
5208
5209 func (s *TestIamPermissionsRequest) MarshalJSON() ([]byte, error) {
5210 type NoMethod TestIamPermissionsRequest
5211 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5212 }
5213
5214
5215
5216 type TestIamPermissionsResponse struct {
5217
5218
5219 Permissions []string `json:"permissions,omitempty"`
5220
5221
5222 googleapi.ServerResponse `json:"-"`
5223
5224
5225
5226
5227
5228 ForceSendFields []string `json:"-"`
5229
5230
5231
5232
5233 NullFields []string `json:"-"`
5234 }
5235
5236 func (s *TestIamPermissionsResponse) MarshalJSON() ([]byte, error) {
5237 type NoMethod TestIamPermissionsResponse
5238 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5239 }
5240
5241 type TextConfig struct {
5242
5243
5244 AdditionalTransformations []*InfoTypeTransformation `json:"additionalTransformations,omitempty"`
5245
5246
5247 ExcludeInfoTypes []string `json:"excludeInfoTypes,omitempty"`
5248
5249
5250 Transformations []*InfoTypeTransformation `json:"transformations,omitempty"`
5251
5252
5253
5254
5255
5256 ForceSendFields []string `json:"-"`
5257
5258
5259
5260
5261 NullFields []string `json:"-"`
5262 }
5263
5264 func (s *TextConfig) MarshalJSON() ([]byte, error) {
5265 type NoMethod TextConfig
5266 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5267 }
5268
5269
5270 type TextSpan struct {
5271
5272 BeginOffset int64 `json:"beginOffset,omitempty"`
5273
5274 Content string `json:"content,omitempty"`
5275
5276
5277
5278
5279
5280 ForceSendFields []string `json:"-"`
5281
5282
5283
5284
5285 NullFields []string `json:"-"`
5286 }
5287
5288 func (s *TextSpan) MarshalJSON() ([]byte, error) {
5289 type NoMethod TextSpan
5290 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5291 }
5292
5293
5294 type TimePartitioning struct {
5295
5296
5297 ExpirationMs int64 `json:"expirationMs,omitempty,string"`
5298
5299
5300
5301
5302
5303
5304
5305
5306 Type string `json:"type,omitempty"`
5307
5308
5309
5310
5311
5312 ForceSendFields []string `json:"-"`
5313
5314
5315
5316
5317 NullFields []string `json:"-"`
5318 }
5319
5320 func (s *TimePartitioning) MarshalJSON() ([]byte, error) {
5321 type NoMethod TimePartitioning
5322 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5323 }
5324
5325
5326 type Type struct {
5327
5328 Fields []*Field `json:"fields,omitempty"`
5329
5330
5331 Name string `json:"name,omitempty"`
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341 Primitive string `json:"primitive,omitempty"`
5342
5343
5344
5345
5346
5347 ForceSendFields []string `json:"-"`
5348
5349
5350
5351
5352 NullFields []string `json:"-"`
5353 }
5354
5355 func (s *Type) MarshalJSON() ([]byte, error) {
5356 type NoMethod Type
5357 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5358 }
5359
5360
5361 type UserDataMapping struct {
5362
5363 ArchiveTime string `json:"archiveTime,omitempty"`
5364
5365 Archived bool `json:"archived,omitempty"`
5366
5367 DataId string `json:"dataId,omitempty"`
5368
5369
5370
5371 Name string `json:"name,omitempty"`
5372
5373
5374
5375
5376
5377 ResourceAttributes []*Attribute `json:"resourceAttributes,omitempty"`
5378
5379 UserId string `json:"userId,omitempty"`
5380
5381
5382 googleapi.ServerResponse `json:"-"`
5383
5384
5385
5386
5387
5388 ForceSendFields []string `json:"-"`
5389
5390
5391
5392
5393 NullFields []string `json:"-"`
5394 }
5395
5396 func (s *UserDataMapping) MarshalJSON() ([]byte, error) {
5397 type NoMethod UserDataMapping
5398 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5399 }
5400
5401
5402
5403 type ValidationConfig struct {
5404
5405
5406
5407
5408
5409
5410 DisableFhirpathValidation bool `json:"disableFhirpathValidation,omitempty"`
5411
5412
5413
5414 DisableProfileValidation bool `json:"disableProfileValidation,omitempty"`
5415
5416
5417
5418
5419
5420
5421 DisableReferenceTypeValidation bool `json:"disableReferenceTypeValidation,omitempty"`
5422
5423
5424
5425
5426
5427
5428 DisableRequiredFieldValidation bool `json:"disableRequiredFieldValidation,omitempty"`
5429
5430
5431
5432
5433
5434
5435
5436
5437
5438
5439
5440
5441
5442
5443 EnabledImplementationGuides []string `json:"enabledImplementationGuides,omitempty"`
5444
5445
5446
5447
5448
5449 ForceSendFields []string `json:"-"`
5450
5451
5452
5453
5454 NullFields []string `json:"-"`
5455 }
5456
5457 func (s *ValidationConfig) MarshalJSON() ([]byte, error) {
5458 type NoMethod ValidationConfig
5459 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5460 }
5461
5462
5463
5464 type VersionSource struct {
5465
5466
5467 MshField string `json:"mshField,omitempty"`
5468
5469
5470 Value string `json:"value,omitempty"`
5471
5472
5473
5474
5475
5476 ForceSendFields []string `json:"-"`
5477
5478
5479
5480
5481 NullFields []string `json:"-"`
5482 }
5483
5484 func (s *VersionSource) MarshalJSON() ([]byte, error) {
5485 type NoMethod VersionSource
5486 return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
5487 }
5488
5489 type ProjectsLocationsGetCall struct {
5490 s *Service
5491 name string
5492 urlParams_ gensupport.URLParams
5493 ifNoneMatch_ string
5494 ctx_ context.Context
5495 header_ http.Header
5496 }
5497
5498
5499
5500
5501 func (r *ProjectsLocationsService) Get(name string) *ProjectsLocationsGetCall {
5502 c := &ProjectsLocationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5503 c.name = name
5504 return c
5505 }
5506
5507
5508
5509
5510 func (c *ProjectsLocationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsGetCall {
5511 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5512 return c
5513 }
5514
5515
5516
5517
5518 func (c *ProjectsLocationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsGetCall {
5519 c.ifNoneMatch_ = entityTag
5520 return c
5521 }
5522
5523
5524 func (c *ProjectsLocationsGetCall) Context(ctx context.Context) *ProjectsLocationsGetCall {
5525 c.ctx_ = ctx
5526 return c
5527 }
5528
5529
5530
5531 func (c *ProjectsLocationsGetCall) Header() http.Header {
5532 if c.header_ == nil {
5533 c.header_ = make(http.Header)
5534 }
5535 return c.header_
5536 }
5537
5538 func (c *ProjectsLocationsGetCall) doRequest(alt string) (*http.Response, error) {
5539 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5540 if c.ifNoneMatch_ != "" {
5541 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5542 }
5543 var body io.Reader = nil
5544 c.urlParams_.Set("alt", alt)
5545 c.urlParams_.Set("prettyPrint", "false")
5546 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
5547 urls += "?" + c.urlParams_.Encode()
5548 req, err := http.NewRequest("GET", urls, body)
5549 if err != nil {
5550 return nil, err
5551 }
5552 req.Header = reqHeaders
5553 googleapi.Expand(req.URL, map[string]string{
5554 "name": c.name,
5555 })
5556 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5557 }
5558
5559
5560
5561
5562
5563
5564 func (c *ProjectsLocationsGetCall) Do(opts ...googleapi.CallOption) (*Location, error) {
5565 gensupport.SetOptions(c.urlParams_, opts...)
5566 res, err := c.doRequest("json")
5567 if res != nil && res.StatusCode == http.StatusNotModified {
5568 if res.Body != nil {
5569 res.Body.Close()
5570 }
5571 return nil, gensupport.WrapError(&googleapi.Error{
5572 Code: res.StatusCode,
5573 Header: res.Header,
5574 })
5575 }
5576 if err != nil {
5577 return nil, err
5578 }
5579 defer googleapi.CloseBody(res)
5580 if err := googleapi.CheckResponse(res); err != nil {
5581 return nil, gensupport.WrapError(err)
5582 }
5583 ret := &Location{
5584 ServerResponse: googleapi.ServerResponse{
5585 Header: res.Header,
5586 HTTPStatusCode: res.StatusCode,
5587 },
5588 }
5589 target := &ret
5590 if err := gensupport.DecodeResponse(target, res); err != nil {
5591 return nil, err
5592 }
5593 return ret, nil
5594 }
5595
5596 type ProjectsLocationsListCall struct {
5597 s *Service
5598 name string
5599 urlParams_ gensupport.URLParams
5600 ifNoneMatch_ string
5601 ctx_ context.Context
5602 header_ http.Header
5603 }
5604
5605
5606
5607
5608 func (r *ProjectsLocationsService) List(name string) *ProjectsLocationsListCall {
5609 c := &ProjectsLocationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5610 c.name = name
5611 return c
5612 }
5613
5614
5615
5616
5617
5618 func (c *ProjectsLocationsListCall) Filter(filter string) *ProjectsLocationsListCall {
5619 c.urlParams_.Set("filter", filter)
5620 return c
5621 }
5622
5623
5624
5625 func (c *ProjectsLocationsListCall) PageSize(pageSize int64) *ProjectsLocationsListCall {
5626 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
5627 return c
5628 }
5629
5630
5631
5632
5633 func (c *ProjectsLocationsListCall) PageToken(pageToken string) *ProjectsLocationsListCall {
5634 c.urlParams_.Set("pageToken", pageToken)
5635 return c
5636 }
5637
5638
5639
5640
5641 func (c *ProjectsLocationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsListCall {
5642 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5643 return c
5644 }
5645
5646
5647
5648
5649 func (c *ProjectsLocationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsListCall {
5650 c.ifNoneMatch_ = entityTag
5651 return c
5652 }
5653
5654
5655 func (c *ProjectsLocationsListCall) Context(ctx context.Context) *ProjectsLocationsListCall {
5656 c.ctx_ = ctx
5657 return c
5658 }
5659
5660
5661
5662 func (c *ProjectsLocationsListCall) Header() http.Header {
5663 if c.header_ == nil {
5664 c.header_ = make(http.Header)
5665 }
5666 return c.header_
5667 }
5668
5669 func (c *ProjectsLocationsListCall) doRequest(alt string) (*http.Response, error) {
5670 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
5671 if c.ifNoneMatch_ != "" {
5672 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
5673 }
5674 var body io.Reader = nil
5675 c.urlParams_.Set("alt", alt)
5676 c.urlParams_.Set("prettyPrint", "false")
5677 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/locations")
5678 urls += "?" + c.urlParams_.Encode()
5679 req, err := http.NewRequest("GET", urls, body)
5680 if err != nil {
5681 return nil, err
5682 }
5683 req.Header = reqHeaders
5684 googleapi.Expand(req.URL, map[string]string{
5685 "name": c.name,
5686 })
5687 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5688 }
5689
5690
5691
5692
5693
5694
5695
5696 func (c *ProjectsLocationsListCall) Do(opts ...googleapi.CallOption) (*ListLocationsResponse, error) {
5697 gensupport.SetOptions(c.urlParams_, opts...)
5698 res, err := c.doRequest("json")
5699 if res != nil && res.StatusCode == http.StatusNotModified {
5700 if res.Body != nil {
5701 res.Body.Close()
5702 }
5703 return nil, gensupport.WrapError(&googleapi.Error{
5704 Code: res.StatusCode,
5705 Header: res.Header,
5706 })
5707 }
5708 if err != nil {
5709 return nil, err
5710 }
5711 defer googleapi.CloseBody(res)
5712 if err := googleapi.CheckResponse(res); err != nil {
5713 return nil, gensupport.WrapError(err)
5714 }
5715 ret := &ListLocationsResponse{
5716 ServerResponse: googleapi.ServerResponse{
5717 Header: res.Header,
5718 HTTPStatusCode: res.StatusCode,
5719 },
5720 }
5721 target := &ret
5722 if err := gensupport.DecodeResponse(target, res); err != nil {
5723 return nil, err
5724 }
5725 return ret, nil
5726 }
5727
5728
5729
5730
5731 func (c *ProjectsLocationsListCall) Pages(ctx context.Context, f func(*ListLocationsResponse) error) error {
5732 c.ctx_ = ctx
5733 defer c.PageToken(c.urlParams_.Get("pageToken"))
5734 for {
5735 x, err := c.Do()
5736 if err != nil {
5737 return err
5738 }
5739 if err := f(x); err != nil {
5740 return err
5741 }
5742 if x.NextPageToken == "" {
5743 return nil
5744 }
5745 c.PageToken(x.NextPageToken)
5746 }
5747 }
5748
5749 type ProjectsLocationsDatasetsCreateCall struct {
5750 s *Service
5751 parent string
5752 dataset *Dataset
5753 urlParams_ gensupport.URLParams
5754 ctx_ context.Context
5755 header_ http.Header
5756 }
5757
5758
5759
5760
5761
5762
5763
5764
5765 func (r *ProjectsLocationsDatasetsService) Create(parent string, dataset *Dataset) *ProjectsLocationsDatasetsCreateCall {
5766 c := &ProjectsLocationsDatasetsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5767 c.parent = parent
5768 c.dataset = dataset
5769 return c
5770 }
5771
5772
5773
5774
5775 func (c *ProjectsLocationsDatasetsCreateCall) DatasetId(datasetId string) *ProjectsLocationsDatasetsCreateCall {
5776 c.urlParams_.Set("datasetId", datasetId)
5777 return c
5778 }
5779
5780
5781
5782
5783 func (c *ProjectsLocationsDatasetsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsCreateCall {
5784 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5785 return c
5786 }
5787
5788
5789 func (c *ProjectsLocationsDatasetsCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsCreateCall {
5790 c.ctx_ = ctx
5791 return c
5792 }
5793
5794
5795
5796 func (c *ProjectsLocationsDatasetsCreateCall) Header() http.Header {
5797 if c.header_ == nil {
5798 c.header_ = make(http.Header)
5799 }
5800 return c.header_
5801 }
5802
5803 func (c *ProjectsLocationsDatasetsCreateCall) doRequest(alt string) (*http.Response, error) {
5804 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5805 var body io.Reader = nil
5806 body, err := googleapi.WithoutDataWrapper.JSONReader(c.dataset)
5807 if err != nil {
5808 return nil, err
5809 }
5810 c.urlParams_.Set("alt", alt)
5811 c.urlParams_.Set("prettyPrint", "false")
5812 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/datasets")
5813 urls += "?" + c.urlParams_.Encode()
5814 req, err := http.NewRequest("POST", urls, body)
5815 if err != nil {
5816 return nil, err
5817 }
5818 req.Header = reqHeaders
5819 googleapi.Expand(req.URL, map[string]string{
5820 "parent": c.parent,
5821 })
5822 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5823 }
5824
5825
5826
5827
5828
5829
5830 func (c *ProjectsLocationsDatasetsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
5831 gensupport.SetOptions(c.urlParams_, opts...)
5832 res, err := c.doRequest("json")
5833 if res != nil && res.StatusCode == http.StatusNotModified {
5834 if res.Body != nil {
5835 res.Body.Close()
5836 }
5837 return nil, gensupport.WrapError(&googleapi.Error{
5838 Code: res.StatusCode,
5839 Header: res.Header,
5840 })
5841 }
5842 if err != nil {
5843 return nil, err
5844 }
5845 defer googleapi.CloseBody(res)
5846 if err := googleapi.CheckResponse(res); err != nil {
5847 return nil, gensupport.WrapError(err)
5848 }
5849 ret := &Operation{
5850 ServerResponse: googleapi.ServerResponse{
5851 Header: res.Header,
5852 HTTPStatusCode: res.StatusCode,
5853 },
5854 }
5855 target := &ret
5856 if err := gensupport.DecodeResponse(target, res); err != nil {
5857 return nil, err
5858 }
5859 return ret, nil
5860 }
5861
5862 type ProjectsLocationsDatasetsDeidentifyCall struct {
5863 s *Service
5864 sourceDataset string
5865 deidentifydatasetrequest *DeidentifyDatasetRequest
5866 urlParams_ gensupport.URLParams
5867 ctx_ context.Context
5868 header_ http.Header
5869 }
5870
5871
5872
5873
5874
5875
5876
5877
5878
5879
5880
5881
5882
5883 func (r *ProjectsLocationsDatasetsService) Deidentify(sourceDataset string, deidentifydatasetrequest *DeidentifyDatasetRequest) *ProjectsLocationsDatasetsDeidentifyCall {
5884 c := &ProjectsLocationsDatasetsDeidentifyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5885 c.sourceDataset = sourceDataset
5886 c.deidentifydatasetrequest = deidentifydatasetrequest
5887 return c
5888 }
5889
5890
5891
5892
5893 func (c *ProjectsLocationsDatasetsDeidentifyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDeidentifyCall {
5894 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5895 return c
5896 }
5897
5898
5899 func (c *ProjectsLocationsDatasetsDeidentifyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDeidentifyCall {
5900 c.ctx_ = ctx
5901 return c
5902 }
5903
5904
5905
5906 func (c *ProjectsLocationsDatasetsDeidentifyCall) Header() http.Header {
5907 if c.header_ == nil {
5908 c.header_ = make(http.Header)
5909 }
5910 return c.header_
5911 }
5912
5913 func (c *ProjectsLocationsDatasetsDeidentifyCall) doRequest(alt string) (*http.Response, error) {
5914 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
5915 var body io.Reader = nil
5916 body, err := googleapi.WithoutDataWrapper.JSONReader(c.deidentifydatasetrequest)
5917 if err != nil {
5918 return nil, err
5919 }
5920 c.urlParams_.Set("alt", alt)
5921 c.urlParams_.Set("prettyPrint", "false")
5922 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+sourceDataset}:deidentify")
5923 urls += "?" + c.urlParams_.Encode()
5924 req, err := http.NewRequest("POST", urls, body)
5925 if err != nil {
5926 return nil, err
5927 }
5928 req.Header = reqHeaders
5929 googleapi.Expand(req.URL, map[string]string{
5930 "sourceDataset": c.sourceDataset,
5931 })
5932 return gensupport.SendRequest(c.ctx_, c.s.client, req)
5933 }
5934
5935
5936
5937
5938
5939
5940 func (c *ProjectsLocationsDatasetsDeidentifyCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
5941 gensupport.SetOptions(c.urlParams_, opts...)
5942 res, err := c.doRequest("json")
5943 if res != nil && res.StatusCode == http.StatusNotModified {
5944 if res.Body != nil {
5945 res.Body.Close()
5946 }
5947 return nil, gensupport.WrapError(&googleapi.Error{
5948 Code: res.StatusCode,
5949 Header: res.Header,
5950 })
5951 }
5952 if err != nil {
5953 return nil, err
5954 }
5955 defer googleapi.CloseBody(res)
5956 if err := googleapi.CheckResponse(res); err != nil {
5957 return nil, gensupport.WrapError(err)
5958 }
5959 ret := &Operation{
5960 ServerResponse: googleapi.ServerResponse{
5961 Header: res.Header,
5962 HTTPStatusCode: res.StatusCode,
5963 },
5964 }
5965 target := &ret
5966 if err := gensupport.DecodeResponse(target, res); err != nil {
5967 return nil, err
5968 }
5969 return ret, nil
5970 }
5971
5972 type ProjectsLocationsDatasetsDeleteCall struct {
5973 s *Service
5974 name string
5975 urlParams_ gensupport.URLParams
5976 ctx_ context.Context
5977 header_ http.Header
5978 }
5979
5980
5981
5982
5983
5984
5985
5986 func (r *ProjectsLocationsDatasetsService) Delete(name string) *ProjectsLocationsDatasetsDeleteCall {
5987 c := &ProjectsLocationsDatasetsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
5988 c.name = name
5989 return c
5990 }
5991
5992
5993
5994
5995 func (c *ProjectsLocationsDatasetsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDeleteCall {
5996 c.urlParams_.Set("fields", googleapi.CombineFields(s))
5997 return c
5998 }
5999
6000
6001 func (c *ProjectsLocationsDatasetsDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDeleteCall {
6002 c.ctx_ = ctx
6003 return c
6004 }
6005
6006
6007
6008 func (c *ProjectsLocationsDatasetsDeleteCall) Header() http.Header {
6009 if c.header_ == nil {
6010 c.header_ = make(http.Header)
6011 }
6012 return c.header_
6013 }
6014
6015 func (c *ProjectsLocationsDatasetsDeleteCall) doRequest(alt string) (*http.Response, error) {
6016 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6017 var body io.Reader = nil
6018 c.urlParams_.Set("alt", alt)
6019 c.urlParams_.Set("prettyPrint", "false")
6020 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
6021 urls += "?" + c.urlParams_.Encode()
6022 req, err := http.NewRequest("DELETE", urls, body)
6023 if err != nil {
6024 return nil, err
6025 }
6026 req.Header = reqHeaders
6027 googleapi.Expand(req.URL, map[string]string{
6028 "name": c.name,
6029 })
6030 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6031 }
6032
6033
6034
6035
6036
6037
6038 func (c *ProjectsLocationsDatasetsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
6039 gensupport.SetOptions(c.urlParams_, opts...)
6040 res, err := c.doRequest("json")
6041 if res != nil && res.StatusCode == http.StatusNotModified {
6042 if res.Body != nil {
6043 res.Body.Close()
6044 }
6045 return nil, gensupport.WrapError(&googleapi.Error{
6046 Code: res.StatusCode,
6047 Header: res.Header,
6048 })
6049 }
6050 if err != nil {
6051 return nil, err
6052 }
6053 defer googleapi.CloseBody(res)
6054 if err := googleapi.CheckResponse(res); err != nil {
6055 return nil, gensupport.WrapError(err)
6056 }
6057 ret := &Empty{
6058 ServerResponse: googleapi.ServerResponse{
6059 Header: res.Header,
6060 HTTPStatusCode: res.StatusCode,
6061 },
6062 }
6063 target := &ret
6064 if err := gensupport.DecodeResponse(target, res); err != nil {
6065 return nil, err
6066 }
6067 return ret, nil
6068 }
6069
6070 type ProjectsLocationsDatasetsGetCall struct {
6071 s *Service
6072 name string
6073 urlParams_ gensupport.URLParams
6074 ifNoneMatch_ string
6075 ctx_ context.Context
6076 header_ http.Header
6077 }
6078
6079
6080
6081
6082
6083 func (r *ProjectsLocationsDatasetsService) Get(name string) *ProjectsLocationsDatasetsGetCall {
6084 c := &ProjectsLocationsDatasetsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6085 c.name = name
6086 return c
6087 }
6088
6089
6090
6091
6092 func (c *ProjectsLocationsDatasetsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsGetCall {
6093 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6094 return c
6095 }
6096
6097
6098
6099
6100 func (c *ProjectsLocationsDatasetsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsGetCall {
6101 c.ifNoneMatch_ = entityTag
6102 return c
6103 }
6104
6105
6106 func (c *ProjectsLocationsDatasetsGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsGetCall {
6107 c.ctx_ = ctx
6108 return c
6109 }
6110
6111
6112
6113 func (c *ProjectsLocationsDatasetsGetCall) Header() http.Header {
6114 if c.header_ == nil {
6115 c.header_ = make(http.Header)
6116 }
6117 return c.header_
6118 }
6119
6120 func (c *ProjectsLocationsDatasetsGetCall) doRequest(alt string) (*http.Response, error) {
6121 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6122 if c.ifNoneMatch_ != "" {
6123 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6124 }
6125 var body io.Reader = nil
6126 c.urlParams_.Set("alt", alt)
6127 c.urlParams_.Set("prettyPrint", "false")
6128 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
6129 urls += "?" + c.urlParams_.Encode()
6130 req, err := http.NewRequest("GET", urls, body)
6131 if err != nil {
6132 return nil, err
6133 }
6134 req.Header = reqHeaders
6135 googleapi.Expand(req.URL, map[string]string{
6136 "name": c.name,
6137 })
6138 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6139 }
6140
6141
6142
6143
6144
6145
6146 func (c *ProjectsLocationsDatasetsGetCall) Do(opts ...googleapi.CallOption) (*Dataset, error) {
6147 gensupport.SetOptions(c.urlParams_, opts...)
6148 res, err := c.doRequest("json")
6149 if res != nil && res.StatusCode == http.StatusNotModified {
6150 if res.Body != nil {
6151 res.Body.Close()
6152 }
6153 return nil, gensupport.WrapError(&googleapi.Error{
6154 Code: res.StatusCode,
6155 Header: res.Header,
6156 })
6157 }
6158 if err != nil {
6159 return nil, err
6160 }
6161 defer googleapi.CloseBody(res)
6162 if err := googleapi.CheckResponse(res); err != nil {
6163 return nil, gensupport.WrapError(err)
6164 }
6165 ret := &Dataset{
6166 ServerResponse: googleapi.ServerResponse{
6167 Header: res.Header,
6168 HTTPStatusCode: res.StatusCode,
6169 },
6170 }
6171 target := &ret
6172 if err := gensupport.DecodeResponse(target, res); err != nil {
6173 return nil, err
6174 }
6175 return ret, nil
6176 }
6177
6178 type ProjectsLocationsDatasetsGetIamPolicyCall struct {
6179 s *Service
6180 resource string
6181 urlParams_ gensupport.URLParams
6182 ifNoneMatch_ string
6183 ctx_ context.Context
6184 header_ http.Header
6185 }
6186
6187
6188
6189
6190
6191
6192
6193 func (r *ProjectsLocationsDatasetsService) GetIamPolicy(resource string) *ProjectsLocationsDatasetsGetIamPolicyCall {
6194 c := &ProjectsLocationsDatasetsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6195 c.resource = resource
6196 return c
6197 }
6198
6199
6200
6201
6202
6203
6204
6205
6206
6207
6208
6209
6210
6211 func (c *ProjectsLocationsDatasetsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDatasetsGetIamPolicyCall {
6212 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
6213 return c
6214 }
6215
6216
6217
6218
6219 func (c *ProjectsLocationsDatasetsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsGetIamPolicyCall {
6220 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6221 return c
6222 }
6223
6224
6225
6226
6227 func (c *ProjectsLocationsDatasetsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsGetIamPolicyCall {
6228 c.ifNoneMatch_ = entityTag
6229 return c
6230 }
6231
6232
6233 func (c *ProjectsLocationsDatasetsGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsGetIamPolicyCall {
6234 c.ctx_ = ctx
6235 return c
6236 }
6237
6238
6239
6240 func (c *ProjectsLocationsDatasetsGetIamPolicyCall) Header() http.Header {
6241 if c.header_ == nil {
6242 c.header_ = make(http.Header)
6243 }
6244 return c.header_
6245 }
6246
6247 func (c *ProjectsLocationsDatasetsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
6248 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6249 if c.ifNoneMatch_ != "" {
6250 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6251 }
6252 var body io.Reader = nil
6253 c.urlParams_.Set("alt", alt)
6254 c.urlParams_.Set("prettyPrint", "false")
6255 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
6256 urls += "?" + c.urlParams_.Encode()
6257 req, err := http.NewRequest("GET", urls, body)
6258 if err != nil {
6259 return nil, err
6260 }
6261 req.Header = reqHeaders
6262 googleapi.Expand(req.URL, map[string]string{
6263 "resource": c.resource,
6264 })
6265 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6266 }
6267
6268
6269
6270
6271
6272
6273 func (c *ProjectsLocationsDatasetsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
6274 gensupport.SetOptions(c.urlParams_, opts...)
6275 res, err := c.doRequest("json")
6276 if res != nil && res.StatusCode == http.StatusNotModified {
6277 if res.Body != nil {
6278 res.Body.Close()
6279 }
6280 return nil, gensupport.WrapError(&googleapi.Error{
6281 Code: res.StatusCode,
6282 Header: res.Header,
6283 })
6284 }
6285 if err != nil {
6286 return nil, err
6287 }
6288 defer googleapi.CloseBody(res)
6289 if err := googleapi.CheckResponse(res); err != nil {
6290 return nil, gensupport.WrapError(err)
6291 }
6292 ret := &Policy{
6293 ServerResponse: googleapi.ServerResponse{
6294 Header: res.Header,
6295 HTTPStatusCode: res.StatusCode,
6296 },
6297 }
6298 target := &ret
6299 if err := gensupport.DecodeResponse(target, res); err != nil {
6300 return nil, err
6301 }
6302 return ret, nil
6303 }
6304
6305 type ProjectsLocationsDatasetsListCall struct {
6306 s *Service
6307 parent string
6308 urlParams_ gensupport.URLParams
6309 ifNoneMatch_ string
6310 ctx_ context.Context
6311 header_ http.Header
6312 }
6313
6314
6315
6316
6317
6318 func (r *ProjectsLocationsDatasetsService) List(parent string) *ProjectsLocationsDatasetsListCall {
6319 c := &ProjectsLocationsDatasetsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6320 c.parent = parent
6321 return c
6322 }
6323
6324
6325
6326 func (c *ProjectsLocationsDatasetsListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsListCall {
6327 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
6328 return c
6329 }
6330
6331
6332
6333 func (c *ProjectsLocationsDatasetsListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsListCall {
6334 c.urlParams_.Set("pageToken", pageToken)
6335 return c
6336 }
6337
6338
6339
6340
6341 func (c *ProjectsLocationsDatasetsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsListCall {
6342 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6343 return c
6344 }
6345
6346
6347
6348
6349 func (c *ProjectsLocationsDatasetsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsListCall {
6350 c.ifNoneMatch_ = entityTag
6351 return c
6352 }
6353
6354
6355 func (c *ProjectsLocationsDatasetsListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsListCall {
6356 c.ctx_ = ctx
6357 return c
6358 }
6359
6360
6361
6362 func (c *ProjectsLocationsDatasetsListCall) Header() http.Header {
6363 if c.header_ == nil {
6364 c.header_ = make(http.Header)
6365 }
6366 return c.header_
6367 }
6368
6369 func (c *ProjectsLocationsDatasetsListCall) doRequest(alt string) (*http.Response, error) {
6370 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
6371 if c.ifNoneMatch_ != "" {
6372 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
6373 }
6374 var body io.Reader = nil
6375 c.urlParams_.Set("alt", alt)
6376 c.urlParams_.Set("prettyPrint", "false")
6377 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/datasets")
6378 urls += "?" + c.urlParams_.Encode()
6379 req, err := http.NewRequest("GET", urls, body)
6380 if err != nil {
6381 return nil, err
6382 }
6383 req.Header = reqHeaders
6384 googleapi.Expand(req.URL, map[string]string{
6385 "parent": c.parent,
6386 })
6387 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6388 }
6389
6390
6391
6392
6393
6394
6395
6396 func (c *ProjectsLocationsDatasetsListCall) Do(opts ...googleapi.CallOption) (*ListDatasetsResponse, error) {
6397 gensupport.SetOptions(c.urlParams_, opts...)
6398 res, err := c.doRequest("json")
6399 if res != nil && res.StatusCode == http.StatusNotModified {
6400 if res.Body != nil {
6401 res.Body.Close()
6402 }
6403 return nil, gensupport.WrapError(&googleapi.Error{
6404 Code: res.StatusCode,
6405 Header: res.Header,
6406 })
6407 }
6408 if err != nil {
6409 return nil, err
6410 }
6411 defer googleapi.CloseBody(res)
6412 if err := googleapi.CheckResponse(res); err != nil {
6413 return nil, gensupport.WrapError(err)
6414 }
6415 ret := &ListDatasetsResponse{
6416 ServerResponse: googleapi.ServerResponse{
6417 Header: res.Header,
6418 HTTPStatusCode: res.StatusCode,
6419 },
6420 }
6421 target := &ret
6422 if err := gensupport.DecodeResponse(target, res); err != nil {
6423 return nil, err
6424 }
6425 return ret, nil
6426 }
6427
6428
6429
6430
6431 func (c *ProjectsLocationsDatasetsListCall) Pages(ctx context.Context, f func(*ListDatasetsResponse) error) error {
6432 c.ctx_ = ctx
6433 defer c.PageToken(c.urlParams_.Get("pageToken"))
6434 for {
6435 x, err := c.Do()
6436 if err != nil {
6437 return err
6438 }
6439 if err := f(x); err != nil {
6440 return err
6441 }
6442 if x.NextPageToken == "" {
6443 return nil
6444 }
6445 c.PageToken(x.NextPageToken)
6446 }
6447 }
6448
6449 type ProjectsLocationsDatasetsPatchCall struct {
6450 s *Service
6451 name string
6452 dataset *Dataset
6453 urlParams_ gensupport.URLParams
6454 ctx_ context.Context
6455 header_ http.Header
6456 }
6457
6458
6459
6460
6461
6462 func (r *ProjectsLocationsDatasetsService) Patch(name string, dataset *Dataset) *ProjectsLocationsDatasetsPatchCall {
6463 c := &ProjectsLocationsDatasetsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6464 c.name = name
6465 c.dataset = dataset
6466 return c
6467 }
6468
6469
6470
6471
6472 func (c *ProjectsLocationsDatasetsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsPatchCall {
6473 c.urlParams_.Set("updateMask", updateMask)
6474 return c
6475 }
6476
6477
6478
6479
6480 func (c *ProjectsLocationsDatasetsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsPatchCall {
6481 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6482 return c
6483 }
6484
6485
6486 func (c *ProjectsLocationsDatasetsPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsPatchCall {
6487 c.ctx_ = ctx
6488 return c
6489 }
6490
6491
6492
6493 func (c *ProjectsLocationsDatasetsPatchCall) Header() http.Header {
6494 if c.header_ == nil {
6495 c.header_ = make(http.Header)
6496 }
6497 return c.header_
6498 }
6499
6500 func (c *ProjectsLocationsDatasetsPatchCall) doRequest(alt string) (*http.Response, error) {
6501 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6502 var body io.Reader = nil
6503 body, err := googleapi.WithoutDataWrapper.JSONReader(c.dataset)
6504 if err != nil {
6505 return nil, err
6506 }
6507 c.urlParams_.Set("alt", alt)
6508 c.urlParams_.Set("prettyPrint", "false")
6509 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
6510 urls += "?" + c.urlParams_.Encode()
6511 req, err := http.NewRequest("PATCH", urls, body)
6512 if err != nil {
6513 return nil, err
6514 }
6515 req.Header = reqHeaders
6516 googleapi.Expand(req.URL, map[string]string{
6517 "name": c.name,
6518 })
6519 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6520 }
6521
6522
6523
6524
6525
6526
6527 func (c *ProjectsLocationsDatasetsPatchCall) Do(opts ...googleapi.CallOption) (*Dataset, error) {
6528 gensupport.SetOptions(c.urlParams_, opts...)
6529 res, err := c.doRequest("json")
6530 if res != nil && res.StatusCode == http.StatusNotModified {
6531 if res.Body != nil {
6532 res.Body.Close()
6533 }
6534 return nil, gensupport.WrapError(&googleapi.Error{
6535 Code: res.StatusCode,
6536 Header: res.Header,
6537 })
6538 }
6539 if err != nil {
6540 return nil, err
6541 }
6542 defer googleapi.CloseBody(res)
6543 if err := googleapi.CheckResponse(res); err != nil {
6544 return nil, gensupport.WrapError(err)
6545 }
6546 ret := &Dataset{
6547 ServerResponse: googleapi.ServerResponse{
6548 Header: res.Header,
6549 HTTPStatusCode: res.StatusCode,
6550 },
6551 }
6552 target := &ret
6553 if err := gensupport.DecodeResponse(target, res); err != nil {
6554 return nil, err
6555 }
6556 return ret, nil
6557 }
6558
6559 type ProjectsLocationsDatasetsSetIamPolicyCall struct {
6560 s *Service
6561 resource string
6562 setiampolicyrequest *SetIamPolicyRequest
6563 urlParams_ gensupport.URLParams
6564 ctx_ context.Context
6565 header_ http.Header
6566 }
6567
6568
6569
6570
6571
6572
6573
6574
6575 func (r *ProjectsLocationsDatasetsService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDatasetsSetIamPolicyCall {
6576 c := &ProjectsLocationsDatasetsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6577 c.resource = resource
6578 c.setiampolicyrequest = setiampolicyrequest
6579 return c
6580 }
6581
6582
6583
6584
6585 func (c *ProjectsLocationsDatasetsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsSetIamPolicyCall {
6586 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6587 return c
6588 }
6589
6590
6591 func (c *ProjectsLocationsDatasetsSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsSetIamPolicyCall {
6592 c.ctx_ = ctx
6593 return c
6594 }
6595
6596
6597
6598 func (c *ProjectsLocationsDatasetsSetIamPolicyCall) Header() http.Header {
6599 if c.header_ == nil {
6600 c.header_ = make(http.Header)
6601 }
6602 return c.header_
6603 }
6604
6605 func (c *ProjectsLocationsDatasetsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
6606 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6607 var body io.Reader = nil
6608 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
6609 if err != nil {
6610 return nil, err
6611 }
6612 c.urlParams_.Set("alt", alt)
6613 c.urlParams_.Set("prettyPrint", "false")
6614 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
6615 urls += "?" + c.urlParams_.Encode()
6616 req, err := http.NewRequest("POST", urls, body)
6617 if err != nil {
6618 return nil, err
6619 }
6620 req.Header = reqHeaders
6621 googleapi.Expand(req.URL, map[string]string{
6622 "resource": c.resource,
6623 })
6624 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6625 }
6626
6627
6628
6629
6630
6631
6632 func (c *ProjectsLocationsDatasetsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
6633 gensupport.SetOptions(c.urlParams_, opts...)
6634 res, err := c.doRequest("json")
6635 if res != nil && res.StatusCode == http.StatusNotModified {
6636 if res.Body != nil {
6637 res.Body.Close()
6638 }
6639 return nil, gensupport.WrapError(&googleapi.Error{
6640 Code: res.StatusCode,
6641 Header: res.Header,
6642 })
6643 }
6644 if err != nil {
6645 return nil, err
6646 }
6647 defer googleapi.CloseBody(res)
6648 if err := googleapi.CheckResponse(res); err != nil {
6649 return nil, gensupport.WrapError(err)
6650 }
6651 ret := &Policy{
6652 ServerResponse: googleapi.ServerResponse{
6653 Header: res.Header,
6654 HTTPStatusCode: res.StatusCode,
6655 },
6656 }
6657 target := &ret
6658 if err := gensupport.DecodeResponse(target, res); err != nil {
6659 return nil, err
6660 }
6661 return ret, nil
6662 }
6663
6664 type ProjectsLocationsDatasetsTestIamPermissionsCall struct {
6665 s *Service
6666 resource string
6667 testiampermissionsrequest *TestIamPermissionsRequest
6668 urlParams_ gensupport.URLParams
6669 ctx_ context.Context
6670 header_ http.Header
6671 }
6672
6673
6674
6675
6676
6677
6678
6679
6680
6681
6682
6683 func (r *ProjectsLocationsDatasetsService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDatasetsTestIamPermissionsCall {
6684 c := &ProjectsLocationsDatasetsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6685 c.resource = resource
6686 c.testiampermissionsrequest = testiampermissionsrequest
6687 return c
6688 }
6689
6690
6691
6692
6693 func (c *ProjectsLocationsDatasetsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsTestIamPermissionsCall {
6694 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6695 return c
6696 }
6697
6698
6699 func (c *ProjectsLocationsDatasetsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsTestIamPermissionsCall {
6700 c.ctx_ = ctx
6701 return c
6702 }
6703
6704
6705
6706 func (c *ProjectsLocationsDatasetsTestIamPermissionsCall) Header() http.Header {
6707 if c.header_ == nil {
6708 c.header_ = make(http.Header)
6709 }
6710 return c.header_
6711 }
6712
6713 func (c *ProjectsLocationsDatasetsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
6714 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6715 var body io.Reader = nil
6716 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
6717 if err != nil {
6718 return nil, err
6719 }
6720 c.urlParams_.Set("alt", alt)
6721 c.urlParams_.Set("prettyPrint", "false")
6722 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
6723 urls += "?" + c.urlParams_.Encode()
6724 req, err := http.NewRequest("POST", urls, body)
6725 if err != nil {
6726 return nil, err
6727 }
6728 req.Header = reqHeaders
6729 googleapi.Expand(req.URL, map[string]string{
6730 "resource": c.resource,
6731 })
6732 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6733 }
6734
6735
6736
6737
6738
6739
6740
6741 func (c *ProjectsLocationsDatasetsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
6742 gensupport.SetOptions(c.urlParams_, opts...)
6743 res, err := c.doRequest("json")
6744 if res != nil && res.StatusCode == http.StatusNotModified {
6745 if res.Body != nil {
6746 res.Body.Close()
6747 }
6748 return nil, gensupport.WrapError(&googleapi.Error{
6749 Code: res.StatusCode,
6750 Header: res.Header,
6751 })
6752 }
6753 if err != nil {
6754 return nil, err
6755 }
6756 defer googleapi.CloseBody(res)
6757 if err := googleapi.CheckResponse(res); err != nil {
6758 return nil, gensupport.WrapError(err)
6759 }
6760 ret := &TestIamPermissionsResponse{
6761 ServerResponse: googleapi.ServerResponse{
6762 Header: res.Header,
6763 HTTPStatusCode: res.StatusCode,
6764 },
6765 }
6766 target := &ret
6767 if err := gensupport.DecodeResponse(target, res); err != nil {
6768 return nil, err
6769 }
6770 return ret, nil
6771 }
6772
6773 type ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall struct {
6774 s *Service
6775 consentStore string
6776 checkdataaccessrequest *CheckDataAccessRequest
6777 urlParams_ gensupport.URLParams
6778 ctx_ context.Context
6779 header_ http.Header
6780 }
6781
6782
6783
6784
6785
6786
6787
6788
6789 func (r *ProjectsLocationsDatasetsConsentStoresService) CheckDataAccess(consentStore string, checkdataaccessrequest *CheckDataAccessRequest) *ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall {
6790 c := &ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6791 c.consentStore = consentStore
6792 c.checkdataaccessrequest = checkdataaccessrequest
6793 return c
6794 }
6795
6796
6797
6798
6799 func (c *ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall {
6800 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6801 return c
6802 }
6803
6804
6805 func (c *ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall {
6806 c.ctx_ = ctx
6807 return c
6808 }
6809
6810
6811
6812 func (c *ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall) Header() http.Header {
6813 if c.header_ == nil {
6814 c.header_ = make(http.Header)
6815 }
6816 return c.header_
6817 }
6818
6819 func (c *ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall) doRequest(alt string) (*http.Response, error) {
6820 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6821 var body io.Reader = nil
6822 body, err := googleapi.WithoutDataWrapper.JSONReader(c.checkdataaccessrequest)
6823 if err != nil {
6824 return nil, err
6825 }
6826 c.urlParams_.Set("alt", alt)
6827 c.urlParams_.Set("prettyPrint", "false")
6828 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+consentStore}:checkDataAccess")
6829 urls += "?" + c.urlParams_.Encode()
6830 req, err := http.NewRequest("POST", urls, body)
6831 if err != nil {
6832 return nil, err
6833 }
6834 req.Header = reqHeaders
6835 googleapi.Expand(req.URL, map[string]string{
6836 "consentStore": c.consentStore,
6837 })
6838 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6839 }
6840
6841
6842
6843
6844
6845
6846
6847 func (c *ProjectsLocationsDatasetsConsentStoresCheckDataAccessCall) Do(opts ...googleapi.CallOption) (*CheckDataAccessResponse, error) {
6848 gensupport.SetOptions(c.urlParams_, opts...)
6849 res, err := c.doRequest("json")
6850 if res != nil && res.StatusCode == http.StatusNotModified {
6851 if res.Body != nil {
6852 res.Body.Close()
6853 }
6854 return nil, gensupport.WrapError(&googleapi.Error{
6855 Code: res.StatusCode,
6856 Header: res.Header,
6857 })
6858 }
6859 if err != nil {
6860 return nil, err
6861 }
6862 defer googleapi.CloseBody(res)
6863 if err := googleapi.CheckResponse(res); err != nil {
6864 return nil, gensupport.WrapError(err)
6865 }
6866 ret := &CheckDataAccessResponse{
6867 ServerResponse: googleapi.ServerResponse{
6868 Header: res.Header,
6869 HTTPStatusCode: res.StatusCode,
6870 },
6871 }
6872 target := &ret
6873 if err := gensupport.DecodeResponse(target, res); err != nil {
6874 return nil, err
6875 }
6876 return ret, nil
6877 }
6878
6879 type ProjectsLocationsDatasetsConsentStoresCreateCall struct {
6880 s *Service
6881 parent string
6882 consentstore *ConsentStore
6883 urlParams_ gensupport.URLParams
6884 ctx_ context.Context
6885 header_ http.Header
6886 }
6887
6888
6889
6890
6891
6892
6893 func (r *ProjectsLocationsDatasetsConsentStoresService) Create(parent string, consentstore *ConsentStore) *ProjectsLocationsDatasetsConsentStoresCreateCall {
6894 c := &ProjectsLocationsDatasetsConsentStoresCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
6895 c.parent = parent
6896 c.consentstore = consentstore
6897 return c
6898 }
6899
6900
6901
6902
6903 func (c *ProjectsLocationsDatasetsConsentStoresCreateCall) ConsentStoreId(consentStoreId string) *ProjectsLocationsDatasetsConsentStoresCreateCall {
6904 c.urlParams_.Set("consentStoreId", consentStoreId)
6905 return c
6906 }
6907
6908
6909
6910
6911 func (c *ProjectsLocationsDatasetsConsentStoresCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresCreateCall {
6912 c.urlParams_.Set("fields", googleapi.CombineFields(s))
6913 return c
6914 }
6915
6916
6917 func (c *ProjectsLocationsDatasetsConsentStoresCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresCreateCall {
6918 c.ctx_ = ctx
6919 return c
6920 }
6921
6922
6923
6924 func (c *ProjectsLocationsDatasetsConsentStoresCreateCall) Header() http.Header {
6925 if c.header_ == nil {
6926 c.header_ = make(http.Header)
6927 }
6928 return c.header_
6929 }
6930
6931 func (c *ProjectsLocationsDatasetsConsentStoresCreateCall) doRequest(alt string) (*http.Response, error) {
6932 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
6933 var body io.Reader = nil
6934 body, err := googleapi.WithoutDataWrapper.JSONReader(c.consentstore)
6935 if err != nil {
6936 return nil, err
6937 }
6938 c.urlParams_.Set("alt", alt)
6939 c.urlParams_.Set("prettyPrint", "false")
6940 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/consentStores")
6941 urls += "?" + c.urlParams_.Encode()
6942 req, err := http.NewRequest("POST", urls, body)
6943 if err != nil {
6944 return nil, err
6945 }
6946 req.Header = reqHeaders
6947 googleapi.Expand(req.URL, map[string]string{
6948 "parent": c.parent,
6949 })
6950 return gensupport.SendRequest(c.ctx_, c.s.client, req)
6951 }
6952
6953
6954
6955
6956
6957
6958 func (c *ProjectsLocationsDatasetsConsentStoresCreateCall) Do(opts ...googleapi.CallOption) (*ConsentStore, error) {
6959 gensupport.SetOptions(c.urlParams_, opts...)
6960 res, err := c.doRequest("json")
6961 if res != nil && res.StatusCode == http.StatusNotModified {
6962 if res.Body != nil {
6963 res.Body.Close()
6964 }
6965 return nil, gensupport.WrapError(&googleapi.Error{
6966 Code: res.StatusCode,
6967 Header: res.Header,
6968 })
6969 }
6970 if err != nil {
6971 return nil, err
6972 }
6973 defer googleapi.CloseBody(res)
6974 if err := googleapi.CheckResponse(res); err != nil {
6975 return nil, gensupport.WrapError(err)
6976 }
6977 ret := &ConsentStore{
6978 ServerResponse: googleapi.ServerResponse{
6979 Header: res.Header,
6980 HTTPStatusCode: res.StatusCode,
6981 },
6982 }
6983 target := &ret
6984 if err := gensupport.DecodeResponse(target, res); err != nil {
6985 return nil, err
6986 }
6987 return ret, nil
6988 }
6989
6990 type ProjectsLocationsDatasetsConsentStoresDeleteCall struct {
6991 s *Service
6992 name string
6993 urlParams_ gensupport.URLParams
6994 ctx_ context.Context
6995 header_ http.Header
6996 }
6997
6998
6999
7000
7001
7002 func (r *ProjectsLocationsDatasetsConsentStoresService) Delete(name string) *ProjectsLocationsDatasetsConsentStoresDeleteCall {
7003 c := &ProjectsLocationsDatasetsConsentStoresDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7004 c.name = name
7005 return c
7006 }
7007
7008
7009
7010
7011 func (c *ProjectsLocationsDatasetsConsentStoresDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresDeleteCall {
7012 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7013 return c
7014 }
7015
7016
7017 func (c *ProjectsLocationsDatasetsConsentStoresDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresDeleteCall {
7018 c.ctx_ = ctx
7019 return c
7020 }
7021
7022
7023
7024 func (c *ProjectsLocationsDatasetsConsentStoresDeleteCall) Header() http.Header {
7025 if c.header_ == nil {
7026 c.header_ = make(http.Header)
7027 }
7028 return c.header_
7029 }
7030
7031 func (c *ProjectsLocationsDatasetsConsentStoresDeleteCall) doRequest(alt string) (*http.Response, error) {
7032 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7033 var body io.Reader = nil
7034 c.urlParams_.Set("alt", alt)
7035 c.urlParams_.Set("prettyPrint", "false")
7036 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
7037 urls += "?" + c.urlParams_.Encode()
7038 req, err := http.NewRequest("DELETE", urls, body)
7039 if err != nil {
7040 return nil, err
7041 }
7042 req.Header = reqHeaders
7043 googleapi.Expand(req.URL, map[string]string{
7044 "name": c.name,
7045 })
7046 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7047 }
7048
7049
7050
7051
7052
7053
7054 func (c *ProjectsLocationsDatasetsConsentStoresDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
7055 gensupport.SetOptions(c.urlParams_, opts...)
7056 res, err := c.doRequest("json")
7057 if res != nil && res.StatusCode == http.StatusNotModified {
7058 if res.Body != nil {
7059 res.Body.Close()
7060 }
7061 return nil, gensupport.WrapError(&googleapi.Error{
7062 Code: res.StatusCode,
7063 Header: res.Header,
7064 })
7065 }
7066 if err != nil {
7067 return nil, err
7068 }
7069 defer googleapi.CloseBody(res)
7070 if err := googleapi.CheckResponse(res); err != nil {
7071 return nil, gensupport.WrapError(err)
7072 }
7073 ret := &Empty{
7074 ServerResponse: googleapi.ServerResponse{
7075 Header: res.Header,
7076 HTTPStatusCode: res.StatusCode,
7077 },
7078 }
7079 target := &ret
7080 if err := gensupport.DecodeResponse(target, res); err != nil {
7081 return nil, err
7082 }
7083 return ret, nil
7084 }
7085
7086 type ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall struct {
7087 s *Service
7088 consentStore string
7089 evaluateuserconsentsrequest *EvaluateUserConsentsRequest
7090 urlParams_ gensupport.URLParams
7091 ctx_ context.Context
7092 header_ http.Header
7093 }
7094
7095
7096
7097
7098
7099
7100
7101
7102 func (r *ProjectsLocationsDatasetsConsentStoresService) EvaluateUserConsents(consentStore string, evaluateuserconsentsrequest *EvaluateUserConsentsRequest) *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall {
7103 c := &ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7104 c.consentStore = consentStore
7105 c.evaluateuserconsentsrequest = evaluateuserconsentsrequest
7106 return c
7107 }
7108
7109
7110
7111
7112 func (c *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall {
7113 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7114 return c
7115 }
7116
7117
7118 func (c *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall {
7119 c.ctx_ = ctx
7120 return c
7121 }
7122
7123
7124
7125 func (c *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall) Header() http.Header {
7126 if c.header_ == nil {
7127 c.header_ = make(http.Header)
7128 }
7129 return c.header_
7130 }
7131
7132 func (c *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall) doRequest(alt string) (*http.Response, error) {
7133 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7134 var body io.Reader = nil
7135 body, err := googleapi.WithoutDataWrapper.JSONReader(c.evaluateuserconsentsrequest)
7136 if err != nil {
7137 return nil, err
7138 }
7139 c.urlParams_.Set("alt", alt)
7140 c.urlParams_.Set("prettyPrint", "false")
7141 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+consentStore}:evaluateUserConsents")
7142 urls += "?" + c.urlParams_.Encode()
7143 req, err := http.NewRequest("POST", urls, body)
7144 if err != nil {
7145 return nil, err
7146 }
7147 req.Header = reqHeaders
7148 googleapi.Expand(req.URL, map[string]string{
7149 "consentStore": c.consentStore,
7150 })
7151 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7152 }
7153
7154
7155
7156
7157
7158
7159
7160 func (c *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall) Do(opts ...googleapi.CallOption) (*EvaluateUserConsentsResponse, error) {
7161 gensupport.SetOptions(c.urlParams_, opts...)
7162 res, err := c.doRequest("json")
7163 if res != nil && res.StatusCode == http.StatusNotModified {
7164 if res.Body != nil {
7165 res.Body.Close()
7166 }
7167 return nil, gensupport.WrapError(&googleapi.Error{
7168 Code: res.StatusCode,
7169 Header: res.Header,
7170 })
7171 }
7172 if err != nil {
7173 return nil, err
7174 }
7175 defer googleapi.CloseBody(res)
7176 if err := googleapi.CheckResponse(res); err != nil {
7177 return nil, gensupport.WrapError(err)
7178 }
7179 ret := &EvaluateUserConsentsResponse{
7180 ServerResponse: googleapi.ServerResponse{
7181 Header: res.Header,
7182 HTTPStatusCode: res.StatusCode,
7183 },
7184 }
7185 target := &ret
7186 if err := gensupport.DecodeResponse(target, res); err != nil {
7187 return nil, err
7188 }
7189 return ret, nil
7190 }
7191
7192
7193
7194
7195 func (c *ProjectsLocationsDatasetsConsentStoresEvaluateUserConsentsCall) Pages(ctx context.Context, f func(*EvaluateUserConsentsResponse) error) error {
7196 c.ctx_ = ctx
7197 defer func(pt string) { c.evaluateuserconsentsrequest.PageToken = pt }(c.evaluateuserconsentsrequest.PageToken)
7198 for {
7199 x, err := c.Do()
7200 if err != nil {
7201 return err
7202 }
7203 if err := f(x); err != nil {
7204 return err
7205 }
7206 if x.NextPageToken == "" {
7207 return nil
7208 }
7209 c.evaluateuserconsentsrequest.PageToken = x.NextPageToken
7210 }
7211 }
7212
7213 type ProjectsLocationsDatasetsConsentStoresGetCall struct {
7214 s *Service
7215 name string
7216 urlParams_ gensupport.URLParams
7217 ifNoneMatch_ string
7218 ctx_ context.Context
7219 header_ http.Header
7220 }
7221
7222
7223
7224
7225 func (r *ProjectsLocationsDatasetsConsentStoresService) Get(name string) *ProjectsLocationsDatasetsConsentStoresGetCall {
7226 c := &ProjectsLocationsDatasetsConsentStoresGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7227 c.name = name
7228 return c
7229 }
7230
7231
7232
7233
7234 func (c *ProjectsLocationsDatasetsConsentStoresGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresGetCall {
7235 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7236 return c
7237 }
7238
7239
7240
7241
7242 func (c *ProjectsLocationsDatasetsConsentStoresGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresGetCall {
7243 c.ifNoneMatch_ = entityTag
7244 return c
7245 }
7246
7247
7248 func (c *ProjectsLocationsDatasetsConsentStoresGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresGetCall {
7249 c.ctx_ = ctx
7250 return c
7251 }
7252
7253
7254
7255 func (c *ProjectsLocationsDatasetsConsentStoresGetCall) Header() http.Header {
7256 if c.header_ == nil {
7257 c.header_ = make(http.Header)
7258 }
7259 return c.header_
7260 }
7261
7262 func (c *ProjectsLocationsDatasetsConsentStoresGetCall) doRequest(alt string) (*http.Response, error) {
7263 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7264 if c.ifNoneMatch_ != "" {
7265 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7266 }
7267 var body io.Reader = nil
7268 c.urlParams_.Set("alt", alt)
7269 c.urlParams_.Set("prettyPrint", "false")
7270 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
7271 urls += "?" + c.urlParams_.Encode()
7272 req, err := http.NewRequest("GET", urls, body)
7273 if err != nil {
7274 return nil, err
7275 }
7276 req.Header = reqHeaders
7277 googleapi.Expand(req.URL, map[string]string{
7278 "name": c.name,
7279 })
7280 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7281 }
7282
7283
7284
7285
7286
7287
7288 func (c *ProjectsLocationsDatasetsConsentStoresGetCall) Do(opts ...googleapi.CallOption) (*ConsentStore, error) {
7289 gensupport.SetOptions(c.urlParams_, opts...)
7290 res, err := c.doRequest("json")
7291 if res != nil && res.StatusCode == http.StatusNotModified {
7292 if res.Body != nil {
7293 res.Body.Close()
7294 }
7295 return nil, gensupport.WrapError(&googleapi.Error{
7296 Code: res.StatusCode,
7297 Header: res.Header,
7298 })
7299 }
7300 if err != nil {
7301 return nil, err
7302 }
7303 defer googleapi.CloseBody(res)
7304 if err := googleapi.CheckResponse(res); err != nil {
7305 return nil, gensupport.WrapError(err)
7306 }
7307 ret := &ConsentStore{
7308 ServerResponse: googleapi.ServerResponse{
7309 Header: res.Header,
7310 HTTPStatusCode: res.StatusCode,
7311 },
7312 }
7313 target := &ret
7314 if err := gensupport.DecodeResponse(target, res); err != nil {
7315 return nil, err
7316 }
7317 return ret, nil
7318 }
7319
7320 type ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall struct {
7321 s *Service
7322 resource string
7323 urlParams_ gensupport.URLParams
7324 ifNoneMatch_ string
7325 ctx_ context.Context
7326 header_ http.Header
7327 }
7328
7329
7330
7331
7332
7333
7334
7335 func (r *ProjectsLocationsDatasetsConsentStoresService) GetIamPolicy(resource string) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall {
7336 c := &ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7337 c.resource = resource
7338 return c
7339 }
7340
7341
7342
7343
7344
7345
7346
7347
7348
7349
7350
7351
7352
7353 func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall {
7354 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
7355 return c
7356 }
7357
7358
7359
7360
7361 func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall {
7362 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7363 return c
7364 }
7365
7366
7367
7368
7369 func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall {
7370 c.ifNoneMatch_ = entityTag
7371 return c
7372 }
7373
7374
7375 func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall {
7376 c.ctx_ = ctx
7377 return c
7378 }
7379
7380
7381
7382 func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Header() http.Header {
7383 if c.header_ == nil {
7384 c.header_ = make(http.Header)
7385 }
7386 return c.header_
7387 }
7388
7389 func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
7390 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7391 if c.ifNoneMatch_ != "" {
7392 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7393 }
7394 var body io.Reader = nil
7395 c.urlParams_.Set("alt", alt)
7396 c.urlParams_.Set("prettyPrint", "false")
7397 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
7398 urls += "?" + c.urlParams_.Encode()
7399 req, err := http.NewRequest("GET", urls, body)
7400 if err != nil {
7401 return nil, err
7402 }
7403 req.Header = reqHeaders
7404 googleapi.Expand(req.URL, map[string]string{
7405 "resource": c.resource,
7406 })
7407 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7408 }
7409
7410
7411
7412
7413
7414
7415 func (c *ProjectsLocationsDatasetsConsentStoresGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
7416 gensupport.SetOptions(c.urlParams_, opts...)
7417 res, err := c.doRequest("json")
7418 if res != nil && res.StatusCode == http.StatusNotModified {
7419 if res.Body != nil {
7420 res.Body.Close()
7421 }
7422 return nil, gensupport.WrapError(&googleapi.Error{
7423 Code: res.StatusCode,
7424 Header: res.Header,
7425 })
7426 }
7427 if err != nil {
7428 return nil, err
7429 }
7430 defer googleapi.CloseBody(res)
7431 if err := googleapi.CheckResponse(res); err != nil {
7432 return nil, gensupport.WrapError(err)
7433 }
7434 ret := &Policy{
7435 ServerResponse: googleapi.ServerResponse{
7436 Header: res.Header,
7437 HTTPStatusCode: res.StatusCode,
7438 },
7439 }
7440 target := &ret
7441 if err := gensupport.DecodeResponse(target, res); err != nil {
7442 return nil, err
7443 }
7444 return ret, nil
7445 }
7446
7447 type ProjectsLocationsDatasetsConsentStoresListCall struct {
7448 s *Service
7449 parent string
7450 urlParams_ gensupport.URLParams
7451 ifNoneMatch_ string
7452 ctx_ context.Context
7453 header_ http.Header
7454 }
7455
7456
7457
7458
7459 func (r *ProjectsLocationsDatasetsConsentStoresService) List(parent string) *ProjectsLocationsDatasetsConsentStoresListCall {
7460 c := &ProjectsLocationsDatasetsConsentStoresListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7461 c.parent = parent
7462 return c
7463 }
7464
7465
7466
7467
7468 func (c *ProjectsLocationsDatasetsConsentStoresListCall) Filter(filter string) *ProjectsLocationsDatasetsConsentStoresListCall {
7469 c.urlParams_.Set("filter", filter)
7470 return c
7471 }
7472
7473
7474
7475
7476 func (c *ProjectsLocationsDatasetsConsentStoresListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsConsentStoresListCall {
7477 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
7478 return c
7479 }
7480
7481
7482
7483 func (c *ProjectsLocationsDatasetsConsentStoresListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsConsentStoresListCall {
7484 c.urlParams_.Set("pageToken", pageToken)
7485 return c
7486 }
7487
7488
7489
7490
7491 func (c *ProjectsLocationsDatasetsConsentStoresListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresListCall {
7492 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7493 return c
7494 }
7495
7496
7497
7498
7499 func (c *ProjectsLocationsDatasetsConsentStoresListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresListCall {
7500 c.ifNoneMatch_ = entityTag
7501 return c
7502 }
7503
7504
7505 func (c *ProjectsLocationsDatasetsConsentStoresListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresListCall {
7506 c.ctx_ = ctx
7507 return c
7508 }
7509
7510
7511
7512 func (c *ProjectsLocationsDatasetsConsentStoresListCall) Header() http.Header {
7513 if c.header_ == nil {
7514 c.header_ = make(http.Header)
7515 }
7516 return c.header_
7517 }
7518
7519 func (c *ProjectsLocationsDatasetsConsentStoresListCall) doRequest(alt string) (*http.Response, error) {
7520 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
7521 if c.ifNoneMatch_ != "" {
7522 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
7523 }
7524 var body io.Reader = nil
7525 c.urlParams_.Set("alt", alt)
7526 c.urlParams_.Set("prettyPrint", "false")
7527 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/consentStores")
7528 urls += "?" + c.urlParams_.Encode()
7529 req, err := http.NewRequest("GET", urls, body)
7530 if err != nil {
7531 return nil, err
7532 }
7533 req.Header = reqHeaders
7534 googleapi.Expand(req.URL, map[string]string{
7535 "parent": c.parent,
7536 })
7537 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7538 }
7539
7540
7541
7542
7543
7544
7545
7546 func (c *ProjectsLocationsDatasetsConsentStoresListCall) Do(opts ...googleapi.CallOption) (*ListConsentStoresResponse, error) {
7547 gensupport.SetOptions(c.urlParams_, opts...)
7548 res, err := c.doRequest("json")
7549 if res != nil && res.StatusCode == http.StatusNotModified {
7550 if res.Body != nil {
7551 res.Body.Close()
7552 }
7553 return nil, gensupport.WrapError(&googleapi.Error{
7554 Code: res.StatusCode,
7555 Header: res.Header,
7556 })
7557 }
7558 if err != nil {
7559 return nil, err
7560 }
7561 defer googleapi.CloseBody(res)
7562 if err := googleapi.CheckResponse(res); err != nil {
7563 return nil, gensupport.WrapError(err)
7564 }
7565 ret := &ListConsentStoresResponse{
7566 ServerResponse: googleapi.ServerResponse{
7567 Header: res.Header,
7568 HTTPStatusCode: res.StatusCode,
7569 },
7570 }
7571 target := &ret
7572 if err := gensupport.DecodeResponse(target, res); err != nil {
7573 return nil, err
7574 }
7575 return ret, nil
7576 }
7577
7578
7579
7580
7581 func (c *ProjectsLocationsDatasetsConsentStoresListCall) Pages(ctx context.Context, f func(*ListConsentStoresResponse) error) error {
7582 c.ctx_ = ctx
7583 defer c.PageToken(c.urlParams_.Get("pageToken"))
7584 for {
7585 x, err := c.Do()
7586 if err != nil {
7587 return err
7588 }
7589 if err := f(x); err != nil {
7590 return err
7591 }
7592 if x.NextPageToken == "" {
7593 return nil
7594 }
7595 c.PageToken(x.NextPageToken)
7596 }
7597 }
7598
7599 type ProjectsLocationsDatasetsConsentStoresPatchCall struct {
7600 s *Service
7601 name string
7602 consentstore *ConsentStore
7603 urlParams_ gensupport.URLParams
7604 ctx_ context.Context
7605 header_ http.Header
7606 }
7607
7608
7609
7610
7611
7612
7613 func (r *ProjectsLocationsDatasetsConsentStoresService) Patch(name string, consentstore *ConsentStore) *ProjectsLocationsDatasetsConsentStoresPatchCall {
7614 c := &ProjectsLocationsDatasetsConsentStoresPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7615 c.name = name
7616 c.consentstore = consentstore
7617 return c
7618 }
7619
7620
7621
7622
7623
7624
7625 func (c *ProjectsLocationsDatasetsConsentStoresPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsConsentStoresPatchCall {
7626 c.urlParams_.Set("updateMask", updateMask)
7627 return c
7628 }
7629
7630
7631
7632
7633 func (c *ProjectsLocationsDatasetsConsentStoresPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresPatchCall {
7634 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7635 return c
7636 }
7637
7638
7639 func (c *ProjectsLocationsDatasetsConsentStoresPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresPatchCall {
7640 c.ctx_ = ctx
7641 return c
7642 }
7643
7644
7645
7646 func (c *ProjectsLocationsDatasetsConsentStoresPatchCall) Header() http.Header {
7647 if c.header_ == nil {
7648 c.header_ = make(http.Header)
7649 }
7650 return c.header_
7651 }
7652
7653 func (c *ProjectsLocationsDatasetsConsentStoresPatchCall) doRequest(alt string) (*http.Response, error) {
7654 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7655 var body io.Reader = nil
7656 body, err := googleapi.WithoutDataWrapper.JSONReader(c.consentstore)
7657 if err != nil {
7658 return nil, err
7659 }
7660 c.urlParams_.Set("alt", alt)
7661 c.urlParams_.Set("prettyPrint", "false")
7662 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
7663 urls += "?" + c.urlParams_.Encode()
7664 req, err := http.NewRequest("PATCH", urls, body)
7665 if err != nil {
7666 return nil, err
7667 }
7668 req.Header = reqHeaders
7669 googleapi.Expand(req.URL, map[string]string{
7670 "name": c.name,
7671 })
7672 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7673 }
7674
7675
7676
7677
7678
7679
7680 func (c *ProjectsLocationsDatasetsConsentStoresPatchCall) Do(opts ...googleapi.CallOption) (*ConsentStore, error) {
7681 gensupport.SetOptions(c.urlParams_, opts...)
7682 res, err := c.doRequest("json")
7683 if res != nil && res.StatusCode == http.StatusNotModified {
7684 if res.Body != nil {
7685 res.Body.Close()
7686 }
7687 return nil, gensupport.WrapError(&googleapi.Error{
7688 Code: res.StatusCode,
7689 Header: res.Header,
7690 })
7691 }
7692 if err != nil {
7693 return nil, err
7694 }
7695 defer googleapi.CloseBody(res)
7696 if err := googleapi.CheckResponse(res); err != nil {
7697 return nil, gensupport.WrapError(err)
7698 }
7699 ret := &ConsentStore{
7700 ServerResponse: googleapi.ServerResponse{
7701 Header: res.Header,
7702 HTTPStatusCode: res.StatusCode,
7703 },
7704 }
7705 target := &ret
7706 if err := gensupport.DecodeResponse(target, res); err != nil {
7707 return nil, err
7708 }
7709 return ret, nil
7710 }
7711
7712 type ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall struct {
7713 s *Service
7714 consentStore string
7715 queryaccessibledatarequest *QueryAccessibleDataRequest
7716 urlParams_ gensupport.URLParams
7717 ctx_ context.Context
7718 header_ http.Header
7719 }
7720
7721
7722
7723
7724
7725
7726
7727
7728
7729
7730
7731
7732
7733
7734
7735
7736
7737
7738
7739
7740
7741
7742
7743
7744
7745
7746
7747
7748
7749
7750 func (r *ProjectsLocationsDatasetsConsentStoresService) QueryAccessibleData(consentStore string, queryaccessibledatarequest *QueryAccessibleDataRequest) *ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall {
7751 c := &ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7752 c.consentStore = consentStore
7753 c.queryaccessibledatarequest = queryaccessibledatarequest
7754 return c
7755 }
7756
7757
7758
7759
7760 func (c *ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall {
7761 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7762 return c
7763 }
7764
7765
7766 func (c *ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall {
7767 c.ctx_ = ctx
7768 return c
7769 }
7770
7771
7772
7773 func (c *ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall) Header() http.Header {
7774 if c.header_ == nil {
7775 c.header_ = make(http.Header)
7776 }
7777 return c.header_
7778 }
7779
7780 func (c *ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall) doRequest(alt string) (*http.Response, error) {
7781 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7782 var body io.Reader = nil
7783 body, err := googleapi.WithoutDataWrapper.JSONReader(c.queryaccessibledatarequest)
7784 if err != nil {
7785 return nil, err
7786 }
7787 c.urlParams_.Set("alt", alt)
7788 c.urlParams_.Set("prettyPrint", "false")
7789 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+consentStore}:queryAccessibleData")
7790 urls += "?" + c.urlParams_.Encode()
7791 req, err := http.NewRequest("POST", urls, body)
7792 if err != nil {
7793 return nil, err
7794 }
7795 req.Header = reqHeaders
7796 googleapi.Expand(req.URL, map[string]string{
7797 "consentStore": c.consentStore,
7798 })
7799 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7800 }
7801
7802
7803
7804
7805
7806
7807 func (c *ProjectsLocationsDatasetsConsentStoresQueryAccessibleDataCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
7808 gensupport.SetOptions(c.urlParams_, opts...)
7809 res, err := c.doRequest("json")
7810 if res != nil && res.StatusCode == http.StatusNotModified {
7811 if res.Body != nil {
7812 res.Body.Close()
7813 }
7814 return nil, gensupport.WrapError(&googleapi.Error{
7815 Code: res.StatusCode,
7816 Header: res.Header,
7817 })
7818 }
7819 if err != nil {
7820 return nil, err
7821 }
7822 defer googleapi.CloseBody(res)
7823 if err := googleapi.CheckResponse(res); err != nil {
7824 return nil, gensupport.WrapError(err)
7825 }
7826 ret := &Operation{
7827 ServerResponse: googleapi.ServerResponse{
7828 Header: res.Header,
7829 HTTPStatusCode: res.StatusCode,
7830 },
7831 }
7832 target := &ret
7833 if err := gensupport.DecodeResponse(target, res); err != nil {
7834 return nil, err
7835 }
7836 return ret, nil
7837 }
7838
7839 type ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall struct {
7840 s *Service
7841 resource string
7842 setiampolicyrequest *SetIamPolicyRequest
7843 urlParams_ gensupport.URLParams
7844 ctx_ context.Context
7845 header_ http.Header
7846 }
7847
7848
7849
7850
7851
7852
7853
7854
7855 func (r *ProjectsLocationsDatasetsConsentStoresService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall {
7856 c := &ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7857 c.resource = resource
7858 c.setiampolicyrequest = setiampolicyrequest
7859 return c
7860 }
7861
7862
7863
7864
7865 func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall {
7866 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7867 return c
7868 }
7869
7870
7871 func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall {
7872 c.ctx_ = ctx
7873 return c
7874 }
7875
7876
7877
7878 func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Header() http.Header {
7879 if c.header_ == nil {
7880 c.header_ = make(http.Header)
7881 }
7882 return c.header_
7883 }
7884
7885 func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
7886 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7887 var body io.Reader = nil
7888 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
7889 if err != nil {
7890 return nil, err
7891 }
7892 c.urlParams_.Set("alt", alt)
7893 c.urlParams_.Set("prettyPrint", "false")
7894 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
7895 urls += "?" + c.urlParams_.Encode()
7896 req, err := http.NewRequest("POST", urls, body)
7897 if err != nil {
7898 return nil, err
7899 }
7900 req.Header = reqHeaders
7901 googleapi.Expand(req.URL, map[string]string{
7902 "resource": c.resource,
7903 })
7904 return gensupport.SendRequest(c.ctx_, c.s.client, req)
7905 }
7906
7907
7908
7909
7910
7911
7912 func (c *ProjectsLocationsDatasetsConsentStoresSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
7913 gensupport.SetOptions(c.urlParams_, opts...)
7914 res, err := c.doRequest("json")
7915 if res != nil && res.StatusCode == http.StatusNotModified {
7916 if res.Body != nil {
7917 res.Body.Close()
7918 }
7919 return nil, gensupport.WrapError(&googleapi.Error{
7920 Code: res.StatusCode,
7921 Header: res.Header,
7922 })
7923 }
7924 if err != nil {
7925 return nil, err
7926 }
7927 defer googleapi.CloseBody(res)
7928 if err := googleapi.CheckResponse(res); err != nil {
7929 return nil, gensupport.WrapError(err)
7930 }
7931 ret := &Policy{
7932 ServerResponse: googleapi.ServerResponse{
7933 Header: res.Header,
7934 HTTPStatusCode: res.StatusCode,
7935 },
7936 }
7937 target := &ret
7938 if err := gensupport.DecodeResponse(target, res); err != nil {
7939 return nil, err
7940 }
7941 return ret, nil
7942 }
7943
7944 type ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall struct {
7945 s *Service
7946 resource string
7947 testiampermissionsrequest *TestIamPermissionsRequest
7948 urlParams_ gensupport.URLParams
7949 ctx_ context.Context
7950 header_ http.Header
7951 }
7952
7953
7954
7955
7956
7957
7958
7959
7960
7961
7962
7963 func (r *ProjectsLocationsDatasetsConsentStoresService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall {
7964 c := &ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
7965 c.resource = resource
7966 c.testiampermissionsrequest = testiampermissionsrequest
7967 return c
7968 }
7969
7970
7971
7972
7973 func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall {
7974 c.urlParams_.Set("fields", googleapi.CombineFields(s))
7975 return c
7976 }
7977
7978
7979 func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall {
7980 c.ctx_ = ctx
7981 return c
7982 }
7983
7984
7985
7986 func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Header() http.Header {
7987 if c.header_ == nil {
7988 c.header_ = make(http.Header)
7989 }
7990 return c.header_
7991 }
7992
7993 func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
7994 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
7995 var body io.Reader = nil
7996 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
7997 if err != nil {
7998 return nil, err
7999 }
8000 c.urlParams_.Set("alt", alt)
8001 c.urlParams_.Set("prettyPrint", "false")
8002 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
8003 urls += "?" + c.urlParams_.Encode()
8004 req, err := http.NewRequest("POST", urls, body)
8005 if err != nil {
8006 return nil, err
8007 }
8008 req.Header = reqHeaders
8009 googleapi.Expand(req.URL, map[string]string{
8010 "resource": c.resource,
8011 })
8012 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8013 }
8014
8015
8016
8017
8018
8019
8020
8021 func (c *ProjectsLocationsDatasetsConsentStoresTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
8022 gensupport.SetOptions(c.urlParams_, opts...)
8023 res, err := c.doRequest("json")
8024 if res != nil && res.StatusCode == http.StatusNotModified {
8025 if res.Body != nil {
8026 res.Body.Close()
8027 }
8028 return nil, gensupport.WrapError(&googleapi.Error{
8029 Code: res.StatusCode,
8030 Header: res.Header,
8031 })
8032 }
8033 if err != nil {
8034 return nil, err
8035 }
8036 defer googleapi.CloseBody(res)
8037 if err := googleapi.CheckResponse(res); err != nil {
8038 return nil, gensupport.WrapError(err)
8039 }
8040 ret := &TestIamPermissionsResponse{
8041 ServerResponse: googleapi.ServerResponse{
8042 Header: res.Header,
8043 HTTPStatusCode: res.StatusCode,
8044 },
8045 }
8046 target := &ret
8047 if err := gensupport.DecodeResponse(target, res); err != nil {
8048 return nil, err
8049 }
8050 return ret, nil
8051 }
8052
8053 type ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall struct {
8054 s *Service
8055 parent string
8056 attributedefinition *AttributeDefinition
8057 urlParams_ gensupport.URLParams
8058 ctx_ context.Context
8059 header_ http.Header
8060 }
8061
8062
8063
8064
8065
8066 func (r *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService) Create(parent string, attributedefinition *AttributeDefinition) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall {
8067 c := &ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8068 c.parent = parent
8069 c.attributedefinition = attributedefinition
8070 return c
8071 }
8072
8073
8074
8075
8076
8077
8078 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall) AttributeDefinitionId(attributeDefinitionId string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall {
8079 c.urlParams_.Set("attributeDefinitionId", attributeDefinitionId)
8080 return c
8081 }
8082
8083
8084
8085
8086 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall {
8087 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8088 return c
8089 }
8090
8091
8092 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall {
8093 c.ctx_ = ctx
8094 return c
8095 }
8096
8097
8098
8099 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall) Header() http.Header {
8100 if c.header_ == nil {
8101 c.header_ = make(http.Header)
8102 }
8103 return c.header_
8104 }
8105
8106 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall) doRequest(alt string) (*http.Response, error) {
8107 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8108 var body io.Reader = nil
8109 body, err := googleapi.WithoutDataWrapper.JSONReader(c.attributedefinition)
8110 if err != nil {
8111 return nil, err
8112 }
8113 c.urlParams_.Set("alt", alt)
8114 c.urlParams_.Set("prettyPrint", "false")
8115 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/attributeDefinitions")
8116 urls += "?" + c.urlParams_.Encode()
8117 req, err := http.NewRequest("POST", urls, body)
8118 if err != nil {
8119 return nil, err
8120 }
8121 req.Header = reqHeaders
8122 googleapi.Expand(req.URL, map[string]string{
8123 "parent": c.parent,
8124 })
8125 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8126 }
8127
8128
8129
8130
8131
8132
8133
8134 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsCreateCall) Do(opts ...googleapi.CallOption) (*AttributeDefinition, error) {
8135 gensupport.SetOptions(c.urlParams_, opts...)
8136 res, err := c.doRequest("json")
8137 if res != nil && res.StatusCode == http.StatusNotModified {
8138 if res.Body != nil {
8139 res.Body.Close()
8140 }
8141 return nil, gensupport.WrapError(&googleapi.Error{
8142 Code: res.StatusCode,
8143 Header: res.Header,
8144 })
8145 }
8146 if err != nil {
8147 return nil, err
8148 }
8149 defer googleapi.CloseBody(res)
8150 if err := googleapi.CheckResponse(res); err != nil {
8151 return nil, gensupport.WrapError(err)
8152 }
8153 ret := &AttributeDefinition{
8154 ServerResponse: googleapi.ServerResponse{
8155 Header: res.Header,
8156 HTTPStatusCode: res.StatusCode,
8157 },
8158 }
8159 target := &ret
8160 if err := gensupport.DecodeResponse(target, res); err != nil {
8161 return nil, err
8162 }
8163 return ret, nil
8164 }
8165
8166 type ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall struct {
8167 s *Service
8168 name string
8169 urlParams_ gensupport.URLParams
8170 ctx_ context.Context
8171 header_ http.Header
8172 }
8173
8174
8175
8176
8177
8178
8179
8180
8181 func (r *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService) Delete(name string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall {
8182 c := &ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8183 c.name = name
8184 return c
8185 }
8186
8187
8188
8189
8190 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall {
8191 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8192 return c
8193 }
8194
8195
8196 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall {
8197 c.ctx_ = ctx
8198 return c
8199 }
8200
8201
8202
8203 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall) Header() http.Header {
8204 if c.header_ == nil {
8205 c.header_ = make(http.Header)
8206 }
8207 return c.header_
8208 }
8209
8210 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall) doRequest(alt string) (*http.Response, error) {
8211 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8212 var body io.Reader = nil
8213 c.urlParams_.Set("alt", alt)
8214 c.urlParams_.Set("prettyPrint", "false")
8215 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8216 urls += "?" + c.urlParams_.Encode()
8217 req, err := http.NewRequest("DELETE", urls, body)
8218 if err != nil {
8219 return nil, err
8220 }
8221 req.Header = reqHeaders
8222 googleapi.Expand(req.URL, map[string]string{
8223 "name": c.name,
8224 })
8225 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8226 }
8227
8228
8229
8230
8231
8232
8233 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
8234 gensupport.SetOptions(c.urlParams_, opts...)
8235 res, err := c.doRequest("json")
8236 if res != nil && res.StatusCode == http.StatusNotModified {
8237 if res.Body != nil {
8238 res.Body.Close()
8239 }
8240 return nil, gensupport.WrapError(&googleapi.Error{
8241 Code: res.StatusCode,
8242 Header: res.Header,
8243 })
8244 }
8245 if err != nil {
8246 return nil, err
8247 }
8248 defer googleapi.CloseBody(res)
8249 if err := googleapi.CheckResponse(res); err != nil {
8250 return nil, gensupport.WrapError(err)
8251 }
8252 ret := &Empty{
8253 ServerResponse: googleapi.ServerResponse{
8254 Header: res.Header,
8255 HTTPStatusCode: res.StatusCode,
8256 },
8257 }
8258 target := &ret
8259 if err := gensupport.DecodeResponse(target, res); err != nil {
8260 return nil, err
8261 }
8262 return ret, nil
8263 }
8264
8265 type ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall struct {
8266 s *Service
8267 name string
8268 urlParams_ gensupport.URLParams
8269 ifNoneMatch_ string
8270 ctx_ context.Context
8271 header_ http.Header
8272 }
8273
8274
8275
8276
8277 func (r *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService) Get(name string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall {
8278 c := &ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8279 c.name = name
8280 return c
8281 }
8282
8283
8284
8285
8286 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall {
8287 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8288 return c
8289 }
8290
8291
8292
8293
8294 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall {
8295 c.ifNoneMatch_ = entityTag
8296 return c
8297 }
8298
8299
8300 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall {
8301 c.ctx_ = ctx
8302 return c
8303 }
8304
8305
8306
8307 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall) Header() http.Header {
8308 if c.header_ == nil {
8309 c.header_ = make(http.Header)
8310 }
8311 return c.header_
8312 }
8313
8314 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall) doRequest(alt string) (*http.Response, error) {
8315 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8316 if c.ifNoneMatch_ != "" {
8317 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8318 }
8319 var body io.Reader = nil
8320 c.urlParams_.Set("alt", alt)
8321 c.urlParams_.Set("prettyPrint", "false")
8322 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8323 urls += "?" + c.urlParams_.Encode()
8324 req, err := http.NewRequest("GET", urls, body)
8325 if err != nil {
8326 return nil, err
8327 }
8328 req.Header = reqHeaders
8329 googleapi.Expand(req.URL, map[string]string{
8330 "name": c.name,
8331 })
8332 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8333 }
8334
8335
8336
8337
8338
8339
8340
8341 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsGetCall) Do(opts ...googleapi.CallOption) (*AttributeDefinition, 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 := &AttributeDefinition{
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 ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall struct {
8374 s *Service
8375 parent string
8376 urlParams_ gensupport.URLParams
8377 ifNoneMatch_ string
8378 ctx_ context.Context
8379 header_ http.Header
8380 }
8381
8382
8383
8384
8385 func (r *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService) List(parent string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall {
8386 c := &ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8387 c.parent = parent
8388 return c
8389 }
8390
8391
8392
8393
8394 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) Filter(filter string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall {
8395 c.urlParams_.Set("filter", filter)
8396 return c
8397 }
8398
8399
8400
8401
8402 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall {
8403 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
8404 return c
8405 }
8406
8407
8408
8409 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall {
8410 c.urlParams_.Set("pageToken", pageToken)
8411 return c
8412 }
8413
8414
8415
8416
8417 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall {
8418 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8419 return c
8420 }
8421
8422
8423
8424
8425 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall {
8426 c.ifNoneMatch_ = entityTag
8427 return c
8428 }
8429
8430
8431 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall {
8432 c.ctx_ = ctx
8433 return c
8434 }
8435
8436
8437
8438 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) Header() http.Header {
8439 if c.header_ == nil {
8440 c.header_ = make(http.Header)
8441 }
8442 return c.header_
8443 }
8444
8445 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) doRequest(alt string) (*http.Response, error) {
8446 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8447 if c.ifNoneMatch_ != "" {
8448 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8449 }
8450 var body io.Reader = nil
8451 c.urlParams_.Set("alt", alt)
8452 c.urlParams_.Set("prettyPrint", "false")
8453 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/attributeDefinitions")
8454 urls += "?" + c.urlParams_.Encode()
8455 req, err := http.NewRequest("GET", urls, body)
8456 if err != nil {
8457 return nil, err
8458 }
8459 req.Header = reqHeaders
8460 googleapi.Expand(req.URL, map[string]string{
8461 "parent": c.parent,
8462 })
8463 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8464 }
8465
8466
8467
8468
8469
8470
8471
8472 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) Do(opts ...googleapi.CallOption) (*ListAttributeDefinitionsResponse, error) {
8473 gensupport.SetOptions(c.urlParams_, opts...)
8474 res, err := c.doRequest("json")
8475 if res != nil && res.StatusCode == http.StatusNotModified {
8476 if res.Body != nil {
8477 res.Body.Close()
8478 }
8479 return nil, gensupport.WrapError(&googleapi.Error{
8480 Code: res.StatusCode,
8481 Header: res.Header,
8482 })
8483 }
8484 if err != nil {
8485 return nil, err
8486 }
8487 defer googleapi.CloseBody(res)
8488 if err := googleapi.CheckResponse(res); err != nil {
8489 return nil, gensupport.WrapError(err)
8490 }
8491 ret := &ListAttributeDefinitionsResponse{
8492 ServerResponse: googleapi.ServerResponse{
8493 Header: res.Header,
8494 HTTPStatusCode: res.StatusCode,
8495 },
8496 }
8497 target := &ret
8498 if err := gensupport.DecodeResponse(target, res); err != nil {
8499 return nil, err
8500 }
8501 return ret, nil
8502 }
8503
8504
8505
8506
8507 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsListCall) Pages(ctx context.Context, f func(*ListAttributeDefinitionsResponse) error) error {
8508 c.ctx_ = ctx
8509 defer c.PageToken(c.urlParams_.Get("pageToken"))
8510 for {
8511 x, err := c.Do()
8512 if err != nil {
8513 return err
8514 }
8515 if err := f(x); err != nil {
8516 return err
8517 }
8518 if x.NextPageToken == "" {
8519 return nil
8520 }
8521 c.PageToken(x.NextPageToken)
8522 }
8523 }
8524
8525 type ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall struct {
8526 s *Service
8527 name string
8528 attributedefinition *AttributeDefinition
8529 urlParams_ gensupport.URLParams
8530 ctx_ context.Context
8531 header_ http.Header
8532 }
8533
8534
8535
8536
8537
8538
8539
8540 func (r *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsService) Patch(name string, attributedefinition *AttributeDefinition) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall {
8541 c := &ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8542 c.name = name
8543 c.attributedefinition = attributedefinition
8544 return c
8545 }
8546
8547
8548
8549
8550
8551
8552
8553 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall {
8554 c.urlParams_.Set("updateMask", updateMask)
8555 return c
8556 }
8557
8558
8559
8560
8561 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall {
8562 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8563 return c
8564 }
8565
8566
8567 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall {
8568 c.ctx_ = ctx
8569 return c
8570 }
8571
8572
8573
8574 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall) Header() http.Header {
8575 if c.header_ == nil {
8576 c.header_ = make(http.Header)
8577 }
8578 return c.header_
8579 }
8580
8581 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall) doRequest(alt string) (*http.Response, error) {
8582 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8583 var body io.Reader = nil
8584 body, err := googleapi.WithoutDataWrapper.JSONReader(c.attributedefinition)
8585 if err != nil {
8586 return nil, err
8587 }
8588 c.urlParams_.Set("alt", alt)
8589 c.urlParams_.Set("prettyPrint", "false")
8590 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8591 urls += "?" + c.urlParams_.Encode()
8592 req, err := http.NewRequest("PATCH", urls, body)
8593 if err != nil {
8594 return nil, err
8595 }
8596 req.Header = reqHeaders
8597 googleapi.Expand(req.URL, map[string]string{
8598 "name": c.name,
8599 })
8600 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8601 }
8602
8603
8604
8605
8606
8607
8608
8609 func (c *ProjectsLocationsDatasetsConsentStoresAttributeDefinitionsPatchCall) Do(opts ...googleapi.CallOption) (*AttributeDefinition, error) {
8610 gensupport.SetOptions(c.urlParams_, opts...)
8611 res, err := c.doRequest("json")
8612 if res != nil && res.StatusCode == http.StatusNotModified {
8613 if res.Body != nil {
8614 res.Body.Close()
8615 }
8616 return nil, gensupport.WrapError(&googleapi.Error{
8617 Code: res.StatusCode,
8618 Header: res.Header,
8619 })
8620 }
8621 if err != nil {
8622 return nil, err
8623 }
8624 defer googleapi.CloseBody(res)
8625 if err := googleapi.CheckResponse(res); err != nil {
8626 return nil, gensupport.WrapError(err)
8627 }
8628 ret := &AttributeDefinition{
8629 ServerResponse: googleapi.ServerResponse{
8630 Header: res.Header,
8631 HTTPStatusCode: res.StatusCode,
8632 },
8633 }
8634 target := &ret
8635 if err := gensupport.DecodeResponse(target, res); err != nil {
8636 return nil, err
8637 }
8638 return ret, nil
8639 }
8640
8641 type ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall struct {
8642 s *Service
8643 parent string
8644 consentartifact *ConsentArtifact
8645 urlParams_ gensupport.URLParams
8646 ctx_ context.Context
8647 header_ http.Header
8648 }
8649
8650
8651
8652
8653 func (r *ProjectsLocationsDatasetsConsentStoresConsentArtifactsService) Create(parent string, consentartifact *ConsentArtifact) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall {
8654 c := &ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8655 c.parent = parent
8656 c.consentartifact = consentartifact
8657 return c
8658 }
8659
8660
8661
8662
8663 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall {
8664 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8665 return c
8666 }
8667
8668
8669 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall {
8670 c.ctx_ = ctx
8671 return c
8672 }
8673
8674
8675
8676 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall) Header() http.Header {
8677 if c.header_ == nil {
8678 c.header_ = make(http.Header)
8679 }
8680 return c.header_
8681 }
8682
8683 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall) doRequest(alt string) (*http.Response, error) {
8684 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
8685 var body io.Reader = nil
8686 body, err := googleapi.WithoutDataWrapper.JSONReader(c.consentartifact)
8687 if err != nil {
8688 return nil, err
8689 }
8690 c.urlParams_.Set("alt", alt)
8691 c.urlParams_.Set("prettyPrint", "false")
8692 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/consentArtifacts")
8693 urls += "?" + c.urlParams_.Encode()
8694 req, err := http.NewRequest("POST", urls, body)
8695 if err != nil {
8696 return nil, err
8697 }
8698 req.Header = reqHeaders
8699 googleapi.Expand(req.URL, map[string]string{
8700 "parent": c.parent,
8701 })
8702 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8703 }
8704
8705
8706
8707
8708
8709
8710
8711 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsCreateCall) Do(opts ...googleapi.CallOption) (*ConsentArtifact, error) {
8712 gensupport.SetOptions(c.urlParams_, opts...)
8713 res, err := c.doRequest("json")
8714 if res != nil && res.StatusCode == http.StatusNotModified {
8715 if res.Body != nil {
8716 res.Body.Close()
8717 }
8718 return nil, gensupport.WrapError(&googleapi.Error{
8719 Code: res.StatusCode,
8720 Header: res.Header,
8721 })
8722 }
8723 if err != nil {
8724 return nil, err
8725 }
8726 defer googleapi.CloseBody(res)
8727 if err := googleapi.CheckResponse(res); err != nil {
8728 return nil, gensupport.WrapError(err)
8729 }
8730 ret := &ConsentArtifact{
8731 ServerResponse: googleapi.ServerResponse{
8732 Header: res.Header,
8733 HTTPStatusCode: res.StatusCode,
8734 },
8735 }
8736 target := &ret
8737 if err := gensupport.DecodeResponse(target, res); err != nil {
8738 return nil, err
8739 }
8740 return ret, nil
8741 }
8742
8743 type ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall struct {
8744 s *Service
8745 name string
8746 urlParams_ gensupport.URLParams
8747 ctx_ context.Context
8748 header_ http.Header
8749 }
8750
8751
8752
8753
8754
8755
8756
8757 func (r *ProjectsLocationsDatasetsConsentStoresConsentArtifactsService) Delete(name string) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall {
8758 c := &ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8759 c.name = name
8760 return c
8761 }
8762
8763
8764
8765
8766 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall {
8767 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8768 return c
8769 }
8770
8771
8772 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall {
8773 c.ctx_ = ctx
8774 return c
8775 }
8776
8777
8778
8779 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall) Header() http.Header {
8780 if c.header_ == nil {
8781 c.header_ = make(http.Header)
8782 }
8783 return c.header_
8784 }
8785
8786 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall) doRequest(alt string) (*http.Response, error) {
8787 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8788 var body io.Reader = nil
8789 c.urlParams_.Set("alt", alt)
8790 c.urlParams_.Set("prettyPrint", "false")
8791 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8792 urls += "?" + c.urlParams_.Encode()
8793 req, err := http.NewRequest("DELETE", urls, body)
8794 if err != nil {
8795 return nil, err
8796 }
8797 req.Header = reqHeaders
8798 googleapi.Expand(req.URL, map[string]string{
8799 "name": c.name,
8800 })
8801 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8802 }
8803
8804
8805
8806
8807
8808
8809 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
8810 gensupport.SetOptions(c.urlParams_, opts...)
8811 res, err := c.doRequest("json")
8812 if res != nil && res.StatusCode == http.StatusNotModified {
8813 if res.Body != nil {
8814 res.Body.Close()
8815 }
8816 return nil, gensupport.WrapError(&googleapi.Error{
8817 Code: res.StatusCode,
8818 Header: res.Header,
8819 })
8820 }
8821 if err != nil {
8822 return nil, err
8823 }
8824 defer googleapi.CloseBody(res)
8825 if err := googleapi.CheckResponse(res); err != nil {
8826 return nil, gensupport.WrapError(err)
8827 }
8828 ret := &Empty{
8829 ServerResponse: googleapi.ServerResponse{
8830 Header: res.Header,
8831 HTTPStatusCode: res.StatusCode,
8832 },
8833 }
8834 target := &ret
8835 if err := gensupport.DecodeResponse(target, res); err != nil {
8836 return nil, err
8837 }
8838 return ret, nil
8839 }
8840
8841 type ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall struct {
8842 s *Service
8843 name string
8844 urlParams_ gensupport.URLParams
8845 ifNoneMatch_ string
8846 ctx_ context.Context
8847 header_ http.Header
8848 }
8849
8850
8851
8852
8853 func (r *ProjectsLocationsDatasetsConsentStoresConsentArtifactsService) Get(name string) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall {
8854 c := &ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8855 c.name = name
8856 return c
8857 }
8858
8859
8860
8861
8862 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall {
8863 c.urlParams_.Set("fields", googleapi.CombineFields(s))
8864 return c
8865 }
8866
8867
8868
8869
8870 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall {
8871 c.ifNoneMatch_ = entityTag
8872 return c
8873 }
8874
8875
8876 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall {
8877 c.ctx_ = ctx
8878 return c
8879 }
8880
8881
8882
8883 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall) Header() http.Header {
8884 if c.header_ == nil {
8885 c.header_ = make(http.Header)
8886 }
8887 return c.header_
8888 }
8889
8890 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall) doRequest(alt string) (*http.Response, error) {
8891 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
8892 if c.ifNoneMatch_ != "" {
8893 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
8894 }
8895 var body io.Reader = nil
8896 c.urlParams_.Set("alt", alt)
8897 c.urlParams_.Set("prettyPrint", "false")
8898 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
8899 urls += "?" + c.urlParams_.Encode()
8900 req, err := http.NewRequest("GET", urls, body)
8901 if err != nil {
8902 return nil, err
8903 }
8904 req.Header = reqHeaders
8905 googleapi.Expand(req.URL, map[string]string{
8906 "name": c.name,
8907 })
8908 return gensupport.SendRequest(c.ctx_, c.s.client, req)
8909 }
8910
8911
8912
8913
8914
8915
8916
8917 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsGetCall) Do(opts ...googleapi.CallOption) (*ConsentArtifact, error) {
8918 gensupport.SetOptions(c.urlParams_, opts...)
8919 res, err := c.doRequest("json")
8920 if res != nil && res.StatusCode == http.StatusNotModified {
8921 if res.Body != nil {
8922 res.Body.Close()
8923 }
8924 return nil, gensupport.WrapError(&googleapi.Error{
8925 Code: res.StatusCode,
8926 Header: res.Header,
8927 })
8928 }
8929 if err != nil {
8930 return nil, err
8931 }
8932 defer googleapi.CloseBody(res)
8933 if err := googleapi.CheckResponse(res); err != nil {
8934 return nil, gensupport.WrapError(err)
8935 }
8936 ret := &ConsentArtifact{
8937 ServerResponse: googleapi.ServerResponse{
8938 Header: res.Header,
8939 HTTPStatusCode: res.StatusCode,
8940 },
8941 }
8942 target := &ret
8943 if err := gensupport.DecodeResponse(target, res); err != nil {
8944 return nil, err
8945 }
8946 return ret, nil
8947 }
8948
8949 type ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall struct {
8950 s *Service
8951 parent string
8952 urlParams_ gensupport.URLParams
8953 ifNoneMatch_ string
8954 ctx_ context.Context
8955 header_ http.Header
8956 }
8957
8958
8959
8960
8961 func (r *ProjectsLocationsDatasetsConsentStoresConsentArtifactsService) List(parent string) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall {
8962 c := &ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
8963 c.parent = parent
8964 return c
8965 }
8966
8967
8968
8969
8970
8971
8972
8973
8974
8975
8976
8977
8978
8979
8980
8981
8982
8983
8984
8985
8986
8987
8988
8989
8990
8991
8992
8993 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) Filter(filter string) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall {
8994 c.urlParams_.Set("filter", filter)
8995 return c
8996 }
8997
8998
8999
9000
9001 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall {
9002 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9003 return c
9004 }
9005
9006
9007
9008 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall {
9009 c.urlParams_.Set("pageToken", pageToken)
9010 return c
9011 }
9012
9013
9014
9015
9016 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall {
9017 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9018 return c
9019 }
9020
9021
9022
9023
9024 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall {
9025 c.ifNoneMatch_ = entityTag
9026 return c
9027 }
9028
9029
9030 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall {
9031 c.ctx_ = ctx
9032 return c
9033 }
9034
9035
9036
9037 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) Header() http.Header {
9038 if c.header_ == nil {
9039 c.header_ = make(http.Header)
9040 }
9041 return c.header_
9042 }
9043
9044 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) doRequest(alt string) (*http.Response, error) {
9045 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9046 if c.ifNoneMatch_ != "" {
9047 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9048 }
9049 var body io.Reader = nil
9050 c.urlParams_.Set("alt", alt)
9051 c.urlParams_.Set("prettyPrint", "false")
9052 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/consentArtifacts")
9053 urls += "?" + c.urlParams_.Encode()
9054 req, err := http.NewRequest("GET", urls, body)
9055 if err != nil {
9056 return nil, err
9057 }
9058 req.Header = reqHeaders
9059 googleapi.Expand(req.URL, map[string]string{
9060 "parent": c.parent,
9061 })
9062 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9063 }
9064
9065
9066
9067
9068
9069
9070
9071 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) Do(opts ...googleapi.CallOption) (*ListConsentArtifactsResponse, error) {
9072 gensupport.SetOptions(c.urlParams_, opts...)
9073 res, err := c.doRequest("json")
9074 if res != nil && res.StatusCode == http.StatusNotModified {
9075 if res.Body != nil {
9076 res.Body.Close()
9077 }
9078 return nil, gensupport.WrapError(&googleapi.Error{
9079 Code: res.StatusCode,
9080 Header: res.Header,
9081 })
9082 }
9083 if err != nil {
9084 return nil, err
9085 }
9086 defer googleapi.CloseBody(res)
9087 if err := googleapi.CheckResponse(res); err != nil {
9088 return nil, gensupport.WrapError(err)
9089 }
9090 ret := &ListConsentArtifactsResponse{
9091 ServerResponse: googleapi.ServerResponse{
9092 Header: res.Header,
9093 HTTPStatusCode: res.StatusCode,
9094 },
9095 }
9096 target := &ret
9097 if err := gensupport.DecodeResponse(target, res); err != nil {
9098 return nil, err
9099 }
9100 return ret, nil
9101 }
9102
9103
9104
9105
9106 func (c *ProjectsLocationsDatasetsConsentStoresConsentArtifactsListCall) Pages(ctx context.Context, f func(*ListConsentArtifactsResponse) error) error {
9107 c.ctx_ = ctx
9108 defer c.PageToken(c.urlParams_.Get("pageToken"))
9109 for {
9110 x, err := c.Do()
9111 if err != nil {
9112 return err
9113 }
9114 if err := f(x); err != nil {
9115 return err
9116 }
9117 if x.NextPageToken == "" {
9118 return nil
9119 }
9120 c.PageToken(x.NextPageToken)
9121 }
9122 }
9123
9124 type ProjectsLocationsDatasetsConsentStoresConsentsActivateCall struct {
9125 s *Service
9126 name string
9127 activateconsentrequest *ActivateConsentRequest
9128 urlParams_ gensupport.URLParams
9129 ctx_ context.Context
9130 header_ http.Header
9131 }
9132
9133
9134
9135
9136
9137
9138
9139
9140
9141
9142
9143 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) Activate(name string, activateconsentrequest *ActivateConsentRequest) *ProjectsLocationsDatasetsConsentStoresConsentsActivateCall {
9144 c := &ProjectsLocationsDatasetsConsentStoresConsentsActivateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9145 c.name = name
9146 c.activateconsentrequest = activateconsentrequest
9147 return c
9148 }
9149
9150
9151
9152
9153 func (c *ProjectsLocationsDatasetsConsentStoresConsentsActivateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsActivateCall {
9154 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9155 return c
9156 }
9157
9158
9159 func (c *ProjectsLocationsDatasetsConsentStoresConsentsActivateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsActivateCall {
9160 c.ctx_ = ctx
9161 return c
9162 }
9163
9164
9165
9166 func (c *ProjectsLocationsDatasetsConsentStoresConsentsActivateCall) Header() http.Header {
9167 if c.header_ == nil {
9168 c.header_ = make(http.Header)
9169 }
9170 return c.header_
9171 }
9172
9173 func (c *ProjectsLocationsDatasetsConsentStoresConsentsActivateCall) doRequest(alt string) (*http.Response, error) {
9174 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9175 var body io.Reader = nil
9176 body, err := googleapi.WithoutDataWrapper.JSONReader(c.activateconsentrequest)
9177 if err != nil {
9178 return nil, err
9179 }
9180 c.urlParams_.Set("alt", alt)
9181 c.urlParams_.Set("prettyPrint", "false")
9182 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:activate")
9183 urls += "?" + c.urlParams_.Encode()
9184 req, err := http.NewRequest("POST", urls, body)
9185 if err != nil {
9186 return nil, err
9187 }
9188 req.Header = reqHeaders
9189 googleapi.Expand(req.URL, map[string]string{
9190 "name": c.name,
9191 })
9192 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9193 }
9194
9195
9196
9197
9198
9199
9200 func (c *ProjectsLocationsDatasetsConsentStoresConsentsActivateCall) Do(opts ...googleapi.CallOption) (*Consent, error) {
9201 gensupport.SetOptions(c.urlParams_, opts...)
9202 res, err := c.doRequest("json")
9203 if res != nil && res.StatusCode == http.StatusNotModified {
9204 if res.Body != nil {
9205 res.Body.Close()
9206 }
9207 return nil, gensupport.WrapError(&googleapi.Error{
9208 Code: res.StatusCode,
9209 Header: res.Header,
9210 })
9211 }
9212 if err != nil {
9213 return nil, err
9214 }
9215 defer googleapi.CloseBody(res)
9216 if err := googleapi.CheckResponse(res); err != nil {
9217 return nil, gensupport.WrapError(err)
9218 }
9219 ret := &Consent{
9220 ServerResponse: googleapi.ServerResponse{
9221 Header: res.Header,
9222 HTTPStatusCode: res.StatusCode,
9223 },
9224 }
9225 target := &ret
9226 if err := gensupport.DecodeResponse(target, res); err != nil {
9227 return nil, err
9228 }
9229 return ret, nil
9230 }
9231
9232 type ProjectsLocationsDatasetsConsentStoresConsentsCreateCall struct {
9233 s *Service
9234 parent string
9235 consent *Consent
9236 urlParams_ gensupport.URLParams
9237 ctx_ context.Context
9238 header_ http.Header
9239 }
9240
9241
9242
9243
9244 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) Create(parent string, consent *Consent) *ProjectsLocationsDatasetsConsentStoresConsentsCreateCall {
9245 c := &ProjectsLocationsDatasetsConsentStoresConsentsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9246 c.parent = parent
9247 c.consent = consent
9248 return c
9249 }
9250
9251
9252
9253
9254 func (c *ProjectsLocationsDatasetsConsentStoresConsentsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsCreateCall {
9255 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9256 return c
9257 }
9258
9259
9260 func (c *ProjectsLocationsDatasetsConsentStoresConsentsCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsCreateCall {
9261 c.ctx_ = ctx
9262 return c
9263 }
9264
9265
9266
9267 func (c *ProjectsLocationsDatasetsConsentStoresConsentsCreateCall) Header() http.Header {
9268 if c.header_ == nil {
9269 c.header_ = make(http.Header)
9270 }
9271 return c.header_
9272 }
9273
9274 func (c *ProjectsLocationsDatasetsConsentStoresConsentsCreateCall) doRequest(alt string) (*http.Response, error) {
9275 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
9276 var body io.Reader = nil
9277 body, err := googleapi.WithoutDataWrapper.JSONReader(c.consent)
9278 if err != nil {
9279 return nil, err
9280 }
9281 c.urlParams_.Set("alt", alt)
9282 c.urlParams_.Set("prettyPrint", "false")
9283 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/consents")
9284 urls += "?" + c.urlParams_.Encode()
9285 req, err := http.NewRequest("POST", urls, body)
9286 if err != nil {
9287 return nil, err
9288 }
9289 req.Header = reqHeaders
9290 googleapi.Expand(req.URL, map[string]string{
9291 "parent": c.parent,
9292 })
9293 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9294 }
9295
9296
9297
9298
9299
9300
9301 func (c *ProjectsLocationsDatasetsConsentStoresConsentsCreateCall) Do(opts ...googleapi.CallOption) (*Consent, error) {
9302 gensupport.SetOptions(c.urlParams_, opts...)
9303 res, err := c.doRequest("json")
9304 if res != nil && res.StatusCode == http.StatusNotModified {
9305 if res.Body != nil {
9306 res.Body.Close()
9307 }
9308 return nil, gensupport.WrapError(&googleapi.Error{
9309 Code: res.StatusCode,
9310 Header: res.Header,
9311 })
9312 }
9313 if err != nil {
9314 return nil, err
9315 }
9316 defer googleapi.CloseBody(res)
9317 if err := googleapi.CheckResponse(res); err != nil {
9318 return nil, gensupport.WrapError(err)
9319 }
9320 ret := &Consent{
9321 ServerResponse: googleapi.ServerResponse{
9322 Header: res.Header,
9323 HTTPStatusCode: res.StatusCode,
9324 },
9325 }
9326 target := &ret
9327 if err := gensupport.DecodeResponse(target, res); err != nil {
9328 return nil, err
9329 }
9330 return ret, nil
9331 }
9332
9333 type ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall struct {
9334 s *Service
9335 name string
9336 urlParams_ gensupport.URLParams
9337 ctx_ context.Context
9338 header_ http.Header
9339 }
9340
9341
9342
9343
9344
9345
9346
9347
9348
9349
9350 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) Delete(name string) *ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall {
9351 c := &ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9352 c.name = name
9353 return c
9354 }
9355
9356
9357
9358
9359 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall {
9360 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9361 return c
9362 }
9363
9364
9365 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall {
9366 c.ctx_ = ctx
9367 return c
9368 }
9369
9370
9371
9372 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall) Header() http.Header {
9373 if c.header_ == nil {
9374 c.header_ = make(http.Header)
9375 }
9376 return c.header_
9377 }
9378
9379 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall) doRequest(alt string) (*http.Response, error) {
9380 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9381 var body io.Reader = nil
9382 c.urlParams_.Set("alt", alt)
9383 c.urlParams_.Set("prettyPrint", "false")
9384 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
9385 urls += "?" + c.urlParams_.Encode()
9386 req, err := http.NewRequest("DELETE", urls, body)
9387 if err != nil {
9388 return nil, err
9389 }
9390 req.Header = reqHeaders
9391 googleapi.Expand(req.URL, map[string]string{
9392 "name": c.name,
9393 })
9394 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9395 }
9396
9397
9398
9399
9400
9401
9402 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
9403 gensupport.SetOptions(c.urlParams_, opts...)
9404 res, err := c.doRequest("json")
9405 if res != nil && res.StatusCode == http.StatusNotModified {
9406 if res.Body != nil {
9407 res.Body.Close()
9408 }
9409 return nil, gensupport.WrapError(&googleapi.Error{
9410 Code: res.StatusCode,
9411 Header: res.Header,
9412 })
9413 }
9414 if err != nil {
9415 return nil, err
9416 }
9417 defer googleapi.CloseBody(res)
9418 if err := googleapi.CheckResponse(res); err != nil {
9419 return nil, gensupport.WrapError(err)
9420 }
9421 ret := &Empty{
9422 ServerResponse: googleapi.ServerResponse{
9423 Header: res.Header,
9424 HTTPStatusCode: res.StatusCode,
9425 },
9426 }
9427 target := &ret
9428 if err := gensupport.DecodeResponse(target, res); err != nil {
9429 return nil, err
9430 }
9431 return ret, nil
9432 }
9433
9434 type ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall struct {
9435 s *Service
9436 name string
9437 urlParams_ gensupport.URLParams
9438 ctx_ context.Context
9439 header_ http.Header
9440 }
9441
9442
9443
9444
9445
9446
9447
9448
9449
9450
9451 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) DeleteRevision(name string) *ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall {
9452 c := &ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9453 c.name = name
9454 return c
9455 }
9456
9457
9458
9459
9460 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall {
9461 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9462 return c
9463 }
9464
9465
9466 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall {
9467 c.ctx_ = ctx
9468 return c
9469 }
9470
9471
9472
9473 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall) Header() http.Header {
9474 if c.header_ == nil {
9475 c.header_ = make(http.Header)
9476 }
9477 return c.header_
9478 }
9479
9480 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall) doRequest(alt string) (*http.Response, error) {
9481 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9482 var body io.Reader = nil
9483 c.urlParams_.Set("alt", alt)
9484 c.urlParams_.Set("prettyPrint", "false")
9485 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:deleteRevision")
9486 urls += "?" + c.urlParams_.Encode()
9487 req, err := http.NewRequest("DELETE", urls, body)
9488 if err != nil {
9489 return nil, err
9490 }
9491 req.Header = reqHeaders
9492 googleapi.Expand(req.URL, map[string]string{
9493 "name": c.name,
9494 })
9495 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9496 }
9497
9498
9499
9500
9501
9502
9503 func (c *ProjectsLocationsDatasetsConsentStoresConsentsDeleteRevisionCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
9504 gensupport.SetOptions(c.urlParams_, opts...)
9505 res, err := c.doRequest("json")
9506 if res != nil && res.StatusCode == http.StatusNotModified {
9507 if res.Body != nil {
9508 res.Body.Close()
9509 }
9510 return nil, gensupport.WrapError(&googleapi.Error{
9511 Code: res.StatusCode,
9512 Header: res.Header,
9513 })
9514 }
9515 if err != nil {
9516 return nil, err
9517 }
9518 defer googleapi.CloseBody(res)
9519 if err := googleapi.CheckResponse(res); err != nil {
9520 return nil, gensupport.WrapError(err)
9521 }
9522 ret := &Empty{
9523 ServerResponse: googleapi.ServerResponse{
9524 Header: res.Header,
9525 HTTPStatusCode: res.StatusCode,
9526 },
9527 }
9528 target := &ret
9529 if err := gensupport.DecodeResponse(target, res); err != nil {
9530 return nil, err
9531 }
9532 return ret, nil
9533 }
9534
9535 type ProjectsLocationsDatasetsConsentStoresConsentsGetCall struct {
9536 s *Service
9537 name string
9538 urlParams_ gensupport.URLParams
9539 ifNoneMatch_ string
9540 ctx_ context.Context
9541 header_ http.Header
9542 }
9543
9544
9545
9546
9547
9548
9549
9550
9551
9552
9553 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) Get(name string) *ProjectsLocationsDatasetsConsentStoresConsentsGetCall {
9554 c := &ProjectsLocationsDatasetsConsentStoresConsentsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9555 c.name = name
9556 return c
9557 }
9558
9559
9560
9561
9562 func (c *ProjectsLocationsDatasetsConsentStoresConsentsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsGetCall {
9563 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9564 return c
9565 }
9566
9567
9568
9569
9570 func (c *ProjectsLocationsDatasetsConsentStoresConsentsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresConsentsGetCall {
9571 c.ifNoneMatch_ = entityTag
9572 return c
9573 }
9574
9575
9576 func (c *ProjectsLocationsDatasetsConsentStoresConsentsGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsGetCall {
9577 c.ctx_ = ctx
9578 return c
9579 }
9580
9581
9582
9583 func (c *ProjectsLocationsDatasetsConsentStoresConsentsGetCall) Header() http.Header {
9584 if c.header_ == nil {
9585 c.header_ = make(http.Header)
9586 }
9587 return c.header_
9588 }
9589
9590 func (c *ProjectsLocationsDatasetsConsentStoresConsentsGetCall) doRequest(alt string) (*http.Response, error) {
9591 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9592 if c.ifNoneMatch_ != "" {
9593 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9594 }
9595 var body io.Reader = nil
9596 c.urlParams_.Set("alt", alt)
9597 c.urlParams_.Set("prettyPrint", "false")
9598 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
9599 urls += "?" + c.urlParams_.Encode()
9600 req, err := http.NewRequest("GET", urls, body)
9601 if err != nil {
9602 return nil, err
9603 }
9604 req.Header = reqHeaders
9605 googleapi.Expand(req.URL, map[string]string{
9606 "name": c.name,
9607 })
9608 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9609 }
9610
9611
9612
9613
9614
9615
9616 func (c *ProjectsLocationsDatasetsConsentStoresConsentsGetCall) Do(opts ...googleapi.CallOption) (*Consent, error) {
9617 gensupport.SetOptions(c.urlParams_, opts...)
9618 res, err := c.doRequest("json")
9619 if res != nil && res.StatusCode == http.StatusNotModified {
9620 if res.Body != nil {
9621 res.Body.Close()
9622 }
9623 return nil, gensupport.WrapError(&googleapi.Error{
9624 Code: res.StatusCode,
9625 Header: res.Header,
9626 })
9627 }
9628 if err != nil {
9629 return nil, err
9630 }
9631 defer googleapi.CloseBody(res)
9632 if err := googleapi.CheckResponse(res); err != nil {
9633 return nil, gensupport.WrapError(err)
9634 }
9635 ret := &Consent{
9636 ServerResponse: googleapi.ServerResponse{
9637 Header: res.Header,
9638 HTTPStatusCode: res.StatusCode,
9639 },
9640 }
9641 target := &ret
9642 if err := gensupport.DecodeResponse(target, res); err != nil {
9643 return nil, err
9644 }
9645 return ret, nil
9646 }
9647
9648 type ProjectsLocationsDatasetsConsentStoresConsentsListCall struct {
9649 s *Service
9650 parent string
9651 urlParams_ gensupport.URLParams
9652 ifNoneMatch_ string
9653 ctx_ context.Context
9654 header_ http.Header
9655 }
9656
9657
9658
9659
9660
9661 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) List(parent string) *ProjectsLocationsDatasetsConsentStoresConsentsListCall {
9662 c := &ProjectsLocationsDatasetsConsentStoresConsentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9663 c.parent = parent
9664 return c
9665 }
9666
9667
9668
9669
9670
9671
9672
9673
9674
9675
9676
9677
9678
9679
9680
9681
9682
9683
9684
9685
9686
9687
9688
9689
9690
9691
9692
9693
9694 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) Filter(filter string) *ProjectsLocationsDatasetsConsentStoresConsentsListCall {
9695 c.urlParams_.Set("filter", filter)
9696 return c
9697 }
9698
9699
9700
9701
9702 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsConsentStoresConsentsListCall {
9703 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9704 return c
9705 }
9706
9707
9708
9709 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsConsentStoresConsentsListCall {
9710 c.urlParams_.Set("pageToken", pageToken)
9711 return c
9712 }
9713
9714
9715
9716
9717 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsListCall {
9718 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9719 return c
9720 }
9721
9722
9723
9724
9725 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresConsentsListCall {
9726 c.ifNoneMatch_ = entityTag
9727 return c
9728 }
9729
9730
9731 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsListCall {
9732 c.ctx_ = ctx
9733 return c
9734 }
9735
9736
9737
9738 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) Header() http.Header {
9739 if c.header_ == nil {
9740 c.header_ = make(http.Header)
9741 }
9742 return c.header_
9743 }
9744
9745 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) doRequest(alt string) (*http.Response, error) {
9746 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9747 if c.ifNoneMatch_ != "" {
9748 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9749 }
9750 var body io.Reader = nil
9751 c.urlParams_.Set("alt", alt)
9752 c.urlParams_.Set("prettyPrint", "false")
9753 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/consents")
9754 urls += "?" + c.urlParams_.Encode()
9755 req, err := http.NewRequest("GET", urls, body)
9756 if err != nil {
9757 return nil, err
9758 }
9759 req.Header = reqHeaders
9760 googleapi.Expand(req.URL, map[string]string{
9761 "parent": c.parent,
9762 })
9763 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9764 }
9765
9766
9767
9768
9769
9770
9771
9772 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) Do(opts ...googleapi.CallOption) (*ListConsentsResponse, error) {
9773 gensupport.SetOptions(c.urlParams_, opts...)
9774 res, err := c.doRequest("json")
9775 if res != nil && res.StatusCode == http.StatusNotModified {
9776 if res.Body != nil {
9777 res.Body.Close()
9778 }
9779 return nil, gensupport.WrapError(&googleapi.Error{
9780 Code: res.StatusCode,
9781 Header: res.Header,
9782 })
9783 }
9784 if err != nil {
9785 return nil, err
9786 }
9787 defer googleapi.CloseBody(res)
9788 if err := googleapi.CheckResponse(res); err != nil {
9789 return nil, gensupport.WrapError(err)
9790 }
9791 ret := &ListConsentsResponse{
9792 ServerResponse: googleapi.ServerResponse{
9793 Header: res.Header,
9794 HTTPStatusCode: res.StatusCode,
9795 },
9796 }
9797 target := &ret
9798 if err := gensupport.DecodeResponse(target, res); err != nil {
9799 return nil, err
9800 }
9801 return ret, nil
9802 }
9803
9804
9805
9806
9807 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListCall) Pages(ctx context.Context, f func(*ListConsentsResponse) error) error {
9808 c.ctx_ = ctx
9809 defer c.PageToken(c.urlParams_.Get("pageToken"))
9810 for {
9811 x, err := c.Do()
9812 if err != nil {
9813 return err
9814 }
9815 if err := f(x); err != nil {
9816 return err
9817 }
9818 if x.NextPageToken == "" {
9819 return nil
9820 }
9821 c.PageToken(x.NextPageToken)
9822 }
9823 }
9824
9825 type ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall struct {
9826 s *Service
9827 name string
9828 urlParams_ gensupport.URLParams
9829 ifNoneMatch_ string
9830 ctx_ context.Context
9831 header_ http.Header
9832 }
9833
9834
9835
9836
9837
9838 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) ListRevisions(name string) *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall {
9839 c := &ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
9840 c.name = name
9841 return c
9842 }
9843
9844
9845
9846
9847
9848
9849
9850
9851
9852
9853
9854
9855
9856
9857
9858
9859
9860
9861
9862
9863
9864
9865
9866
9867
9868
9869
9870
9871 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) Filter(filter string) *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall {
9872 c.urlParams_.Set("filter", filter)
9873 return c
9874 }
9875
9876
9877
9878
9879 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall {
9880 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
9881 return c
9882 }
9883
9884
9885
9886 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) PageToken(pageToken string) *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall {
9887 c.urlParams_.Set("pageToken", pageToken)
9888 return c
9889 }
9890
9891
9892
9893
9894 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall {
9895 c.urlParams_.Set("fields", googleapi.CombineFields(s))
9896 return c
9897 }
9898
9899
9900
9901
9902 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall {
9903 c.ifNoneMatch_ = entityTag
9904 return c
9905 }
9906
9907
9908 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall {
9909 c.ctx_ = ctx
9910 return c
9911 }
9912
9913
9914
9915 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) Header() http.Header {
9916 if c.header_ == nil {
9917 c.header_ = make(http.Header)
9918 }
9919 return c.header_
9920 }
9921
9922 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) doRequest(alt string) (*http.Response, error) {
9923 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
9924 if c.ifNoneMatch_ != "" {
9925 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
9926 }
9927 var body io.Reader = nil
9928 c.urlParams_.Set("alt", alt)
9929 c.urlParams_.Set("prettyPrint", "false")
9930 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:listRevisions")
9931 urls += "?" + c.urlParams_.Encode()
9932 req, err := http.NewRequest("GET", urls, body)
9933 if err != nil {
9934 return nil, err
9935 }
9936 req.Header = reqHeaders
9937 googleapi.Expand(req.URL, map[string]string{
9938 "name": c.name,
9939 })
9940 return gensupport.SendRequest(c.ctx_, c.s.client, req)
9941 }
9942
9943
9944
9945
9946
9947
9948
9949 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) Do(opts ...googleapi.CallOption) (*ListConsentRevisionsResponse, error) {
9950 gensupport.SetOptions(c.urlParams_, opts...)
9951 res, err := c.doRequest("json")
9952 if res != nil && res.StatusCode == http.StatusNotModified {
9953 if res.Body != nil {
9954 res.Body.Close()
9955 }
9956 return nil, gensupport.WrapError(&googleapi.Error{
9957 Code: res.StatusCode,
9958 Header: res.Header,
9959 })
9960 }
9961 if err != nil {
9962 return nil, err
9963 }
9964 defer googleapi.CloseBody(res)
9965 if err := googleapi.CheckResponse(res); err != nil {
9966 return nil, gensupport.WrapError(err)
9967 }
9968 ret := &ListConsentRevisionsResponse{
9969 ServerResponse: googleapi.ServerResponse{
9970 Header: res.Header,
9971 HTTPStatusCode: res.StatusCode,
9972 },
9973 }
9974 target := &ret
9975 if err := gensupport.DecodeResponse(target, res); err != nil {
9976 return nil, err
9977 }
9978 return ret, nil
9979 }
9980
9981
9982
9983
9984 func (c *ProjectsLocationsDatasetsConsentStoresConsentsListRevisionsCall) Pages(ctx context.Context, f func(*ListConsentRevisionsResponse) error) error {
9985 c.ctx_ = ctx
9986 defer c.PageToken(c.urlParams_.Get("pageToken"))
9987 for {
9988 x, err := c.Do()
9989 if err != nil {
9990 return err
9991 }
9992 if err := f(x); err != nil {
9993 return err
9994 }
9995 if x.NextPageToken == "" {
9996 return nil
9997 }
9998 c.PageToken(x.NextPageToken)
9999 }
10000 }
10001
10002 type ProjectsLocationsDatasetsConsentStoresConsentsPatchCall struct {
10003 s *Service
10004 name string
10005 consent *Consent
10006 urlParams_ gensupport.URLParams
10007 ctx_ context.Context
10008 header_ http.Header
10009 }
10010
10011
10012
10013
10014
10015
10016
10017
10018
10019
10020 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) Patch(name string, consent *Consent) *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall {
10021 c := &ProjectsLocationsDatasetsConsentStoresConsentsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10022 c.name = name
10023 c.consent = consent
10024 return c
10025 }
10026
10027
10028
10029
10030
10031
10032 func (c *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall {
10033 c.urlParams_.Set("updateMask", updateMask)
10034 return c
10035 }
10036
10037
10038
10039
10040 func (c *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall {
10041 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10042 return c
10043 }
10044
10045
10046 func (c *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall {
10047 c.ctx_ = ctx
10048 return c
10049 }
10050
10051
10052
10053 func (c *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall) Header() http.Header {
10054 if c.header_ == nil {
10055 c.header_ = make(http.Header)
10056 }
10057 return c.header_
10058 }
10059
10060 func (c *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall) doRequest(alt string) (*http.Response, error) {
10061 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10062 var body io.Reader = nil
10063 body, err := googleapi.WithoutDataWrapper.JSONReader(c.consent)
10064 if err != nil {
10065 return nil, err
10066 }
10067 c.urlParams_.Set("alt", alt)
10068 c.urlParams_.Set("prettyPrint", "false")
10069 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10070 urls += "?" + c.urlParams_.Encode()
10071 req, err := http.NewRequest("PATCH", urls, body)
10072 if err != nil {
10073 return nil, err
10074 }
10075 req.Header = reqHeaders
10076 googleapi.Expand(req.URL, map[string]string{
10077 "name": c.name,
10078 })
10079 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10080 }
10081
10082
10083
10084
10085
10086
10087 func (c *ProjectsLocationsDatasetsConsentStoresConsentsPatchCall) Do(opts ...googleapi.CallOption) (*Consent, error) {
10088 gensupport.SetOptions(c.urlParams_, opts...)
10089 res, err := c.doRequest("json")
10090 if res != nil && res.StatusCode == http.StatusNotModified {
10091 if res.Body != nil {
10092 res.Body.Close()
10093 }
10094 return nil, gensupport.WrapError(&googleapi.Error{
10095 Code: res.StatusCode,
10096 Header: res.Header,
10097 })
10098 }
10099 if err != nil {
10100 return nil, err
10101 }
10102 defer googleapi.CloseBody(res)
10103 if err := googleapi.CheckResponse(res); err != nil {
10104 return nil, gensupport.WrapError(err)
10105 }
10106 ret := &Consent{
10107 ServerResponse: googleapi.ServerResponse{
10108 Header: res.Header,
10109 HTTPStatusCode: res.StatusCode,
10110 },
10111 }
10112 target := &ret
10113 if err := gensupport.DecodeResponse(target, res); err != nil {
10114 return nil, err
10115 }
10116 return ret, nil
10117 }
10118
10119 type ProjectsLocationsDatasetsConsentStoresConsentsRejectCall struct {
10120 s *Service
10121 name string
10122 rejectconsentrequest *RejectConsentRequest
10123 urlParams_ gensupport.URLParams
10124 ctx_ context.Context
10125 header_ http.Header
10126 }
10127
10128
10129
10130
10131
10132
10133
10134
10135
10136
10137
10138 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) Reject(name string, rejectconsentrequest *RejectConsentRequest) *ProjectsLocationsDatasetsConsentStoresConsentsRejectCall {
10139 c := &ProjectsLocationsDatasetsConsentStoresConsentsRejectCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10140 c.name = name
10141 c.rejectconsentrequest = rejectconsentrequest
10142 return c
10143 }
10144
10145
10146
10147
10148 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRejectCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsRejectCall {
10149 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10150 return c
10151 }
10152
10153
10154 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRejectCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsRejectCall {
10155 c.ctx_ = ctx
10156 return c
10157 }
10158
10159
10160
10161 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRejectCall) Header() http.Header {
10162 if c.header_ == nil {
10163 c.header_ = make(http.Header)
10164 }
10165 return c.header_
10166 }
10167
10168 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRejectCall) doRequest(alt string) (*http.Response, error) {
10169 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10170 var body io.Reader = nil
10171 body, err := googleapi.WithoutDataWrapper.JSONReader(c.rejectconsentrequest)
10172 if err != nil {
10173 return nil, err
10174 }
10175 c.urlParams_.Set("alt", alt)
10176 c.urlParams_.Set("prettyPrint", "false")
10177 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:reject")
10178 urls += "?" + c.urlParams_.Encode()
10179 req, err := http.NewRequest("POST", urls, body)
10180 if err != nil {
10181 return nil, err
10182 }
10183 req.Header = reqHeaders
10184 googleapi.Expand(req.URL, map[string]string{
10185 "name": c.name,
10186 })
10187 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10188 }
10189
10190
10191
10192
10193
10194
10195 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRejectCall) Do(opts ...googleapi.CallOption) (*Consent, error) {
10196 gensupport.SetOptions(c.urlParams_, opts...)
10197 res, err := c.doRequest("json")
10198 if res != nil && res.StatusCode == http.StatusNotModified {
10199 if res.Body != nil {
10200 res.Body.Close()
10201 }
10202 return nil, gensupport.WrapError(&googleapi.Error{
10203 Code: res.StatusCode,
10204 Header: res.Header,
10205 })
10206 }
10207 if err != nil {
10208 return nil, err
10209 }
10210 defer googleapi.CloseBody(res)
10211 if err := googleapi.CheckResponse(res); err != nil {
10212 return nil, gensupport.WrapError(err)
10213 }
10214 ret := &Consent{
10215 ServerResponse: googleapi.ServerResponse{
10216 Header: res.Header,
10217 HTTPStatusCode: res.StatusCode,
10218 },
10219 }
10220 target := &ret
10221 if err := gensupport.DecodeResponse(target, res); err != nil {
10222 return nil, err
10223 }
10224 return ret, nil
10225 }
10226
10227 type ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall struct {
10228 s *Service
10229 name string
10230 revokeconsentrequest *RevokeConsentRequest
10231 urlParams_ gensupport.URLParams
10232 ctx_ context.Context
10233 header_ http.Header
10234 }
10235
10236
10237
10238
10239
10240
10241
10242
10243
10244
10245
10246 func (r *ProjectsLocationsDatasetsConsentStoresConsentsService) Revoke(name string, revokeconsentrequest *RevokeConsentRequest) *ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall {
10247 c := &ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10248 c.name = name
10249 c.revokeconsentrequest = revokeconsentrequest
10250 return c
10251 }
10252
10253
10254
10255
10256 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall {
10257 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10258 return c
10259 }
10260
10261
10262 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall {
10263 c.ctx_ = ctx
10264 return c
10265 }
10266
10267
10268
10269 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall) Header() http.Header {
10270 if c.header_ == nil {
10271 c.header_ = make(http.Header)
10272 }
10273 return c.header_
10274 }
10275
10276 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall) doRequest(alt string) (*http.Response, error) {
10277 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10278 var body io.Reader = nil
10279 body, err := googleapi.WithoutDataWrapper.JSONReader(c.revokeconsentrequest)
10280 if err != nil {
10281 return nil, err
10282 }
10283 c.urlParams_.Set("alt", alt)
10284 c.urlParams_.Set("prettyPrint", "false")
10285 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:revoke")
10286 urls += "?" + c.urlParams_.Encode()
10287 req, err := http.NewRequest("POST", urls, body)
10288 if err != nil {
10289 return nil, err
10290 }
10291 req.Header = reqHeaders
10292 googleapi.Expand(req.URL, map[string]string{
10293 "name": c.name,
10294 })
10295 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10296 }
10297
10298
10299
10300
10301
10302
10303 func (c *ProjectsLocationsDatasetsConsentStoresConsentsRevokeCall) Do(opts ...googleapi.CallOption) (*Consent, error) {
10304 gensupport.SetOptions(c.urlParams_, opts...)
10305 res, err := c.doRequest("json")
10306 if res != nil && res.StatusCode == http.StatusNotModified {
10307 if res.Body != nil {
10308 res.Body.Close()
10309 }
10310 return nil, gensupport.WrapError(&googleapi.Error{
10311 Code: res.StatusCode,
10312 Header: res.Header,
10313 })
10314 }
10315 if err != nil {
10316 return nil, err
10317 }
10318 defer googleapi.CloseBody(res)
10319 if err := googleapi.CheckResponse(res); err != nil {
10320 return nil, gensupport.WrapError(err)
10321 }
10322 ret := &Consent{
10323 ServerResponse: googleapi.ServerResponse{
10324 Header: res.Header,
10325 HTTPStatusCode: res.StatusCode,
10326 },
10327 }
10328 target := &ret
10329 if err := gensupport.DecodeResponse(target, res); err != nil {
10330 return nil, err
10331 }
10332 return ret, nil
10333 }
10334
10335 type ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall struct {
10336 s *Service
10337 name string
10338 archiveuserdatamappingrequest *ArchiveUserDataMappingRequest
10339 urlParams_ gensupport.URLParams
10340 ctx_ context.Context
10341 header_ http.Header
10342 }
10343
10344
10345
10346
10347 func (r *ProjectsLocationsDatasetsConsentStoresUserDataMappingsService) Archive(name string, archiveuserdatamappingrequest *ArchiveUserDataMappingRequest) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall {
10348 c := &ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10349 c.name = name
10350 c.archiveuserdatamappingrequest = archiveuserdatamappingrequest
10351 return c
10352 }
10353
10354
10355
10356
10357 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall {
10358 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10359 return c
10360 }
10361
10362
10363 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall {
10364 c.ctx_ = ctx
10365 return c
10366 }
10367
10368
10369
10370 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall) Header() http.Header {
10371 if c.header_ == nil {
10372 c.header_ = make(http.Header)
10373 }
10374 return c.header_
10375 }
10376
10377 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall) doRequest(alt string) (*http.Response, error) {
10378 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10379 var body io.Reader = nil
10380 body, err := googleapi.WithoutDataWrapper.JSONReader(c.archiveuserdatamappingrequest)
10381 if err != nil {
10382 return nil, err
10383 }
10384 c.urlParams_.Set("alt", alt)
10385 c.urlParams_.Set("prettyPrint", "false")
10386 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:archive")
10387 urls += "?" + c.urlParams_.Encode()
10388 req, err := http.NewRequest("POST", urls, body)
10389 if err != nil {
10390 return nil, err
10391 }
10392 req.Header = reqHeaders
10393 googleapi.Expand(req.URL, map[string]string{
10394 "name": c.name,
10395 })
10396 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10397 }
10398
10399
10400
10401
10402
10403
10404
10405 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsArchiveCall) Do(opts ...googleapi.CallOption) (*ArchiveUserDataMappingResponse, error) {
10406 gensupport.SetOptions(c.urlParams_, opts...)
10407 res, err := c.doRequest("json")
10408 if res != nil && res.StatusCode == http.StatusNotModified {
10409 if res.Body != nil {
10410 res.Body.Close()
10411 }
10412 return nil, gensupport.WrapError(&googleapi.Error{
10413 Code: res.StatusCode,
10414 Header: res.Header,
10415 })
10416 }
10417 if err != nil {
10418 return nil, err
10419 }
10420 defer googleapi.CloseBody(res)
10421 if err := googleapi.CheckResponse(res); err != nil {
10422 return nil, gensupport.WrapError(err)
10423 }
10424 ret := &ArchiveUserDataMappingResponse{
10425 ServerResponse: googleapi.ServerResponse{
10426 Header: res.Header,
10427 HTTPStatusCode: res.StatusCode,
10428 },
10429 }
10430 target := &ret
10431 if err := gensupport.DecodeResponse(target, res); err != nil {
10432 return nil, err
10433 }
10434 return ret, nil
10435 }
10436
10437 type ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall struct {
10438 s *Service
10439 parent string
10440 userdatamapping *UserDataMapping
10441 urlParams_ gensupport.URLParams
10442 ctx_ context.Context
10443 header_ http.Header
10444 }
10445
10446
10447
10448
10449 func (r *ProjectsLocationsDatasetsConsentStoresUserDataMappingsService) Create(parent string, userdatamapping *UserDataMapping) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall {
10450 c := &ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10451 c.parent = parent
10452 c.userdatamapping = userdatamapping
10453 return c
10454 }
10455
10456
10457
10458
10459 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall {
10460 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10461 return c
10462 }
10463
10464
10465 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall {
10466 c.ctx_ = ctx
10467 return c
10468 }
10469
10470
10471
10472 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall) Header() http.Header {
10473 if c.header_ == nil {
10474 c.header_ = make(http.Header)
10475 }
10476 return c.header_
10477 }
10478
10479 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall) doRequest(alt string) (*http.Response, error) {
10480 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10481 var body io.Reader = nil
10482 body, err := googleapi.WithoutDataWrapper.JSONReader(c.userdatamapping)
10483 if err != nil {
10484 return nil, err
10485 }
10486 c.urlParams_.Set("alt", alt)
10487 c.urlParams_.Set("prettyPrint", "false")
10488 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/userDataMappings")
10489 urls += "?" + c.urlParams_.Encode()
10490 req, err := http.NewRequest("POST", urls, body)
10491 if err != nil {
10492 return nil, err
10493 }
10494 req.Header = reqHeaders
10495 googleapi.Expand(req.URL, map[string]string{
10496 "parent": c.parent,
10497 })
10498 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10499 }
10500
10501
10502
10503
10504
10505
10506
10507 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsCreateCall) Do(opts ...googleapi.CallOption) (*UserDataMapping, error) {
10508 gensupport.SetOptions(c.urlParams_, opts...)
10509 res, err := c.doRequest("json")
10510 if res != nil && res.StatusCode == http.StatusNotModified {
10511 if res.Body != nil {
10512 res.Body.Close()
10513 }
10514 return nil, gensupport.WrapError(&googleapi.Error{
10515 Code: res.StatusCode,
10516 Header: res.Header,
10517 })
10518 }
10519 if err != nil {
10520 return nil, err
10521 }
10522 defer googleapi.CloseBody(res)
10523 if err := googleapi.CheckResponse(res); err != nil {
10524 return nil, gensupport.WrapError(err)
10525 }
10526 ret := &UserDataMapping{
10527 ServerResponse: googleapi.ServerResponse{
10528 Header: res.Header,
10529 HTTPStatusCode: res.StatusCode,
10530 },
10531 }
10532 target := &ret
10533 if err := gensupport.DecodeResponse(target, res); err != nil {
10534 return nil, err
10535 }
10536 return ret, nil
10537 }
10538
10539 type ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall struct {
10540 s *Service
10541 name string
10542 urlParams_ gensupport.URLParams
10543 ctx_ context.Context
10544 header_ http.Header
10545 }
10546
10547
10548
10549
10550 func (r *ProjectsLocationsDatasetsConsentStoresUserDataMappingsService) Delete(name string) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall {
10551 c := &ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10552 c.name = name
10553 return c
10554 }
10555
10556
10557
10558
10559 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall {
10560 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10561 return c
10562 }
10563
10564
10565 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall {
10566 c.ctx_ = ctx
10567 return c
10568 }
10569
10570
10571
10572 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall) Header() http.Header {
10573 if c.header_ == nil {
10574 c.header_ = make(http.Header)
10575 }
10576 return c.header_
10577 }
10578
10579 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall) doRequest(alt string) (*http.Response, error) {
10580 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10581 var body io.Reader = nil
10582 c.urlParams_.Set("alt", alt)
10583 c.urlParams_.Set("prettyPrint", "false")
10584 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10585 urls += "?" + c.urlParams_.Encode()
10586 req, err := http.NewRequest("DELETE", urls, body)
10587 if err != nil {
10588 return nil, err
10589 }
10590 req.Header = reqHeaders
10591 googleapi.Expand(req.URL, map[string]string{
10592 "name": c.name,
10593 })
10594 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10595 }
10596
10597
10598
10599
10600
10601
10602 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
10603 gensupport.SetOptions(c.urlParams_, opts...)
10604 res, err := c.doRequest("json")
10605 if res != nil && res.StatusCode == http.StatusNotModified {
10606 if res.Body != nil {
10607 res.Body.Close()
10608 }
10609 return nil, gensupport.WrapError(&googleapi.Error{
10610 Code: res.StatusCode,
10611 Header: res.Header,
10612 })
10613 }
10614 if err != nil {
10615 return nil, err
10616 }
10617 defer googleapi.CloseBody(res)
10618 if err := googleapi.CheckResponse(res); err != nil {
10619 return nil, gensupport.WrapError(err)
10620 }
10621 ret := &Empty{
10622 ServerResponse: googleapi.ServerResponse{
10623 Header: res.Header,
10624 HTTPStatusCode: res.StatusCode,
10625 },
10626 }
10627 target := &ret
10628 if err := gensupport.DecodeResponse(target, res); err != nil {
10629 return nil, err
10630 }
10631 return ret, nil
10632 }
10633
10634 type ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall struct {
10635 s *Service
10636 name string
10637 urlParams_ gensupport.URLParams
10638 ifNoneMatch_ string
10639 ctx_ context.Context
10640 header_ http.Header
10641 }
10642
10643
10644
10645
10646 func (r *ProjectsLocationsDatasetsConsentStoresUserDataMappingsService) Get(name string) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall {
10647 c := &ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10648 c.name = name
10649 return c
10650 }
10651
10652
10653
10654
10655 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall {
10656 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10657 return c
10658 }
10659
10660
10661
10662
10663 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall {
10664 c.ifNoneMatch_ = entityTag
10665 return c
10666 }
10667
10668
10669 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall {
10670 c.ctx_ = ctx
10671 return c
10672 }
10673
10674
10675
10676 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall) Header() http.Header {
10677 if c.header_ == nil {
10678 c.header_ = make(http.Header)
10679 }
10680 return c.header_
10681 }
10682
10683 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall) doRequest(alt string) (*http.Response, error) {
10684 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10685 if c.ifNoneMatch_ != "" {
10686 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10687 }
10688 var body io.Reader = nil
10689 c.urlParams_.Set("alt", alt)
10690 c.urlParams_.Set("prettyPrint", "false")
10691 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10692 urls += "?" + c.urlParams_.Encode()
10693 req, err := http.NewRequest("GET", urls, body)
10694 if err != nil {
10695 return nil, err
10696 }
10697 req.Header = reqHeaders
10698 googleapi.Expand(req.URL, map[string]string{
10699 "name": c.name,
10700 })
10701 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10702 }
10703
10704
10705
10706
10707
10708
10709
10710 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsGetCall) Do(opts ...googleapi.CallOption) (*UserDataMapping, error) {
10711 gensupport.SetOptions(c.urlParams_, opts...)
10712 res, err := c.doRequest("json")
10713 if res != nil && res.StatusCode == http.StatusNotModified {
10714 if res.Body != nil {
10715 res.Body.Close()
10716 }
10717 return nil, gensupport.WrapError(&googleapi.Error{
10718 Code: res.StatusCode,
10719 Header: res.Header,
10720 })
10721 }
10722 if err != nil {
10723 return nil, err
10724 }
10725 defer googleapi.CloseBody(res)
10726 if err := googleapi.CheckResponse(res); err != nil {
10727 return nil, gensupport.WrapError(err)
10728 }
10729 ret := &UserDataMapping{
10730 ServerResponse: googleapi.ServerResponse{
10731 Header: res.Header,
10732 HTTPStatusCode: res.StatusCode,
10733 },
10734 }
10735 target := &ret
10736 if err := gensupport.DecodeResponse(target, res); err != nil {
10737 return nil, err
10738 }
10739 return ret, nil
10740 }
10741
10742 type ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall struct {
10743 s *Service
10744 parent string
10745 urlParams_ gensupport.URLParams
10746 ifNoneMatch_ string
10747 ctx_ context.Context
10748 header_ http.Header
10749 }
10750
10751
10752
10753
10754 func (r *ProjectsLocationsDatasetsConsentStoresUserDataMappingsService) List(parent string) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall {
10755 c := &ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10756 c.parent = parent
10757 return c
10758 }
10759
10760
10761
10762
10763
10764
10765
10766
10767
10768
10769
10770
10771
10772
10773
10774
10775
10776
10777
10778
10779
10780
10781
10782
10783
10784 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) Filter(filter string) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall {
10785 c.urlParams_.Set("filter", filter)
10786 return c
10787 }
10788
10789
10790
10791
10792 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall {
10793 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
10794 return c
10795 }
10796
10797
10798
10799 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall {
10800 c.urlParams_.Set("pageToken", pageToken)
10801 return c
10802 }
10803
10804
10805
10806
10807 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall {
10808 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10809 return c
10810 }
10811
10812
10813
10814
10815 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall {
10816 c.ifNoneMatch_ = entityTag
10817 return c
10818 }
10819
10820
10821 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall {
10822 c.ctx_ = ctx
10823 return c
10824 }
10825
10826
10827
10828 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) Header() http.Header {
10829 if c.header_ == nil {
10830 c.header_ = make(http.Header)
10831 }
10832 return c.header_
10833 }
10834
10835 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) doRequest(alt string) (*http.Response, error) {
10836 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
10837 if c.ifNoneMatch_ != "" {
10838 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
10839 }
10840 var body io.Reader = nil
10841 c.urlParams_.Set("alt", alt)
10842 c.urlParams_.Set("prettyPrint", "false")
10843 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/userDataMappings")
10844 urls += "?" + c.urlParams_.Encode()
10845 req, err := http.NewRequest("GET", urls, body)
10846 if err != nil {
10847 return nil, err
10848 }
10849 req.Header = reqHeaders
10850 googleapi.Expand(req.URL, map[string]string{
10851 "parent": c.parent,
10852 })
10853 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10854 }
10855
10856
10857
10858
10859
10860
10861
10862 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) Do(opts ...googleapi.CallOption) (*ListUserDataMappingsResponse, error) {
10863 gensupport.SetOptions(c.urlParams_, opts...)
10864 res, err := c.doRequest("json")
10865 if res != nil && res.StatusCode == http.StatusNotModified {
10866 if res.Body != nil {
10867 res.Body.Close()
10868 }
10869 return nil, gensupport.WrapError(&googleapi.Error{
10870 Code: res.StatusCode,
10871 Header: res.Header,
10872 })
10873 }
10874 if err != nil {
10875 return nil, err
10876 }
10877 defer googleapi.CloseBody(res)
10878 if err := googleapi.CheckResponse(res); err != nil {
10879 return nil, gensupport.WrapError(err)
10880 }
10881 ret := &ListUserDataMappingsResponse{
10882 ServerResponse: googleapi.ServerResponse{
10883 Header: res.Header,
10884 HTTPStatusCode: res.StatusCode,
10885 },
10886 }
10887 target := &ret
10888 if err := gensupport.DecodeResponse(target, res); err != nil {
10889 return nil, err
10890 }
10891 return ret, nil
10892 }
10893
10894
10895
10896
10897 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsListCall) Pages(ctx context.Context, f func(*ListUserDataMappingsResponse) error) error {
10898 c.ctx_ = ctx
10899 defer c.PageToken(c.urlParams_.Get("pageToken"))
10900 for {
10901 x, err := c.Do()
10902 if err != nil {
10903 return err
10904 }
10905 if err := f(x); err != nil {
10906 return err
10907 }
10908 if x.NextPageToken == "" {
10909 return nil
10910 }
10911 c.PageToken(x.NextPageToken)
10912 }
10913 }
10914
10915 type ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall struct {
10916 s *Service
10917 name string
10918 userdatamapping *UserDataMapping
10919 urlParams_ gensupport.URLParams
10920 ctx_ context.Context
10921 header_ http.Header
10922 }
10923
10924
10925
10926
10927
10928
10929 func (r *ProjectsLocationsDatasetsConsentStoresUserDataMappingsService) Patch(name string, userdatamapping *UserDataMapping) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall {
10930 c := &ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
10931 c.name = name
10932 c.userdatamapping = userdatamapping
10933 return c
10934 }
10935
10936
10937
10938
10939
10940
10941 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall {
10942 c.urlParams_.Set("updateMask", updateMask)
10943 return c
10944 }
10945
10946
10947
10948
10949 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall {
10950 c.urlParams_.Set("fields", googleapi.CombineFields(s))
10951 return c
10952 }
10953
10954
10955 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall {
10956 c.ctx_ = ctx
10957 return c
10958 }
10959
10960
10961
10962 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall) Header() http.Header {
10963 if c.header_ == nil {
10964 c.header_ = make(http.Header)
10965 }
10966 return c.header_
10967 }
10968
10969 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall) doRequest(alt string) (*http.Response, error) {
10970 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
10971 var body io.Reader = nil
10972 body, err := googleapi.WithoutDataWrapper.JSONReader(c.userdatamapping)
10973 if err != nil {
10974 return nil, err
10975 }
10976 c.urlParams_.Set("alt", alt)
10977 c.urlParams_.Set("prettyPrint", "false")
10978 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
10979 urls += "?" + c.urlParams_.Encode()
10980 req, err := http.NewRequest("PATCH", urls, body)
10981 if err != nil {
10982 return nil, err
10983 }
10984 req.Header = reqHeaders
10985 googleapi.Expand(req.URL, map[string]string{
10986 "name": c.name,
10987 })
10988 return gensupport.SendRequest(c.ctx_, c.s.client, req)
10989 }
10990
10991
10992
10993
10994
10995
10996
10997 func (c *ProjectsLocationsDatasetsConsentStoresUserDataMappingsPatchCall) Do(opts ...googleapi.CallOption) (*UserDataMapping, error) {
10998 gensupport.SetOptions(c.urlParams_, opts...)
10999 res, err := c.doRequest("json")
11000 if res != nil && res.StatusCode == http.StatusNotModified {
11001 if res.Body != nil {
11002 res.Body.Close()
11003 }
11004 return nil, gensupport.WrapError(&googleapi.Error{
11005 Code: res.StatusCode,
11006 Header: res.Header,
11007 })
11008 }
11009 if err != nil {
11010 return nil, err
11011 }
11012 defer googleapi.CloseBody(res)
11013 if err := googleapi.CheckResponse(res); err != nil {
11014 return nil, gensupport.WrapError(err)
11015 }
11016 ret := &UserDataMapping{
11017 ServerResponse: googleapi.ServerResponse{
11018 Header: res.Header,
11019 HTTPStatusCode: res.StatusCode,
11020 },
11021 }
11022 target := &ret
11023 if err := gensupport.DecodeResponse(target, res); err != nil {
11024 return nil, err
11025 }
11026 return ret, nil
11027 }
11028
11029 type ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall struct {
11030 s *Service
11031 resource string
11032 urlParams_ gensupport.URLParams
11033 ifNoneMatch_ string
11034 ctx_ context.Context
11035 header_ http.Header
11036 }
11037
11038
11039
11040
11041
11042
11043
11044 func (r *ProjectsLocationsDatasetsDataMapperWorkspacesService) GetIamPolicy(resource string) *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall {
11045 c := &ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11046 c.resource = resource
11047 return c
11048 }
11049
11050
11051
11052
11053
11054
11055
11056
11057
11058
11059
11060
11061
11062 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall {
11063 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
11064 return c
11065 }
11066
11067
11068
11069
11070 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall {
11071 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11072 return c
11073 }
11074
11075
11076
11077
11078 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall {
11079 c.ifNoneMatch_ = entityTag
11080 return c
11081 }
11082
11083
11084 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall {
11085 c.ctx_ = ctx
11086 return c
11087 }
11088
11089
11090
11091 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall) Header() http.Header {
11092 if c.header_ == nil {
11093 c.header_ = make(http.Header)
11094 }
11095 return c.header_
11096 }
11097
11098 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
11099 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11100 if c.ifNoneMatch_ != "" {
11101 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11102 }
11103 var body io.Reader = nil
11104 c.urlParams_.Set("alt", alt)
11105 c.urlParams_.Set("prettyPrint", "false")
11106 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
11107 urls += "?" + c.urlParams_.Encode()
11108 req, err := http.NewRequest("GET", urls, body)
11109 if err != nil {
11110 return nil, err
11111 }
11112 req.Header = reqHeaders
11113 googleapi.Expand(req.URL, map[string]string{
11114 "resource": c.resource,
11115 })
11116 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11117 }
11118
11119
11120
11121
11122
11123
11124 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
11125 gensupport.SetOptions(c.urlParams_, opts...)
11126 res, err := c.doRequest("json")
11127 if res != nil && res.StatusCode == http.StatusNotModified {
11128 if res.Body != nil {
11129 res.Body.Close()
11130 }
11131 return nil, gensupport.WrapError(&googleapi.Error{
11132 Code: res.StatusCode,
11133 Header: res.Header,
11134 })
11135 }
11136 if err != nil {
11137 return nil, err
11138 }
11139 defer googleapi.CloseBody(res)
11140 if err := googleapi.CheckResponse(res); err != nil {
11141 return nil, gensupport.WrapError(err)
11142 }
11143 ret := &Policy{
11144 ServerResponse: googleapi.ServerResponse{
11145 Header: res.Header,
11146 HTTPStatusCode: res.StatusCode,
11147 },
11148 }
11149 target := &ret
11150 if err := gensupport.DecodeResponse(target, res); err != nil {
11151 return nil, err
11152 }
11153 return ret, nil
11154 }
11155
11156 type ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall struct {
11157 s *Service
11158 resource string
11159 setiampolicyrequest *SetIamPolicyRequest
11160 urlParams_ gensupport.URLParams
11161 ctx_ context.Context
11162 header_ http.Header
11163 }
11164
11165
11166
11167
11168
11169
11170
11171
11172 func (r *ProjectsLocationsDatasetsDataMapperWorkspacesService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall {
11173 c := &ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11174 c.resource = resource
11175 c.setiampolicyrequest = setiampolicyrequest
11176 return c
11177 }
11178
11179
11180
11181
11182 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall {
11183 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11184 return c
11185 }
11186
11187
11188 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall {
11189 c.ctx_ = ctx
11190 return c
11191 }
11192
11193
11194
11195 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall) Header() http.Header {
11196 if c.header_ == nil {
11197 c.header_ = make(http.Header)
11198 }
11199 return c.header_
11200 }
11201
11202 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
11203 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11204 var body io.Reader = nil
11205 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
11206 if err != nil {
11207 return nil, err
11208 }
11209 c.urlParams_.Set("alt", alt)
11210 c.urlParams_.Set("prettyPrint", "false")
11211 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
11212 urls += "?" + c.urlParams_.Encode()
11213 req, err := http.NewRequest("POST", urls, body)
11214 if err != nil {
11215 return nil, err
11216 }
11217 req.Header = reqHeaders
11218 googleapi.Expand(req.URL, map[string]string{
11219 "resource": c.resource,
11220 })
11221 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11222 }
11223
11224
11225
11226
11227
11228
11229 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
11230 gensupport.SetOptions(c.urlParams_, opts...)
11231 res, err := c.doRequest("json")
11232 if res != nil && res.StatusCode == http.StatusNotModified {
11233 if res.Body != nil {
11234 res.Body.Close()
11235 }
11236 return nil, gensupport.WrapError(&googleapi.Error{
11237 Code: res.StatusCode,
11238 Header: res.Header,
11239 })
11240 }
11241 if err != nil {
11242 return nil, err
11243 }
11244 defer googleapi.CloseBody(res)
11245 if err := googleapi.CheckResponse(res); err != nil {
11246 return nil, gensupport.WrapError(err)
11247 }
11248 ret := &Policy{
11249 ServerResponse: googleapi.ServerResponse{
11250 Header: res.Header,
11251 HTTPStatusCode: res.StatusCode,
11252 },
11253 }
11254 target := &ret
11255 if err := gensupport.DecodeResponse(target, res); err != nil {
11256 return nil, err
11257 }
11258 return ret, nil
11259 }
11260
11261 type ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall struct {
11262 s *Service
11263 resource string
11264 testiampermissionsrequest *TestIamPermissionsRequest
11265 urlParams_ gensupport.URLParams
11266 ctx_ context.Context
11267 header_ http.Header
11268 }
11269
11270
11271
11272
11273
11274
11275
11276
11277
11278
11279
11280 func (r *ProjectsLocationsDatasetsDataMapperWorkspacesService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall {
11281 c := &ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11282 c.resource = resource
11283 c.testiampermissionsrequest = testiampermissionsrequest
11284 return c
11285 }
11286
11287
11288
11289
11290 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall {
11291 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11292 return c
11293 }
11294
11295
11296 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall {
11297 c.ctx_ = ctx
11298 return c
11299 }
11300
11301
11302
11303 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall) Header() http.Header {
11304 if c.header_ == nil {
11305 c.header_ = make(http.Header)
11306 }
11307 return c.header_
11308 }
11309
11310 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
11311 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11312 var body io.Reader = nil
11313 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
11314 if err != nil {
11315 return nil, err
11316 }
11317 c.urlParams_.Set("alt", alt)
11318 c.urlParams_.Set("prettyPrint", "false")
11319 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
11320 urls += "?" + c.urlParams_.Encode()
11321 req, err := http.NewRequest("POST", urls, body)
11322 if err != nil {
11323 return nil, err
11324 }
11325 req.Header = reqHeaders
11326 googleapi.Expand(req.URL, map[string]string{
11327 "resource": c.resource,
11328 })
11329 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11330 }
11331
11332
11333
11334
11335
11336
11337
11338 func (c *ProjectsLocationsDatasetsDataMapperWorkspacesTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
11339 gensupport.SetOptions(c.urlParams_, opts...)
11340 res, err := c.doRequest("json")
11341 if res != nil && res.StatusCode == http.StatusNotModified {
11342 if res.Body != nil {
11343 res.Body.Close()
11344 }
11345 return nil, gensupport.WrapError(&googleapi.Error{
11346 Code: res.StatusCode,
11347 Header: res.Header,
11348 })
11349 }
11350 if err != nil {
11351 return nil, err
11352 }
11353 defer googleapi.CloseBody(res)
11354 if err := googleapi.CheckResponse(res); err != nil {
11355 return nil, gensupport.WrapError(err)
11356 }
11357 ret := &TestIamPermissionsResponse{
11358 ServerResponse: googleapi.ServerResponse{
11359 Header: res.Header,
11360 HTTPStatusCode: res.StatusCode,
11361 },
11362 }
11363 target := &ret
11364 if err := gensupport.DecodeResponse(target, res); err != nil {
11365 return nil, err
11366 }
11367 return ret, nil
11368 }
11369
11370 type ProjectsLocationsDatasetsDicomStoresCreateCall struct {
11371 s *Service
11372 parent string
11373 dicomstore *DicomStore
11374 urlParams_ gensupport.URLParams
11375 ctx_ context.Context
11376 header_ http.Header
11377 }
11378
11379
11380
11381
11382 func (r *ProjectsLocationsDatasetsDicomStoresService) Create(parent string, dicomstore *DicomStore) *ProjectsLocationsDatasetsDicomStoresCreateCall {
11383 c := &ProjectsLocationsDatasetsDicomStoresCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11384 c.parent = parent
11385 c.dicomstore = dicomstore
11386 return c
11387 }
11388
11389
11390
11391
11392 func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) DicomStoreId(dicomStoreId string) *ProjectsLocationsDatasetsDicomStoresCreateCall {
11393 c.urlParams_.Set("dicomStoreId", dicomStoreId)
11394 return c
11395 }
11396
11397
11398
11399
11400 func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresCreateCall {
11401 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11402 return c
11403 }
11404
11405
11406 func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresCreateCall {
11407 c.ctx_ = ctx
11408 return c
11409 }
11410
11411
11412
11413 func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) Header() http.Header {
11414 if c.header_ == nil {
11415 c.header_ = make(http.Header)
11416 }
11417 return c.header_
11418 }
11419
11420 func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) doRequest(alt string) (*http.Response, error) {
11421 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11422 var body io.Reader = nil
11423 body, err := googleapi.WithoutDataWrapper.JSONReader(c.dicomstore)
11424 if err != nil {
11425 return nil, err
11426 }
11427 c.urlParams_.Set("alt", alt)
11428 c.urlParams_.Set("prettyPrint", "false")
11429 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomStores")
11430 urls += "?" + c.urlParams_.Encode()
11431 req, err := http.NewRequest("POST", urls, body)
11432 if err != nil {
11433 return nil, err
11434 }
11435 req.Header = reqHeaders
11436 googleapi.Expand(req.URL, map[string]string{
11437 "parent": c.parent,
11438 })
11439 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11440 }
11441
11442
11443
11444
11445
11446
11447 func (c *ProjectsLocationsDatasetsDicomStoresCreateCall) Do(opts ...googleapi.CallOption) (*DicomStore, error) {
11448 gensupport.SetOptions(c.urlParams_, opts...)
11449 res, err := c.doRequest("json")
11450 if res != nil && res.StatusCode == http.StatusNotModified {
11451 if res.Body != nil {
11452 res.Body.Close()
11453 }
11454 return nil, gensupport.WrapError(&googleapi.Error{
11455 Code: res.StatusCode,
11456 Header: res.Header,
11457 })
11458 }
11459 if err != nil {
11460 return nil, err
11461 }
11462 defer googleapi.CloseBody(res)
11463 if err := googleapi.CheckResponse(res); err != nil {
11464 return nil, gensupport.WrapError(err)
11465 }
11466 ret := &DicomStore{
11467 ServerResponse: googleapi.ServerResponse{
11468 Header: res.Header,
11469 HTTPStatusCode: res.StatusCode,
11470 },
11471 }
11472 target := &ret
11473 if err := gensupport.DecodeResponse(target, res); err != nil {
11474 return nil, err
11475 }
11476 return ret, nil
11477 }
11478
11479 type ProjectsLocationsDatasetsDicomStoresDeidentifyCall struct {
11480 s *Service
11481 sourceStore string
11482 deidentifydicomstorerequest *DeidentifyDicomStoreRequest
11483 urlParams_ gensupport.URLParams
11484 ctx_ context.Context
11485 header_ http.Header
11486 }
11487
11488
11489
11490
11491
11492
11493
11494
11495
11496
11497
11498
11499
11500
11501 func (r *ProjectsLocationsDatasetsDicomStoresService) Deidentify(sourceStore string, deidentifydicomstorerequest *DeidentifyDicomStoreRequest) *ProjectsLocationsDatasetsDicomStoresDeidentifyCall {
11502 c := &ProjectsLocationsDatasetsDicomStoresDeidentifyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11503 c.sourceStore = sourceStore
11504 c.deidentifydicomstorerequest = deidentifydicomstorerequest
11505 return c
11506 }
11507
11508
11509
11510
11511 func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresDeidentifyCall {
11512 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11513 return c
11514 }
11515
11516
11517 func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresDeidentifyCall {
11518 c.ctx_ = ctx
11519 return c
11520 }
11521
11522
11523
11524 func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Header() http.Header {
11525 if c.header_ == nil {
11526 c.header_ = make(http.Header)
11527 }
11528 return c.header_
11529 }
11530
11531 func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) doRequest(alt string) (*http.Response, error) {
11532 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11533 var body io.Reader = nil
11534 body, err := googleapi.WithoutDataWrapper.JSONReader(c.deidentifydicomstorerequest)
11535 if err != nil {
11536 return nil, err
11537 }
11538 c.urlParams_.Set("alt", alt)
11539 c.urlParams_.Set("prettyPrint", "false")
11540 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+sourceStore}:deidentify")
11541 urls += "?" + c.urlParams_.Encode()
11542 req, err := http.NewRequest("POST", urls, body)
11543 if err != nil {
11544 return nil, err
11545 }
11546 req.Header = reqHeaders
11547 googleapi.Expand(req.URL, map[string]string{
11548 "sourceStore": c.sourceStore,
11549 })
11550 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11551 }
11552
11553
11554
11555
11556
11557
11558 func (c *ProjectsLocationsDatasetsDicomStoresDeidentifyCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
11559 gensupport.SetOptions(c.urlParams_, opts...)
11560 res, err := c.doRequest("json")
11561 if res != nil && res.StatusCode == http.StatusNotModified {
11562 if res.Body != nil {
11563 res.Body.Close()
11564 }
11565 return nil, gensupport.WrapError(&googleapi.Error{
11566 Code: res.StatusCode,
11567 Header: res.Header,
11568 })
11569 }
11570 if err != nil {
11571 return nil, err
11572 }
11573 defer googleapi.CloseBody(res)
11574 if err := googleapi.CheckResponse(res); err != nil {
11575 return nil, gensupport.WrapError(err)
11576 }
11577 ret := &Operation{
11578 ServerResponse: googleapi.ServerResponse{
11579 Header: res.Header,
11580 HTTPStatusCode: res.StatusCode,
11581 },
11582 }
11583 target := &ret
11584 if err := gensupport.DecodeResponse(target, res); err != nil {
11585 return nil, err
11586 }
11587 return ret, nil
11588 }
11589
11590 type ProjectsLocationsDatasetsDicomStoresDeleteCall struct {
11591 s *Service
11592 name string
11593 urlParams_ gensupport.URLParams
11594 ctx_ context.Context
11595 header_ http.Header
11596 }
11597
11598
11599
11600
11601
11602 func (r *ProjectsLocationsDatasetsDicomStoresService) Delete(name string) *ProjectsLocationsDatasetsDicomStoresDeleteCall {
11603 c := &ProjectsLocationsDatasetsDicomStoresDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11604 c.name = name
11605 return c
11606 }
11607
11608
11609
11610
11611 func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresDeleteCall {
11612 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11613 return c
11614 }
11615
11616
11617 func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresDeleteCall {
11618 c.ctx_ = ctx
11619 return c
11620 }
11621
11622
11623
11624 func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) Header() http.Header {
11625 if c.header_ == nil {
11626 c.header_ = make(http.Header)
11627 }
11628 return c.header_
11629 }
11630
11631 func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) doRequest(alt string) (*http.Response, error) {
11632 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11633 var body io.Reader = nil
11634 c.urlParams_.Set("alt", alt)
11635 c.urlParams_.Set("prettyPrint", "false")
11636 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
11637 urls += "?" + c.urlParams_.Encode()
11638 req, err := http.NewRequest("DELETE", urls, body)
11639 if err != nil {
11640 return nil, err
11641 }
11642 req.Header = reqHeaders
11643 googleapi.Expand(req.URL, map[string]string{
11644 "name": c.name,
11645 })
11646 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11647 }
11648
11649
11650
11651
11652
11653
11654 func (c *ProjectsLocationsDatasetsDicomStoresDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
11655 gensupport.SetOptions(c.urlParams_, opts...)
11656 res, err := c.doRequest("json")
11657 if res != nil && res.StatusCode == http.StatusNotModified {
11658 if res.Body != nil {
11659 res.Body.Close()
11660 }
11661 return nil, gensupport.WrapError(&googleapi.Error{
11662 Code: res.StatusCode,
11663 Header: res.Header,
11664 })
11665 }
11666 if err != nil {
11667 return nil, err
11668 }
11669 defer googleapi.CloseBody(res)
11670 if err := googleapi.CheckResponse(res); err != nil {
11671 return nil, gensupport.WrapError(err)
11672 }
11673 ret := &Empty{
11674 ServerResponse: googleapi.ServerResponse{
11675 Header: res.Header,
11676 HTTPStatusCode: res.StatusCode,
11677 },
11678 }
11679 target := &ret
11680 if err := gensupport.DecodeResponse(target, res); err != nil {
11681 return nil, err
11682 }
11683 return ret, nil
11684 }
11685
11686 type ProjectsLocationsDatasetsDicomStoresExportCall struct {
11687 s *Service
11688 name string
11689 exportdicomdatarequest *ExportDicomDataRequest
11690 urlParams_ gensupport.URLParams
11691 ctx_ context.Context
11692 header_ http.Header
11693 }
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705 func (r *ProjectsLocationsDatasetsDicomStoresService) Export(name string, exportdicomdatarequest *ExportDicomDataRequest) *ProjectsLocationsDatasetsDicomStoresExportCall {
11706 c := &ProjectsLocationsDatasetsDicomStoresExportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11707 c.name = name
11708 c.exportdicomdatarequest = exportdicomdatarequest
11709 return c
11710 }
11711
11712
11713
11714
11715 func (c *ProjectsLocationsDatasetsDicomStoresExportCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresExportCall {
11716 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11717 return c
11718 }
11719
11720
11721 func (c *ProjectsLocationsDatasetsDicomStoresExportCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresExportCall {
11722 c.ctx_ = ctx
11723 return c
11724 }
11725
11726
11727
11728 func (c *ProjectsLocationsDatasetsDicomStoresExportCall) Header() http.Header {
11729 if c.header_ == nil {
11730 c.header_ = make(http.Header)
11731 }
11732 return c.header_
11733 }
11734
11735 func (c *ProjectsLocationsDatasetsDicomStoresExportCall) doRequest(alt string) (*http.Response, error) {
11736 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
11737 var body io.Reader = nil
11738 body, err := googleapi.WithoutDataWrapper.JSONReader(c.exportdicomdatarequest)
11739 if err != nil {
11740 return nil, err
11741 }
11742 c.urlParams_.Set("alt", alt)
11743 c.urlParams_.Set("prettyPrint", "false")
11744 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:export")
11745 urls += "?" + c.urlParams_.Encode()
11746 req, err := http.NewRequest("POST", urls, body)
11747 if err != nil {
11748 return nil, err
11749 }
11750 req.Header = reqHeaders
11751 googleapi.Expand(req.URL, map[string]string{
11752 "name": c.name,
11753 })
11754 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11755 }
11756
11757
11758
11759
11760
11761
11762 func (c *ProjectsLocationsDatasetsDicomStoresExportCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
11763 gensupport.SetOptions(c.urlParams_, opts...)
11764 res, err := c.doRequest("json")
11765 if res != nil && res.StatusCode == http.StatusNotModified {
11766 if res.Body != nil {
11767 res.Body.Close()
11768 }
11769 return nil, gensupport.WrapError(&googleapi.Error{
11770 Code: res.StatusCode,
11771 Header: res.Header,
11772 })
11773 }
11774 if err != nil {
11775 return nil, err
11776 }
11777 defer googleapi.CloseBody(res)
11778 if err := googleapi.CheckResponse(res); err != nil {
11779 return nil, gensupport.WrapError(err)
11780 }
11781 ret := &Operation{
11782 ServerResponse: googleapi.ServerResponse{
11783 Header: res.Header,
11784 HTTPStatusCode: res.StatusCode,
11785 },
11786 }
11787 target := &ret
11788 if err := gensupport.DecodeResponse(target, res); err != nil {
11789 return nil, err
11790 }
11791 return ret, nil
11792 }
11793
11794 type ProjectsLocationsDatasetsDicomStoresGetCall struct {
11795 s *Service
11796 name string
11797 urlParams_ gensupport.URLParams
11798 ifNoneMatch_ string
11799 ctx_ context.Context
11800 header_ http.Header
11801 }
11802
11803
11804
11805
11806 func (r *ProjectsLocationsDatasetsDicomStoresService) Get(name string) *ProjectsLocationsDatasetsDicomStoresGetCall {
11807 c := &ProjectsLocationsDatasetsDicomStoresGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11808 c.name = name
11809 return c
11810 }
11811
11812
11813
11814
11815 func (c *ProjectsLocationsDatasetsDicomStoresGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresGetCall {
11816 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11817 return c
11818 }
11819
11820
11821
11822
11823 func (c *ProjectsLocationsDatasetsDicomStoresGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresGetCall {
11824 c.ifNoneMatch_ = entityTag
11825 return c
11826 }
11827
11828
11829 func (c *ProjectsLocationsDatasetsDicomStoresGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresGetCall {
11830 c.ctx_ = ctx
11831 return c
11832 }
11833
11834
11835
11836 func (c *ProjectsLocationsDatasetsDicomStoresGetCall) Header() http.Header {
11837 if c.header_ == nil {
11838 c.header_ = make(http.Header)
11839 }
11840 return c.header_
11841 }
11842
11843 func (c *ProjectsLocationsDatasetsDicomStoresGetCall) doRequest(alt string) (*http.Response, error) {
11844 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11845 if c.ifNoneMatch_ != "" {
11846 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11847 }
11848 var body io.Reader = nil
11849 c.urlParams_.Set("alt", alt)
11850 c.urlParams_.Set("prettyPrint", "false")
11851 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
11852 urls += "?" + c.urlParams_.Encode()
11853 req, err := http.NewRequest("GET", urls, body)
11854 if err != nil {
11855 return nil, err
11856 }
11857 req.Header = reqHeaders
11858 googleapi.Expand(req.URL, map[string]string{
11859 "name": c.name,
11860 })
11861 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11862 }
11863
11864
11865
11866
11867
11868
11869 func (c *ProjectsLocationsDatasetsDicomStoresGetCall) Do(opts ...googleapi.CallOption) (*DicomStore, error) {
11870 gensupport.SetOptions(c.urlParams_, opts...)
11871 res, err := c.doRequest("json")
11872 if res != nil && res.StatusCode == http.StatusNotModified {
11873 if res.Body != nil {
11874 res.Body.Close()
11875 }
11876 return nil, gensupport.WrapError(&googleapi.Error{
11877 Code: res.StatusCode,
11878 Header: res.Header,
11879 })
11880 }
11881 if err != nil {
11882 return nil, err
11883 }
11884 defer googleapi.CloseBody(res)
11885 if err := googleapi.CheckResponse(res); err != nil {
11886 return nil, gensupport.WrapError(err)
11887 }
11888 ret := &DicomStore{
11889 ServerResponse: googleapi.ServerResponse{
11890 Header: res.Header,
11891 HTTPStatusCode: res.StatusCode,
11892 },
11893 }
11894 target := &ret
11895 if err := gensupport.DecodeResponse(target, res); err != nil {
11896 return nil, err
11897 }
11898 return ret, nil
11899 }
11900
11901 type ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall struct {
11902 s *Service
11903 name string
11904 urlParams_ gensupport.URLParams
11905 ifNoneMatch_ string
11906 ctx_ context.Context
11907 header_ http.Header
11908 }
11909
11910
11911
11912
11913 func (r *ProjectsLocationsDatasetsDicomStoresService) GetDICOMStoreMetrics(name string) *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall {
11914 c := &ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
11915 c.name = name
11916 return c
11917 }
11918
11919
11920
11921
11922 func (c *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall {
11923 c.urlParams_.Set("fields", googleapi.CombineFields(s))
11924 return c
11925 }
11926
11927
11928
11929
11930 func (c *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall {
11931 c.ifNoneMatch_ = entityTag
11932 return c
11933 }
11934
11935
11936 func (c *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall {
11937 c.ctx_ = ctx
11938 return c
11939 }
11940
11941
11942
11943 func (c *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall) Header() http.Header {
11944 if c.header_ == nil {
11945 c.header_ = make(http.Header)
11946 }
11947 return c.header_
11948 }
11949
11950 func (c *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall) doRequest(alt string) (*http.Response, error) {
11951 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
11952 if c.ifNoneMatch_ != "" {
11953 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
11954 }
11955 var body io.Reader = nil
11956 c.urlParams_.Set("alt", alt)
11957 c.urlParams_.Set("prettyPrint", "false")
11958 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:getDICOMStoreMetrics")
11959 urls += "?" + c.urlParams_.Encode()
11960 req, err := http.NewRequest("GET", urls, body)
11961 if err != nil {
11962 return nil, err
11963 }
11964 req.Header = reqHeaders
11965 googleapi.Expand(req.URL, map[string]string{
11966 "name": c.name,
11967 })
11968 return gensupport.SendRequest(c.ctx_, c.s.client, req)
11969 }
11970
11971
11972
11973
11974
11975
11976
11977 func (c *ProjectsLocationsDatasetsDicomStoresGetDICOMStoreMetricsCall) Do(opts ...googleapi.CallOption) (*DicomStoreMetrics, error) {
11978 gensupport.SetOptions(c.urlParams_, opts...)
11979 res, err := c.doRequest("json")
11980 if res != nil && res.StatusCode == http.StatusNotModified {
11981 if res.Body != nil {
11982 res.Body.Close()
11983 }
11984 return nil, gensupport.WrapError(&googleapi.Error{
11985 Code: res.StatusCode,
11986 Header: res.Header,
11987 })
11988 }
11989 if err != nil {
11990 return nil, err
11991 }
11992 defer googleapi.CloseBody(res)
11993 if err := googleapi.CheckResponse(res); err != nil {
11994 return nil, gensupport.WrapError(err)
11995 }
11996 ret := &DicomStoreMetrics{
11997 ServerResponse: googleapi.ServerResponse{
11998 Header: res.Header,
11999 HTTPStatusCode: res.StatusCode,
12000 },
12001 }
12002 target := &ret
12003 if err := gensupport.DecodeResponse(target, res); err != nil {
12004 return nil, err
12005 }
12006 return ret, nil
12007 }
12008
12009 type ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall struct {
12010 s *Service
12011 resource string
12012 urlParams_ gensupport.URLParams
12013 ifNoneMatch_ string
12014 ctx_ context.Context
12015 header_ http.Header
12016 }
12017
12018
12019
12020
12021
12022
12023
12024 func (r *ProjectsLocationsDatasetsDicomStoresService) GetIamPolicy(resource string) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall {
12025 c := &ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12026 c.resource = resource
12027 return c
12028 }
12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042 func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall {
12043 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
12044 return c
12045 }
12046
12047
12048
12049
12050 func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall {
12051 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12052 return c
12053 }
12054
12055
12056
12057
12058 func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall {
12059 c.ifNoneMatch_ = entityTag
12060 return c
12061 }
12062
12063
12064 func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall {
12065 c.ctx_ = ctx
12066 return c
12067 }
12068
12069
12070
12071 func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Header() http.Header {
12072 if c.header_ == nil {
12073 c.header_ = make(http.Header)
12074 }
12075 return c.header_
12076 }
12077
12078 func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12079 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12080 if c.ifNoneMatch_ != "" {
12081 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12082 }
12083 var body io.Reader = nil
12084 c.urlParams_.Set("alt", alt)
12085 c.urlParams_.Set("prettyPrint", "false")
12086 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
12087 urls += "?" + c.urlParams_.Encode()
12088 req, err := http.NewRequest("GET", urls, body)
12089 if err != nil {
12090 return nil, err
12091 }
12092 req.Header = reqHeaders
12093 googleapi.Expand(req.URL, map[string]string{
12094 "resource": c.resource,
12095 })
12096 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12097 }
12098
12099
12100
12101
12102
12103
12104 func (c *ProjectsLocationsDatasetsDicomStoresGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
12105 gensupport.SetOptions(c.urlParams_, opts...)
12106 res, err := c.doRequest("json")
12107 if res != nil && res.StatusCode == http.StatusNotModified {
12108 if res.Body != nil {
12109 res.Body.Close()
12110 }
12111 return nil, gensupport.WrapError(&googleapi.Error{
12112 Code: res.StatusCode,
12113 Header: res.Header,
12114 })
12115 }
12116 if err != nil {
12117 return nil, err
12118 }
12119 defer googleapi.CloseBody(res)
12120 if err := googleapi.CheckResponse(res); err != nil {
12121 return nil, gensupport.WrapError(err)
12122 }
12123 ret := &Policy{
12124 ServerResponse: googleapi.ServerResponse{
12125 Header: res.Header,
12126 HTTPStatusCode: res.StatusCode,
12127 },
12128 }
12129 target := &ret
12130 if err := gensupport.DecodeResponse(target, res); err != nil {
12131 return nil, err
12132 }
12133 return ret, nil
12134 }
12135
12136 type ProjectsLocationsDatasetsDicomStoresImportCall struct {
12137 s *Service
12138 name string
12139 importdicomdatarequest *ImportDicomDataRequest
12140 urlParams_ gensupport.URLParams
12141 ctx_ context.Context
12142 header_ http.Header
12143 }
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155 func (r *ProjectsLocationsDatasetsDicomStoresService) Import(name string, importdicomdatarequest *ImportDicomDataRequest) *ProjectsLocationsDatasetsDicomStoresImportCall {
12156 c := &ProjectsLocationsDatasetsDicomStoresImportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12157 c.name = name
12158 c.importdicomdatarequest = importdicomdatarequest
12159 return c
12160 }
12161
12162
12163
12164
12165 func (c *ProjectsLocationsDatasetsDicomStoresImportCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresImportCall {
12166 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12167 return c
12168 }
12169
12170
12171 func (c *ProjectsLocationsDatasetsDicomStoresImportCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresImportCall {
12172 c.ctx_ = ctx
12173 return c
12174 }
12175
12176
12177
12178 func (c *ProjectsLocationsDatasetsDicomStoresImportCall) Header() http.Header {
12179 if c.header_ == nil {
12180 c.header_ = make(http.Header)
12181 }
12182 return c.header_
12183 }
12184
12185 func (c *ProjectsLocationsDatasetsDicomStoresImportCall) doRequest(alt string) (*http.Response, error) {
12186 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12187 var body io.Reader = nil
12188 body, err := googleapi.WithoutDataWrapper.JSONReader(c.importdicomdatarequest)
12189 if err != nil {
12190 return nil, err
12191 }
12192 c.urlParams_.Set("alt", alt)
12193 c.urlParams_.Set("prettyPrint", "false")
12194 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:import")
12195 urls += "?" + c.urlParams_.Encode()
12196 req, err := http.NewRequest("POST", urls, body)
12197 if err != nil {
12198 return nil, err
12199 }
12200 req.Header = reqHeaders
12201 googleapi.Expand(req.URL, map[string]string{
12202 "name": c.name,
12203 })
12204 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12205 }
12206
12207
12208
12209
12210
12211
12212 func (c *ProjectsLocationsDatasetsDicomStoresImportCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
12213 gensupport.SetOptions(c.urlParams_, opts...)
12214 res, err := c.doRequest("json")
12215 if res != nil && res.StatusCode == http.StatusNotModified {
12216 if res.Body != nil {
12217 res.Body.Close()
12218 }
12219 return nil, gensupport.WrapError(&googleapi.Error{
12220 Code: res.StatusCode,
12221 Header: res.Header,
12222 })
12223 }
12224 if err != nil {
12225 return nil, err
12226 }
12227 defer googleapi.CloseBody(res)
12228 if err := googleapi.CheckResponse(res); err != nil {
12229 return nil, gensupport.WrapError(err)
12230 }
12231 ret := &Operation{
12232 ServerResponse: googleapi.ServerResponse{
12233 Header: res.Header,
12234 HTTPStatusCode: res.StatusCode,
12235 },
12236 }
12237 target := &ret
12238 if err := gensupport.DecodeResponse(target, res); err != nil {
12239 return nil, err
12240 }
12241 return ret, nil
12242 }
12243
12244 type ProjectsLocationsDatasetsDicomStoresListCall struct {
12245 s *Service
12246 parent string
12247 urlParams_ gensupport.URLParams
12248 ifNoneMatch_ string
12249 ctx_ context.Context
12250 header_ http.Header
12251 }
12252
12253
12254
12255
12256 func (r *ProjectsLocationsDatasetsDicomStoresService) List(parent string) *ProjectsLocationsDatasetsDicomStoresListCall {
12257 c := &ProjectsLocationsDatasetsDicomStoresListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12258 c.parent = parent
12259 return c
12260 }
12261
12262
12263
12264
12265
12266
12267
12268
12269
12270
12271
12272
12273
12274
12275
12276
12277
12278
12279
12280
12281
12282
12283
12284
12285 func (c *ProjectsLocationsDatasetsDicomStoresListCall) Filter(filter string) *ProjectsLocationsDatasetsDicomStoresListCall {
12286 c.urlParams_.Set("filter", filter)
12287 return c
12288 }
12289
12290
12291
12292
12293 func (c *ProjectsLocationsDatasetsDicomStoresListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsDicomStoresListCall {
12294 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
12295 return c
12296 }
12297
12298
12299
12300 func (c *ProjectsLocationsDatasetsDicomStoresListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsDicomStoresListCall {
12301 c.urlParams_.Set("pageToken", pageToken)
12302 return c
12303 }
12304
12305
12306
12307
12308 func (c *ProjectsLocationsDatasetsDicomStoresListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresListCall {
12309 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12310 return c
12311 }
12312
12313
12314
12315
12316 func (c *ProjectsLocationsDatasetsDicomStoresListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresListCall {
12317 c.ifNoneMatch_ = entityTag
12318 return c
12319 }
12320
12321
12322 func (c *ProjectsLocationsDatasetsDicomStoresListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresListCall {
12323 c.ctx_ = ctx
12324 return c
12325 }
12326
12327
12328
12329 func (c *ProjectsLocationsDatasetsDicomStoresListCall) Header() http.Header {
12330 if c.header_ == nil {
12331 c.header_ = make(http.Header)
12332 }
12333 return c.header_
12334 }
12335
12336 func (c *ProjectsLocationsDatasetsDicomStoresListCall) doRequest(alt string) (*http.Response, error) {
12337 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12338 if c.ifNoneMatch_ != "" {
12339 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12340 }
12341 var body io.Reader = nil
12342 c.urlParams_.Set("alt", alt)
12343 c.urlParams_.Set("prettyPrint", "false")
12344 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomStores")
12345 urls += "?" + c.urlParams_.Encode()
12346 req, err := http.NewRequest("GET", urls, body)
12347 if err != nil {
12348 return nil, err
12349 }
12350 req.Header = reqHeaders
12351 googleapi.Expand(req.URL, map[string]string{
12352 "parent": c.parent,
12353 })
12354 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12355 }
12356
12357
12358
12359
12360
12361
12362
12363 func (c *ProjectsLocationsDatasetsDicomStoresListCall) Do(opts ...googleapi.CallOption) (*ListDicomStoresResponse, error) {
12364 gensupport.SetOptions(c.urlParams_, opts...)
12365 res, err := c.doRequest("json")
12366 if res != nil && res.StatusCode == http.StatusNotModified {
12367 if res.Body != nil {
12368 res.Body.Close()
12369 }
12370 return nil, gensupport.WrapError(&googleapi.Error{
12371 Code: res.StatusCode,
12372 Header: res.Header,
12373 })
12374 }
12375 if err != nil {
12376 return nil, err
12377 }
12378 defer googleapi.CloseBody(res)
12379 if err := googleapi.CheckResponse(res); err != nil {
12380 return nil, gensupport.WrapError(err)
12381 }
12382 ret := &ListDicomStoresResponse{
12383 ServerResponse: googleapi.ServerResponse{
12384 Header: res.Header,
12385 HTTPStatusCode: res.StatusCode,
12386 },
12387 }
12388 target := &ret
12389 if err := gensupport.DecodeResponse(target, res); err != nil {
12390 return nil, err
12391 }
12392 return ret, nil
12393 }
12394
12395
12396
12397
12398 func (c *ProjectsLocationsDatasetsDicomStoresListCall) Pages(ctx context.Context, f func(*ListDicomStoresResponse) error) error {
12399 c.ctx_ = ctx
12400 defer c.PageToken(c.urlParams_.Get("pageToken"))
12401 for {
12402 x, err := c.Do()
12403 if err != nil {
12404 return err
12405 }
12406 if err := f(x); err != nil {
12407 return err
12408 }
12409 if x.NextPageToken == "" {
12410 return nil
12411 }
12412 c.PageToken(x.NextPageToken)
12413 }
12414 }
12415
12416 type ProjectsLocationsDatasetsDicomStoresPatchCall struct {
12417 s *Service
12418 name string
12419 dicomstore *DicomStore
12420 urlParams_ gensupport.URLParams
12421 ctx_ context.Context
12422 header_ http.Header
12423 }
12424
12425
12426
12427
12428
12429
12430 func (r *ProjectsLocationsDatasetsDicomStoresService) Patch(name string, dicomstore *DicomStore) *ProjectsLocationsDatasetsDicomStoresPatchCall {
12431 c := &ProjectsLocationsDatasetsDicomStoresPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12432 c.name = name
12433 c.dicomstore = dicomstore
12434 return c
12435 }
12436
12437
12438
12439
12440 func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsDicomStoresPatchCall {
12441 c.urlParams_.Set("updateMask", updateMask)
12442 return c
12443 }
12444
12445
12446
12447
12448 func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresPatchCall {
12449 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12450 return c
12451 }
12452
12453
12454 func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresPatchCall {
12455 c.ctx_ = ctx
12456 return c
12457 }
12458
12459
12460
12461 func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) Header() http.Header {
12462 if c.header_ == nil {
12463 c.header_ = make(http.Header)
12464 }
12465 return c.header_
12466 }
12467
12468 func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) doRequest(alt string) (*http.Response, error) {
12469 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12470 var body io.Reader = nil
12471 body, err := googleapi.WithoutDataWrapper.JSONReader(c.dicomstore)
12472 if err != nil {
12473 return nil, err
12474 }
12475 c.urlParams_.Set("alt", alt)
12476 c.urlParams_.Set("prettyPrint", "false")
12477 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
12478 urls += "?" + c.urlParams_.Encode()
12479 req, err := http.NewRequest("PATCH", urls, body)
12480 if err != nil {
12481 return nil, err
12482 }
12483 req.Header = reqHeaders
12484 googleapi.Expand(req.URL, map[string]string{
12485 "name": c.name,
12486 })
12487 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12488 }
12489
12490
12491
12492
12493
12494
12495 func (c *ProjectsLocationsDatasetsDicomStoresPatchCall) Do(opts ...googleapi.CallOption) (*DicomStore, error) {
12496 gensupport.SetOptions(c.urlParams_, opts...)
12497 res, err := c.doRequest("json")
12498 if res != nil && res.StatusCode == http.StatusNotModified {
12499 if res.Body != nil {
12500 res.Body.Close()
12501 }
12502 return nil, gensupport.WrapError(&googleapi.Error{
12503 Code: res.StatusCode,
12504 Header: res.Header,
12505 })
12506 }
12507 if err != nil {
12508 return nil, err
12509 }
12510 defer googleapi.CloseBody(res)
12511 if err := googleapi.CheckResponse(res); err != nil {
12512 return nil, gensupport.WrapError(err)
12513 }
12514 ret := &DicomStore{
12515 ServerResponse: googleapi.ServerResponse{
12516 Header: res.Header,
12517 HTTPStatusCode: res.StatusCode,
12518 },
12519 }
12520 target := &ret
12521 if err := gensupport.DecodeResponse(target, res); err != nil {
12522 return nil, err
12523 }
12524 return ret, nil
12525 }
12526
12527 type ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall struct {
12528 s *Service
12529 parent string
12530 dicomWebPath string
12531 urlParams_ gensupport.URLParams
12532 ifNoneMatch_ string
12533 ctx_ context.Context
12534 header_ http.Header
12535 }
12536
12537
12538
12539
12540
12541
12542
12543
12544
12545
12546
12547
12548
12549
12550
12551
12552
12553 func (r *ProjectsLocationsDatasetsDicomStoresService) SearchForInstances(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall {
12554 c := &ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12555 c.parent = parent
12556 c.dicomWebPath = dicomWebPath
12557 return c
12558 }
12559
12560
12561
12562
12563 func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall {
12564 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12565 return c
12566 }
12567
12568
12569
12570
12571 func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall {
12572 c.ifNoneMatch_ = entityTag
12573 return c
12574 }
12575
12576
12577 func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall {
12578 c.ctx_ = ctx
12579 return c
12580 }
12581
12582
12583
12584 func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Header() http.Header {
12585 if c.header_ == nil {
12586 c.header_ = make(http.Header)
12587 }
12588 return c.header_
12589 }
12590
12591 func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) doRequest(alt string) (*http.Response, error) {
12592 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12593 if c.ifNoneMatch_ != "" {
12594 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12595 }
12596 var body io.Reader = nil
12597 c.urlParams_.Set("alt", alt)
12598 c.urlParams_.Set("prettyPrint", "false")
12599 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
12600 urls += "?" + c.urlParams_.Encode()
12601 req, err := http.NewRequest("GET", urls, body)
12602 if err != nil {
12603 return nil, err
12604 }
12605 req.Header = reqHeaders
12606 googleapi.Expand(req.URL, map[string]string{
12607 "parent": c.parent,
12608 "dicomWebPath": c.dicomWebPath,
12609 })
12610 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12611 }
12612
12613
12614 func (c *ProjectsLocationsDatasetsDicomStoresSearchForInstancesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
12615 gensupport.SetOptions(c.urlParams_, opts...)
12616 return c.doRequest("")
12617 }
12618
12619 type ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall struct {
12620 s *Service
12621 parent string
12622 dicomWebPath string
12623 urlParams_ gensupport.URLParams
12624 ifNoneMatch_ string
12625 ctx_ context.Context
12626 header_ http.Header
12627 }
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643 func (r *ProjectsLocationsDatasetsDicomStoresService) SearchForSeries(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall {
12644 c := &ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12645 c.parent = parent
12646 c.dicomWebPath = dicomWebPath
12647 return c
12648 }
12649
12650
12651
12652
12653 func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall {
12654 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12655 return c
12656 }
12657
12658
12659
12660
12661 func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall {
12662 c.ifNoneMatch_ = entityTag
12663 return c
12664 }
12665
12666
12667 func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall {
12668 c.ctx_ = ctx
12669 return c
12670 }
12671
12672
12673
12674 func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Header() http.Header {
12675 if c.header_ == nil {
12676 c.header_ = make(http.Header)
12677 }
12678 return c.header_
12679 }
12680
12681 func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) doRequest(alt string) (*http.Response, error) {
12682 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12683 if c.ifNoneMatch_ != "" {
12684 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12685 }
12686 var body io.Reader = nil
12687 c.urlParams_.Set("alt", alt)
12688 c.urlParams_.Set("prettyPrint", "false")
12689 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
12690 urls += "?" + c.urlParams_.Encode()
12691 req, err := http.NewRequest("GET", urls, body)
12692 if err != nil {
12693 return nil, err
12694 }
12695 req.Header = reqHeaders
12696 googleapi.Expand(req.URL, map[string]string{
12697 "parent": c.parent,
12698 "dicomWebPath": c.dicomWebPath,
12699 })
12700 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12701 }
12702
12703
12704 func (c *ProjectsLocationsDatasetsDicomStoresSearchForSeriesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
12705 gensupport.SetOptions(c.urlParams_, opts...)
12706 return c.doRequest("")
12707 }
12708
12709 type ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall struct {
12710 s *Service
12711 parent string
12712 dicomWebPath string
12713 urlParams_ gensupport.URLParams
12714 ifNoneMatch_ string
12715 ctx_ context.Context
12716 header_ http.Header
12717 }
12718
12719
12720
12721
12722
12723
12724
12725
12726
12727
12728
12729
12730
12731
12732
12733
12734 func (r *ProjectsLocationsDatasetsDicomStoresService) SearchForStudies(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall {
12735 c := &ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12736 c.parent = parent
12737 c.dicomWebPath = dicomWebPath
12738 return c
12739 }
12740
12741
12742
12743
12744 func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall {
12745 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12746 return c
12747 }
12748
12749
12750
12751
12752 func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall {
12753 c.ifNoneMatch_ = entityTag
12754 return c
12755 }
12756
12757
12758 func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall {
12759 c.ctx_ = ctx
12760 return c
12761 }
12762
12763
12764
12765 func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Header() http.Header {
12766 if c.header_ == nil {
12767 c.header_ = make(http.Header)
12768 }
12769 return c.header_
12770 }
12771
12772 func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) doRequest(alt string) (*http.Response, error) {
12773 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12774 if c.ifNoneMatch_ != "" {
12775 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
12776 }
12777 var body io.Reader = nil
12778 c.urlParams_.Set("alt", alt)
12779 c.urlParams_.Set("prettyPrint", "false")
12780 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
12781 urls += "?" + c.urlParams_.Encode()
12782 req, err := http.NewRequest("GET", urls, body)
12783 if err != nil {
12784 return nil, err
12785 }
12786 req.Header = reqHeaders
12787 googleapi.Expand(req.URL, map[string]string{
12788 "parent": c.parent,
12789 "dicomWebPath": c.dicomWebPath,
12790 })
12791 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12792 }
12793
12794
12795 func (c *ProjectsLocationsDatasetsDicomStoresSearchForStudiesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
12796 gensupport.SetOptions(c.urlParams_, opts...)
12797 return c.doRequest("")
12798 }
12799
12800 type ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall struct {
12801 s *Service
12802 resource string
12803 setiampolicyrequest *SetIamPolicyRequest
12804 urlParams_ gensupport.URLParams
12805 ctx_ context.Context
12806 header_ http.Header
12807 }
12808
12809
12810
12811
12812
12813
12814
12815
12816 func (r *ProjectsLocationsDatasetsDicomStoresService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall {
12817 c := &ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12818 c.resource = resource
12819 c.setiampolicyrequest = setiampolicyrequest
12820 return c
12821 }
12822
12823
12824
12825
12826 func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall {
12827 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12828 return c
12829 }
12830
12831
12832 func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall {
12833 c.ctx_ = ctx
12834 return c
12835 }
12836
12837
12838
12839 func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Header() http.Header {
12840 if c.header_ == nil {
12841 c.header_ = make(http.Header)
12842 }
12843 return c.header_
12844 }
12845
12846 func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
12847 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
12848 var body io.Reader = nil
12849 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
12850 if err != nil {
12851 return nil, err
12852 }
12853 c.urlParams_.Set("alt", alt)
12854 c.urlParams_.Set("prettyPrint", "false")
12855 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
12856 urls += "?" + c.urlParams_.Encode()
12857 req, err := http.NewRequest("POST", urls, body)
12858 if err != nil {
12859 return nil, err
12860 }
12861 req.Header = reqHeaders
12862 googleapi.Expand(req.URL, map[string]string{
12863 "resource": c.resource,
12864 })
12865 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12866 }
12867
12868
12869
12870
12871
12872
12873 func (c *ProjectsLocationsDatasetsDicomStoresSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
12874 gensupport.SetOptions(c.urlParams_, opts...)
12875 res, err := c.doRequest("json")
12876 if res != nil && res.StatusCode == http.StatusNotModified {
12877 if res.Body != nil {
12878 res.Body.Close()
12879 }
12880 return nil, gensupport.WrapError(&googleapi.Error{
12881 Code: res.StatusCode,
12882 Header: res.Header,
12883 })
12884 }
12885 if err != nil {
12886 return nil, err
12887 }
12888 defer googleapi.CloseBody(res)
12889 if err := googleapi.CheckResponse(res); err != nil {
12890 return nil, gensupport.WrapError(err)
12891 }
12892 ret := &Policy{
12893 ServerResponse: googleapi.ServerResponse{
12894 Header: res.Header,
12895 HTTPStatusCode: res.StatusCode,
12896 },
12897 }
12898 target := &ret
12899 if err := gensupport.DecodeResponse(target, res); err != nil {
12900 return nil, err
12901 }
12902 return ret, nil
12903 }
12904
12905 type ProjectsLocationsDatasetsDicomStoresStoreInstancesCall struct {
12906 s *Service
12907 parent string
12908 dicomWebPath string
12909 body_ io.Reader
12910 urlParams_ gensupport.URLParams
12911 ctx_ context.Context
12912 header_ http.Header
12913 }
12914
12915
12916
12917
12918
12919
12920
12921
12922
12923
12924
12925
12926
12927
12928
12929 func (r *ProjectsLocationsDatasetsDicomStoresService) StoreInstances(parent string, dicomWebPath string, body_ io.Reader) *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall {
12930 c := &ProjectsLocationsDatasetsDicomStoresStoreInstancesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
12931 c.parent = parent
12932 c.dicomWebPath = dicomWebPath
12933 c.body_ = body_
12934 return c
12935 }
12936
12937
12938
12939
12940 func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall {
12941 c.urlParams_.Set("fields", googleapi.CombineFields(s))
12942 return c
12943 }
12944
12945
12946 func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall {
12947 c.ctx_ = ctx
12948 return c
12949 }
12950
12951
12952
12953 func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Header() http.Header {
12954 if c.header_ == nil {
12955 c.header_ = make(http.Header)
12956 }
12957 return c.header_
12958 }
12959
12960 func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) doRequest(alt string) (*http.Response, error) {
12961 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
12962 var body io.Reader = nil
12963 body = c.body_
12964 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
12965 urls += "?" + c.urlParams_.Encode()
12966 req, err := http.NewRequest("POST", urls, body)
12967 if err != nil {
12968 return nil, err
12969 }
12970 req.Header = reqHeaders
12971 googleapi.Expand(req.URL, map[string]string{
12972 "parent": c.parent,
12973 "dicomWebPath": c.dicomWebPath,
12974 })
12975 return gensupport.SendRequest(c.ctx_, c.s.client, req)
12976 }
12977
12978
12979 func (c *ProjectsLocationsDatasetsDicomStoresStoreInstancesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
12980 gensupport.SetOptions(c.urlParams_, opts...)
12981 return c.doRequest("")
12982 }
12983
12984 type ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall struct {
12985 s *Service
12986 resource string
12987 testiampermissionsrequest *TestIamPermissionsRequest
12988 urlParams_ gensupport.URLParams
12989 ctx_ context.Context
12990 header_ http.Header
12991 }
12992
12993
12994
12995
12996
12997
12998
12999
13000
13001
13002
13003 func (r *ProjectsLocationsDatasetsDicomStoresService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall {
13004 c := &ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13005 c.resource = resource
13006 c.testiampermissionsrequest = testiampermissionsrequest
13007 return c
13008 }
13009
13010
13011
13012
13013 func (c *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall {
13014 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13015 return c
13016 }
13017
13018
13019 func (c *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall {
13020 c.ctx_ = ctx
13021 return c
13022 }
13023
13024
13025
13026 func (c *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall) Header() http.Header {
13027 if c.header_ == nil {
13028 c.header_ = make(http.Header)
13029 }
13030 return c.header_
13031 }
13032
13033 func (c *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
13034 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
13035 var body io.Reader = nil
13036 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
13037 if err != nil {
13038 return nil, err
13039 }
13040 c.urlParams_.Set("alt", alt)
13041 c.urlParams_.Set("prettyPrint", "false")
13042 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
13043 urls += "?" + c.urlParams_.Encode()
13044 req, err := http.NewRequest("POST", urls, body)
13045 if err != nil {
13046 return nil, err
13047 }
13048 req.Header = reqHeaders
13049 googleapi.Expand(req.URL, map[string]string{
13050 "resource": c.resource,
13051 })
13052 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13053 }
13054
13055
13056
13057
13058
13059
13060
13061 func (c *ProjectsLocationsDatasetsDicomStoresTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
13062 gensupport.SetOptions(c.urlParams_, opts...)
13063 res, err := c.doRequest("json")
13064 if res != nil && res.StatusCode == http.StatusNotModified {
13065 if res.Body != nil {
13066 res.Body.Close()
13067 }
13068 return nil, gensupport.WrapError(&googleapi.Error{
13069 Code: res.StatusCode,
13070 Header: res.Header,
13071 })
13072 }
13073 if err != nil {
13074 return nil, err
13075 }
13076 defer googleapi.CloseBody(res)
13077 if err := googleapi.CheckResponse(res); err != nil {
13078 return nil, gensupport.WrapError(err)
13079 }
13080 ret := &TestIamPermissionsResponse{
13081 ServerResponse: googleapi.ServerResponse{
13082 Header: res.Header,
13083 HTTPStatusCode: res.StatusCode,
13084 },
13085 }
13086 target := &ret
13087 if err := gensupport.DecodeResponse(target, res); err != nil {
13088 return nil, err
13089 }
13090 return ret, nil
13091 }
13092
13093 type ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall struct {
13094 s *Service
13095 study string
13096 urlParams_ gensupport.URLParams
13097 ifNoneMatch_ string
13098 ctx_ context.Context
13099 header_ http.Header
13100 }
13101
13102
13103
13104
13105
13106
13107 func (r *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesService) GetStudyMetrics(study string) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall {
13108 c := &ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13109 c.study = study
13110 return c
13111 }
13112
13113
13114
13115
13116 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall {
13117 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13118 return c
13119 }
13120
13121
13122
13123
13124 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall {
13125 c.ifNoneMatch_ = entityTag
13126 return c
13127 }
13128
13129
13130 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall {
13131 c.ctx_ = ctx
13132 return c
13133 }
13134
13135
13136
13137 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall) Header() http.Header {
13138 if c.header_ == nil {
13139 c.header_ = make(http.Header)
13140 }
13141 return c.header_
13142 }
13143
13144 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall) doRequest(alt string) (*http.Response, error) {
13145 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13146 if c.ifNoneMatch_ != "" {
13147 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13148 }
13149 var body io.Reader = nil
13150 c.urlParams_.Set("alt", alt)
13151 c.urlParams_.Set("prettyPrint", "false")
13152 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+study}:getStudyMetrics")
13153 urls += "?" + c.urlParams_.Encode()
13154 req, err := http.NewRequest("GET", urls, body)
13155 if err != nil {
13156 return nil, err
13157 }
13158 req.Header = reqHeaders
13159 googleapi.Expand(req.URL, map[string]string{
13160 "study": c.study,
13161 })
13162 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13163 }
13164
13165
13166
13167
13168
13169
13170 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesGetStudyMetricsCall) Do(opts ...googleapi.CallOption) (*StudyMetrics, error) {
13171 gensupport.SetOptions(c.urlParams_, opts...)
13172 res, err := c.doRequest("json")
13173 if res != nil && res.StatusCode == http.StatusNotModified {
13174 if res.Body != nil {
13175 res.Body.Close()
13176 }
13177 return nil, gensupport.WrapError(&googleapi.Error{
13178 Code: res.StatusCode,
13179 Header: res.Header,
13180 })
13181 }
13182 if err != nil {
13183 return nil, err
13184 }
13185 defer googleapi.CloseBody(res)
13186 if err := googleapi.CheckResponse(res); err != nil {
13187 return nil, gensupport.WrapError(err)
13188 }
13189 ret := &StudyMetrics{
13190 ServerResponse: googleapi.ServerResponse{
13191 Header: res.Header,
13192 HTTPStatusCode: res.StatusCode,
13193 },
13194 }
13195 target := &ret
13196 if err := gensupport.DecodeResponse(target, res); err != nil {
13197 return nil, err
13198 }
13199 return ret, nil
13200 }
13201
13202 type ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall struct {
13203 s *Service
13204 series string
13205 urlParams_ gensupport.URLParams
13206 ifNoneMatch_ string
13207 ctx_ context.Context
13208 header_ http.Header
13209 }
13210
13211
13212
13213
13214
13215
13216 func (r *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesService) GetSeriesMetrics(series string) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall {
13217 c := &ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13218 c.series = series
13219 return c
13220 }
13221
13222
13223
13224
13225 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall {
13226 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13227 return c
13228 }
13229
13230
13231
13232
13233 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall {
13234 c.ifNoneMatch_ = entityTag
13235 return c
13236 }
13237
13238
13239 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall {
13240 c.ctx_ = ctx
13241 return c
13242 }
13243
13244
13245
13246 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall) Header() http.Header {
13247 if c.header_ == nil {
13248 c.header_ = make(http.Header)
13249 }
13250 return c.header_
13251 }
13252
13253 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall) doRequest(alt string) (*http.Response, error) {
13254 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13255 if c.ifNoneMatch_ != "" {
13256 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13257 }
13258 var body io.Reader = nil
13259 c.urlParams_.Set("alt", alt)
13260 c.urlParams_.Set("prettyPrint", "false")
13261 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+series}:getSeriesMetrics")
13262 urls += "?" + c.urlParams_.Encode()
13263 req, err := http.NewRequest("GET", urls, body)
13264 if err != nil {
13265 return nil, err
13266 }
13267 req.Header = reqHeaders
13268 googleapi.Expand(req.URL, map[string]string{
13269 "series": c.series,
13270 })
13271 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13272 }
13273
13274
13275
13276
13277
13278
13279 func (c *ProjectsLocationsDatasetsDicomStoresDicomWebStudiesSeriesGetSeriesMetricsCall) Do(opts ...googleapi.CallOption) (*SeriesMetrics, error) {
13280 gensupport.SetOptions(c.urlParams_, opts...)
13281 res, err := c.doRequest("json")
13282 if res != nil && res.StatusCode == http.StatusNotModified {
13283 if res.Body != nil {
13284 res.Body.Close()
13285 }
13286 return nil, gensupport.WrapError(&googleapi.Error{
13287 Code: res.StatusCode,
13288 Header: res.Header,
13289 })
13290 }
13291 if err != nil {
13292 return nil, err
13293 }
13294 defer googleapi.CloseBody(res)
13295 if err := googleapi.CheckResponse(res); err != nil {
13296 return nil, gensupport.WrapError(err)
13297 }
13298 ret := &SeriesMetrics{
13299 ServerResponse: googleapi.ServerResponse{
13300 Header: res.Header,
13301 HTTPStatusCode: res.StatusCode,
13302 },
13303 }
13304 target := &ret
13305 if err := gensupport.DecodeResponse(target, res); err != nil {
13306 return nil, err
13307 }
13308 return ret, nil
13309 }
13310
13311 type ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall struct {
13312 s *Service
13313 parent string
13314 dicomWebPath string
13315 urlParams_ gensupport.URLParams
13316 ctx_ context.Context
13317 header_ http.Header
13318 }
13319
13320
13321
13322
13323
13324
13325
13326
13327
13328
13329
13330
13331
13332 func (r *ProjectsLocationsDatasetsDicomStoresStudiesService) Delete(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall {
13333 c := &ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13334 c.parent = parent
13335 c.dicomWebPath = dicomWebPath
13336 return c
13337 }
13338
13339
13340
13341
13342 func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall {
13343 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13344 return c
13345 }
13346
13347
13348 func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall {
13349 c.ctx_ = ctx
13350 return c
13351 }
13352
13353
13354
13355 func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Header() http.Header {
13356 if c.header_ == nil {
13357 c.header_ = make(http.Header)
13358 }
13359 return c.header_
13360 }
13361
13362 func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) doRequest(alt string) (*http.Response, error) {
13363 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13364 var body io.Reader = nil
13365 c.urlParams_.Set("alt", alt)
13366 c.urlParams_.Set("prettyPrint", "false")
13367 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
13368 urls += "?" + c.urlParams_.Encode()
13369 req, err := http.NewRequest("DELETE", urls, body)
13370 if err != nil {
13371 return nil, err
13372 }
13373 req.Header = reqHeaders
13374 googleapi.Expand(req.URL, map[string]string{
13375 "parent": c.parent,
13376 "dicomWebPath": c.dicomWebPath,
13377 })
13378 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13379 }
13380
13381
13382
13383
13384
13385
13386 func (c *ProjectsLocationsDatasetsDicomStoresStudiesDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
13387 gensupport.SetOptions(c.urlParams_, opts...)
13388 res, err := c.doRequest("json")
13389 if res != nil && res.StatusCode == http.StatusNotModified {
13390 if res.Body != nil {
13391 res.Body.Close()
13392 }
13393 return nil, gensupport.WrapError(&googleapi.Error{
13394 Code: res.StatusCode,
13395 Header: res.Header,
13396 })
13397 }
13398 if err != nil {
13399 return nil, err
13400 }
13401 defer googleapi.CloseBody(res)
13402 if err := googleapi.CheckResponse(res); err != nil {
13403 return nil, gensupport.WrapError(err)
13404 }
13405 ret := &Operation{
13406 ServerResponse: googleapi.ServerResponse{
13407 Header: res.Header,
13408 HTTPStatusCode: res.StatusCode,
13409 },
13410 }
13411 target := &ret
13412 if err := gensupport.DecodeResponse(target, res); err != nil {
13413 return nil, err
13414 }
13415 return ret, nil
13416 }
13417
13418 type ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall struct {
13419 s *Service
13420 parent string
13421 dicomWebPath string
13422 urlParams_ gensupport.URLParams
13423 ifNoneMatch_ string
13424 ctx_ context.Context
13425 header_ http.Header
13426 }
13427
13428
13429
13430
13431
13432
13433
13434
13435
13436
13437
13438
13439
13440
13441
13442
13443
13444 func (r *ProjectsLocationsDatasetsDicomStoresStudiesService) RetrieveMetadata(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall {
13445 c := &ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13446 c.parent = parent
13447 c.dicomWebPath = dicomWebPath
13448 return c
13449 }
13450
13451
13452
13453
13454 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall {
13455 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13456 return c
13457 }
13458
13459
13460
13461
13462 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall {
13463 c.ifNoneMatch_ = entityTag
13464 return c
13465 }
13466
13467
13468 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall {
13469 c.ctx_ = ctx
13470 return c
13471 }
13472
13473
13474
13475 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Header() http.Header {
13476 if c.header_ == nil {
13477 c.header_ = make(http.Header)
13478 }
13479 return c.header_
13480 }
13481
13482 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) doRequest(alt string) (*http.Response, error) {
13483 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13484 if c.ifNoneMatch_ != "" {
13485 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13486 }
13487 var body io.Reader = nil
13488 c.urlParams_.Set("alt", alt)
13489 c.urlParams_.Set("prettyPrint", "false")
13490 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
13491 urls += "?" + c.urlParams_.Encode()
13492 req, err := http.NewRequest("GET", urls, body)
13493 if err != nil {
13494 return nil, err
13495 }
13496 req.Header = reqHeaders
13497 googleapi.Expand(req.URL, map[string]string{
13498 "parent": c.parent,
13499 "dicomWebPath": c.dicomWebPath,
13500 })
13501 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13502 }
13503
13504
13505 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveMetadataCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
13506 gensupport.SetOptions(c.urlParams_, opts...)
13507 return c.doRequest("")
13508 }
13509
13510 type ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall struct {
13511 s *Service
13512 parent string
13513 dicomWebPath string
13514 urlParams_ gensupport.URLParams
13515 ifNoneMatch_ string
13516 ctx_ context.Context
13517 header_ http.Header
13518 }
13519
13520
13521
13522
13523
13524
13525
13526
13527
13528
13529
13530
13531
13532
13533
13534
13535 func (r *ProjectsLocationsDatasetsDicomStoresStudiesService) RetrieveStudy(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall {
13536 c := &ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13537 c.parent = parent
13538 c.dicomWebPath = dicomWebPath
13539 return c
13540 }
13541
13542
13543
13544
13545 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall {
13546 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13547 return c
13548 }
13549
13550
13551
13552
13553 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall {
13554 c.ifNoneMatch_ = entityTag
13555 return c
13556 }
13557
13558
13559 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall {
13560 c.ctx_ = ctx
13561 return c
13562 }
13563
13564
13565
13566 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Header() http.Header {
13567 if c.header_ == nil {
13568 c.header_ = make(http.Header)
13569 }
13570 return c.header_
13571 }
13572
13573 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) doRequest(alt string) (*http.Response, error) {
13574 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13575 if c.ifNoneMatch_ != "" {
13576 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13577 }
13578 var body io.Reader = nil
13579 c.urlParams_.Set("alt", alt)
13580 c.urlParams_.Set("prettyPrint", "false")
13581 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
13582 urls += "?" + c.urlParams_.Encode()
13583 req, err := http.NewRequest("GET", urls, body)
13584 if err != nil {
13585 return nil, err
13586 }
13587 req.Header = reqHeaders
13588 googleapi.Expand(req.URL, map[string]string{
13589 "parent": c.parent,
13590 "dicomWebPath": c.dicomWebPath,
13591 })
13592 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13593 }
13594
13595
13596 func (c *ProjectsLocationsDatasetsDicomStoresStudiesRetrieveStudyCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
13597 gensupport.SetOptions(c.urlParams_, opts...)
13598 return c.doRequest("")
13599 }
13600
13601 type ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall struct {
13602 s *Service
13603 parent string
13604 dicomWebPath string
13605 urlParams_ gensupport.URLParams
13606 ifNoneMatch_ string
13607 ctx_ context.Context
13608 header_ http.Header
13609 }
13610
13611
13612
13613
13614
13615
13616
13617
13618
13619
13620
13621
13622
13623
13624
13625
13626
13627 func (r *ProjectsLocationsDatasetsDicomStoresStudiesService) SearchForInstances(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall {
13628 c := &ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13629 c.parent = parent
13630 c.dicomWebPath = dicomWebPath
13631 return c
13632 }
13633
13634
13635
13636
13637 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall {
13638 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13639 return c
13640 }
13641
13642
13643
13644
13645 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall {
13646 c.ifNoneMatch_ = entityTag
13647 return c
13648 }
13649
13650
13651 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall {
13652 c.ctx_ = ctx
13653 return c
13654 }
13655
13656
13657
13658 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Header() http.Header {
13659 if c.header_ == nil {
13660 c.header_ = make(http.Header)
13661 }
13662 return c.header_
13663 }
13664
13665 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) doRequest(alt string) (*http.Response, error) {
13666 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13667 if c.ifNoneMatch_ != "" {
13668 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13669 }
13670 var body io.Reader = nil
13671 c.urlParams_.Set("alt", alt)
13672 c.urlParams_.Set("prettyPrint", "false")
13673 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
13674 urls += "?" + c.urlParams_.Encode()
13675 req, err := http.NewRequest("GET", urls, body)
13676 if err != nil {
13677 return nil, err
13678 }
13679 req.Header = reqHeaders
13680 googleapi.Expand(req.URL, map[string]string{
13681 "parent": c.parent,
13682 "dicomWebPath": c.dicomWebPath,
13683 })
13684 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13685 }
13686
13687
13688 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForInstancesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
13689 gensupport.SetOptions(c.urlParams_, opts...)
13690 return c.doRequest("")
13691 }
13692
13693 type ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall struct {
13694 s *Service
13695 parent string
13696 dicomWebPath string
13697 urlParams_ gensupport.URLParams
13698 ifNoneMatch_ string
13699 ctx_ context.Context
13700 header_ http.Header
13701 }
13702
13703
13704
13705
13706
13707
13708
13709
13710
13711
13712
13713
13714
13715
13716
13717 func (r *ProjectsLocationsDatasetsDicomStoresStudiesService) SearchForSeries(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall {
13718 c := &ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13719 c.parent = parent
13720 c.dicomWebPath = dicomWebPath
13721 return c
13722 }
13723
13724
13725
13726
13727 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall {
13728 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13729 return c
13730 }
13731
13732
13733
13734
13735 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall {
13736 c.ifNoneMatch_ = entityTag
13737 return c
13738 }
13739
13740
13741 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall {
13742 c.ctx_ = ctx
13743 return c
13744 }
13745
13746
13747
13748 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Header() http.Header {
13749 if c.header_ == nil {
13750 c.header_ = make(http.Header)
13751 }
13752 return c.header_
13753 }
13754
13755 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) doRequest(alt string) (*http.Response, error) {
13756 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13757 if c.ifNoneMatch_ != "" {
13758 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
13759 }
13760 var body io.Reader = nil
13761 c.urlParams_.Set("alt", alt)
13762 c.urlParams_.Set("prettyPrint", "false")
13763 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
13764 urls += "?" + c.urlParams_.Encode()
13765 req, err := http.NewRequest("GET", urls, body)
13766 if err != nil {
13767 return nil, err
13768 }
13769 req.Header = reqHeaders
13770 googleapi.Expand(req.URL, map[string]string{
13771 "parent": c.parent,
13772 "dicomWebPath": c.dicomWebPath,
13773 })
13774 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13775 }
13776
13777
13778 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSearchForSeriesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
13779 gensupport.SetOptions(c.urlParams_, opts...)
13780 return c.doRequest("")
13781 }
13782
13783 type ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall struct {
13784 s *Service
13785 parent string
13786 dicomWebPath string
13787 body_ io.Reader
13788 urlParams_ gensupport.URLParams
13789 ctx_ context.Context
13790 header_ http.Header
13791 }
13792
13793
13794
13795
13796
13797
13798
13799
13800
13801
13802
13803
13804
13805
13806
13807 func (r *ProjectsLocationsDatasetsDicomStoresStudiesService) StoreInstances(parent string, dicomWebPath string, body_ io.Reader) *ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall {
13808 c := &ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13809 c.parent = parent
13810 c.dicomWebPath = dicomWebPath
13811 c.body_ = body_
13812 return c
13813 }
13814
13815
13816
13817
13818 func (c *ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall {
13819 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13820 return c
13821 }
13822
13823
13824 func (c *ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall {
13825 c.ctx_ = ctx
13826 return c
13827 }
13828
13829
13830
13831 func (c *ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall) Header() http.Header {
13832 if c.header_ == nil {
13833 c.header_ = make(http.Header)
13834 }
13835 return c.header_
13836 }
13837
13838 func (c *ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall) doRequest(alt string) (*http.Response, error) {
13839 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13840 var body io.Reader = nil
13841 body = c.body_
13842 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
13843 urls += "?" + c.urlParams_.Encode()
13844 req, err := http.NewRequest("POST", urls, body)
13845 if err != nil {
13846 return nil, err
13847 }
13848 req.Header = reqHeaders
13849 googleapi.Expand(req.URL, map[string]string{
13850 "parent": c.parent,
13851 "dicomWebPath": c.dicomWebPath,
13852 })
13853 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13854 }
13855
13856
13857 func (c *ProjectsLocationsDatasetsDicomStoresStudiesStoreInstancesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
13858 gensupport.SetOptions(c.urlParams_, opts...)
13859 return c.doRequest("")
13860 }
13861
13862 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall struct {
13863 s *Service
13864 parent string
13865 dicomWebPath string
13866 urlParams_ gensupport.URLParams
13867 ctx_ context.Context
13868 header_ http.Header
13869 }
13870
13871
13872
13873
13874
13875
13876
13877
13878
13879
13880
13881
13882
13883
13884
13885 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesService) Delete(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall {
13886 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13887 c.parent = parent
13888 c.dicomWebPath = dicomWebPath
13889 return c
13890 }
13891
13892
13893
13894
13895 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall {
13896 c.urlParams_.Set("fields", googleapi.CombineFields(s))
13897 return c
13898 }
13899
13900
13901 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall {
13902 c.ctx_ = ctx
13903 return c
13904 }
13905
13906
13907
13908 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Header() http.Header {
13909 if c.header_ == nil {
13910 c.header_ = make(http.Header)
13911 }
13912 return c.header_
13913 }
13914
13915 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) doRequest(alt string) (*http.Response, error) {
13916 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
13917 var body io.Reader = nil
13918 c.urlParams_.Set("alt", alt)
13919 c.urlParams_.Set("prettyPrint", "false")
13920 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
13921 urls += "?" + c.urlParams_.Encode()
13922 req, err := http.NewRequest("DELETE", urls, body)
13923 if err != nil {
13924 return nil, err
13925 }
13926 req.Header = reqHeaders
13927 googleapi.Expand(req.URL, map[string]string{
13928 "parent": c.parent,
13929 "dicomWebPath": c.dicomWebPath,
13930 })
13931 return gensupport.SendRequest(c.ctx_, c.s.client, req)
13932 }
13933
13934
13935
13936
13937
13938
13939 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
13940 gensupport.SetOptions(c.urlParams_, opts...)
13941 res, err := c.doRequest("json")
13942 if res != nil && res.StatusCode == http.StatusNotModified {
13943 if res.Body != nil {
13944 res.Body.Close()
13945 }
13946 return nil, gensupport.WrapError(&googleapi.Error{
13947 Code: res.StatusCode,
13948 Header: res.Header,
13949 })
13950 }
13951 if err != nil {
13952 return nil, err
13953 }
13954 defer googleapi.CloseBody(res)
13955 if err := googleapi.CheckResponse(res); err != nil {
13956 return nil, gensupport.WrapError(err)
13957 }
13958 ret := &Operation{
13959 ServerResponse: googleapi.ServerResponse{
13960 Header: res.Header,
13961 HTTPStatusCode: res.StatusCode,
13962 },
13963 }
13964 target := &ret
13965 if err := gensupport.DecodeResponse(target, res); err != nil {
13966 return nil, err
13967 }
13968 return ret, nil
13969 }
13970
13971 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall struct {
13972 s *Service
13973 parent string
13974 dicomWebPath string
13975 urlParams_ gensupport.URLParams
13976 ifNoneMatch_ string
13977 ctx_ context.Context
13978 header_ http.Header
13979 }
13980
13981
13982
13983
13984
13985
13986
13987
13988
13989
13990
13991
13992
13993
13994
13995
13996
13997 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesService) RetrieveMetadata(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall {
13998 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall{s: r.s, urlParams_: make(gensupport.URLParams)}
13999 c.parent = parent
14000 c.dicomWebPath = dicomWebPath
14001 return c
14002 }
14003
14004
14005
14006
14007 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall {
14008 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14009 return c
14010 }
14011
14012
14013
14014
14015 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall {
14016 c.ifNoneMatch_ = entityTag
14017 return c
14018 }
14019
14020
14021 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall {
14022 c.ctx_ = ctx
14023 return c
14024 }
14025
14026
14027
14028 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall) Header() http.Header {
14029 if c.header_ == nil {
14030 c.header_ = make(http.Header)
14031 }
14032 return c.header_
14033 }
14034
14035 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall) doRequest(alt string) (*http.Response, error) {
14036 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14037 if c.ifNoneMatch_ != "" {
14038 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14039 }
14040 var body io.Reader = nil
14041 c.urlParams_.Set("alt", alt)
14042 c.urlParams_.Set("prettyPrint", "false")
14043 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14044 urls += "?" + c.urlParams_.Encode()
14045 req, err := http.NewRequest("GET", urls, body)
14046 if err != nil {
14047 return nil, err
14048 }
14049 req.Header = reqHeaders
14050 googleapi.Expand(req.URL, map[string]string{
14051 "parent": c.parent,
14052 "dicomWebPath": c.dicomWebPath,
14053 })
14054 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14055 }
14056
14057
14058 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveMetadataCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
14059 gensupport.SetOptions(c.urlParams_, opts...)
14060 return c.doRequest("")
14061 }
14062
14063 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall struct {
14064 s *Service
14065 parent string
14066 dicomWebPath string
14067 urlParams_ gensupport.URLParams
14068 ifNoneMatch_ string
14069 ctx_ context.Context
14070 header_ http.Header
14071 }
14072
14073
14074
14075
14076
14077
14078
14079
14080
14081
14082
14083
14084
14085
14086
14087
14088 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesService) RetrieveSeries(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall {
14089 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14090 c.parent = parent
14091 c.dicomWebPath = dicomWebPath
14092 return c
14093 }
14094
14095
14096
14097
14098 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall {
14099 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14100 return c
14101 }
14102
14103
14104
14105
14106 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall {
14107 c.ifNoneMatch_ = entityTag
14108 return c
14109 }
14110
14111
14112 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall {
14113 c.ctx_ = ctx
14114 return c
14115 }
14116
14117
14118
14119 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall) Header() http.Header {
14120 if c.header_ == nil {
14121 c.header_ = make(http.Header)
14122 }
14123 return c.header_
14124 }
14125
14126 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall) doRequest(alt string) (*http.Response, error) {
14127 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14128 if c.ifNoneMatch_ != "" {
14129 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14130 }
14131 var body io.Reader = nil
14132 c.urlParams_.Set("alt", alt)
14133 c.urlParams_.Set("prettyPrint", "false")
14134 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14135 urls += "?" + c.urlParams_.Encode()
14136 req, err := http.NewRequest("GET", urls, body)
14137 if err != nil {
14138 return nil, err
14139 }
14140 req.Header = reqHeaders
14141 googleapi.Expand(req.URL, map[string]string{
14142 "parent": c.parent,
14143 "dicomWebPath": c.dicomWebPath,
14144 })
14145 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14146 }
14147
14148
14149 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesRetrieveSeriesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
14150 gensupport.SetOptions(c.urlParams_, opts...)
14151 return c.doRequest("")
14152 }
14153
14154 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall struct {
14155 s *Service
14156 parent string
14157 dicomWebPath string
14158 urlParams_ gensupport.URLParams
14159 ifNoneMatch_ string
14160 ctx_ context.Context
14161 header_ http.Header
14162 }
14163
14164
14165
14166
14167
14168
14169
14170
14171
14172
14173
14174
14175
14176
14177
14178
14179
14180 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesService) SearchForInstances(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall {
14181 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14182 c.parent = parent
14183 c.dicomWebPath = dicomWebPath
14184 return c
14185 }
14186
14187
14188
14189
14190 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall {
14191 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14192 return c
14193 }
14194
14195
14196
14197
14198 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall {
14199 c.ifNoneMatch_ = entityTag
14200 return c
14201 }
14202
14203
14204 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall {
14205 c.ctx_ = ctx
14206 return c
14207 }
14208
14209
14210
14211 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall) Header() http.Header {
14212 if c.header_ == nil {
14213 c.header_ = make(http.Header)
14214 }
14215 return c.header_
14216 }
14217
14218 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall) doRequest(alt string) (*http.Response, error) {
14219 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14220 if c.ifNoneMatch_ != "" {
14221 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14222 }
14223 var body io.Reader = nil
14224 c.urlParams_.Set("alt", alt)
14225 c.urlParams_.Set("prettyPrint", "false")
14226 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14227 urls += "?" + c.urlParams_.Encode()
14228 req, err := http.NewRequest("GET", urls, body)
14229 if err != nil {
14230 return nil, err
14231 }
14232 req.Header = reqHeaders
14233 googleapi.Expand(req.URL, map[string]string{
14234 "parent": c.parent,
14235 "dicomWebPath": c.dicomWebPath,
14236 })
14237 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14238 }
14239
14240
14241 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesSearchForInstancesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
14242 gensupport.SetOptions(c.urlParams_, opts...)
14243 return c.doRequest("")
14244 }
14245
14246 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall struct {
14247 s *Service
14248 parent string
14249 dicomWebPath string
14250 urlParams_ gensupport.URLParams
14251 ctx_ context.Context
14252 header_ http.Header
14253 }
14254
14255
14256
14257
14258
14259
14260
14261
14262
14263
14264
14265
14266
14267
14268 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService) Delete(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall {
14269 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14270 c.parent = parent
14271 c.dicomWebPath = dicomWebPath
14272 return c
14273 }
14274
14275
14276
14277
14278 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall {
14279 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14280 return c
14281 }
14282
14283
14284 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall {
14285 c.ctx_ = ctx
14286 return c
14287 }
14288
14289
14290
14291 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Header() http.Header {
14292 if c.header_ == nil {
14293 c.header_ = make(http.Header)
14294 }
14295 return c.header_
14296 }
14297
14298 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) doRequest(alt string) (*http.Response, error) {
14299 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14300 var body io.Reader = nil
14301 c.urlParams_.Set("alt", alt)
14302 c.urlParams_.Set("prettyPrint", "false")
14303 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14304 urls += "?" + c.urlParams_.Encode()
14305 req, err := http.NewRequest("DELETE", urls, body)
14306 if err != nil {
14307 return nil, err
14308 }
14309 req.Header = reqHeaders
14310 googleapi.Expand(req.URL, map[string]string{
14311 "parent": c.parent,
14312 "dicomWebPath": c.dicomWebPath,
14313 })
14314 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14315 }
14316
14317
14318
14319
14320
14321
14322 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
14323 gensupport.SetOptions(c.urlParams_, opts...)
14324 res, err := c.doRequest("json")
14325 if res != nil && res.StatusCode == http.StatusNotModified {
14326 if res.Body != nil {
14327 res.Body.Close()
14328 }
14329 return nil, gensupport.WrapError(&googleapi.Error{
14330 Code: res.StatusCode,
14331 Header: res.Header,
14332 })
14333 }
14334 if err != nil {
14335 return nil, err
14336 }
14337 defer googleapi.CloseBody(res)
14338 if err := googleapi.CheckResponse(res); err != nil {
14339 return nil, gensupport.WrapError(err)
14340 }
14341 ret := &Empty{
14342 ServerResponse: googleapi.ServerResponse{
14343 Header: res.Header,
14344 HTTPStatusCode: res.StatusCode,
14345 },
14346 }
14347 target := &ret
14348 if err := gensupport.DecodeResponse(target, res); err != nil {
14349 return nil, err
14350 }
14351 return ret, nil
14352 }
14353
14354 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall struct {
14355 s *Service
14356 parent string
14357 dicomWebPath string
14358 urlParams_ gensupport.URLParams
14359 ifNoneMatch_ string
14360 ctx_ context.Context
14361 header_ http.Header
14362 }
14363
14364
14365
14366
14367
14368
14369
14370
14371
14372
14373
14374
14375
14376
14377
14378
14379
14380
14381
14382 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService) RetrieveInstance(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall {
14383 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14384 c.parent = parent
14385 c.dicomWebPath = dicomWebPath
14386 return c
14387 }
14388
14389
14390
14391
14392 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall {
14393 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14394 return c
14395 }
14396
14397
14398
14399
14400 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall {
14401 c.ifNoneMatch_ = entityTag
14402 return c
14403 }
14404
14405
14406 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall {
14407 c.ctx_ = ctx
14408 return c
14409 }
14410
14411
14412
14413 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall) Header() http.Header {
14414 if c.header_ == nil {
14415 c.header_ = make(http.Header)
14416 }
14417 return c.header_
14418 }
14419
14420 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall) doRequest(alt string) (*http.Response, error) {
14421 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14422 if c.ifNoneMatch_ != "" {
14423 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14424 }
14425 var body io.Reader = nil
14426 c.urlParams_.Set("alt", alt)
14427 c.urlParams_.Set("prettyPrint", "false")
14428 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14429 urls += "?" + c.urlParams_.Encode()
14430 req, err := http.NewRequest("GET", urls, body)
14431 if err != nil {
14432 return nil, err
14433 }
14434 req.Header = reqHeaders
14435 googleapi.Expand(req.URL, map[string]string{
14436 "parent": c.parent,
14437 "dicomWebPath": c.dicomWebPath,
14438 })
14439 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14440 }
14441
14442
14443 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveInstanceCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
14444 gensupport.SetOptions(c.urlParams_, opts...)
14445 return c.doRequest("")
14446 }
14447
14448 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall struct {
14449 s *Service
14450 parent string
14451 dicomWebPath string
14452 urlParams_ gensupport.URLParams
14453 ifNoneMatch_ string
14454 ctx_ context.Context
14455 header_ http.Header
14456 }
14457
14458
14459
14460
14461
14462
14463
14464
14465
14466
14467
14468
14469
14470
14471
14472
14473
14474
14475
14476 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService) RetrieveMetadata(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall {
14477 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14478 c.parent = parent
14479 c.dicomWebPath = dicomWebPath
14480 return c
14481 }
14482
14483
14484
14485
14486 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall {
14487 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14488 return c
14489 }
14490
14491
14492
14493
14494 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall {
14495 c.ifNoneMatch_ = entityTag
14496 return c
14497 }
14498
14499
14500 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall {
14501 c.ctx_ = ctx
14502 return c
14503 }
14504
14505
14506
14507 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall) Header() http.Header {
14508 if c.header_ == nil {
14509 c.header_ = make(http.Header)
14510 }
14511 return c.header_
14512 }
14513
14514 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall) doRequest(alt string) (*http.Response, error) {
14515 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14516 if c.ifNoneMatch_ != "" {
14517 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14518 }
14519 var body io.Reader = nil
14520 c.urlParams_.Set("alt", alt)
14521 c.urlParams_.Set("prettyPrint", "false")
14522 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14523 urls += "?" + c.urlParams_.Encode()
14524 req, err := http.NewRequest("GET", urls, body)
14525 if err != nil {
14526 return nil, err
14527 }
14528 req.Header = reqHeaders
14529 googleapi.Expand(req.URL, map[string]string{
14530 "parent": c.parent,
14531 "dicomWebPath": c.dicomWebPath,
14532 })
14533 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14534 }
14535
14536
14537 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveMetadataCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
14538 gensupport.SetOptions(c.urlParams_, opts...)
14539 return c.doRequest("")
14540 }
14541
14542 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall struct {
14543 s *Service
14544 parent string
14545 dicomWebPath string
14546 urlParams_ gensupport.URLParams
14547 ifNoneMatch_ string
14548 ctx_ context.Context
14549 header_ http.Header
14550 }
14551
14552
14553
14554
14555
14556
14557
14558
14559
14560
14561
14562
14563
14564
14565
14566
14567
14568
14569
14570 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesService) RetrieveRendered(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall {
14571 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14572 c.parent = parent
14573 c.dicomWebPath = dicomWebPath
14574 return c
14575 }
14576
14577
14578
14579
14580 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall {
14581 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14582 return c
14583 }
14584
14585
14586
14587
14588 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall {
14589 c.ifNoneMatch_ = entityTag
14590 return c
14591 }
14592
14593
14594 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall {
14595 c.ctx_ = ctx
14596 return c
14597 }
14598
14599
14600
14601 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall) Header() http.Header {
14602 if c.header_ == nil {
14603 c.header_ = make(http.Header)
14604 }
14605 return c.header_
14606 }
14607
14608 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall) doRequest(alt string) (*http.Response, error) {
14609 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14610 if c.ifNoneMatch_ != "" {
14611 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14612 }
14613 var body io.Reader = nil
14614 c.urlParams_.Set("alt", alt)
14615 c.urlParams_.Set("prettyPrint", "false")
14616 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14617 urls += "?" + c.urlParams_.Encode()
14618 req, err := http.NewRequest("GET", urls, body)
14619 if err != nil {
14620 return nil, err
14621 }
14622 req.Header = reqHeaders
14623 googleapi.Expand(req.URL, map[string]string{
14624 "parent": c.parent,
14625 "dicomWebPath": c.dicomWebPath,
14626 })
14627 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14628 }
14629
14630
14631 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesRetrieveRenderedCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
14632 gensupport.SetOptions(c.urlParams_, opts...)
14633 return c.doRequest("")
14634 }
14635
14636 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall struct {
14637 s *Service
14638 parent string
14639 dicomWebPath string
14640 urlParams_ gensupport.URLParams
14641 ifNoneMatch_ string
14642 ctx_ context.Context
14643 header_ http.Header
14644 }
14645
14646
14647
14648
14649
14650
14651
14652
14653
14654
14655
14656
14657
14658
14659
14660
14661
14662 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService) RetrieveFrames(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall {
14663 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14664 c.parent = parent
14665 c.dicomWebPath = dicomWebPath
14666 return c
14667 }
14668
14669
14670
14671
14672 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall {
14673 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14674 return c
14675 }
14676
14677
14678
14679
14680 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall {
14681 c.ifNoneMatch_ = entityTag
14682 return c
14683 }
14684
14685
14686 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall {
14687 c.ctx_ = ctx
14688 return c
14689 }
14690
14691
14692
14693 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Header() http.Header {
14694 if c.header_ == nil {
14695 c.header_ = make(http.Header)
14696 }
14697 return c.header_
14698 }
14699
14700 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) doRequest(alt string) (*http.Response, error) {
14701 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14702 if c.ifNoneMatch_ != "" {
14703 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14704 }
14705 var body io.Reader = nil
14706 c.urlParams_.Set("alt", alt)
14707 c.urlParams_.Set("prettyPrint", "false")
14708 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14709 urls += "?" + c.urlParams_.Encode()
14710 req, err := http.NewRequest("GET", urls, body)
14711 if err != nil {
14712 return nil, err
14713 }
14714 req.Header = reqHeaders
14715 googleapi.Expand(req.URL, map[string]string{
14716 "parent": c.parent,
14717 "dicomWebPath": c.dicomWebPath,
14718 })
14719 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14720 }
14721
14722
14723 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveFramesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
14724 gensupport.SetOptions(c.urlParams_, opts...)
14725 return c.doRequest("")
14726 }
14727
14728 type ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall struct {
14729 s *Service
14730 parent string
14731 dicomWebPath string
14732 urlParams_ gensupport.URLParams
14733 ifNoneMatch_ string
14734 ctx_ context.Context
14735 header_ http.Header
14736 }
14737
14738
14739
14740
14741
14742
14743
14744
14745
14746
14747
14748
14749
14750
14751
14752
14753
14754
14755
14756 func (r *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesService) RetrieveRendered(parent string, dicomWebPath string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall {
14757 c := &ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14758 c.parent = parent
14759 c.dicomWebPath = dicomWebPath
14760 return c
14761 }
14762
14763
14764
14765
14766 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall {
14767 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14768 return c
14769 }
14770
14771
14772
14773
14774 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall {
14775 c.ifNoneMatch_ = entityTag
14776 return c
14777 }
14778
14779
14780 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Context(ctx context.Context) *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall {
14781 c.ctx_ = ctx
14782 return c
14783 }
14784
14785
14786
14787 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Header() http.Header {
14788 if c.header_ == nil {
14789 c.header_ = make(http.Header)
14790 }
14791 return c.header_
14792 }
14793
14794 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) doRequest(alt string) (*http.Response, error) {
14795 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
14796 if c.ifNoneMatch_ != "" {
14797 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
14798 }
14799 var body io.Reader = nil
14800 c.urlParams_.Set("alt", alt)
14801 c.urlParams_.Set("prettyPrint", "false")
14802 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/dicomWeb/{+dicomWebPath}")
14803 urls += "?" + c.urlParams_.Encode()
14804 req, err := http.NewRequest("GET", urls, body)
14805 if err != nil {
14806 return nil, err
14807 }
14808 req.Header = reqHeaders
14809 googleapi.Expand(req.URL, map[string]string{
14810 "parent": c.parent,
14811 "dicomWebPath": c.dicomWebPath,
14812 })
14813 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14814 }
14815
14816
14817 func (c *ProjectsLocationsDatasetsDicomStoresStudiesSeriesInstancesFramesRetrieveRenderedCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
14818 gensupport.SetOptions(c.urlParams_, opts...)
14819 return c.doRequest("")
14820 }
14821
14822 type ProjectsLocationsDatasetsFhirStoresCreateCall struct {
14823 s *Service
14824 parent string
14825 fhirstore *FhirStore
14826 urlParams_ gensupport.URLParams
14827 ctx_ context.Context
14828 header_ http.Header
14829 }
14830
14831
14832
14833
14834 func (r *ProjectsLocationsDatasetsFhirStoresService) Create(parent string, fhirstore *FhirStore) *ProjectsLocationsDatasetsFhirStoresCreateCall {
14835 c := &ProjectsLocationsDatasetsFhirStoresCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14836 c.parent = parent
14837 c.fhirstore = fhirstore
14838 return c
14839 }
14840
14841
14842
14843
14844 func (c *ProjectsLocationsDatasetsFhirStoresCreateCall) FhirStoreId(fhirStoreId string) *ProjectsLocationsDatasetsFhirStoresCreateCall {
14845 c.urlParams_.Set("fhirStoreId", fhirStoreId)
14846 return c
14847 }
14848
14849
14850
14851
14852 func (c *ProjectsLocationsDatasetsFhirStoresCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresCreateCall {
14853 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14854 return c
14855 }
14856
14857
14858 func (c *ProjectsLocationsDatasetsFhirStoresCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresCreateCall {
14859 c.ctx_ = ctx
14860 return c
14861 }
14862
14863
14864
14865 func (c *ProjectsLocationsDatasetsFhirStoresCreateCall) Header() http.Header {
14866 if c.header_ == nil {
14867 c.header_ = make(http.Header)
14868 }
14869 return c.header_
14870 }
14871
14872 func (c *ProjectsLocationsDatasetsFhirStoresCreateCall) doRequest(alt string) (*http.Response, error) {
14873 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14874 var body io.Reader = nil
14875 body, err := googleapi.WithoutDataWrapper.JSONReader(c.fhirstore)
14876 if err != nil {
14877 return nil, err
14878 }
14879 c.urlParams_.Set("alt", alt)
14880 c.urlParams_.Set("prettyPrint", "false")
14881 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhirStores")
14882 urls += "?" + c.urlParams_.Encode()
14883 req, err := http.NewRequest("POST", urls, body)
14884 if err != nil {
14885 return nil, err
14886 }
14887 req.Header = reqHeaders
14888 googleapi.Expand(req.URL, map[string]string{
14889 "parent": c.parent,
14890 })
14891 return gensupport.SendRequest(c.ctx_, c.s.client, req)
14892 }
14893
14894
14895
14896
14897
14898
14899 func (c *ProjectsLocationsDatasetsFhirStoresCreateCall) Do(opts ...googleapi.CallOption) (*FhirStore, error) {
14900 gensupport.SetOptions(c.urlParams_, opts...)
14901 res, err := c.doRequest("json")
14902 if res != nil && res.StatusCode == http.StatusNotModified {
14903 if res.Body != nil {
14904 res.Body.Close()
14905 }
14906 return nil, gensupport.WrapError(&googleapi.Error{
14907 Code: res.StatusCode,
14908 Header: res.Header,
14909 })
14910 }
14911 if err != nil {
14912 return nil, err
14913 }
14914 defer googleapi.CloseBody(res)
14915 if err := googleapi.CheckResponse(res); err != nil {
14916 return nil, gensupport.WrapError(err)
14917 }
14918 ret := &FhirStore{
14919 ServerResponse: googleapi.ServerResponse{
14920 Header: res.Header,
14921 HTTPStatusCode: res.StatusCode,
14922 },
14923 }
14924 target := &ret
14925 if err := gensupport.DecodeResponse(target, res); err != nil {
14926 return nil, err
14927 }
14928 return ret, nil
14929 }
14930
14931 type ProjectsLocationsDatasetsFhirStoresDeidentifyCall struct {
14932 s *Service
14933 sourceStore string
14934 deidentifyfhirstorerequest *DeidentifyFhirStoreRequest
14935 urlParams_ gensupport.URLParams
14936 ctx_ context.Context
14937 header_ http.Header
14938 }
14939
14940
14941
14942
14943
14944
14945
14946
14947
14948
14949
14950 func (r *ProjectsLocationsDatasetsFhirStoresService) Deidentify(sourceStore string, deidentifyfhirstorerequest *DeidentifyFhirStoreRequest) *ProjectsLocationsDatasetsFhirStoresDeidentifyCall {
14951 c := &ProjectsLocationsDatasetsFhirStoresDeidentifyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
14952 c.sourceStore = sourceStore
14953 c.deidentifyfhirstorerequest = deidentifyfhirstorerequest
14954 return c
14955 }
14956
14957
14958
14959
14960 func (c *ProjectsLocationsDatasetsFhirStoresDeidentifyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresDeidentifyCall {
14961 c.urlParams_.Set("fields", googleapi.CombineFields(s))
14962 return c
14963 }
14964
14965
14966 func (c *ProjectsLocationsDatasetsFhirStoresDeidentifyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresDeidentifyCall {
14967 c.ctx_ = ctx
14968 return c
14969 }
14970
14971
14972
14973 func (c *ProjectsLocationsDatasetsFhirStoresDeidentifyCall) Header() http.Header {
14974 if c.header_ == nil {
14975 c.header_ = make(http.Header)
14976 }
14977 return c.header_
14978 }
14979
14980 func (c *ProjectsLocationsDatasetsFhirStoresDeidentifyCall) doRequest(alt string) (*http.Response, error) {
14981 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
14982 var body io.Reader = nil
14983 body, err := googleapi.WithoutDataWrapper.JSONReader(c.deidentifyfhirstorerequest)
14984 if err != nil {
14985 return nil, err
14986 }
14987 c.urlParams_.Set("alt", alt)
14988 c.urlParams_.Set("prettyPrint", "false")
14989 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+sourceStore}:deidentify")
14990 urls += "?" + c.urlParams_.Encode()
14991 req, err := http.NewRequest("POST", urls, body)
14992 if err != nil {
14993 return nil, err
14994 }
14995 req.Header = reqHeaders
14996 googleapi.Expand(req.URL, map[string]string{
14997 "sourceStore": c.sourceStore,
14998 })
14999 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15000 }
15001
15002
15003
15004
15005
15006
15007 func (c *ProjectsLocationsDatasetsFhirStoresDeidentifyCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
15008 gensupport.SetOptions(c.urlParams_, opts...)
15009 res, err := c.doRequest("json")
15010 if res != nil && res.StatusCode == http.StatusNotModified {
15011 if res.Body != nil {
15012 res.Body.Close()
15013 }
15014 return nil, gensupport.WrapError(&googleapi.Error{
15015 Code: res.StatusCode,
15016 Header: res.Header,
15017 })
15018 }
15019 if err != nil {
15020 return nil, err
15021 }
15022 defer googleapi.CloseBody(res)
15023 if err := googleapi.CheckResponse(res); err != nil {
15024 return nil, gensupport.WrapError(err)
15025 }
15026 ret := &Operation{
15027 ServerResponse: googleapi.ServerResponse{
15028 Header: res.Header,
15029 HTTPStatusCode: res.StatusCode,
15030 },
15031 }
15032 target := &ret
15033 if err := gensupport.DecodeResponse(target, res); err != nil {
15034 return nil, err
15035 }
15036 return ret, nil
15037 }
15038
15039 type ProjectsLocationsDatasetsFhirStoresDeleteCall struct {
15040 s *Service
15041 name string
15042 urlParams_ gensupport.URLParams
15043 ctx_ context.Context
15044 header_ http.Header
15045 }
15046
15047
15048
15049
15050
15051 func (r *ProjectsLocationsDatasetsFhirStoresService) Delete(name string) *ProjectsLocationsDatasetsFhirStoresDeleteCall {
15052 c := &ProjectsLocationsDatasetsFhirStoresDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15053 c.name = name
15054 return c
15055 }
15056
15057
15058
15059
15060 func (c *ProjectsLocationsDatasetsFhirStoresDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresDeleteCall {
15061 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15062 return c
15063 }
15064
15065
15066 func (c *ProjectsLocationsDatasetsFhirStoresDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresDeleteCall {
15067 c.ctx_ = ctx
15068 return c
15069 }
15070
15071
15072
15073 func (c *ProjectsLocationsDatasetsFhirStoresDeleteCall) Header() http.Header {
15074 if c.header_ == nil {
15075 c.header_ = make(http.Header)
15076 }
15077 return c.header_
15078 }
15079
15080 func (c *ProjectsLocationsDatasetsFhirStoresDeleteCall) doRequest(alt string) (*http.Response, error) {
15081 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15082 var body io.Reader = nil
15083 c.urlParams_.Set("alt", alt)
15084 c.urlParams_.Set("prettyPrint", "false")
15085 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
15086 urls += "?" + c.urlParams_.Encode()
15087 req, err := http.NewRequest("DELETE", urls, body)
15088 if err != nil {
15089 return nil, err
15090 }
15091 req.Header = reqHeaders
15092 googleapi.Expand(req.URL, map[string]string{
15093 "name": c.name,
15094 })
15095 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15096 }
15097
15098
15099
15100
15101
15102
15103 func (c *ProjectsLocationsDatasetsFhirStoresDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
15104 gensupport.SetOptions(c.urlParams_, opts...)
15105 res, err := c.doRequest("json")
15106 if res != nil && res.StatusCode == http.StatusNotModified {
15107 if res.Body != nil {
15108 res.Body.Close()
15109 }
15110 return nil, gensupport.WrapError(&googleapi.Error{
15111 Code: res.StatusCode,
15112 Header: res.Header,
15113 })
15114 }
15115 if err != nil {
15116 return nil, err
15117 }
15118 defer googleapi.CloseBody(res)
15119 if err := googleapi.CheckResponse(res); err != nil {
15120 return nil, gensupport.WrapError(err)
15121 }
15122 ret := &Empty{
15123 ServerResponse: googleapi.ServerResponse{
15124 Header: res.Header,
15125 HTTPStatusCode: res.StatusCode,
15126 },
15127 }
15128 target := &ret
15129 if err := gensupport.DecodeResponse(target, res); err != nil {
15130 return nil, err
15131 }
15132 return ret, nil
15133 }
15134
15135 type ProjectsLocationsDatasetsFhirStoresExportCall struct {
15136 s *Service
15137 name string
15138 exportresourcesrequest *ExportResourcesRequest
15139 urlParams_ gensupport.URLParams
15140 ctx_ context.Context
15141 header_ http.Header
15142 }
15143
15144
15145
15146
15147
15148
15149
15150
15151
15152
15153
15154
15155
15156 func (r *ProjectsLocationsDatasetsFhirStoresService) Export(name string, exportresourcesrequest *ExportResourcesRequest) *ProjectsLocationsDatasetsFhirStoresExportCall {
15157 c := &ProjectsLocationsDatasetsFhirStoresExportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15158 c.name = name
15159 c.exportresourcesrequest = exportresourcesrequest
15160 return c
15161 }
15162
15163
15164
15165
15166 func (c *ProjectsLocationsDatasetsFhirStoresExportCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresExportCall {
15167 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15168 return c
15169 }
15170
15171
15172 func (c *ProjectsLocationsDatasetsFhirStoresExportCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresExportCall {
15173 c.ctx_ = ctx
15174 return c
15175 }
15176
15177
15178
15179 func (c *ProjectsLocationsDatasetsFhirStoresExportCall) Header() http.Header {
15180 if c.header_ == nil {
15181 c.header_ = make(http.Header)
15182 }
15183 return c.header_
15184 }
15185
15186 func (c *ProjectsLocationsDatasetsFhirStoresExportCall) doRequest(alt string) (*http.Response, error) {
15187 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15188 var body io.Reader = nil
15189 body, err := googleapi.WithoutDataWrapper.JSONReader(c.exportresourcesrequest)
15190 if err != nil {
15191 return nil, err
15192 }
15193 c.urlParams_.Set("alt", alt)
15194 c.urlParams_.Set("prettyPrint", "false")
15195 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:export")
15196 urls += "?" + c.urlParams_.Encode()
15197 req, err := http.NewRequest("POST", urls, body)
15198 if err != nil {
15199 return nil, err
15200 }
15201 req.Header = reqHeaders
15202 googleapi.Expand(req.URL, map[string]string{
15203 "name": c.name,
15204 })
15205 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15206 }
15207
15208
15209
15210
15211
15212
15213 func (c *ProjectsLocationsDatasetsFhirStoresExportCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
15214 gensupport.SetOptions(c.urlParams_, opts...)
15215 res, err := c.doRequest("json")
15216 if res != nil && res.StatusCode == http.StatusNotModified {
15217 if res.Body != nil {
15218 res.Body.Close()
15219 }
15220 return nil, gensupport.WrapError(&googleapi.Error{
15221 Code: res.StatusCode,
15222 Header: res.Header,
15223 })
15224 }
15225 if err != nil {
15226 return nil, err
15227 }
15228 defer googleapi.CloseBody(res)
15229 if err := googleapi.CheckResponse(res); err != nil {
15230 return nil, gensupport.WrapError(err)
15231 }
15232 ret := &Operation{
15233 ServerResponse: googleapi.ServerResponse{
15234 Header: res.Header,
15235 HTTPStatusCode: res.StatusCode,
15236 },
15237 }
15238 target := &ret
15239 if err := gensupport.DecodeResponse(target, res); err != nil {
15240 return nil, err
15241 }
15242 return ret, nil
15243 }
15244
15245 type ProjectsLocationsDatasetsFhirStoresGetCall struct {
15246 s *Service
15247 name string
15248 urlParams_ gensupport.URLParams
15249 ifNoneMatch_ string
15250 ctx_ context.Context
15251 header_ http.Header
15252 }
15253
15254
15255
15256
15257 func (r *ProjectsLocationsDatasetsFhirStoresService) Get(name string) *ProjectsLocationsDatasetsFhirStoresGetCall {
15258 c := &ProjectsLocationsDatasetsFhirStoresGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15259 c.name = name
15260 return c
15261 }
15262
15263
15264
15265
15266 func (c *ProjectsLocationsDatasetsFhirStoresGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresGetCall {
15267 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15268 return c
15269 }
15270
15271
15272
15273
15274 func (c *ProjectsLocationsDatasetsFhirStoresGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresGetCall {
15275 c.ifNoneMatch_ = entityTag
15276 return c
15277 }
15278
15279
15280 func (c *ProjectsLocationsDatasetsFhirStoresGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresGetCall {
15281 c.ctx_ = ctx
15282 return c
15283 }
15284
15285
15286
15287 func (c *ProjectsLocationsDatasetsFhirStoresGetCall) Header() http.Header {
15288 if c.header_ == nil {
15289 c.header_ = make(http.Header)
15290 }
15291 return c.header_
15292 }
15293
15294 func (c *ProjectsLocationsDatasetsFhirStoresGetCall) doRequest(alt string) (*http.Response, error) {
15295 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15296 if c.ifNoneMatch_ != "" {
15297 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15298 }
15299 var body io.Reader = nil
15300 c.urlParams_.Set("alt", alt)
15301 c.urlParams_.Set("prettyPrint", "false")
15302 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
15303 urls += "?" + c.urlParams_.Encode()
15304 req, err := http.NewRequest("GET", urls, body)
15305 if err != nil {
15306 return nil, err
15307 }
15308 req.Header = reqHeaders
15309 googleapi.Expand(req.URL, map[string]string{
15310 "name": c.name,
15311 })
15312 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15313 }
15314
15315
15316
15317
15318
15319
15320 func (c *ProjectsLocationsDatasetsFhirStoresGetCall) Do(opts ...googleapi.CallOption) (*FhirStore, error) {
15321 gensupport.SetOptions(c.urlParams_, opts...)
15322 res, err := c.doRequest("json")
15323 if res != nil && res.StatusCode == http.StatusNotModified {
15324 if res.Body != nil {
15325 res.Body.Close()
15326 }
15327 return nil, gensupport.WrapError(&googleapi.Error{
15328 Code: res.StatusCode,
15329 Header: res.Header,
15330 })
15331 }
15332 if err != nil {
15333 return nil, err
15334 }
15335 defer googleapi.CloseBody(res)
15336 if err := googleapi.CheckResponse(res); err != nil {
15337 return nil, gensupport.WrapError(err)
15338 }
15339 ret := &FhirStore{
15340 ServerResponse: googleapi.ServerResponse{
15341 Header: res.Header,
15342 HTTPStatusCode: res.StatusCode,
15343 },
15344 }
15345 target := &ret
15346 if err := gensupport.DecodeResponse(target, res); err != nil {
15347 return nil, err
15348 }
15349 return ret, nil
15350 }
15351
15352 type ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall struct {
15353 s *Service
15354 name string
15355 urlParams_ gensupport.URLParams
15356 ifNoneMatch_ string
15357 ctx_ context.Context
15358 header_ http.Header
15359 }
15360
15361
15362
15363
15364 func (r *ProjectsLocationsDatasetsFhirStoresService) GetFHIRStoreMetrics(name string) *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall {
15365 c := &ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15366 c.name = name
15367 return c
15368 }
15369
15370
15371
15372
15373 func (c *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall {
15374 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15375 return c
15376 }
15377
15378
15379
15380
15381 func (c *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall {
15382 c.ifNoneMatch_ = entityTag
15383 return c
15384 }
15385
15386
15387 func (c *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall {
15388 c.ctx_ = ctx
15389 return c
15390 }
15391
15392
15393
15394 func (c *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall) Header() http.Header {
15395 if c.header_ == nil {
15396 c.header_ = make(http.Header)
15397 }
15398 return c.header_
15399 }
15400
15401 func (c *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall) doRequest(alt string) (*http.Response, error) {
15402 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15403 if c.ifNoneMatch_ != "" {
15404 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15405 }
15406 var body io.Reader = nil
15407 c.urlParams_.Set("alt", alt)
15408 c.urlParams_.Set("prettyPrint", "false")
15409 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:getFHIRStoreMetrics")
15410 urls += "?" + c.urlParams_.Encode()
15411 req, err := http.NewRequest("GET", urls, body)
15412 if err != nil {
15413 return nil, err
15414 }
15415 req.Header = reqHeaders
15416 googleapi.Expand(req.URL, map[string]string{
15417 "name": c.name,
15418 })
15419 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15420 }
15421
15422
15423
15424
15425
15426
15427
15428 func (c *ProjectsLocationsDatasetsFhirStoresGetFHIRStoreMetricsCall) Do(opts ...googleapi.CallOption) (*FhirStoreMetrics, error) {
15429 gensupport.SetOptions(c.urlParams_, opts...)
15430 res, err := c.doRequest("json")
15431 if res != nil && res.StatusCode == http.StatusNotModified {
15432 if res.Body != nil {
15433 res.Body.Close()
15434 }
15435 return nil, gensupport.WrapError(&googleapi.Error{
15436 Code: res.StatusCode,
15437 Header: res.Header,
15438 })
15439 }
15440 if err != nil {
15441 return nil, err
15442 }
15443 defer googleapi.CloseBody(res)
15444 if err := googleapi.CheckResponse(res); err != nil {
15445 return nil, gensupport.WrapError(err)
15446 }
15447 ret := &FhirStoreMetrics{
15448 ServerResponse: googleapi.ServerResponse{
15449 Header: res.Header,
15450 HTTPStatusCode: res.StatusCode,
15451 },
15452 }
15453 target := &ret
15454 if err := gensupport.DecodeResponse(target, res); err != nil {
15455 return nil, err
15456 }
15457 return ret, nil
15458 }
15459
15460 type ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall struct {
15461 s *Service
15462 resource string
15463 urlParams_ gensupport.URLParams
15464 ifNoneMatch_ string
15465 ctx_ context.Context
15466 header_ http.Header
15467 }
15468
15469
15470
15471
15472
15473
15474
15475 func (r *ProjectsLocationsDatasetsFhirStoresService) GetIamPolicy(resource string) *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall {
15476 c := &ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15477 c.resource = resource
15478 return c
15479 }
15480
15481
15482
15483
15484
15485
15486
15487
15488
15489
15490
15491
15492
15493 func (c *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall {
15494 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
15495 return c
15496 }
15497
15498
15499
15500
15501 func (c *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall {
15502 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15503 return c
15504 }
15505
15506
15507
15508
15509 func (c *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall {
15510 c.ifNoneMatch_ = entityTag
15511 return c
15512 }
15513
15514
15515 func (c *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall {
15516 c.ctx_ = ctx
15517 return c
15518 }
15519
15520
15521
15522 func (c *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall) Header() http.Header {
15523 if c.header_ == nil {
15524 c.header_ = make(http.Header)
15525 }
15526 return c.header_
15527 }
15528
15529 func (c *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
15530 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15531 if c.ifNoneMatch_ != "" {
15532 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15533 }
15534 var body io.Reader = nil
15535 c.urlParams_.Set("alt", alt)
15536 c.urlParams_.Set("prettyPrint", "false")
15537 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
15538 urls += "?" + c.urlParams_.Encode()
15539 req, err := http.NewRequest("GET", urls, body)
15540 if err != nil {
15541 return nil, err
15542 }
15543 req.Header = reqHeaders
15544 googleapi.Expand(req.URL, map[string]string{
15545 "resource": c.resource,
15546 })
15547 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15548 }
15549
15550
15551
15552
15553
15554
15555 func (c *ProjectsLocationsDatasetsFhirStoresGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
15556 gensupport.SetOptions(c.urlParams_, opts...)
15557 res, err := c.doRequest("json")
15558 if res != nil && res.StatusCode == http.StatusNotModified {
15559 if res.Body != nil {
15560 res.Body.Close()
15561 }
15562 return nil, gensupport.WrapError(&googleapi.Error{
15563 Code: res.StatusCode,
15564 Header: res.Header,
15565 })
15566 }
15567 if err != nil {
15568 return nil, err
15569 }
15570 defer googleapi.CloseBody(res)
15571 if err := googleapi.CheckResponse(res); err != nil {
15572 return nil, gensupport.WrapError(err)
15573 }
15574 ret := &Policy{
15575 ServerResponse: googleapi.ServerResponse{
15576 Header: res.Header,
15577 HTTPStatusCode: res.StatusCode,
15578 },
15579 }
15580 target := &ret
15581 if err := gensupport.DecodeResponse(target, res); err != nil {
15582 return nil, err
15583 }
15584 return ret, nil
15585 }
15586
15587 type ProjectsLocationsDatasetsFhirStoresImportCall struct {
15588 s *Service
15589 name string
15590 importresourcesrequest *ImportResourcesRequest
15591 urlParams_ gensupport.URLParams
15592 ctx_ context.Context
15593 header_ http.Header
15594 }
15595
15596
15597
15598
15599
15600
15601
15602
15603
15604
15605
15606
15607
15608
15609
15610
15611
15612
15613
15614
15615
15616
15617
15618
15619
15620
15621
15622
15623
15624
15625
15626
15627
15628
15629
15630
15631
15632
15633
15634
15635
15636
15637
15638
15639
15640
15641
15642
15643
15644
15645
15646
15647
15648
15649
15650
15651
15652
15653
15654
15655
15656 func (r *ProjectsLocationsDatasetsFhirStoresService) Import(name string, importresourcesrequest *ImportResourcesRequest) *ProjectsLocationsDatasetsFhirStoresImportCall {
15657 c := &ProjectsLocationsDatasetsFhirStoresImportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15658 c.name = name
15659 c.importresourcesrequest = importresourcesrequest
15660 return c
15661 }
15662
15663
15664
15665
15666 func (c *ProjectsLocationsDatasetsFhirStoresImportCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresImportCall {
15667 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15668 return c
15669 }
15670
15671
15672 func (c *ProjectsLocationsDatasetsFhirStoresImportCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresImportCall {
15673 c.ctx_ = ctx
15674 return c
15675 }
15676
15677
15678
15679 func (c *ProjectsLocationsDatasetsFhirStoresImportCall) Header() http.Header {
15680 if c.header_ == nil {
15681 c.header_ = make(http.Header)
15682 }
15683 return c.header_
15684 }
15685
15686 func (c *ProjectsLocationsDatasetsFhirStoresImportCall) doRequest(alt string) (*http.Response, error) {
15687 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15688 var body io.Reader = nil
15689 body, err := googleapi.WithoutDataWrapper.JSONReader(c.importresourcesrequest)
15690 if err != nil {
15691 return nil, err
15692 }
15693 c.urlParams_.Set("alt", alt)
15694 c.urlParams_.Set("prettyPrint", "false")
15695 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:import")
15696 urls += "?" + c.urlParams_.Encode()
15697 req, err := http.NewRequest("POST", urls, body)
15698 if err != nil {
15699 return nil, err
15700 }
15701 req.Header = reqHeaders
15702 googleapi.Expand(req.URL, map[string]string{
15703 "name": c.name,
15704 })
15705 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15706 }
15707
15708
15709
15710
15711
15712
15713 func (c *ProjectsLocationsDatasetsFhirStoresImportCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
15714 gensupport.SetOptions(c.urlParams_, opts...)
15715 res, err := c.doRequest("json")
15716 if res != nil && res.StatusCode == http.StatusNotModified {
15717 if res.Body != nil {
15718 res.Body.Close()
15719 }
15720 return nil, gensupport.WrapError(&googleapi.Error{
15721 Code: res.StatusCode,
15722 Header: res.Header,
15723 })
15724 }
15725 if err != nil {
15726 return nil, err
15727 }
15728 defer googleapi.CloseBody(res)
15729 if err := googleapi.CheckResponse(res); err != nil {
15730 return nil, gensupport.WrapError(err)
15731 }
15732 ret := &Operation{
15733 ServerResponse: googleapi.ServerResponse{
15734 Header: res.Header,
15735 HTTPStatusCode: res.StatusCode,
15736 },
15737 }
15738 target := &ret
15739 if err := gensupport.DecodeResponse(target, res); err != nil {
15740 return nil, err
15741 }
15742 return ret, nil
15743 }
15744
15745 type ProjectsLocationsDatasetsFhirStoresListCall struct {
15746 s *Service
15747 parent string
15748 urlParams_ gensupport.URLParams
15749 ifNoneMatch_ string
15750 ctx_ context.Context
15751 header_ http.Header
15752 }
15753
15754
15755
15756
15757 func (r *ProjectsLocationsDatasetsFhirStoresService) List(parent string) *ProjectsLocationsDatasetsFhirStoresListCall {
15758 c := &ProjectsLocationsDatasetsFhirStoresListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15759 c.parent = parent
15760 return c
15761 }
15762
15763
15764
15765
15766
15767
15768
15769
15770
15771
15772
15773
15774
15775
15776
15777
15778
15779
15780
15781
15782
15783
15784
15785
15786 func (c *ProjectsLocationsDatasetsFhirStoresListCall) Filter(filter string) *ProjectsLocationsDatasetsFhirStoresListCall {
15787 c.urlParams_.Set("filter", filter)
15788 return c
15789 }
15790
15791
15792
15793
15794 func (c *ProjectsLocationsDatasetsFhirStoresListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsFhirStoresListCall {
15795 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
15796 return c
15797 }
15798
15799
15800
15801 func (c *ProjectsLocationsDatasetsFhirStoresListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsFhirStoresListCall {
15802 c.urlParams_.Set("pageToken", pageToken)
15803 return c
15804 }
15805
15806
15807
15808
15809 func (c *ProjectsLocationsDatasetsFhirStoresListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresListCall {
15810 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15811 return c
15812 }
15813
15814
15815
15816
15817 func (c *ProjectsLocationsDatasetsFhirStoresListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresListCall {
15818 c.ifNoneMatch_ = entityTag
15819 return c
15820 }
15821
15822
15823 func (c *ProjectsLocationsDatasetsFhirStoresListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresListCall {
15824 c.ctx_ = ctx
15825 return c
15826 }
15827
15828
15829
15830 func (c *ProjectsLocationsDatasetsFhirStoresListCall) Header() http.Header {
15831 if c.header_ == nil {
15832 c.header_ = make(http.Header)
15833 }
15834 return c.header_
15835 }
15836
15837 func (c *ProjectsLocationsDatasetsFhirStoresListCall) doRequest(alt string) (*http.Response, error) {
15838 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
15839 if c.ifNoneMatch_ != "" {
15840 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
15841 }
15842 var body io.Reader = nil
15843 c.urlParams_.Set("alt", alt)
15844 c.urlParams_.Set("prettyPrint", "false")
15845 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhirStores")
15846 urls += "?" + c.urlParams_.Encode()
15847 req, err := http.NewRequest("GET", urls, body)
15848 if err != nil {
15849 return nil, err
15850 }
15851 req.Header = reqHeaders
15852 googleapi.Expand(req.URL, map[string]string{
15853 "parent": c.parent,
15854 })
15855 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15856 }
15857
15858
15859
15860
15861
15862
15863
15864 func (c *ProjectsLocationsDatasetsFhirStoresListCall) Do(opts ...googleapi.CallOption) (*ListFhirStoresResponse, error) {
15865 gensupport.SetOptions(c.urlParams_, opts...)
15866 res, err := c.doRequest("json")
15867 if res != nil && res.StatusCode == http.StatusNotModified {
15868 if res.Body != nil {
15869 res.Body.Close()
15870 }
15871 return nil, gensupport.WrapError(&googleapi.Error{
15872 Code: res.StatusCode,
15873 Header: res.Header,
15874 })
15875 }
15876 if err != nil {
15877 return nil, err
15878 }
15879 defer googleapi.CloseBody(res)
15880 if err := googleapi.CheckResponse(res); err != nil {
15881 return nil, gensupport.WrapError(err)
15882 }
15883 ret := &ListFhirStoresResponse{
15884 ServerResponse: googleapi.ServerResponse{
15885 Header: res.Header,
15886 HTTPStatusCode: res.StatusCode,
15887 },
15888 }
15889 target := &ret
15890 if err := gensupport.DecodeResponse(target, res); err != nil {
15891 return nil, err
15892 }
15893 return ret, nil
15894 }
15895
15896
15897
15898
15899 func (c *ProjectsLocationsDatasetsFhirStoresListCall) Pages(ctx context.Context, f func(*ListFhirStoresResponse) error) error {
15900 c.ctx_ = ctx
15901 defer c.PageToken(c.urlParams_.Get("pageToken"))
15902 for {
15903 x, err := c.Do()
15904 if err != nil {
15905 return err
15906 }
15907 if err := f(x); err != nil {
15908 return err
15909 }
15910 if x.NextPageToken == "" {
15911 return nil
15912 }
15913 c.PageToken(x.NextPageToken)
15914 }
15915 }
15916
15917 type ProjectsLocationsDatasetsFhirStoresPatchCall struct {
15918 s *Service
15919 name string
15920 fhirstore *FhirStore
15921 urlParams_ gensupport.URLParams
15922 ctx_ context.Context
15923 header_ http.Header
15924 }
15925
15926
15927
15928
15929
15930
15931
15932 func (r *ProjectsLocationsDatasetsFhirStoresService) Patch(name string, fhirstore *FhirStore) *ProjectsLocationsDatasetsFhirStoresPatchCall {
15933 c := &ProjectsLocationsDatasetsFhirStoresPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
15934 c.name = name
15935 c.fhirstore = fhirstore
15936 return c
15937 }
15938
15939
15940
15941
15942 func (c *ProjectsLocationsDatasetsFhirStoresPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsFhirStoresPatchCall {
15943 c.urlParams_.Set("updateMask", updateMask)
15944 return c
15945 }
15946
15947
15948
15949
15950 func (c *ProjectsLocationsDatasetsFhirStoresPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresPatchCall {
15951 c.urlParams_.Set("fields", googleapi.CombineFields(s))
15952 return c
15953 }
15954
15955
15956 func (c *ProjectsLocationsDatasetsFhirStoresPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresPatchCall {
15957 c.ctx_ = ctx
15958 return c
15959 }
15960
15961
15962
15963 func (c *ProjectsLocationsDatasetsFhirStoresPatchCall) Header() http.Header {
15964 if c.header_ == nil {
15965 c.header_ = make(http.Header)
15966 }
15967 return c.header_
15968 }
15969
15970 func (c *ProjectsLocationsDatasetsFhirStoresPatchCall) doRequest(alt string) (*http.Response, error) {
15971 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
15972 var body io.Reader = nil
15973 body, err := googleapi.WithoutDataWrapper.JSONReader(c.fhirstore)
15974 if err != nil {
15975 return nil, err
15976 }
15977 c.urlParams_.Set("alt", alt)
15978 c.urlParams_.Set("prettyPrint", "false")
15979 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
15980 urls += "?" + c.urlParams_.Encode()
15981 req, err := http.NewRequest("PATCH", urls, body)
15982 if err != nil {
15983 return nil, err
15984 }
15985 req.Header = reqHeaders
15986 googleapi.Expand(req.URL, map[string]string{
15987 "name": c.name,
15988 })
15989 return gensupport.SendRequest(c.ctx_, c.s.client, req)
15990 }
15991
15992
15993
15994
15995
15996
15997 func (c *ProjectsLocationsDatasetsFhirStoresPatchCall) Do(opts ...googleapi.CallOption) (*FhirStore, error) {
15998 gensupport.SetOptions(c.urlParams_, opts...)
15999 res, err := c.doRequest("json")
16000 if res != nil && res.StatusCode == http.StatusNotModified {
16001 if res.Body != nil {
16002 res.Body.Close()
16003 }
16004 return nil, gensupport.WrapError(&googleapi.Error{
16005 Code: res.StatusCode,
16006 Header: res.Header,
16007 })
16008 }
16009 if err != nil {
16010 return nil, err
16011 }
16012 defer googleapi.CloseBody(res)
16013 if err := googleapi.CheckResponse(res); err != nil {
16014 return nil, gensupport.WrapError(err)
16015 }
16016 ret := &FhirStore{
16017 ServerResponse: googleapi.ServerResponse{
16018 Header: res.Header,
16019 HTTPStatusCode: res.StatusCode,
16020 },
16021 }
16022 target := &ret
16023 if err := gensupport.DecodeResponse(target, res); err != nil {
16024 return nil, err
16025 }
16026 return ret, nil
16027 }
16028
16029 type ProjectsLocationsDatasetsFhirStoresRollbackCall struct {
16030 s *Service
16031 name string
16032 rollbackfhirresourcesrequest *RollbackFhirResourcesRequest
16033 urlParams_ gensupport.URLParams
16034 ctx_ context.Context
16035 header_ http.Header
16036 }
16037
16038
16039
16040
16041
16042
16043
16044
16045
16046
16047
16048
16049
16050 func (r *ProjectsLocationsDatasetsFhirStoresService) Rollback(name string, rollbackfhirresourcesrequest *RollbackFhirResourcesRequest) *ProjectsLocationsDatasetsFhirStoresRollbackCall {
16051 c := &ProjectsLocationsDatasetsFhirStoresRollbackCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16052 c.name = name
16053 c.rollbackfhirresourcesrequest = rollbackfhirresourcesrequest
16054 return c
16055 }
16056
16057
16058
16059
16060 func (c *ProjectsLocationsDatasetsFhirStoresRollbackCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresRollbackCall {
16061 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16062 return c
16063 }
16064
16065
16066 func (c *ProjectsLocationsDatasetsFhirStoresRollbackCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresRollbackCall {
16067 c.ctx_ = ctx
16068 return c
16069 }
16070
16071
16072
16073 func (c *ProjectsLocationsDatasetsFhirStoresRollbackCall) Header() http.Header {
16074 if c.header_ == nil {
16075 c.header_ = make(http.Header)
16076 }
16077 return c.header_
16078 }
16079
16080 func (c *ProjectsLocationsDatasetsFhirStoresRollbackCall) doRequest(alt string) (*http.Response, error) {
16081 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16082 var body io.Reader = nil
16083 body, err := googleapi.WithoutDataWrapper.JSONReader(c.rollbackfhirresourcesrequest)
16084 if err != nil {
16085 return nil, err
16086 }
16087 c.urlParams_.Set("alt", alt)
16088 c.urlParams_.Set("prettyPrint", "false")
16089 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:rollback")
16090 urls += "?" + c.urlParams_.Encode()
16091 req, err := http.NewRequest("POST", urls, body)
16092 if err != nil {
16093 return nil, err
16094 }
16095 req.Header = reqHeaders
16096 googleapi.Expand(req.URL, map[string]string{
16097 "name": c.name,
16098 })
16099 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16100 }
16101
16102
16103
16104
16105
16106
16107 func (c *ProjectsLocationsDatasetsFhirStoresRollbackCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
16108 gensupport.SetOptions(c.urlParams_, opts...)
16109 res, err := c.doRequest("json")
16110 if res != nil && res.StatusCode == http.StatusNotModified {
16111 if res.Body != nil {
16112 res.Body.Close()
16113 }
16114 return nil, gensupport.WrapError(&googleapi.Error{
16115 Code: res.StatusCode,
16116 Header: res.Header,
16117 })
16118 }
16119 if err != nil {
16120 return nil, err
16121 }
16122 defer googleapi.CloseBody(res)
16123 if err := googleapi.CheckResponse(res); err != nil {
16124 return nil, gensupport.WrapError(err)
16125 }
16126 ret := &Operation{
16127 ServerResponse: googleapi.ServerResponse{
16128 Header: res.Header,
16129 HTTPStatusCode: res.StatusCode,
16130 },
16131 }
16132 target := &ret
16133 if err := gensupport.DecodeResponse(target, res); err != nil {
16134 return nil, err
16135 }
16136 return ret, nil
16137 }
16138
16139 type ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall struct {
16140 s *Service
16141 resource string
16142 setiampolicyrequest *SetIamPolicyRequest
16143 urlParams_ gensupport.URLParams
16144 ctx_ context.Context
16145 header_ http.Header
16146 }
16147
16148
16149
16150
16151
16152
16153
16154
16155 func (r *ProjectsLocationsDatasetsFhirStoresService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall {
16156 c := &ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16157 c.resource = resource
16158 c.setiampolicyrequest = setiampolicyrequest
16159 return c
16160 }
16161
16162
16163
16164
16165 func (c *ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall {
16166 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16167 return c
16168 }
16169
16170
16171 func (c *ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall {
16172 c.ctx_ = ctx
16173 return c
16174 }
16175
16176
16177
16178 func (c *ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall) Header() http.Header {
16179 if c.header_ == nil {
16180 c.header_ = make(http.Header)
16181 }
16182 return c.header_
16183 }
16184
16185 func (c *ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
16186 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16187 var body io.Reader = nil
16188 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
16189 if err != nil {
16190 return nil, err
16191 }
16192 c.urlParams_.Set("alt", alt)
16193 c.urlParams_.Set("prettyPrint", "false")
16194 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
16195 urls += "?" + c.urlParams_.Encode()
16196 req, err := http.NewRequest("POST", urls, body)
16197 if err != nil {
16198 return nil, err
16199 }
16200 req.Header = reqHeaders
16201 googleapi.Expand(req.URL, map[string]string{
16202 "resource": c.resource,
16203 })
16204 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16205 }
16206
16207
16208
16209
16210
16211
16212 func (c *ProjectsLocationsDatasetsFhirStoresSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
16213 gensupport.SetOptions(c.urlParams_, opts...)
16214 res, err := c.doRequest("json")
16215 if res != nil && res.StatusCode == http.StatusNotModified {
16216 if res.Body != nil {
16217 res.Body.Close()
16218 }
16219 return nil, gensupport.WrapError(&googleapi.Error{
16220 Code: res.StatusCode,
16221 Header: res.Header,
16222 })
16223 }
16224 if err != nil {
16225 return nil, err
16226 }
16227 defer googleapi.CloseBody(res)
16228 if err := googleapi.CheckResponse(res); err != nil {
16229 return nil, gensupport.WrapError(err)
16230 }
16231 ret := &Policy{
16232 ServerResponse: googleapi.ServerResponse{
16233 Header: res.Header,
16234 HTTPStatusCode: res.StatusCode,
16235 },
16236 }
16237 target := &ret
16238 if err := gensupport.DecodeResponse(target, res); err != nil {
16239 return nil, err
16240 }
16241 return ret, nil
16242 }
16243
16244 type ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall struct {
16245 s *Service
16246 resource string
16247 testiampermissionsrequest *TestIamPermissionsRequest
16248 urlParams_ gensupport.URLParams
16249 ctx_ context.Context
16250 header_ http.Header
16251 }
16252
16253
16254
16255
16256
16257
16258
16259
16260
16261
16262
16263 func (r *ProjectsLocationsDatasetsFhirStoresService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall {
16264 c := &ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16265 c.resource = resource
16266 c.testiampermissionsrequest = testiampermissionsrequest
16267 return c
16268 }
16269
16270
16271
16272
16273 func (c *ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall {
16274 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16275 return c
16276 }
16277
16278
16279 func (c *ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall {
16280 c.ctx_ = ctx
16281 return c
16282 }
16283
16284
16285
16286 func (c *ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall) Header() http.Header {
16287 if c.header_ == nil {
16288 c.header_ = make(http.Header)
16289 }
16290 return c.header_
16291 }
16292
16293 func (c *ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
16294 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
16295 var body io.Reader = nil
16296 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
16297 if err != nil {
16298 return nil, err
16299 }
16300 c.urlParams_.Set("alt", alt)
16301 c.urlParams_.Set("prettyPrint", "false")
16302 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
16303 urls += "?" + c.urlParams_.Encode()
16304 req, err := http.NewRequest("POST", urls, body)
16305 if err != nil {
16306 return nil, err
16307 }
16308 req.Header = reqHeaders
16309 googleapi.Expand(req.URL, map[string]string{
16310 "resource": c.resource,
16311 })
16312 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16313 }
16314
16315
16316
16317
16318
16319
16320
16321 func (c *ProjectsLocationsDatasetsFhirStoresTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
16322 gensupport.SetOptions(c.urlParams_, opts...)
16323 res, err := c.doRequest("json")
16324 if res != nil && res.StatusCode == http.StatusNotModified {
16325 if res.Body != nil {
16326 res.Body.Close()
16327 }
16328 return nil, gensupport.WrapError(&googleapi.Error{
16329 Code: res.StatusCode,
16330 Header: res.Header,
16331 })
16332 }
16333 if err != nil {
16334 return nil, err
16335 }
16336 defer googleapi.CloseBody(res)
16337 if err := googleapi.CheckResponse(res); err != nil {
16338 return nil, gensupport.WrapError(err)
16339 }
16340 ret := &TestIamPermissionsResponse{
16341 ServerResponse: googleapi.ServerResponse{
16342 Header: res.Header,
16343 HTTPStatusCode: res.StatusCode,
16344 },
16345 }
16346 target := &ret
16347 if err := gensupport.DecodeResponse(target, res); err != nil {
16348 return nil, err
16349 }
16350 return ret, nil
16351 }
16352
16353 type ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall struct {
16354 s *Service
16355 name string
16356 urlParams_ gensupport.URLParams
16357 ifNoneMatch_ string
16358 ctx_ context.Context
16359 header_ http.Header
16360 }
16361
16362
16363
16364
16365
16366
16367
16368
16369
16370
16371
16372
16373
16374
16375
16376
16377
16378
16379
16380
16381
16382
16383
16384
16385
16386
16387
16388
16389
16390 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) PatientEverything(name string) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16391 c := &ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16392 c.name = name
16393 return c
16394 }
16395
16396
16397
16398 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) Count(Count int64) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16399 c.urlParams_.Set("_count", fmt.Sprint(Count))
16400 return c
16401 }
16402
16403
16404
16405
16406
16407
16408
16409 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) PageToken(PageToken string) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16410 c.urlParams_.Set("_page_token", PageToken)
16411 return c
16412 }
16413
16414
16415
16416
16417
16418
16419 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) Since(Since string) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16420 c.urlParams_.Set("_since", Since)
16421 return c
16422 }
16423
16424
16425
16426
16427
16428
16429 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) Type(Type string) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16430 c.urlParams_.Set("_type", Type)
16431 return c
16432 }
16433
16434
16435
16436
16437 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) End(end string) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16438 c.urlParams_.Set("end", end)
16439 return c
16440 }
16441
16442
16443
16444
16445 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) Start(start string) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16446 c.urlParams_.Set("start", start)
16447 return c
16448 }
16449
16450
16451
16452
16453 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16454 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16455 return c
16456 }
16457
16458
16459
16460
16461 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16462 c.ifNoneMatch_ = entityTag
16463 return c
16464 }
16465
16466
16467 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall {
16468 c.ctx_ = ctx
16469 return c
16470 }
16471
16472
16473
16474 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) Header() http.Header {
16475 if c.header_ == nil {
16476 c.header_ = make(http.Header)
16477 }
16478 return c.header_
16479 }
16480
16481 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) doRequest(alt string) (*http.Response, error) {
16482 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16483 if c.ifNoneMatch_ != "" {
16484 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16485 }
16486 var body io.Reader = nil
16487 c.urlParams_.Set("alt", alt)
16488 c.urlParams_.Set("prettyPrint", "false")
16489 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/$everything")
16490 urls += "?" + c.urlParams_.Encode()
16491 req, err := http.NewRequest("GET", urls, body)
16492 if err != nil {
16493 return nil, err
16494 }
16495 req.Header = reqHeaders
16496 googleapi.Expand(req.URL, map[string]string{
16497 "name": c.name,
16498 })
16499 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16500 }
16501
16502
16503 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatientEverythingCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
16504 gensupport.SetOptions(c.urlParams_, opts...)
16505 return c.doRequest("")
16506 }
16507
16508 type ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall struct {
16509 s *Service
16510 name string
16511 urlParams_ gensupport.URLParams
16512 ctx_ context.Context
16513 header_ http.Header
16514 }
16515
16516
16517
16518
16519
16520
16521
16522
16523
16524 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) ResourcePurge(name string) *ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall {
16525 c := &ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16526 c.name = name
16527 return c
16528 }
16529
16530
16531
16532
16533 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall {
16534 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16535 return c
16536 }
16537
16538
16539 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall {
16540 c.ctx_ = ctx
16541 return c
16542 }
16543
16544
16545
16546 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall) Header() http.Header {
16547 if c.header_ == nil {
16548 c.header_ = make(http.Header)
16549 }
16550 return c.header_
16551 }
16552
16553 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall) doRequest(alt string) (*http.Response, error) {
16554 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16555 var body io.Reader = nil
16556 c.urlParams_.Set("alt", alt)
16557 c.urlParams_.Set("prettyPrint", "false")
16558 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/$purge")
16559 urls += "?" + c.urlParams_.Encode()
16560 req, err := http.NewRequest("DELETE", urls, body)
16561 if err != nil {
16562 return nil, err
16563 }
16564 req.Header = reqHeaders
16565 googleapi.Expand(req.URL, map[string]string{
16566 "name": c.name,
16567 })
16568 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16569 }
16570
16571
16572
16573
16574
16575
16576 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourcePurgeCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
16577 gensupport.SetOptions(c.urlParams_, opts...)
16578 res, err := c.doRequest("json")
16579 if res != nil && res.StatusCode == http.StatusNotModified {
16580 if res.Body != nil {
16581 res.Body.Close()
16582 }
16583 return nil, gensupport.WrapError(&googleapi.Error{
16584 Code: res.StatusCode,
16585 Header: res.Header,
16586 })
16587 }
16588 if err != nil {
16589 return nil, err
16590 }
16591 defer googleapi.CloseBody(res)
16592 if err := googleapi.CheckResponse(res); err != nil {
16593 return nil, gensupport.WrapError(err)
16594 }
16595 ret := &Empty{
16596 ServerResponse: googleapi.ServerResponse{
16597 Header: res.Header,
16598 HTTPStatusCode: res.StatusCode,
16599 },
16600 }
16601 target := &ret
16602 if err := gensupport.DecodeResponse(target, res); err != nil {
16603 return nil, err
16604 }
16605 return ret, nil
16606 }
16607
16608 type ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall struct {
16609 s *Service
16610 parent string
16611 type_ string
16612 body_ io.Reader
16613 urlParams_ gensupport.URLParams
16614 ctx_ context.Context
16615 header_ http.Header
16616 }
16617
16618
16619
16620
16621
16622
16623
16624
16625
16626
16627
16628
16629
16630
16631
16632
16633
16634
16635
16636
16637
16638
16639
16640
16641
16642
16643
16644 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) ResourceValidate(parent string, type_ string, body_ io.Reader) *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall {
16645 c := &ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16646 c.parent = parent
16647 c.type_ = type_
16648 c.body_ = body_
16649 return c
16650 }
16651
16652
16653
16654
16655
16656
16657
16658 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall) Profile(profile string) *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall {
16659 c.urlParams_.Set("profile", profile)
16660 return c
16661 }
16662
16663
16664
16665
16666 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall {
16667 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16668 return c
16669 }
16670
16671
16672 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall {
16673 c.ctx_ = ctx
16674 return c
16675 }
16676
16677
16678
16679 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall) Header() http.Header {
16680 if c.header_ == nil {
16681 c.header_ = make(http.Header)
16682 }
16683 return c.header_
16684 }
16685
16686 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall) doRequest(alt string) (*http.Response, error) {
16687 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16688 var body io.Reader = nil
16689 body = c.body_
16690 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhir/{+type}/$validate")
16691 urls += "?" + c.urlParams_.Encode()
16692 req, err := http.NewRequest("POST", urls, body)
16693 if err != nil {
16694 return nil, err
16695 }
16696 req.Header = reqHeaders
16697 googleapi.Expand(req.URL, map[string]string{
16698 "parent": c.parent,
16699 "type": c.type_,
16700 })
16701 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16702 }
16703
16704
16705 func (c *ProjectsLocationsDatasetsFhirStoresFhirResourceValidateCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
16706 gensupport.SetOptions(c.urlParams_, opts...)
16707 return c.doRequest("")
16708 }
16709
16710 type ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall struct {
16711 s *Service
16712 name string
16713 urlParams_ gensupport.URLParams
16714 ifNoneMatch_ string
16715 ctx_ context.Context
16716 header_ http.Header
16717 }
16718
16719
16720
16721
16722
16723
16724
16725
16726
16727
16728
16729
16730
16731
16732
16733
16734
16735 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) Capabilities(name string) *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall {
16736 c := &ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16737 c.name = name
16738 return c
16739 }
16740
16741
16742
16743
16744 func (c *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall {
16745 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16746 return c
16747 }
16748
16749
16750
16751
16752 func (c *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall {
16753 c.ifNoneMatch_ = entityTag
16754 return c
16755 }
16756
16757
16758 func (c *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall {
16759 c.ctx_ = ctx
16760 return c
16761 }
16762
16763
16764
16765 func (c *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall) Header() http.Header {
16766 if c.header_ == nil {
16767 c.header_ = make(http.Header)
16768 }
16769 return c.header_
16770 }
16771
16772 func (c *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall) doRequest(alt string) (*http.Response, error) {
16773 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16774 if c.ifNoneMatch_ != "" {
16775 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
16776 }
16777 var body io.Reader = nil
16778 c.urlParams_.Set("alt", alt)
16779 c.urlParams_.Set("prettyPrint", "false")
16780 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/fhir/metadata")
16781 urls += "?" + c.urlParams_.Encode()
16782 req, err := http.NewRequest("GET", urls, body)
16783 if err != nil {
16784 return nil, err
16785 }
16786 req.Header = reqHeaders
16787 googleapi.Expand(req.URL, map[string]string{
16788 "name": c.name,
16789 })
16790 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16791 }
16792
16793
16794 func (c *ProjectsLocationsDatasetsFhirStoresFhirCapabilitiesCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
16795 gensupport.SetOptions(c.urlParams_, opts...)
16796 return c.doRequest("")
16797 }
16798
16799 type ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall struct {
16800 s *Service
16801 parent string
16802 type_ string
16803 urlParams_ gensupport.URLParams
16804 ctx_ context.Context
16805 header_ http.Header
16806 }
16807
16808
16809
16810
16811
16812
16813
16814
16815
16816
16817
16818
16819
16820
16821
16822
16823
16824
16825
16826
16827
16828 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) ConditionalDelete(parent string, type_ string) *ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall {
16829 c := &ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16830 c.parent = parent
16831 c.type_ = type_
16832 return c
16833 }
16834
16835
16836
16837
16838 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall {
16839 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16840 return c
16841 }
16842
16843
16844 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall {
16845 c.ctx_ = ctx
16846 return c
16847 }
16848
16849
16850
16851 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall) Header() http.Header {
16852 if c.header_ == nil {
16853 c.header_ = make(http.Header)
16854 }
16855 return c.header_
16856 }
16857
16858 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall) doRequest(alt string) (*http.Response, error) {
16859 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16860 var body io.Reader = nil
16861 c.urlParams_.Set("alt", alt)
16862 c.urlParams_.Set("prettyPrint", "false")
16863 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhir/{+type}")
16864 urls += "?" + c.urlParams_.Encode()
16865 req, err := http.NewRequest("DELETE", urls, body)
16866 if err != nil {
16867 return nil, err
16868 }
16869 req.Header = reqHeaders
16870 googleapi.Expand(req.URL, map[string]string{
16871 "parent": c.parent,
16872 "type": c.type_,
16873 })
16874 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16875 }
16876
16877
16878
16879
16880
16881
16882 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
16883 gensupport.SetOptions(c.urlParams_, opts...)
16884 res, err := c.doRequest("json")
16885 if res != nil && res.StatusCode == http.StatusNotModified {
16886 if res.Body != nil {
16887 res.Body.Close()
16888 }
16889 return nil, gensupport.WrapError(&googleapi.Error{
16890 Code: res.StatusCode,
16891 Header: res.Header,
16892 })
16893 }
16894 if err != nil {
16895 return nil, err
16896 }
16897 defer googleapi.CloseBody(res)
16898 if err := googleapi.CheckResponse(res); err != nil {
16899 return nil, gensupport.WrapError(err)
16900 }
16901 ret := &Empty{
16902 ServerResponse: googleapi.ServerResponse{
16903 Header: res.Header,
16904 HTTPStatusCode: res.StatusCode,
16905 },
16906 }
16907 target := &ret
16908 if err := gensupport.DecodeResponse(target, res); err != nil {
16909 return nil, err
16910 }
16911 return ret, nil
16912 }
16913
16914 type ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall struct {
16915 s *Service
16916 parent string
16917 type_ string
16918 body_ io.Reader
16919 urlParams_ gensupport.URLParams
16920 ctx_ context.Context
16921 header_ http.Header
16922 }
16923
16924
16925
16926
16927
16928
16929
16930
16931
16932
16933
16934
16935
16936
16937
16938
16939
16940
16941
16942
16943
16944
16945
16946
16947
16948
16949
16950 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) ConditionalPatch(parent string, type_ string, body_ io.Reader) *ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall {
16951 c := &ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
16952 c.parent = parent
16953 c.type_ = type_
16954 c.body_ = body_
16955 return c
16956 }
16957
16958
16959
16960
16961 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall {
16962 c.urlParams_.Set("fields", googleapi.CombineFields(s))
16963 return c
16964 }
16965
16966
16967 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall {
16968 c.ctx_ = ctx
16969 return c
16970 }
16971
16972
16973
16974 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall) Header() http.Header {
16975 if c.header_ == nil {
16976 c.header_ = make(http.Header)
16977 }
16978 return c.header_
16979 }
16980
16981 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall) doRequest(alt string) (*http.Response, error) {
16982 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
16983 var body io.Reader = nil
16984 body = c.body_
16985 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhir/{+type}")
16986 urls += "?" + c.urlParams_.Encode()
16987 req, err := http.NewRequest("PATCH", urls, body)
16988 if err != nil {
16989 return nil, err
16990 }
16991 req.Header = reqHeaders
16992 googleapi.Expand(req.URL, map[string]string{
16993 "parent": c.parent,
16994 "type": c.type_,
16995 })
16996 return gensupport.SendRequest(c.ctx_, c.s.client, req)
16997 }
16998
16999
17000 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalPatchCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17001 gensupport.SetOptions(c.urlParams_, opts...)
17002 return c.doRequest("")
17003 }
17004
17005 type ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall struct {
17006 s *Service
17007 parent string
17008 type_ string
17009 body_ io.Reader
17010 urlParams_ gensupport.URLParams
17011 ctx_ context.Context
17012 header_ http.Header
17013 }
17014
17015
17016
17017
17018
17019
17020
17021
17022
17023
17024
17025
17026
17027
17028
17029
17030
17031
17032
17033
17034
17035
17036
17037
17038
17039
17040
17041
17042
17043
17044
17045
17046
17047
17048
17049 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) ConditionalUpdate(parent string, type_ string, body_ io.Reader) *ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall {
17050 c := &ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17051 c.parent = parent
17052 c.type_ = type_
17053 c.body_ = body_
17054 return c
17055 }
17056
17057
17058
17059
17060 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall {
17061 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17062 return c
17063 }
17064
17065
17066 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall {
17067 c.ctx_ = ctx
17068 return c
17069 }
17070
17071
17072
17073 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall) Header() http.Header {
17074 if c.header_ == nil {
17075 c.header_ = make(http.Header)
17076 }
17077 return c.header_
17078 }
17079
17080 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall) doRequest(alt string) (*http.Response, error) {
17081 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17082 var body io.Reader = nil
17083 body = c.body_
17084 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhir/{+type}")
17085 urls += "?" + c.urlParams_.Encode()
17086 req, err := http.NewRequest("PUT", urls, body)
17087 if err != nil {
17088 return nil, err
17089 }
17090 req.Header = reqHeaders
17091 googleapi.Expand(req.URL, map[string]string{
17092 "parent": c.parent,
17093 "type": c.type_,
17094 })
17095 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17096 }
17097
17098
17099 func (c *ProjectsLocationsDatasetsFhirStoresFhirConditionalUpdateCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17100 gensupport.SetOptions(c.urlParams_, opts...)
17101 return c.doRequest("")
17102 }
17103
17104 type ProjectsLocationsDatasetsFhirStoresFhirCreateCall struct {
17105 s *Service
17106 parent string
17107 type_ string
17108 body_ io.Reader
17109 urlParams_ gensupport.URLParams
17110 ctx_ context.Context
17111 header_ http.Header
17112 }
17113
17114
17115
17116
17117
17118
17119
17120
17121
17122
17123
17124
17125
17126
17127
17128
17129
17130
17131
17132
17133
17134
17135
17136
17137
17138
17139
17140
17141
17142
17143
17144
17145
17146
17147
17148 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) Create(parent string, type_ string, body_ io.Reader) *ProjectsLocationsDatasetsFhirStoresFhirCreateCall {
17149 c := &ProjectsLocationsDatasetsFhirStoresFhirCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17150 c.parent = parent
17151 c.type_ = type_
17152 c.body_ = body_
17153 return c
17154 }
17155
17156
17157
17158
17159 func (c *ProjectsLocationsDatasetsFhirStoresFhirCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirCreateCall {
17160 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17161 return c
17162 }
17163
17164
17165 func (c *ProjectsLocationsDatasetsFhirStoresFhirCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirCreateCall {
17166 c.ctx_ = ctx
17167 return c
17168 }
17169
17170
17171
17172 func (c *ProjectsLocationsDatasetsFhirStoresFhirCreateCall) Header() http.Header {
17173 if c.header_ == nil {
17174 c.header_ = make(http.Header)
17175 }
17176 return c.header_
17177 }
17178
17179 func (c *ProjectsLocationsDatasetsFhirStoresFhirCreateCall) doRequest(alt string) (*http.Response, error) {
17180 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17181 var body io.Reader = nil
17182 body = c.body_
17183 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhir/{+type}")
17184 urls += "?" + c.urlParams_.Encode()
17185 req, err := http.NewRequest("POST", urls, body)
17186 if err != nil {
17187 return nil, err
17188 }
17189 req.Header = reqHeaders
17190 googleapi.Expand(req.URL, map[string]string{
17191 "parent": c.parent,
17192 "type": c.type_,
17193 })
17194 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17195 }
17196
17197
17198 func (c *ProjectsLocationsDatasetsFhirStoresFhirCreateCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17199 gensupport.SetOptions(c.urlParams_, opts...)
17200 return c.doRequest("")
17201 }
17202
17203 type ProjectsLocationsDatasetsFhirStoresFhirDeleteCall struct {
17204 s *Service
17205 name string
17206 urlParams_ gensupport.URLParams
17207 ctx_ context.Context
17208 header_ http.Header
17209 }
17210
17211
17212
17213
17214
17215
17216
17217
17218
17219
17220
17221
17222
17223
17224 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) Delete(name string) *ProjectsLocationsDatasetsFhirStoresFhirDeleteCall {
17225 c := &ProjectsLocationsDatasetsFhirStoresFhirDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17226 c.name = name
17227 return c
17228 }
17229
17230
17231
17232
17233 func (c *ProjectsLocationsDatasetsFhirStoresFhirDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirDeleteCall {
17234 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17235 return c
17236 }
17237
17238
17239 func (c *ProjectsLocationsDatasetsFhirStoresFhirDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirDeleteCall {
17240 c.ctx_ = ctx
17241 return c
17242 }
17243
17244
17245
17246 func (c *ProjectsLocationsDatasetsFhirStoresFhirDeleteCall) Header() http.Header {
17247 if c.header_ == nil {
17248 c.header_ = make(http.Header)
17249 }
17250 return c.header_
17251 }
17252
17253 func (c *ProjectsLocationsDatasetsFhirStoresFhirDeleteCall) doRequest(alt string) (*http.Response, error) {
17254 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17255 var body io.Reader = nil
17256 c.urlParams_.Set("alt", alt)
17257 c.urlParams_.Set("prettyPrint", "false")
17258 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
17259 urls += "?" + c.urlParams_.Encode()
17260 req, err := http.NewRequest("DELETE", urls, body)
17261 if err != nil {
17262 return nil, err
17263 }
17264 req.Header = reqHeaders
17265 googleapi.Expand(req.URL, map[string]string{
17266 "name": c.name,
17267 })
17268 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17269 }
17270
17271
17272 func (c *ProjectsLocationsDatasetsFhirStoresFhirDeleteCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17273 gensupport.SetOptions(c.urlParams_, opts...)
17274 return c.doRequest("")
17275 }
17276
17277 type ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall struct {
17278 s *Service
17279 parent string
17280 body_ io.Reader
17281 urlParams_ gensupport.URLParams
17282 ctx_ context.Context
17283 header_ http.Header
17284 }
17285
17286
17287
17288
17289
17290
17291
17292
17293
17294
17295
17296
17297
17298
17299
17300
17301
17302
17303
17304
17305
17306
17307
17308
17309
17310
17311
17312
17313
17314
17315
17316
17317
17318
17319
17320
17321
17322
17323
17324 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) ExecuteBundle(parent string, body_ io.Reader) *ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall {
17325 c := &ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17326 c.parent = parent
17327 c.body_ = body_
17328 return c
17329 }
17330
17331
17332
17333
17334 func (c *ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall {
17335 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17336 return c
17337 }
17338
17339
17340 func (c *ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall {
17341 c.ctx_ = ctx
17342 return c
17343 }
17344
17345
17346
17347 func (c *ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall) Header() http.Header {
17348 if c.header_ == nil {
17349 c.header_ = make(http.Header)
17350 }
17351 return c.header_
17352 }
17353
17354 func (c *ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall) doRequest(alt string) (*http.Response, error) {
17355 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17356 var body io.Reader = nil
17357 body = c.body_
17358 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhir")
17359 urls += "?" + c.urlParams_.Encode()
17360 req, err := http.NewRequest("POST", urls, body)
17361 if err != nil {
17362 return nil, err
17363 }
17364 req.Header = reqHeaders
17365 googleapi.Expand(req.URL, map[string]string{
17366 "parent": c.parent,
17367 })
17368 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17369 }
17370
17371
17372 func (c *ProjectsLocationsDatasetsFhirStoresFhirExecuteBundleCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17373 gensupport.SetOptions(c.urlParams_, opts...)
17374 return c.doRequest("")
17375 }
17376
17377 type ProjectsLocationsDatasetsFhirStoresFhirHistoryCall struct {
17378 s *Service
17379 name string
17380 urlParams_ gensupport.URLParams
17381 ifNoneMatch_ string
17382 ctx_ context.Context
17383 header_ http.Header
17384 }
17385
17386
17387
17388
17389
17390
17391
17392
17393
17394
17395
17396
17397
17398
17399
17400
17401
17402 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) History(name string) *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall {
17403 c := &ProjectsLocationsDatasetsFhirStoresFhirHistoryCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17404 c.name = name
17405 return c
17406 }
17407
17408
17409
17410
17411
17412
17413
17414 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) At(At string) *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall {
17415 c.urlParams_.Set("_at", At)
17416 return c
17417 }
17418
17419
17420
17421
17422 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) Count(Count int64) *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall {
17423 c.urlParams_.Set("_count", fmt.Sprint(Count))
17424 return c
17425 }
17426
17427
17428
17429
17430
17431
17432
17433 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) PageToken(PageToken string) *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall {
17434 c.urlParams_.Set("_page_token", PageToken)
17435 return c
17436 }
17437
17438
17439
17440
17441
17442
17443 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) Since(Since string) *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall {
17444 c.urlParams_.Set("_since", Since)
17445 return c
17446 }
17447
17448
17449
17450
17451 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall {
17452 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17453 return c
17454 }
17455
17456
17457
17458
17459 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall {
17460 c.ifNoneMatch_ = entityTag
17461 return c
17462 }
17463
17464
17465 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall {
17466 c.ctx_ = ctx
17467 return c
17468 }
17469
17470
17471
17472 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) Header() http.Header {
17473 if c.header_ == nil {
17474 c.header_ = make(http.Header)
17475 }
17476 return c.header_
17477 }
17478
17479 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) doRequest(alt string) (*http.Response, error) {
17480 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17481 if c.ifNoneMatch_ != "" {
17482 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17483 }
17484 var body io.Reader = nil
17485 c.urlParams_.Set("alt", alt)
17486 c.urlParams_.Set("prettyPrint", "false")
17487 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/_history")
17488 urls += "?" + c.urlParams_.Encode()
17489 req, err := http.NewRequest("GET", urls, body)
17490 if err != nil {
17491 return nil, err
17492 }
17493 req.Header = reqHeaders
17494 googleapi.Expand(req.URL, map[string]string{
17495 "name": c.name,
17496 })
17497 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17498 }
17499
17500
17501 func (c *ProjectsLocationsDatasetsFhirStoresFhirHistoryCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17502 gensupport.SetOptions(c.urlParams_, opts...)
17503 return c.doRequest("")
17504 }
17505
17506 type ProjectsLocationsDatasetsFhirStoresFhirPatchCall struct {
17507 s *Service
17508 name string
17509 body_ io.Reader
17510 urlParams_ gensupport.URLParams
17511 ctx_ context.Context
17512 header_ http.Header
17513 }
17514
17515
17516
17517
17518
17519
17520
17521
17522
17523
17524
17525
17526
17527
17528
17529
17530
17531
17532
17533 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) Patch(name string, body_ io.Reader) *ProjectsLocationsDatasetsFhirStoresFhirPatchCall {
17534 c := &ProjectsLocationsDatasetsFhirStoresFhirPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17535 c.name = name
17536 c.body_ = body_
17537 return c
17538 }
17539
17540
17541
17542
17543 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirPatchCall {
17544 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17545 return c
17546 }
17547
17548
17549 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirPatchCall {
17550 c.ctx_ = ctx
17551 return c
17552 }
17553
17554
17555
17556 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatchCall) Header() http.Header {
17557 if c.header_ == nil {
17558 c.header_ = make(http.Header)
17559 }
17560 return c.header_
17561 }
17562
17563 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatchCall) doRequest(alt string) (*http.Response, error) {
17564 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17565 var body io.Reader = nil
17566 body = c.body_
17567 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
17568 urls += "?" + c.urlParams_.Encode()
17569 req, err := http.NewRequest("PATCH", urls, body)
17570 if err != nil {
17571 return nil, err
17572 }
17573 req.Header = reqHeaders
17574 googleapi.Expand(req.URL, map[string]string{
17575 "name": c.name,
17576 })
17577 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17578 }
17579
17580
17581 func (c *ProjectsLocationsDatasetsFhirStoresFhirPatchCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17582 gensupport.SetOptions(c.urlParams_, opts...)
17583 return c.doRequest("")
17584 }
17585
17586 type ProjectsLocationsDatasetsFhirStoresFhirReadCall struct {
17587 s *Service
17588 name string
17589 urlParams_ gensupport.URLParams
17590 ifNoneMatch_ string
17591 ctx_ context.Context
17592 header_ http.Header
17593 }
17594
17595
17596
17597
17598
17599
17600
17601
17602
17603
17604
17605
17606
17607
17608
17609
17610
17611
17612
17613
17614 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) Read(name string) *ProjectsLocationsDatasetsFhirStoresFhirReadCall {
17615 c := &ProjectsLocationsDatasetsFhirStoresFhirReadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17616 c.name = name
17617 return c
17618 }
17619
17620
17621
17622
17623 func (c *ProjectsLocationsDatasetsFhirStoresFhirReadCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirReadCall {
17624 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17625 return c
17626 }
17627
17628
17629
17630
17631 func (c *ProjectsLocationsDatasetsFhirStoresFhirReadCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresFhirReadCall {
17632 c.ifNoneMatch_ = entityTag
17633 return c
17634 }
17635
17636
17637 func (c *ProjectsLocationsDatasetsFhirStoresFhirReadCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirReadCall {
17638 c.ctx_ = ctx
17639 return c
17640 }
17641
17642
17643
17644 func (c *ProjectsLocationsDatasetsFhirStoresFhirReadCall) Header() http.Header {
17645 if c.header_ == nil {
17646 c.header_ = make(http.Header)
17647 }
17648 return c.header_
17649 }
17650
17651 func (c *ProjectsLocationsDatasetsFhirStoresFhirReadCall) doRequest(alt string) (*http.Response, error) {
17652 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
17653 if c.ifNoneMatch_ != "" {
17654 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
17655 }
17656 var body io.Reader = nil
17657 c.urlParams_.Set("alt", alt)
17658 c.urlParams_.Set("prettyPrint", "false")
17659 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
17660 urls += "?" + c.urlParams_.Encode()
17661 req, err := http.NewRequest("GET", urls, body)
17662 if err != nil {
17663 return nil, err
17664 }
17665 req.Header = reqHeaders
17666 googleapi.Expand(req.URL, map[string]string{
17667 "name": c.name,
17668 })
17669 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17670 }
17671
17672
17673 func (c *ProjectsLocationsDatasetsFhirStoresFhirReadCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17674 gensupport.SetOptions(c.urlParams_, opts...)
17675 return c.doRequest("")
17676 }
17677
17678 type ProjectsLocationsDatasetsFhirStoresFhirSearchCall struct {
17679 s *Service
17680 parent string
17681 searchresourcesrequest *SearchResourcesRequest
17682 urlParams_ gensupport.URLParams
17683 ctx_ context.Context
17684 header_ http.Header
17685 }
17686
17687
17688
17689
17690
17691
17692
17693
17694
17695
17696
17697
17698
17699
17700
17701
17702
17703
17704
17705
17706
17707
17708
17709
17710
17711
17712
17713
17714
17715
17716
17717
17718
17719
17720
17721
17722
17723
17724
17725
17726
17727
17728
17729
17730
17731
17732
17733
17734
17735
17736
17737
17738
17739
17740
17741
17742
17743
17744
17745
17746
17747
17748
17749
17750
17751
17752
17753
17754
17755
17756
17757 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) Search(parent string, searchresourcesrequest *SearchResourcesRequest) *ProjectsLocationsDatasetsFhirStoresFhirSearchCall {
17758 c := &ProjectsLocationsDatasetsFhirStoresFhirSearchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17759 c.parent = parent
17760 c.searchresourcesrequest = searchresourcesrequest
17761 return c
17762 }
17763
17764
17765
17766
17767 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirSearchCall {
17768 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17769 return c
17770 }
17771
17772
17773 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirSearchCall {
17774 c.ctx_ = ctx
17775 return c
17776 }
17777
17778
17779
17780 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchCall) Header() http.Header {
17781 if c.header_ == nil {
17782 c.header_ = make(http.Header)
17783 }
17784 return c.header_
17785 }
17786
17787 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchCall) doRequest(alt string) (*http.Response, error) {
17788 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17789 var body io.Reader = nil
17790 body, err := googleapi.WithoutDataWrapper.JSONReader(c.searchresourcesrequest)
17791 if err != nil {
17792 return nil, err
17793 }
17794 c.urlParams_.Set("alt", alt)
17795 c.urlParams_.Set("prettyPrint", "false")
17796 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhir/_search")
17797 urls += "?" + c.urlParams_.Encode()
17798 req, err := http.NewRequest("POST", urls, body)
17799 if err != nil {
17800 return nil, err
17801 }
17802 req.Header = reqHeaders
17803 googleapi.Expand(req.URL, map[string]string{
17804 "parent": c.parent,
17805 })
17806 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17807 }
17808
17809
17810 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17811 gensupport.SetOptions(c.urlParams_, opts...)
17812 return c.doRequest("")
17813 }
17814
17815 type ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall struct {
17816 s *Service
17817 parent string
17818 resourceType string
17819 searchresourcesrequest *SearchResourcesRequest
17820 urlParams_ gensupport.URLParams
17821 ctx_ context.Context
17822 header_ http.Header
17823 }
17824
17825
17826
17827
17828
17829
17830
17831
17832
17833
17834
17835
17836
17837
17838
17839
17840
17841
17842
17843
17844
17845
17846
17847
17848
17849
17850
17851
17852
17853
17854
17855
17856
17857
17858
17859
17860
17861
17862
17863
17864
17865
17866
17867
17868
17869
17870
17871
17872
17873
17874
17875
17876
17877
17878
17879
17880
17881
17882
17883
17884
17885
17886
17887
17888
17889
17890
17891
17892
17893
17894
17895
17896
17897
17898
17899
17900 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) SearchType(parent string, resourceType string, searchresourcesrequest *SearchResourcesRequest) *ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall {
17901 c := &ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17902 c.parent = parent
17903 c.resourceType = resourceType
17904 c.searchresourcesrequest = searchresourcesrequest
17905 return c
17906 }
17907
17908
17909
17910
17911 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall {
17912 c.urlParams_.Set("fields", googleapi.CombineFields(s))
17913 return c
17914 }
17915
17916
17917 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall {
17918 c.ctx_ = ctx
17919 return c
17920 }
17921
17922
17923
17924 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall) Header() http.Header {
17925 if c.header_ == nil {
17926 c.header_ = make(http.Header)
17927 }
17928 return c.header_
17929 }
17930
17931 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall) doRequest(alt string) (*http.Response, error) {
17932 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
17933 var body io.Reader = nil
17934 body, err := googleapi.WithoutDataWrapper.JSONReader(c.searchresourcesrequest)
17935 if err != nil {
17936 return nil, err
17937 }
17938 c.urlParams_.Set("alt", alt)
17939 c.urlParams_.Set("prettyPrint", "false")
17940 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/fhir/{resourceType}/_search")
17941 urls += "?" + c.urlParams_.Encode()
17942 req, err := http.NewRequest("POST", urls, body)
17943 if err != nil {
17944 return nil, err
17945 }
17946 req.Header = reqHeaders
17947 googleapi.Expand(req.URL, map[string]string{
17948 "parent": c.parent,
17949 "resourceType": c.resourceType,
17950 })
17951 return gensupport.SendRequest(c.ctx_, c.s.client, req)
17952 }
17953
17954
17955 func (c *ProjectsLocationsDatasetsFhirStoresFhirSearchTypeCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
17956 gensupport.SetOptions(c.urlParams_, opts...)
17957 return c.doRequest("")
17958 }
17959
17960 type ProjectsLocationsDatasetsFhirStoresFhirUpdateCall struct {
17961 s *Service
17962 name string
17963 body_ io.Reader
17964 urlParams_ gensupport.URLParams
17965 ctx_ context.Context
17966 header_ http.Header
17967 }
17968
17969
17970
17971
17972
17973
17974
17975
17976
17977
17978
17979
17980
17981
17982
17983
17984
17985
17986
17987
17988
17989
17990
17991
17992
17993 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) Update(name string, body_ io.Reader) *ProjectsLocationsDatasetsFhirStoresFhirUpdateCall {
17994 c := &ProjectsLocationsDatasetsFhirStoresFhirUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
17995 c.name = name
17996 c.body_ = body_
17997 return c
17998 }
17999
18000
18001
18002
18003 func (c *ProjectsLocationsDatasetsFhirStoresFhirUpdateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirUpdateCall {
18004 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18005 return c
18006 }
18007
18008
18009 func (c *ProjectsLocationsDatasetsFhirStoresFhirUpdateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirUpdateCall {
18010 c.ctx_ = ctx
18011 return c
18012 }
18013
18014
18015
18016 func (c *ProjectsLocationsDatasetsFhirStoresFhirUpdateCall) Header() http.Header {
18017 if c.header_ == nil {
18018 c.header_ = make(http.Header)
18019 }
18020 return c.header_
18021 }
18022
18023 func (c *ProjectsLocationsDatasetsFhirStoresFhirUpdateCall) doRequest(alt string) (*http.Response, error) {
18024 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18025 var body io.Reader = nil
18026 body = c.body_
18027 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
18028 urls += "?" + c.urlParams_.Encode()
18029 req, err := http.NewRequest("PUT", urls, body)
18030 if err != nil {
18031 return nil, err
18032 }
18033 req.Header = reqHeaders
18034 googleapi.Expand(req.URL, map[string]string{
18035 "name": c.name,
18036 })
18037 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18038 }
18039
18040
18041 func (c *ProjectsLocationsDatasetsFhirStoresFhirUpdateCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
18042 gensupport.SetOptions(c.urlParams_, opts...)
18043 return c.doRequest("")
18044 }
18045
18046 type ProjectsLocationsDatasetsFhirStoresFhirVreadCall struct {
18047 s *Service
18048 name string
18049 urlParams_ gensupport.URLParams
18050 ifNoneMatch_ string
18051 ctx_ context.Context
18052 header_ http.Header
18053 }
18054
18055
18056
18057
18058
18059
18060
18061
18062
18063
18064
18065
18066
18067
18068
18069 func (r *ProjectsLocationsDatasetsFhirStoresFhirService) Vread(name string) *ProjectsLocationsDatasetsFhirStoresFhirVreadCall {
18070 c := &ProjectsLocationsDatasetsFhirStoresFhirVreadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18071 c.name = name
18072 return c
18073 }
18074
18075
18076
18077
18078 func (c *ProjectsLocationsDatasetsFhirStoresFhirVreadCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsFhirStoresFhirVreadCall {
18079 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18080 return c
18081 }
18082
18083
18084
18085
18086 func (c *ProjectsLocationsDatasetsFhirStoresFhirVreadCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsFhirStoresFhirVreadCall {
18087 c.ifNoneMatch_ = entityTag
18088 return c
18089 }
18090
18091
18092 func (c *ProjectsLocationsDatasetsFhirStoresFhirVreadCall) Context(ctx context.Context) *ProjectsLocationsDatasetsFhirStoresFhirVreadCall {
18093 c.ctx_ = ctx
18094 return c
18095 }
18096
18097
18098
18099 func (c *ProjectsLocationsDatasetsFhirStoresFhirVreadCall) Header() http.Header {
18100 if c.header_ == nil {
18101 c.header_ = make(http.Header)
18102 }
18103 return c.header_
18104 }
18105
18106 func (c *ProjectsLocationsDatasetsFhirStoresFhirVreadCall) doRequest(alt string) (*http.Response, error) {
18107 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18108 if c.ifNoneMatch_ != "" {
18109 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18110 }
18111 var body io.Reader = nil
18112 c.urlParams_.Set("alt", alt)
18113 c.urlParams_.Set("prettyPrint", "false")
18114 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
18115 urls += "?" + c.urlParams_.Encode()
18116 req, err := http.NewRequest("GET", urls, body)
18117 if err != nil {
18118 return nil, err
18119 }
18120 req.Header = reqHeaders
18121 googleapi.Expand(req.URL, map[string]string{
18122 "name": c.name,
18123 })
18124 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18125 }
18126
18127
18128 func (c *ProjectsLocationsDatasetsFhirStoresFhirVreadCall) Do(opts ...googleapi.CallOption) (*http.Response, error) {
18129 gensupport.SetOptions(c.urlParams_, opts...)
18130 return c.doRequest("")
18131 }
18132
18133 type ProjectsLocationsDatasetsHl7V2StoresCreateCall struct {
18134 s *Service
18135 parent string
18136 hl7v2store *Hl7V2Store
18137 urlParams_ gensupport.URLParams
18138 ctx_ context.Context
18139 header_ http.Header
18140 }
18141
18142
18143
18144
18145 func (r *ProjectsLocationsDatasetsHl7V2StoresService) Create(parent string, hl7v2store *Hl7V2Store) *ProjectsLocationsDatasetsHl7V2StoresCreateCall {
18146 c := &ProjectsLocationsDatasetsHl7V2StoresCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18147 c.parent = parent
18148 c.hl7v2store = hl7v2store
18149 return c
18150 }
18151
18152
18153
18154
18155 func (c *ProjectsLocationsDatasetsHl7V2StoresCreateCall) Hl7V2StoreId(hl7V2StoreId string) *ProjectsLocationsDatasetsHl7V2StoresCreateCall {
18156 c.urlParams_.Set("hl7V2StoreId", hl7V2StoreId)
18157 return c
18158 }
18159
18160
18161
18162
18163 func (c *ProjectsLocationsDatasetsHl7V2StoresCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresCreateCall {
18164 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18165 return c
18166 }
18167
18168
18169 func (c *ProjectsLocationsDatasetsHl7V2StoresCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresCreateCall {
18170 c.ctx_ = ctx
18171 return c
18172 }
18173
18174
18175
18176 func (c *ProjectsLocationsDatasetsHl7V2StoresCreateCall) Header() http.Header {
18177 if c.header_ == nil {
18178 c.header_ = make(http.Header)
18179 }
18180 return c.header_
18181 }
18182
18183 func (c *ProjectsLocationsDatasetsHl7V2StoresCreateCall) doRequest(alt string) (*http.Response, error) {
18184 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
18185 var body io.Reader = nil
18186 body, err := googleapi.WithoutDataWrapper.JSONReader(c.hl7v2store)
18187 if err != nil {
18188 return nil, err
18189 }
18190 c.urlParams_.Set("alt", alt)
18191 c.urlParams_.Set("prettyPrint", "false")
18192 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/hl7V2Stores")
18193 urls += "?" + c.urlParams_.Encode()
18194 req, err := http.NewRequest("POST", urls, body)
18195 if err != nil {
18196 return nil, err
18197 }
18198 req.Header = reqHeaders
18199 googleapi.Expand(req.URL, map[string]string{
18200 "parent": c.parent,
18201 })
18202 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18203 }
18204
18205
18206
18207
18208
18209
18210 func (c *ProjectsLocationsDatasetsHl7V2StoresCreateCall) Do(opts ...googleapi.CallOption) (*Hl7V2Store, error) {
18211 gensupport.SetOptions(c.urlParams_, opts...)
18212 res, err := c.doRequest("json")
18213 if res != nil && res.StatusCode == http.StatusNotModified {
18214 if res.Body != nil {
18215 res.Body.Close()
18216 }
18217 return nil, gensupport.WrapError(&googleapi.Error{
18218 Code: res.StatusCode,
18219 Header: res.Header,
18220 })
18221 }
18222 if err != nil {
18223 return nil, err
18224 }
18225 defer googleapi.CloseBody(res)
18226 if err := googleapi.CheckResponse(res); err != nil {
18227 return nil, gensupport.WrapError(err)
18228 }
18229 ret := &Hl7V2Store{
18230 ServerResponse: googleapi.ServerResponse{
18231 Header: res.Header,
18232 HTTPStatusCode: res.StatusCode,
18233 },
18234 }
18235 target := &ret
18236 if err := gensupport.DecodeResponse(target, res); err != nil {
18237 return nil, err
18238 }
18239 return ret, nil
18240 }
18241
18242 type ProjectsLocationsDatasetsHl7V2StoresDeleteCall struct {
18243 s *Service
18244 name string
18245 urlParams_ gensupport.URLParams
18246 ctx_ context.Context
18247 header_ http.Header
18248 }
18249
18250
18251
18252
18253
18254 func (r *ProjectsLocationsDatasetsHl7V2StoresService) Delete(name string) *ProjectsLocationsDatasetsHl7V2StoresDeleteCall {
18255 c := &ProjectsLocationsDatasetsHl7V2StoresDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18256 c.name = name
18257 return c
18258 }
18259
18260
18261
18262
18263 func (c *ProjectsLocationsDatasetsHl7V2StoresDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresDeleteCall {
18264 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18265 return c
18266 }
18267
18268
18269 func (c *ProjectsLocationsDatasetsHl7V2StoresDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresDeleteCall {
18270 c.ctx_ = ctx
18271 return c
18272 }
18273
18274
18275
18276 func (c *ProjectsLocationsDatasetsHl7V2StoresDeleteCall) Header() http.Header {
18277 if c.header_ == nil {
18278 c.header_ = make(http.Header)
18279 }
18280 return c.header_
18281 }
18282
18283 func (c *ProjectsLocationsDatasetsHl7V2StoresDeleteCall) doRequest(alt string) (*http.Response, error) {
18284 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18285 var body io.Reader = nil
18286 c.urlParams_.Set("alt", alt)
18287 c.urlParams_.Set("prettyPrint", "false")
18288 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
18289 urls += "?" + c.urlParams_.Encode()
18290 req, err := http.NewRequest("DELETE", urls, body)
18291 if err != nil {
18292 return nil, err
18293 }
18294 req.Header = reqHeaders
18295 googleapi.Expand(req.URL, map[string]string{
18296 "name": c.name,
18297 })
18298 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18299 }
18300
18301
18302
18303
18304
18305
18306 func (c *ProjectsLocationsDatasetsHl7V2StoresDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
18307 gensupport.SetOptions(c.urlParams_, opts...)
18308 res, err := c.doRequest("json")
18309 if res != nil && res.StatusCode == http.StatusNotModified {
18310 if res.Body != nil {
18311 res.Body.Close()
18312 }
18313 return nil, gensupport.WrapError(&googleapi.Error{
18314 Code: res.StatusCode,
18315 Header: res.Header,
18316 })
18317 }
18318 if err != nil {
18319 return nil, err
18320 }
18321 defer googleapi.CloseBody(res)
18322 if err := googleapi.CheckResponse(res); err != nil {
18323 return nil, gensupport.WrapError(err)
18324 }
18325 ret := &Empty{
18326 ServerResponse: googleapi.ServerResponse{
18327 Header: res.Header,
18328 HTTPStatusCode: res.StatusCode,
18329 },
18330 }
18331 target := &ret
18332 if err := gensupport.DecodeResponse(target, res); err != nil {
18333 return nil, err
18334 }
18335 return ret, nil
18336 }
18337
18338 type ProjectsLocationsDatasetsHl7V2StoresExportCall struct {
18339 s *Service
18340 name string
18341 exportmessagesrequest *ExportMessagesRequest
18342 urlParams_ gensupport.URLParams
18343 ctx_ context.Context
18344 header_ http.Header
18345 }
18346
18347
18348
18349
18350
18351
18352
18353
18354
18355
18356
18357
18358 func (r *ProjectsLocationsDatasetsHl7V2StoresService) Export(name string, exportmessagesrequest *ExportMessagesRequest) *ProjectsLocationsDatasetsHl7V2StoresExportCall {
18359 c := &ProjectsLocationsDatasetsHl7V2StoresExportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18360 c.name = name
18361 c.exportmessagesrequest = exportmessagesrequest
18362 return c
18363 }
18364
18365
18366
18367
18368 func (c *ProjectsLocationsDatasetsHl7V2StoresExportCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresExportCall {
18369 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18370 return c
18371 }
18372
18373
18374 func (c *ProjectsLocationsDatasetsHl7V2StoresExportCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresExportCall {
18375 c.ctx_ = ctx
18376 return c
18377 }
18378
18379
18380
18381 func (c *ProjectsLocationsDatasetsHl7V2StoresExportCall) Header() http.Header {
18382 if c.header_ == nil {
18383 c.header_ = make(http.Header)
18384 }
18385 return c.header_
18386 }
18387
18388 func (c *ProjectsLocationsDatasetsHl7V2StoresExportCall) doRequest(alt string) (*http.Response, error) {
18389 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
18390 var body io.Reader = nil
18391 body, err := googleapi.WithoutDataWrapper.JSONReader(c.exportmessagesrequest)
18392 if err != nil {
18393 return nil, err
18394 }
18395 c.urlParams_.Set("alt", alt)
18396 c.urlParams_.Set("prettyPrint", "false")
18397 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:export")
18398 urls += "?" + c.urlParams_.Encode()
18399 req, err := http.NewRequest("POST", urls, body)
18400 if err != nil {
18401 return nil, err
18402 }
18403 req.Header = reqHeaders
18404 googleapi.Expand(req.URL, map[string]string{
18405 "name": c.name,
18406 })
18407 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18408 }
18409
18410
18411
18412
18413
18414
18415 func (c *ProjectsLocationsDatasetsHl7V2StoresExportCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
18416 gensupport.SetOptions(c.urlParams_, opts...)
18417 res, err := c.doRequest("json")
18418 if res != nil && res.StatusCode == http.StatusNotModified {
18419 if res.Body != nil {
18420 res.Body.Close()
18421 }
18422 return nil, gensupport.WrapError(&googleapi.Error{
18423 Code: res.StatusCode,
18424 Header: res.Header,
18425 })
18426 }
18427 if err != nil {
18428 return nil, err
18429 }
18430 defer googleapi.CloseBody(res)
18431 if err := googleapi.CheckResponse(res); err != nil {
18432 return nil, gensupport.WrapError(err)
18433 }
18434 ret := &Operation{
18435 ServerResponse: googleapi.ServerResponse{
18436 Header: res.Header,
18437 HTTPStatusCode: res.StatusCode,
18438 },
18439 }
18440 target := &ret
18441 if err := gensupport.DecodeResponse(target, res); err != nil {
18442 return nil, err
18443 }
18444 return ret, nil
18445 }
18446
18447 type ProjectsLocationsDatasetsHl7V2StoresGetCall struct {
18448 s *Service
18449 name string
18450 urlParams_ gensupport.URLParams
18451 ifNoneMatch_ string
18452 ctx_ context.Context
18453 header_ http.Header
18454 }
18455
18456
18457
18458
18459 func (r *ProjectsLocationsDatasetsHl7V2StoresService) Get(name string) *ProjectsLocationsDatasetsHl7V2StoresGetCall {
18460 c := &ProjectsLocationsDatasetsHl7V2StoresGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18461 c.name = name
18462 return c
18463 }
18464
18465
18466
18467
18468 func (c *ProjectsLocationsDatasetsHl7V2StoresGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresGetCall {
18469 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18470 return c
18471 }
18472
18473
18474
18475
18476 func (c *ProjectsLocationsDatasetsHl7V2StoresGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsHl7V2StoresGetCall {
18477 c.ifNoneMatch_ = entityTag
18478 return c
18479 }
18480
18481
18482 func (c *ProjectsLocationsDatasetsHl7V2StoresGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresGetCall {
18483 c.ctx_ = ctx
18484 return c
18485 }
18486
18487
18488
18489 func (c *ProjectsLocationsDatasetsHl7V2StoresGetCall) Header() http.Header {
18490 if c.header_ == nil {
18491 c.header_ = make(http.Header)
18492 }
18493 return c.header_
18494 }
18495
18496 func (c *ProjectsLocationsDatasetsHl7V2StoresGetCall) doRequest(alt string) (*http.Response, error) {
18497 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18498 if c.ifNoneMatch_ != "" {
18499 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18500 }
18501 var body io.Reader = nil
18502 c.urlParams_.Set("alt", alt)
18503 c.urlParams_.Set("prettyPrint", "false")
18504 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
18505 urls += "?" + c.urlParams_.Encode()
18506 req, err := http.NewRequest("GET", urls, body)
18507 if err != nil {
18508 return nil, err
18509 }
18510 req.Header = reqHeaders
18511 googleapi.Expand(req.URL, map[string]string{
18512 "name": c.name,
18513 })
18514 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18515 }
18516
18517
18518
18519
18520
18521
18522 func (c *ProjectsLocationsDatasetsHl7V2StoresGetCall) Do(opts ...googleapi.CallOption) (*Hl7V2Store, error) {
18523 gensupport.SetOptions(c.urlParams_, opts...)
18524 res, err := c.doRequest("json")
18525 if res != nil && res.StatusCode == http.StatusNotModified {
18526 if res.Body != nil {
18527 res.Body.Close()
18528 }
18529 return nil, gensupport.WrapError(&googleapi.Error{
18530 Code: res.StatusCode,
18531 Header: res.Header,
18532 })
18533 }
18534 if err != nil {
18535 return nil, err
18536 }
18537 defer googleapi.CloseBody(res)
18538 if err := googleapi.CheckResponse(res); err != nil {
18539 return nil, gensupport.WrapError(err)
18540 }
18541 ret := &Hl7V2Store{
18542 ServerResponse: googleapi.ServerResponse{
18543 Header: res.Header,
18544 HTTPStatusCode: res.StatusCode,
18545 },
18546 }
18547 target := &ret
18548 if err := gensupport.DecodeResponse(target, res); err != nil {
18549 return nil, err
18550 }
18551 return ret, nil
18552 }
18553
18554 type ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall struct {
18555 s *Service
18556 name string
18557 urlParams_ gensupport.URLParams
18558 ifNoneMatch_ string
18559 ctx_ context.Context
18560 header_ http.Header
18561 }
18562
18563
18564
18565
18566
18567
18568
18569 func (r *ProjectsLocationsDatasetsHl7V2StoresService) GetHL7v2StoreMetrics(name string) *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall {
18570 c := &ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18571 c.name = name
18572 return c
18573 }
18574
18575
18576
18577
18578 func (c *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall {
18579 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18580 return c
18581 }
18582
18583
18584
18585
18586 func (c *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall {
18587 c.ifNoneMatch_ = entityTag
18588 return c
18589 }
18590
18591
18592 func (c *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall {
18593 c.ctx_ = ctx
18594 return c
18595 }
18596
18597
18598
18599 func (c *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall) Header() http.Header {
18600 if c.header_ == nil {
18601 c.header_ = make(http.Header)
18602 }
18603 return c.header_
18604 }
18605
18606 func (c *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall) doRequest(alt string) (*http.Response, error) {
18607 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18608 if c.ifNoneMatch_ != "" {
18609 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18610 }
18611 var body io.Reader = nil
18612 c.urlParams_.Set("alt", alt)
18613 c.urlParams_.Set("prettyPrint", "false")
18614 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:getHL7v2StoreMetrics")
18615 urls += "?" + c.urlParams_.Encode()
18616 req, err := http.NewRequest("GET", urls, body)
18617 if err != nil {
18618 return nil, err
18619 }
18620 req.Header = reqHeaders
18621 googleapi.Expand(req.URL, map[string]string{
18622 "name": c.name,
18623 })
18624 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18625 }
18626
18627
18628
18629
18630
18631
18632
18633 func (c *ProjectsLocationsDatasetsHl7V2StoresGetHL7v2StoreMetricsCall) Do(opts ...googleapi.CallOption) (*Hl7V2StoreMetrics, error) {
18634 gensupport.SetOptions(c.urlParams_, opts...)
18635 res, err := c.doRequest("json")
18636 if res != nil && res.StatusCode == http.StatusNotModified {
18637 if res.Body != nil {
18638 res.Body.Close()
18639 }
18640 return nil, gensupport.WrapError(&googleapi.Error{
18641 Code: res.StatusCode,
18642 Header: res.Header,
18643 })
18644 }
18645 if err != nil {
18646 return nil, err
18647 }
18648 defer googleapi.CloseBody(res)
18649 if err := googleapi.CheckResponse(res); err != nil {
18650 return nil, gensupport.WrapError(err)
18651 }
18652 ret := &Hl7V2StoreMetrics{
18653 ServerResponse: googleapi.ServerResponse{
18654 Header: res.Header,
18655 HTTPStatusCode: res.StatusCode,
18656 },
18657 }
18658 target := &ret
18659 if err := gensupport.DecodeResponse(target, res); err != nil {
18660 return nil, err
18661 }
18662 return ret, nil
18663 }
18664
18665 type ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall struct {
18666 s *Service
18667 resource string
18668 urlParams_ gensupport.URLParams
18669 ifNoneMatch_ string
18670 ctx_ context.Context
18671 header_ http.Header
18672 }
18673
18674
18675
18676
18677
18678
18679
18680 func (r *ProjectsLocationsDatasetsHl7V2StoresService) GetIamPolicy(resource string) *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall {
18681 c := &ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18682 c.resource = resource
18683 return c
18684 }
18685
18686
18687
18688
18689
18690
18691
18692
18693
18694
18695
18696
18697
18698 func (c *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall {
18699 c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
18700 return c
18701 }
18702
18703
18704
18705
18706 func (c *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall {
18707 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18708 return c
18709 }
18710
18711
18712
18713
18714 func (c *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall {
18715 c.ifNoneMatch_ = entityTag
18716 return c
18717 }
18718
18719
18720 func (c *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall {
18721 c.ctx_ = ctx
18722 return c
18723 }
18724
18725
18726
18727 func (c *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall) Header() http.Header {
18728 if c.header_ == nil {
18729 c.header_ = make(http.Header)
18730 }
18731 return c.header_
18732 }
18733
18734 func (c *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
18735 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
18736 if c.ifNoneMatch_ != "" {
18737 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
18738 }
18739 var body io.Reader = nil
18740 c.urlParams_.Set("alt", alt)
18741 c.urlParams_.Set("prettyPrint", "false")
18742 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:getIamPolicy")
18743 urls += "?" + c.urlParams_.Encode()
18744 req, err := http.NewRequest("GET", urls, body)
18745 if err != nil {
18746 return nil, err
18747 }
18748 req.Header = reqHeaders
18749 googleapi.Expand(req.URL, map[string]string{
18750 "resource": c.resource,
18751 })
18752 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18753 }
18754
18755
18756
18757
18758
18759
18760 func (c *ProjectsLocationsDatasetsHl7V2StoresGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
18761 gensupport.SetOptions(c.urlParams_, opts...)
18762 res, err := c.doRequest("json")
18763 if res != nil && res.StatusCode == http.StatusNotModified {
18764 if res.Body != nil {
18765 res.Body.Close()
18766 }
18767 return nil, gensupport.WrapError(&googleapi.Error{
18768 Code: res.StatusCode,
18769 Header: res.Header,
18770 })
18771 }
18772 if err != nil {
18773 return nil, err
18774 }
18775 defer googleapi.CloseBody(res)
18776 if err := googleapi.CheckResponse(res); err != nil {
18777 return nil, gensupport.WrapError(err)
18778 }
18779 ret := &Policy{
18780 ServerResponse: googleapi.ServerResponse{
18781 Header: res.Header,
18782 HTTPStatusCode: res.StatusCode,
18783 },
18784 }
18785 target := &ret
18786 if err := gensupport.DecodeResponse(target, res); err != nil {
18787 return nil, err
18788 }
18789 return ret, nil
18790 }
18791
18792 type ProjectsLocationsDatasetsHl7V2StoresImportCall struct {
18793 s *Service
18794 name string
18795 importmessagesrequest *ImportMessagesRequest
18796 urlParams_ gensupport.URLParams
18797 ctx_ context.Context
18798 header_ http.Header
18799 }
18800
18801
18802
18803
18804
18805
18806
18807
18808
18809
18810
18811
18812
18813
18814
18815
18816
18817
18818
18819
18820
18821
18822
18823
18824
18825
18826
18827
18828
18829
18830 func (r *ProjectsLocationsDatasetsHl7V2StoresService) Import(name string, importmessagesrequest *ImportMessagesRequest) *ProjectsLocationsDatasetsHl7V2StoresImportCall {
18831 c := &ProjectsLocationsDatasetsHl7V2StoresImportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18832 c.name = name
18833 c.importmessagesrequest = importmessagesrequest
18834 return c
18835 }
18836
18837
18838
18839
18840 func (c *ProjectsLocationsDatasetsHl7V2StoresImportCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresImportCall {
18841 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18842 return c
18843 }
18844
18845
18846 func (c *ProjectsLocationsDatasetsHl7V2StoresImportCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresImportCall {
18847 c.ctx_ = ctx
18848 return c
18849 }
18850
18851
18852
18853 func (c *ProjectsLocationsDatasetsHl7V2StoresImportCall) Header() http.Header {
18854 if c.header_ == nil {
18855 c.header_ = make(http.Header)
18856 }
18857 return c.header_
18858 }
18859
18860 func (c *ProjectsLocationsDatasetsHl7V2StoresImportCall) doRequest(alt string) (*http.Response, error) {
18861 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
18862 var body io.Reader = nil
18863 body, err := googleapi.WithoutDataWrapper.JSONReader(c.importmessagesrequest)
18864 if err != nil {
18865 return nil, err
18866 }
18867 c.urlParams_.Set("alt", alt)
18868 c.urlParams_.Set("prettyPrint", "false")
18869 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:import")
18870 urls += "?" + c.urlParams_.Encode()
18871 req, err := http.NewRequest("POST", urls, body)
18872 if err != nil {
18873 return nil, err
18874 }
18875 req.Header = reqHeaders
18876 googleapi.Expand(req.URL, map[string]string{
18877 "name": c.name,
18878 })
18879 return gensupport.SendRequest(c.ctx_, c.s.client, req)
18880 }
18881
18882
18883
18884
18885
18886
18887 func (c *ProjectsLocationsDatasetsHl7V2StoresImportCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
18888 gensupport.SetOptions(c.urlParams_, opts...)
18889 res, err := c.doRequest("json")
18890 if res != nil && res.StatusCode == http.StatusNotModified {
18891 if res.Body != nil {
18892 res.Body.Close()
18893 }
18894 return nil, gensupport.WrapError(&googleapi.Error{
18895 Code: res.StatusCode,
18896 Header: res.Header,
18897 })
18898 }
18899 if err != nil {
18900 return nil, err
18901 }
18902 defer googleapi.CloseBody(res)
18903 if err := googleapi.CheckResponse(res); err != nil {
18904 return nil, gensupport.WrapError(err)
18905 }
18906 ret := &Operation{
18907 ServerResponse: googleapi.ServerResponse{
18908 Header: res.Header,
18909 HTTPStatusCode: res.StatusCode,
18910 },
18911 }
18912 target := &ret
18913 if err := gensupport.DecodeResponse(target, res); err != nil {
18914 return nil, err
18915 }
18916 return ret, nil
18917 }
18918
18919 type ProjectsLocationsDatasetsHl7V2StoresListCall struct {
18920 s *Service
18921 parent string
18922 urlParams_ gensupport.URLParams
18923 ifNoneMatch_ string
18924 ctx_ context.Context
18925 header_ http.Header
18926 }
18927
18928
18929
18930
18931 func (r *ProjectsLocationsDatasetsHl7V2StoresService) List(parent string) *ProjectsLocationsDatasetsHl7V2StoresListCall {
18932 c := &ProjectsLocationsDatasetsHl7V2StoresListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
18933 c.parent = parent
18934 return c
18935 }
18936
18937
18938
18939
18940
18941
18942
18943
18944
18945
18946
18947
18948
18949
18950
18951
18952
18953
18954
18955
18956
18957
18958
18959
18960 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) Filter(filter string) *ProjectsLocationsDatasetsHl7V2StoresListCall {
18961 c.urlParams_.Set("filter", filter)
18962 return c
18963 }
18964
18965
18966
18967
18968 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsHl7V2StoresListCall {
18969 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
18970 return c
18971 }
18972
18973
18974
18975 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsHl7V2StoresListCall {
18976 c.urlParams_.Set("pageToken", pageToken)
18977 return c
18978 }
18979
18980
18981
18982
18983 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresListCall {
18984 c.urlParams_.Set("fields", googleapi.CombineFields(s))
18985 return c
18986 }
18987
18988
18989
18990
18991 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsHl7V2StoresListCall {
18992 c.ifNoneMatch_ = entityTag
18993 return c
18994 }
18995
18996
18997 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresListCall {
18998 c.ctx_ = ctx
18999 return c
19000 }
19001
19002
19003
19004 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) Header() http.Header {
19005 if c.header_ == nil {
19006 c.header_ = make(http.Header)
19007 }
19008 return c.header_
19009 }
19010
19011 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) doRequest(alt string) (*http.Response, error) {
19012 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19013 if c.ifNoneMatch_ != "" {
19014 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
19015 }
19016 var body io.Reader = nil
19017 c.urlParams_.Set("alt", alt)
19018 c.urlParams_.Set("prettyPrint", "false")
19019 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/hl7V2Stores")
19020 urls += "?" + c.urlParams_.Encode()
19021 req, err := http.NewRequest("GET", urls, body)
19022 if err != nil {
19023 return nil, err
19024 }
19025 req.Header = reqHeaders
19026 googleapi.Expand(req.URL, map[string]string{
19027 "parent": c.parent,
19028 })
19029 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19030 }
19031
19032
19033
19034
19035
19036
19037
19038 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) Do(opts ...googleapi.CallOption) (*ListHl7V2StoresResponse, error) {
19039 gensupport.SetOptions(c.urlParams_, opts...)
19040 res, err := c.doRequest("json")
19041 if res != nil && res.StatusCode == http.StatusNotModified {
19042 if res.Body != nil {
19043 res.Body.Close()
19044 }
19045 return nil, gensupport.WrapError(&googleapi.Error{
19046 Code: res.StatusCode,
19047 Header: res.Header,
19048 })
19049 }
19050 if err != nil {
19051 return nil, err
19052 }
19053 defer googleapi.CloseBody(res)
19054 if err := googleapi.CheckResponse(res); err != nil {
19055 return nil, gensupport.WrapError(err)
19056 }
19057 ret := &ListHl7V2StoresResponse{
19058 ServerResponse: googleapi.ServerResponse{
19059 Header: res.Header,
19060 HTTPStatusCode: res.StatusCode,
19061 },
19062 }
19063 target := &ret
19064 if err := gensupport.DecodeResponse(target, res); err != nil {
19065 return nil, err
19066 }
19067 return ret, nil
19068 }
19069
19070
19071
19072
19073 func (c *ProjectsLocationsDatasetsHl7V2StoresListCall) Pages(ctx context.Context, f func(*ListHl7V2StoresResponse) error) error {
19074 c.ctx_ = ctx
19075 defer c.PageToken(c.urlParams_.Get("pageToken"))
19076 for {
19077 x, err := c.Do()
19078 if err != nil {
19079 return err
19080 }
19081 if err := f(x); err != nil {
19082 return err
19083 }
19084 if x.NextPageToken == "" {
19085 return nil
19086 }
19087 c.PageToken(x.NextPageToken)
19088 }
19089 }
19090
19091 type ProjectsLocationsDatasetsHl7V2StoresPatchCall struct {
19092 s *Service
19093 name string
19094 hl7v2store *Hl7V2Store
19095 urlParams_ gensupport.URLParams
19096 ctx_ context.Context
19097 header_ http.Header
19098 }
19099
19100
19101
19102
19103
19104
19105 func (r *ProjectsLocationsDatasetsHl7V2StoresService) Patch(name string, hl7v2store *Hl7V2Store) *ProjectsLocationsDatasetsHl7V2StoresPatchCall {
19106 c := &ProjectsLocationsDatasetsHl7V2StoresPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19107 c.name = name
19108 c.hl7v2store = hl7v2store
19109 return c
19110 }
19111
19112
19113
19114
19115 func (c *ProjectsLocationsDatasetsHl7V2StoresPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsHl7V2StoresPatchCall {
19116 c.urlParams_.Set("updateMask", updateMask)
19117 return c
19118 }
19119
19120
19121
19122
19123 func (c *ProjectsLocationsDatasetsHl7V2StoresPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresPatchCall {
19124 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19125 return c
19126 }
19127
19128
19129 func (c *ProjectsLocationsDatasetsHl7V2StoresPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresPatchCall {
19130 c.ctx_ = ctx
19131 return c
19132 }
19133
19134
19135
19136 func (c *ProjectsLocationsDatasetsHl7V2StoresPatchCall) Header() http.Header {
19137 if c.header_ == nil {
19138 c.header_ = make(http.Header)
19139 }
19140 return c.header_
19141 }
19142
19143 func (c *ProjectsLocationsDatasetsHl7V2StoresPatchCall) doRequest(alt string) (*http.Response, error) {
19144 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
19145 var body io.Reader = nil
19146 body, err := googleapi.WithoutDataWrapper.JSONReader(c.hl7v2store)
19147 if err != nil {
19148 return nil, err
19149 }
19150 c.urlParams_.Set("alt", alt)
19151 c.urlParams_.Set("prettyPrint", "false")
19152 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
19153 urls += "?" + c.urlParams_.Encode()
19154 req, err := http.NewRequest("PATCH", urls, body)
19155 if err != nil {
19156 return nil, err
19157 }
19158 req.Header = reqHeaders
19159 googleapi.Expand(req.URL, map[string]string{
19160 "name": c.name,
19161 })
19162 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19163 }
19164
19165
19166
19167
19168
19169
19170 func (c *ProjectsLocationsDatasetsHl7V2StoresPatchCall) Do(opts ...googleapi.CallOption) (*Hl7V2Store, error) {
19171 gensupport.SetOptions(c.urlParams_, opts...)
19172 res, err := c.doRequest("json")
19173 if res != nil && res.StatusCode == http.StatusNotModified {
19174 if res.Body != nil {
19175 res.Body.Close()
19176 }
19177 return nil, gensupport.WrapError(&googleapi.Error{
19178 Code: res.StatusCode,
19179 Header: res.Header,
19180 })
19181 }
19182 if err != nil {
19183 return nil, err
19184 }
19185 defer googleapi.CloseBody(res)
19186 if err := googleapi.CheckResponse(res); err != nil {
19187 return nil, gensupport.WrapError(err)
19188 }
19189 ret := &Hl7V2Store{
19190 ServerResponse: googleapi.ServerResponse{
19191 Header: res.Header,
19192 HTTPStatusCode: res.StatusCode,
19193 },
19194 }
19195 target := &ret
19196 if err := gensupport.DecodeResponse(target, res); err != nil {
19197 return nil, err
19198 }
19199 return ret, nil
19200 }
19201
19202 type ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall struct {
19203 s *Service
19204 resource string
19205 setiampolicyrequest *SetIamPolicyRequest
19206 urlParams_ gensupport.URLParams
19207 ctx_ context.Context
19208 header_ http.Header
19209 }
19210
19211
19212
19213
19214
19215
19216
19217
19218 func (r *ProjectsLocationsDatasetsHl7V2StoresService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall {
19219 c := &ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19220 c.resource = resource
19221 c.setiampolicyrequest = setiampolicyrequest
19222 return c
19223 }
19224
19225
19226
19227
19228 func (c *ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall {
19229 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19230 return c
19231 }
19232
19233
19234 func (c *ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall {
19235 c.ctx_ = ctx
19236 return c
19237 }
19238
19239
19240
19241 func (c *ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall) Header() http.Header {
19242 if c.header_ == nil {
19243 c.header_ = make(http.Header)
19244 }
19245 return c.header_
19246 }
19247
19248 func (c *ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
19249 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
19250 var body io.Reader = nil
19251 body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
19252 if err != nil {
19253 return nil, err
19254 }
19255 c.urlParams_.Set("alt", alt)
19256 c.urlParams_.Set("prettyPrint", "false")
19257 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
19258 urls += "?" + c.urlParams_.Encode()
19259 req, err := http.NewRequest("POST", urls, body)
19260 if err != nil {
19261 return nil, err
19262 }
19263 req.Header = reqHeaders
19264 googleapi.Expand(req.URL, map[string]string{
19265 "resource": c.resource,
19266 })
19267 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19268 }
19269
19270
19271
19272
19273
19274
19275 func (c *ProjectsLocationsDatasetsHl7V2StoresSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
19276 gensupport.SetOptions(c.urlParams_, opts...)
19277 res, err := c.doRequest("json")
19278 if res != nil && res.StatusCode == http.StatusNotModified {
19279 if res.Body != nil {
19280 res.Body.Close()
19281 }
19282 return nil, gensupport.WrapError(&googleapi.Error{
19283 Code: res.StatusCode,
19284 Header: res.Header,
19285 })
19286 }
19287 if err != nil {
19288 return nil, err
19289 }
19290 defer googleapi.CloseBody(res)
19291 if err := googleapi.CheckResponse(res); err != nil {
19292 return nil, gensupport.WrapError(err)
19293 }
19294 ret := &Policy{
19295 ServerResponse: googleapi.ServerResponse{
19296 Header: res.Header,
19297 HTTPStatusCode: res.StatusCode,
19298 },
19299 }
19300 target := &ret
19301 if err := gensupport.DecodeResponse(target, res); err != nil {
19302 return nil, err
19303 }
19304 return ret, nil
19305 }
19306
19307 type ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall struct {
19308 s *Service
19309 resource string
19310 testiampermissionsrequest *TestIamPermissionsRequest
19311 urlParams_ gensupport.URLParams
19312 ctx_ context.Context
19313 header_ http.Header
19314 }
19315
19316
19317
19318
19319
19320
19321
19322
19323
19324
19325
19326 func (r *ProjectsLocationsDatasetsHl7V2StoresService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall {
19327 c := &ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19328 c.resource = resource
19329 c.testiampermissionsrequest = testiampermissionsrequest
19330 return c
19331 }
19332
19333
19334
19335
19336 func (c *ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall {
19337 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19338 return c
19339 }
19340
19341
19342 func (c *ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall {
19343 c.ctx_ = ctx
19344 return c
19345 }
19346
19347
19348
19349 func (c *ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall) Header() http.Header {
19350 if c.header_ == nil {
19351 c.header_ = make(http.Header)
19352 }
19353 return c.header_
19354 }
19355
19356 func (c *ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
19357 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
19358 var body io.Reader = nil
19359 body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
19360 if err != nil {
19361 return nil, err
19362 }
19363 c.urlParams_.Set("alt", alt)
19364 c.urlParams_.Set("prettyPrint", "false")
19365 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
19366 urls += "?" + c.urlParams_.Encode()
19367 req, err := http.NewRequest("POST", urls, body)
19368 if err != nil {
19369 return nil, err
19370 }
19371 req.Header = reqHeaders
19372 googleapi.Expand(req.URL, map[string]string{
19373 "resource": c.resource,
19374 })
19375 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19376 }
19377
19378
19379
19380
19381
19382
19383
19384 func (c *ProjectsLocationsDatasetsHl7V2StoresTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
19385 gensupport.SetOptions(c.urlParams_, opts...)
19386 res, err := c.doRequest("json")
19387 if res != nil && res.StatusCode == http.StatusNotModified {
19388 if res.Body != nil {
19389 res.Body.Close()
19390 }
19391 return nil, gensupport.WrapError(&googleapi.Error{
19392 Code: res.StatusCode,
19393 Header: res.Header,
19394 })
19395 }
19396 if err != nil {
19397 return nil, err
19398 }
19399 defer googleapi.CloseBody(res)
19400 if err := googleapi.CheckResponse(res); err != nil {
19401 return nil, gensupport.WrapError(err)
19402 }
19403 ret := &TestIamPermissionsResponse{
19404 ServerResponse: googleapi.ServerResponse{
19405 Header: res.Header,
19406 HTTPStatusCode: res.StatusCode,
19407 },
19408 }
19409 target := &ret
19410 if err := gensupport.DecodeResponse(target, res); err != nil {
19411 return nil, err
19412 }
19413 return ret, nil
19414 }
19415
19416 type ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall struct {
19417 s *Service
19418 parent string
19419 createmessagerequest *CreateMessageRequest
19420 urlParams_ gensupport.URLParams
19421 ctx_ context.Context
19422 header_ http.Header
19423 }
19424
19425
19426
19427
19428
19429
19430
19431
19432 func (r *ProjectsLocationsDatasetsHl7V2StoresMessagesService) Create(parent string, createmessagerequest *CreateMessageRequest) *ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall {
19433 c := &ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19434 c.parent = parent
19435 c.createmessagerequest = createmessagerequest
19436 return c
19437 }
19438
19439
19440
19441
19442 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall {
19443 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19444 return c
19445 }
19446
19447
19448 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall {
19449 c.ctx_ = ctx
19450 return c
19451 }
19452
19453
19454
19455 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall) Header() http.Header {
19456 if c.header_ == nil {
19457 c.header_ = make(http.Header)
19458 }
19459 return c.header_
19460 }
19461
19462 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall) doRequest(alt string) (*http.Response, error) {
19463 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
19464 var body io.Reader = nil
19465 body, err := googleapi.WithoutDataWrapper.JSONReader(c.createmessagerequest)
19466 if err != nil {
19467 return nil, err
19468 }
19469 c.urlParams_.Set("alt", alt)
19470 c.urlParams_.Set("prettyPrint", "false")
19471 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/messages")
19472 urls += "?" + c.urlParams_.Encode()
19473 req, err := http.NewRequest("POST", urls, body)
19474 if err != nil {
19475 return nil, err
19476 }
19477 req.Header = reqHeaders
19478 googleapi.Expand(req.URL, map[string]string{
19479 "parent": c.parent,
19480 })
19481 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19482 }
19483
19484
19485
19486
19487
19488
19489 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesCreateCall) Do(opts ...googleapi.CallOption) (*Message, error) {
19490 gensupport.SetOptions(c.urlParams_, opts...)
19491 res, err := c.doRequest("json")
19492 if res != nil && res.StatusCode == http.StatusNotModified {
19493 if res.Body != nil {
19494 res.Body.Close()
19495 }
19496 return nil, gensupport.WrapError(&googleapi.Error{
19497 Code: res.StatusCode,
19498 Header: res.Header,
19499 })
19500 }
19501 if err != nil {
19502 return nil, err
19503 }
19504 defer googleapi.CloseBody(res)
19505 if err := googleapi.CheckResponse(res); err != nil {
19506 return nil, gensupport.WrapError(err)
19507 }
19508 ret := &Message{
19509 ServerResponse: googleapi.ServerResponse{
19510 Header: res.Header,
19511 HTTPStatusCode: res.StatusCode,
19512 },
19513 }
19514 target := &ret
19515 if err := gensupport.DecodeResponse(target, res); err != nil {
19516 return nil, err
19517 }
19518 return ret, nil
19519 }
19520
19521 type ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall struct {
19522 s *Service
19523 name string
19524 urlParams_ gensupport.URLParams
19525 ctx_ context.Context
19526 header_ http.Header
19527 }
19528
19529
19530
19531
19532 func (r *ProjectsLocationsDatasetsHl7V2StoresMessagesService) Delete(name string) *ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall {
19533 c := &ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19534 c.name = name
19535 return c
19536 }
19537
19538
19539
19540
19541 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall {
19542 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19543 return c
19544 }
19545
19546
19547 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall {
19548 c.ctx_ = ctx
19549 return c
19550 }
19551
19552
19553
19554 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall) Header() http.Header {
19555 if c.header_ == nil {
19556 c.header_ = make(http.Header)
19557 }
19558 return c.header_
19559 }
19560
19561 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall) doRequest(alt string) (*http.Response, error) {
19562 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19563 var body io.Reader = nil
19564 c.urlParams_.Set("alt", alt)
19565 c.urlParams_.Set("prettyPrint", "false")
19566 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
19567 urls += "?" + c.urlParams_.Encode()
19568 req, err := http.NewRequest("DELETE", urls, body)
19569 if err != nil {
19570 return nil, err
19571 }
19572 req.Header = reqHeaders
19573 googleapi.Expand(req.URL, map[string]string{
19574 "name": c.name,
19575 })
19576 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19577 }
19578
19579
19580
19581
19582
19583
19584 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
19585 gensupport.SetOptions(c.urlParams_, opts...)
19586 res, err := c.doRequest("json")
19587 if res != nil && res.StatusCode == http.StatusNotModified {
19588 if res.Body != nil {
19589 res.Body.Close()
19590 }
19591 return nil, gensupport.WrapError(&googleapi.Error{
19592 Code: res.StatusCode,
19593 Header: res.Header,
19594 })
19595 }
19596 if err != nil {
19597 return nil, err
19598 }
19599 defer googleapi.CloseBody(res)
19600 if err := googleapi.CheckResponse(res); err != nil {
19601 return nil, gensupport.WrapError(err)
19602 }
19603 ret := &Empty{
19604 ServerResponse: googleapi.ServerResponse{
19605 Header: res.Header,
19606 HTTPStatusCode: res.StatusCode,
19607 },
19608 }
19609 target := &ret
19610 if err := gensupport.DecodeResponse(target, res); err != nil {
19611 return nil, err
19612 }
19613 return ret, nil
19614 }
19615
19616 type ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall struct {
19617 s *Service
19618 name string
19619 urlParams_ gensupport.URLParams
19620 ifNoneMatch_ string
19621 ctx_ context.Context
19622 header_ http.Header
19623 }
19624
19625
19626
19627
19628 func (r *ProjectsLocationsDatasetsHl7V2StoresMessagesService) Get(name string) *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall {
19629 c := &ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19630 c.name = name
19631 return c
19632 }
19633
19634
19635
19636
19637
19638
19639
19640
19641
19642
19643
19644
19645
19646
19647
19648
19649
19650
19651
19652
19653
19654
19655 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall) View(view string) *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall {
19656 c.urlParams_.Set("view", view)
19657 return c
19658 }
19659
19660
19661
19662
19663 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall {
19664 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19665 return c
19666 }
19667
19668
19669
19670
19671 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall {
19672 c.ifNoneMatch_ = entityTag
19673 return c
19674 }
19675
19676
19677 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall {
19678 c.ctx_ = ctx
19679 return c
19680 }
19681
19682
19683
19684 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall) Header() http.Header {
19685 if c.header_ == nil {
19686 c.header_ = make(http.Header)
19687 }
19688 return c.header_
19689 }
19690
19691 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall) doRequest(alt string) (*http.Response, error) {
19692 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
19693 if c.ifNoneMatch_ != "" {
19694 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
19695 }
19696 var body io.Reader = nil
19697 c.urlParams_.Set("alt", alt)
19698 c.urlParams_.Set("prettyPrint", "false")
19699 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
19700 urls += "?" + c.urlParams_.Encode()
19701 req, err := http.NewRequest("GET", urls, body)
19702 if err != nil {
19703 return nil, err
19704 }
19705 req.Header = reqHeaders
19706 googleapi.Expand(req.URL, map[string]string{
19707 "name": c.name,
19708 })
19709 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19710 }
19711
19712
19713
19714
19715
19716
19717 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesGetCall) Do(opts ...googleapi.CallOption) (*Message, error) {
19718 gensupport.SetOptions(c.urlParams_, opts...)
19719 res, err := c.doRequest("json")
19720 if res != nil && res.StatusCode == http.StatusNotModified {
19721 if res.Body != nil {
19722 res.Body.Close()
19723 }
19724 return nil, gensupport.WrapError(&googleapi.Error{
19725 Code: res.StatusCode,
19726 Header: res.Header,
19727 })
19728 }
19729 if err != nil {
19730 return nil, err
19731 }
19732 defer googleapi.CloseBody(res)
19733 if err := googleapi.CheckResponse(res); err != nil {
19734 return nil, gensupport.WrapError(err)
19735 }
19736 ret := &Message{
19737 ServerResponse: googleapi.ServerResponse{
19738 Header: res.Header,
19739 HTTPStatusCode: res.StatusCode,
19740 },
19741 }
19742 target := &ret
19743 if err := gensupport.DecodeResponse(target, res); err != nil {
19744 return nil, err
19745 }
19746 return ret, nil
19747 }
19748
19749 type ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall struct {
19750 s *Service
19751 parent string
19752 ingestmessagerequest *IngestMessageRequest
19753 urlParams_ gensupport.URLParams
19754 ctx_ context.Context
19755 header_ http.Header
19756 }
19757
19758
19759
19760
19761
19762
19763
19764
19765
19766
19767
19768
19769 func (r *ProjectsLocationsDatasetsHl7V2StoresMessagesService) Ingest(parent string, ingestmessagerequest *IngestMessageRequest) *ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall {
19770 c := &ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19771 c.parent = parent
19772 c.ingestmessagerequest = ingestmessagerequest
19773 return c
19774 }
19775
19776
19777
19778
19779 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall {
19780 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19781 return c
19782 }
19783
19784
19785 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall {
19786 c.ctx_ = ctx
19787 return c
19788 }
19789
19790
19791
19792 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall) Header() http.Header {
19793 if c.header_ == nil {
19794 c.header_ = make(http.Header)
19795 }
19796 return c.header_
19797 }
19798
19799 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall) doRequest(alt string) (*http.Response, error) {
19800 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
19801 var body io.Reader = nil
19802 body, err := googleapi.WithoutDataWrapper.JSONReader(c.ingestmessagerequest)
19803 if err != nil {
19804 return nil, err
19805 }
19806 c.urlParams_.Set("alt", alt)
19807 c.urlParams_.Set("prettyPrint", "false")
19808 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/messages:ingest")
19809 urls += "?" + c.urlParams_.Encode()
19810 req, err := http.NewRequest("POST", urls, body)
19811 if err != nil {
19812 return nil, err
19813 }
19814 req.Header = reqHeaders
19815 googleapi.Expand(req.URL, map[string]string{
19816 "parent": c.parent,
19817 })
19818 return gensupport.SendRequest(c.ctx_, c.s.client, req)
19819 }
19820
19821
19822
19823
19824
19825
19826
19827 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesIngestCall) Do(opts ...googleapi.CallOption) (*IngestMessageResponse, error) {
19828 gensupport.SetOptions(c.urlParams_, opts...)
19829 res, err := c.doRequest("json")
19830 if res != nil && res.StatusCode == http.StatusNotModified {
19831 if res.Body != nil {
19832 res.Body.Close()
19833 }
19834 return nil, gensupport.WrapError(&googleapi.Error{
19835 Code: res.StatusCode,
19836 Header: res.Header,
19837 })
19838 }
19839 if err != nil {
19840 return nil, err
19841 }
19842 defer googleapi.CloseBody(res)
19843 if err := googleapi.CheckResponse(res); err != nil {
19844 return nil, gensupport.WrapError(err)
19845 }
19846 ret := &IngestMessageResponse{
19847 ServerResponse: googleapi.ServerResponse{
19848 Header: res.Header,
19849 HTTPStatusCode: res.StatusCode,
19850 },
19851 }
19852 target := &ret
19853 if err := gensupport.DecodeResponse(target, res); err != nil {
19854 return nil, err
19855 }
19856 return ret, nil
19857 }
19858
19859 type ProjectsLocationsDatasetsHl7V2StoresMessagesListCall struct {
19860 s *Service
19861 parent string
19862 urlParams_ gensupport.URLParams
19863 ifNoneMatch_ string
19864 ctx_ context.Context
19865 header_ http.Header
19866 }
19867
19868
19869
19870
19871
19872
19873
19874 func (r *ProjectsLocationsDatasetsHl7V2StoresMessagesService) List(parent string) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19875 c := &ProjectsLocationsDatasetsHl7V2StoresMessagesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
19876 c.parent = parent
19877 return c
19878 }
19879
19880
19881
19882
19883
19884
19885
19886
19887
19888
19889
19890
19891
19892
19893
19894
19895
19896
19897
19898
19899
19900
19901
19902
19903
19904
19905
19906
19907
19908
19909
19910
19911
19912
19913
19914
19915
19916
19917
19918
19919 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) Filter(filter string) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19920 c.urlParams_.Set("filter", filter)
19921 return c
19922 }
19923
19924
19925
19926
19927
19928 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) OrderBy(orderBy string) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19929 c.urlParams_.Set("orderBy", orderBy)
19930 return c
19931 }
19932
19933
19934
19935
19936 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19937 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
19938 return c
19939 }
19940
19941
19942
19943 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19944 c.urlParams_.Set("pageToken", pageToken)
19945 return c
19946 }
19947
19948
19949
19950
19951
19952
19953
19954
19955
19956
19957
19958
19959
19960
19961
19962
19963
19964
19965
19966
19967
19968
19969
19970 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) View(view string) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19971 c.urlParams_.Set("view", view)
19972 return c
19973 }
19974
19975
19976
19977
19978 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19979 c.urlParams_.Set("fields", googleapi.CombineFields(s))
19980 return c
19981 }
19982
19983
19984
19985
19986 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19987 c.ifNoneMatch_ = entityTag
19988 return c
19989 }
19990
19991
19992 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall {
19993 c.ctx_ = ctx
19994 return c
19995 }
19996
19997
19998
19999 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) Header() http.Header {
20000 if c.header_ == nil {
20001 c.header_ = make(http.Header)
20002 }
20003 return c.header_
20004 }
20005
20006 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) doRequest(alt string) (*http.Response, error) {
20007 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
20008 if c.ifNoneMatch_ != "" {
20009 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20010 }
20011 var body io.Reader = nil
20012 c.urlParams_.Set("alt", alt)
20013 c.urlParams_.Set("prettyPrint", "false")
20014 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/messages")
20015 urls += "?" + c.urlParams_.Encode()
20016 req, err := http.NewRequest("GET", urls, body)
20017 if err != nil {
20018 return nil, err
20019 }
20020 req.Header = reqHeaders
20021 googleapi.Expand(req.URL, map[string]string{
20022 "parent": c.parent,
20023 })
20024 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20025 }
20026
20027
20028
20029
20030
20031
20032
20033 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) Do(opts ...googleapi.CallOption) (*ListMessagesResponse, error) {
20034 gensupport.SetOptions(c.urlParams_, opts...)
20035 res, err := c.doRequest("json")
20036 if res != nil && res.StatusCode == http.StatusNotModified {
20037 if res.Body != nil {
20038 res.Body.Close()
20039 }
20040 return nil, gensupport.WrapError(&googleapi.Error{
20041 Code: res.StatusCode,
20042 Header: res.Header,
20043 })
20044 }
20045 if err != nil {
20046 return nil, err
20047 }
20048 defer googleapi.CloseBody(res)
20049 if err := googleapi.CheckResponse(res); err != nil {
20050 return nil, gensupport.WrapError(err)
20051 }
20052 ret := &ListMessagesResponse{
20053 ServerResponse: googleapi.ServerResponse{
20054 Header: res.Header,
20055 HTTPStatusCode: res.StatusCode,
20056 },
20057 }
20058 target := &ret
20059 if err := gensupport.DecodeResponse(target, res); err != nil {
20060 return nil, err
20061 }
20062 return ret, nil
20063 }
20064
20065
20066
20067
20068 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesListCall) Pages(ctx context.Context, f func(*ListMessagesResponse) error) error {
20069 c.ctx_ = ctx
20070 defer c.PageToken(c.urlParams_.Get("pageToken"))
20071 for {
20072 x, err := c.Do()
20073 if err != nil {
20074 return err
20075 }
20076 if err := f(x); err != nil {
20077 return err
20078 }
20079 if x.NextPageToken == "" {
20080 return nil
20081 }
20082 c.PageToken(x.NextPageToken)
20083 }
20084 }
20085
20086 type ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall struct {
20087 s *Service
20088 name string
20089 message *Message
20090 urlParams_ gensupport.URLParams
20091 ctx_ context.Context
20092 header_ http.Header
20093 }
20094
20095
20096
20097
20098
20099
20100
20101
20102
20103
20104 func (r *ProjectsLocationsDatasetsHl7V2StoresMessagesService) Patch(name string, message *Message) *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall {
20105 c := &ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20106 c.name = name
20107 c.message = message
20108 return c
20109 }
20110
20111
20112
20113
20114 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall) UpdateMask(updateMask string) *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall {
20115 c.urlParams_.Set("updateMask", updateMask)
20116 return c
20117 }
20118
20119
20120
20121
20122 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall {
20123 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20124 return c
20125 }
20126
20127
20128 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall) Context(ctx context.Context) *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall {
20129 c.ctx_ = ctx
20130 return c
20131 }
20132
20133
20134
20135 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall) Header() http.Header {
20136 if c.header_ == nil {
20137 c.header_ = make(http.Header)
20138 }
20139 return c.header_
20140 }
20141
20142 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall) doRequest(alt string) (*http.Response, error) {
20143 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
20144 var body io.Reader = nil
20145 body, err := googleapi.WithoutDataWrapper.JSONReader(c.message)
20146 if err != nil {
20147 return nil, err
20148 }
20149 c.urlParams_.Set("alt", alt)
20150 c.urlParams_.Set("prettyPrint", "false")
20151 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
20152 urls += "?" + c.urlParams_.Encode()
20153 req, err := http.NewRequest("PATCH", urls, body)
20154 if err != nil {
20155 return nil, err
20156 }
20157 req.Header = reqHeaders
20158 googleapi.Expand(req.URL, map[string]string{
20159 "name": c.name,
20160 })
20161 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20162 }
20163
20164
20165
20166
20167
20168
20169 func (c *ProjectsLocationsDatasetsHl7V2StoresMessagesPatchCall) Do(opts ...googleapi.CallOption) (*Message, error) {
20170 gensupport.SetOptions(c.urlParams_, opts...)
20171 res, err := c.doRequest("json")
20172 if res != nil && res.StatusCode == http.StatusNotModified {
20173 if res.Body != nil {
20174 res.Body.Close()
20175 }
20176 return nil, gensupport.WrapError(&googleapi.Error{
20177 Code: res.StatusCode,
20178 Header: res.Header,
20179 })
20180 }
20181 if err != nil {
20182 return nil, err
20183 }
20184 defer googleapi.CloseBody(res)
20185 if err := googleapi.CheckResponse(res); err != nil {
20186 return nil, gensupport.WrapError(err)
20187 }
20188 ret := &Message{
20189 ServerResponse: googleapi.ServerResponse{
20190 Header: res.Header,
20191 HTTPStatusCode: res.StatusCode,
20192 },
20193 }
20194 target := &ret
20195 if err := gensupport.DecodeResponse(target, res); err != nil {
20196 return nil, err
20197 }
20198 return ret, nil
20199 }
20200
20201 type ProjectsLocationsDatasetsOperationsCancelCall struct {
20202 s *Service
20203 name string
20204 canceloperationrequest *CancelOperationRequest
20205 urlParams_ gensupport.URLParams
20206 ctx_ context.Context
20207 header_ http.Header
20208 }
20209
20210
20211
20212
20213
20214
20215
20216
20217
20218
20219
20220
20221 func (r *ProjectsLocationsDatasetsOperationsService) Cancel(name string, canceloperationrequest *CancelOperationRequest) *ProjectsLocationsDatasetsOperationsCancelCall {
20222 c := &ProjectsLocationsDatasetsOperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20223 c.name = name
20224 c.canceloperationrequest = canceloperationrequest
20225 return c
20226 }
20227
20228
20229
20230
20231 func (c *ProjectsLocationsDatasetsOperationsCancelCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsOperationsCancelCall {
20232 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20233 return c
20234 }
20235
20236
20237 func (c *ProjectsLocationsDatasetsOperationsCancelCall) Context(ctx context.Context) *ProjectsLocationsDatasetsOperationsCancelCall {
20238 c.ctx_ = ctx
20239 return c
20240 }
20241
20242
20243
20244 func (c *ProjectsLocationsDatasetsOperationsCancelCall) Header() http.Header {
20245 if c.header_ == nil {
20246 c.header_ = make(http.Header)
20247 }
20248 return c.header_
20249 }
20250
20251 func (c *ProjectsLocationsDatasetsOperationsCancelCall) doRequest(alt string) (*http.Response, error) {
20252 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
20253 var body io.Reader = nil
20254 body, err := googleapi.WithoutDataWrapper.JSONReader(c.canceloperationrequest)
20255 if err != nil {
20256 return nil, err
20257 }
20258 c.urlParams_.Set("alt", alt)
20259 c.urlParams_.Set("prettyPrint", "false")
20260 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:cancel")
20261 urls += "?" + c.urlParams_.Encode()
20262 req, err := http.NewRequest("POST", urls, body)
20263 if err != nil {
20264 return nil, err
20265 }
20266 req.Header = reqHeaders
20267 googleapi.Expand(req.URL, map[string]string{
20268 "name": c.name,
20269 })
20270 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20271 }
20272
20273
20274
20275
20276
20277
20278 func (c *ProjectsLocationsDatasetsOperationsCancelCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
20279 gensupport.SetOptions(c.urlParams_, opts...)
20280 res, err := c.doRequest("json")
20281 if res != nil && res.StatusCode == http.StatusNotModified {
20282 if res.Body != nil {
20283 res.Body.Close()
20284 }
20285 return nil, gensupport.WrapError(&googleapi.Error{
20286 Code: res.StatusCode,
20287 Header: res.Header,
20288 })
20289 }
20290 if err != nil {
20291 return nil, err
20292 }
20293 defer googleapi.CloseBody(res)
20294 if err := googleapi.CheckResponse(res); err != nil {
20295 return nil, gensupport.WrapError(err)
20296 }
20297 ret := &Empty{
20298 ServerResponse: googleapi.ServerResponse{
20299 Header: res.Header,
20300 HTTPStatusCode: res.StatusCode,
20301 },
20302 }
20303 target := &ret
20304 if err := gensupport.DecodeResponse(target, res); err != nil {
20305 return nil, err
20306 }
20307 return ret, nil
20308 }
20309
20310 type ProjectsLocationsDatasetsOperationsGetCall struct {
20311 s *Service
20312 name string
20313 urlParams_ gensupport.URLParams
20314 ifNoneMatch_ string
20315 ctx_ context.Context
20316 header_ http.Header
20317 }
20318
20319
20320
20321
20322
20323
20324 func (r *ProjectsLocationsDatasetsOperationsService) Get(name string) *ProjectsLocationsDatasetsOperationsGetCall {
20325 c := &ProjectsLocationsDatasetsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20326 c.name = name
20327 return c
20328 }
20329
20330
20331
20332
20333 func (c *ProjectsLocationsDatasetsOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsOperationsGetCall {
20334 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20335 return c
20336 }
20337
20338
20339
20340
20341 func (c *ProjectsLocationsDatasetsOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsOperationsGetCall {
20342 c.ifNoneMatch_ = entityTag
20343 return c
20344 }
20345
20346
20347 func (c *ProjectsLocationsDatasetsOperationsGetCall) Context(ctx context.Context) *ProjectsLocationsDatasetsOperationsGetCall {
20348 c.ctx_ = ctx
20349 return c
20350 }
20351
20352
20353
20354 func (c *ProjectsLocationsDatasetsOperationsGetCall) Header() http.Header {
20355 if c.header_ == nil {
20356 c.header_ = make(http.Header)
20357 }
20358 return c.header_
20359 }
20360
20361 func (c *ProjectsLocationsDatasetsOperationsGetCall) doRequest(alt string) (*http.Response, error) {
20362 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
20363 if c.ifNoneMatch_ != "" {
20364 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20365 }
20366 var body io.Reader = nil
20367 c.urlParams_.Set("alt", alt)
20368 c.urlParams_.Set("prettyPrint", "false")
20369 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
20370 urls += "?" + c.urlParams_.Encode()
20371 req, err := http.NewRequest("GET", urls, body)
20372 if err != nil {
20373 return nil, err
20374 }
20375 req.Header = reqHeaders
20376 googleapi.Expand(req.URL, map[string]string{
20377 "name": c.name,
20378 })
20379 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20380 }
20381
20382
20383
20384
20385
20386
20387 func (c *ProjectsLocationsDatasetsOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
20388 gensupport.SetOptions(c.urlParams_, opts...)
20389 res, err := c.doRequest("json")
20390 if res != nil && res.StatusCode == http.StatusNotModified {
20391 if res.Body != nil {
20392 res.Body.Close()
20393 }
20394 return nil, gensupport.WrapError(&googleapi.Error{
20395 Code: res.StatusCode,
20396 Header: res.Header,
20397 })
20398 }
20399 if err != nil {
20400 return nil, err
20401 }
20402 defer googleapi.CloseBody(res)
20403 if err := googleapi.CheckResponse(res); err != nil {
20404 return nil, gensupport.WrapError(err)
20405 }
20406 ret := &Operation{
20407 ServerResponse: googleapi.ServerResponse{
20408 Header: res.Header,
20409 HTTPStatusCode: res.StatusCode,
20410 },
20411 }
20412 target := &ret
20413 if err := gensupport.DecodeResponse(target, res); err != nil {
20414 return nil, err
20415 }
20416 return ret, nil
20417 }
20418
20419 type ProjectsLocationsDatasetsOperationsListCall struct {
20420 s *Service
20421 name string
20422 urlParams_ gensupport.URLParams
20423 ifNoneMatch_ string
20424 ctx_ context.Context
20425 header_ http.Header
20426 }
20427
20428
20429
20430
20431
20432 func (r *ProjectsLocationsDatasetsOperationsService) List(name string) *ProjectsLocationsDatasetsOperationsListCall {
20433 c := &ProjectsLocationsDatasetsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20434 c.name = name
20435 return c
20436 }
20437
20438
20439 func (c *ProjectsLocationsDatasetsOperationsListCall) Filter(filter string) *ProjectsLocationsDatasetsOperationsListCall {
20440 c.urlParams_.Set("filter", filter)
20441 return c
20442 }
20443
20444
20445
20446 func (c *ProjectsLocationsDatasetsOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsDatasetsOperationsListCall {
20447 c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
20448 return c
20449 }
20450
20451
20452
20453 func (c *ProjectsLocationsDatasetsOperationsListCall) PageToken(pageToken string) *ProjectsLocationsDatasetsOperationsListCall {
20454 c.urlParams_.Set("pageToken", pageToken)
20455 return c
20456 }
20457
20458
20459
20460
20461 func (c *ProjectsLocationsDatasetsOperationsListCall) Fields(s ...googleapi.Field) *ProjectsLocationsDatasetsOperationsListCall {
20462 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20463 return c
20464 }
20465
20466
20467
20468
20469 func (c *ProjectsLocationsDatasetsOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsDatasetsOperationsListCall {
20470 c.ifNoneMatch_ = entityTag
20471 return c
20472 }
20473
20474
20475 func (c *ProjectsLocationsDatasetsOperationsListCall) Context(ctx context.Context) *ProjectsLocationsDatasetsOperationsListCall {
20476 c.ctx_ = ctx
20477 return c
20478 }
20479
20480
20481
20482 func (c *ProjectsLocationsDatasetsOperationsListCall) Header() http.Header {
20483 if c.header_ == nil {
20484 c.header_ = make(http.Header)
20485 }
20486 return c.header_
20487 }
20488
20489 func (c *ProjectsLocationsDatasetsOperationsListCall) doRequest(alt string) (*http.Response, error) {
20490 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
20491 if c.ifNoneMatch_ != "" {
20492 reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
20493 }
20494 var body io.Reader = nil
20495 c.urlParams_.Set("alt", alt)
20496 c.urlParams_.Set("prettyPrint", "false")
20497 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}/operations")
20498 urls += "?" + c.urlParams_.Encode()
20499 req, err := http.NewRequest("GET", urls, body)
20500 if err != nil {
20501 return nil, err
20502 }
20503 req.Header = reqHeaders
20504 googleapi.Expand(req.URL, map[string]string{
20505 "name": c.name,
20506 })
20507 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20508 }
20509
20510
20511
20512
20513
20514
20515
20516 func (c *ProjectsLocationsDatasetsOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
20517 gensupport.SetOptions(c.urlParams_, opts...)
20518 res, err := c.doRequest("json")
20519 if res != nil && res.StatusCode == http.StatusNotModified {
20520 if res.Body != nil {
20521 res.Body.Close()
20522 }
20523 return nil, gensupport.WrapError(&googleapi.Error{
20524 Code: res.StatusCode,
20525 Header: res.Header,
20526 })
20527 }
20528 if err != nil {
20529 return nil, err
20530 }
20531 defer googleapi.CloseBody(res)
20532 if err := googleapi.CheckResponse(res); err != nil {
20533 return nil, gensupport.WrapError(err)
20534 }
20535 ret := &ListOperationsResponse{
20536 ServerResponse: googleapi.ServerResponse{
20537 Header: res.Header,
20538 HTTPStatusCode: res.StatusCode,
20539 },
20540 }
20541 target := &ret
20542 if err := gensupport.DecodeResponse(target, res); err != nil {
20543 return nil, err
20544 }
20545 return ret, nil
20546 }
20547
20548
20549
20550
20551 func (c *ProjectsLocationsDatasetsOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
20552 c.ctx_ = ctx
20553 defer c.PageToken(c.urlParams_.Get("pageToken"))
20554 for {
20555 x, err := c.Do()
20556 if err != nil {
20557 return err
20558 }
20559 if err := f(x); err != nil {
20560 return err
20561 }
20562 if x.NextPageToken == "" {
20563 return nil
20564 }
20565 c.PageToken(x.NextPageToken)
20566 }
20567 }
20568
20569 type ProjectsLocationsServicesNlpAnalyzeEntitiesCall struct {
20570 s *Service
20571 nlpService string
20572 analyzeentitiesrequest *AnalyzeEntitiesRequest
20573 urlParams_ gensupport.URLParams
20574 ctx_ context.Context
20575 header_ http.Header
20576 }
20577
20578
20579
20580
20581
20582
20583
20584 func (r *ProjectsLocationsServicesNlpService) AnalyzeEntities(nlpService string, analyzeentitiesrequest *AnalyzeEntitiesRequest) *ProjectsLocationsServicesNlpAnalyzeEntitiesCall {
20585 c := &ProjectsLocationsServicesNlpAnalyzeEntitiesCall{s: r.s, urlParams_: make(gensupport.URLParams)}
20586 c.nlpService = nlpService
20587 c.analyzeentitiesrequest = analyzeentitiesrequest
20588 return c
20589 }
20590
20591
20592
20593
20594 func (c *ProjectsLocationsServicesNlpAnalyzeEntitiesCall) Fields(s ...googleapi.Field) *ProjectsLocationsServicesNlpAnalyzeEntitiesCall {
20595 c.urlParams_.Set("fields", googleapi.CombineFields(s))
20596 return c
20597 }
20598
20599
20600 func (c *ProjectsLocationsServicesNlpAnalyzeEntitiesCall) Context(ctx context.Context) *ProjectsLocationsServicesNlpAnalyzeEntitiesCall {
20601 c.ctx_ = ctx
20602 return c
20603 }
20604
20605
20606
20607 func (c *ProjectsLocationsServicesNlpAnalyzeEntitiesCall) Header() http.Header {
20608 if c.header_ == nil {
20609 c.header_ = make(http.Header)
20610 }
20611 return c.header_
20612 }
20613
20614 func (c *ProjectsLocationsServicesNlpAnalyzeEntitiesCall) doRequest(alt string) (*http.Response, error) {
20615 reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
20616 var body io.Reader = nil
20617 body, err := googleapi.WithoutDataWrapper.JSONReader(c.analyzeentitiesrequest)
20618 if err != nil {
20619 return nil, err
20620 }
20621 c.urlParams_.Set("alt", alt)
20622 c.urlParams_.Set("prettyPrint", "false")
20623 urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+nlpService}:analyzeEntities")
20624 urls += "?" + c.urlParams_.Encode()
20625 req, err := http.NewRequest("POST", urls, body)
20626 if err != nil {
20627 return nil, err
20628 }
20629 req.Header = reqHeaders
20630 googleapi.Expand(req.URL, map[string]string{
20631 "nlpService": c.nlpService,
20632 })
20633 return gensupport.SendRequest(c.ctx_, c.s.client, req)
20634 }
20635
20636
20637
20638
20639
20640
20641
20642 func (c *ProjectsLocationsServicesNlpAnalyzeEntitiesCall) Do(opts ...googleapi.CallOption) (*AnalyzeEntitiesResponse, error) {
20643 gensupport.SetOptions(c.urlParams_, opts...)
20644 res, err := c.doRequest("json")
20645 if res != nil && res.StatusCode == http.StatusNotModified {
20646 if res.Body != nil {
20647 res.Body.Close()
20648 }
20649 return nil, gensupport.WrapError(&googleapi.Error{
20650 Code: res.StatusCode,
20651 Header: res.Header,
20652 })
20653 }
20654 if err != nil {
20655 return nil, err
20656 }
20657 defer googleapi.CloseBody(res)
20658 if err := googleapi.CheckResponse(res); err != nil {
20659 return nil, gensupport.WrapError(err)
20660 }
20661 ret := &AnalyzeEntitiesResponse{
20662 ServerResponse: googleapi.ServerResponse{
20663 Header: res.Header,
20664 HTTPStatusCode: res.StatusCode,
20665 },
20666 }
20667 target := &ret
20668 if err := gensupport.DecodeResponse(target, res); err != nil {
20669 return nil, err
20670 }
20671 return ret, nil
20672 }
20673
View as plain text