Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(449)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: generated/googleapis_beta/lib/genomics/v1beta.dart

Issue 1078053002: Roll of googleapis as of 4/7/2015. (Closed) Base URL: https://github.com/dart-lang/googleapis.git@master
Patch Set: Created 5 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « generated/googleapis_beta/lib/dns/v1beta1.dart ('k') | generated/googleapis_beta/lib/genomics/v1beta2.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 library googleapis_beta.genomics.v1beta;
2
3 import "dart:core" as core;
4 import "dart:collection" as collection;
5 import "dart:async" as async;
6 import "dart:convert" as convert;
7
8 import "package:crypto/crypto.dart" as crypto;
9 import 'package:http/http.dart' as http;
10 import '../src/common_internal.dart' as common_internal;
11 import '../common/common.dart' as common;
12
13 export '../common/common.dart' show ApiRequestError;
14 export '../common/common.dart' show DetailedApiRequestError;
15
16 /** Provides access to Genomics data. */
17 class GenomicsApi {
18 /** View and manage your data in Google BigQuery */
19 static const BigqueryScope = "https://www.googleapis.com/auth/bigquery";
20
21 /** Manage your data in Google Cloud Storage */
22 static const DevstorageReadWriteScope = "https://www.googleapis.com/auth/devst orage.read_write";
23
24 /** View and manage Genomics data */
25 static const GenomicsScope = "https://www.googleapis.com/auth/genomics";
26
27 /** View Genomics data */
28 static const GenomicsReadonlyScope = "https://www.googleapis.com/auth/genomics .readonly";
29
30
31 final common_internal.ApiRequester _requester;
32
33 CallsetsResourceApi get callsets => new CallsetsResourceApi(_requester);
34 DatasetsResourceApi get datasets => new DatasetsResourceApi(_requester);
35 ExperimentalResourceApi get experimental => new ExperimentalResourceApi(_reque ster);
36 JobsResourceApi get jobs => new JobsResourceApi(_requester);
37 ReadsResourceApi get reads => new ReadsResourceApi(_requester);
38 ReadsetsResourceApi get readsets => new ReadsetsResourceApi(_requester);
39 VariantsResourceApi get variants => new VariantsResourceApi(_requester);
40 VariantsetsResourceApi get variantsets => new VariantsetsResourceApi(_requeste r);
41
42 GenomicsApi(http.Client client, {core.String rootUrl: "https://www.googleapis. com/", core.String servicePath: "genomics/v1beta/"}) :
43 _requester = new common_internal.ApiRequester(client, rootUrl, servicePath );
44 }
45
46
47 /** Not documented yet. */
48 class CallsetsResourceApi {
49 final common_internal.ApiRequester _requester;
50
51 CallsetsResourceApi(common_internal.ApiRequester client) :
52 _requester = client;
53
54 /**
55 * Creates a new call set.
56 *
57 * [request] - The metadata request object.
58 *
59 * Request parameters:
60 *
61 * Completes with a [CallSet].
62 *
63 * Completes with a [common.ApiRequestError] if the API endpoint returned an
64 * error.
65 *
66 * If the used [http.Client] completes with an error when making a REST call,
67 * this method will complete with the same error.
68 */
69 async.Future<CallSet> create(CallSet request) {
70 var _url = null;
71 var _queryParams = new core.Map();
72 var _uploadMedia = null;
73 var _uploadOptions = null;
74 var _downloadOptions = common.DownloadOptions.Metadata;
75 var _body = null;
76
77 if (request != null) {
78 _body = convert.JSON.encode((request).toJson());
79 }
80
81
82 _url = 'callsets';
83
84 var _response = _requester.request(_url,
85 "POST",
86 body: _body,
87 queryParams: _queryParams,
88 uploadOptions: _uploadOptions,
89 uploadMedia: _uploadMedia,
90 downloadOptions: _downloadOptions);
91 return _response.then((data) => new CallSet.fromJson(data));
92 }
93
94 /**
95 * Deletes a call set.
96 *
97 * Request parameters:
98 *
99 * [callSetId] - The ID of the call set to be deleted.
100 *
101 * Completes with a [common.ApiRequestError] if the API endpoint returned an
102 * error.
103 *
104 * If the used [http.Client] completes with an error when making a REST call,
105 * this method will complete with the same error.
106 */
107 async.Future delete(core.String callSetId) {
108 var _url = null;
109 var _queryParams = new core.Map();
110 var _uploadMedia = null;
111 var _uploadOptions = null;
112 var _downloadOptions = common.DownloadOptions.Metadata;
113 var _body = null;
114
115 if (callSetId == null) {
116 throw new core.ArgumentError("Parameter callSetId is required.");
117 }
118
119 _downloadOptions = null;
120
121 _url = 'callsets/' + common_internal.Escaper.ecapeVariable('$callSetId');
122
123 var _response = _requester.request(_url,
124 "DELETE",
125 body: _body,
126 queryParams: _queryParams,
127 uploadOptions: _uploadOptions,
128 uploadMedia: _uploadMedia,
129 downloadOptions: _downloadOptions);
130 return _response.then((data) => null);
131 }
132
133 /**
134 * Gets a call set by ID.
135 *
136 * Request parameters:
137 *
138 * [callSetId] - The ID of the call set.
139 *
140 * Completes with a [CallSet].
141 *
142 * Completes with a [common.ApiRequestError] if the API endpoint returned an
143 * error.
144 *
145 * If the used [http.Client] completes with an error when making a REST call,
146 * this method will complete with the same error.
147 */
148 async.Future<CallSet> get(core.String callSetId) {
149 var _url = null;
150 var _queryParams = new core.Map();
151 var _uploadMedia = null;
152 var _uploadOptions = null;
153 var _downloadOptions = common.DownloadOptions.Metadata;
154 var _body = null;
155
156 if (callSetId == null) {
157 throw new core.ArgumentError("Parameter callSetId is required.");
158 }
159
160
161 _url = 'callsets/' + common_internal.Escaper.ecapeVariable('$callSetId');
162
163 var _response = _requester.request(_url,
164 "GET",
165 body: _body,
166 queryParams: _queryParams,
167 uploadOptions: _uploadOptions,
168 uploadMedia: _uploadMedia,
169 downloadOptions: _downloadOptions);
170 return _response.then((data) => new CallSet.fromJson(data));
171 }
172
173 /**
174 * Updates a call set. This method supports patch semantics.
175 *
176 * [request] - The metadata request object.
177 *
178 * Request parameters:
179 *
180 * [callSetId] - The ID of the call set to be updated.
181 *
182 * Completes with a [CallSet].
183 *
184 * Completes with a [common.ApiRequestError] if the API endpoint returned an
185 * error.
186 *
187 * If the used [http.Client] completes with an error when making a REST call,
188 * this method will complete with the same error.
189 */
190 async.Future<CallSet> patch(CallSet request, core.String callSetId) {
191 var _url = null;
192 var _queryParams = new core.Map();
193 var _uploadMedia = null;
194 var _uploadOptions = null;
195 var _downloadOptions = common.DownloadOptions.Metadata;
196 var _body = null;
197
198 if (request != null) {
199 _body = convert.JSON.encode((request).toJson());
200 }
201 if (callSetId == null) {
202 throw new core.ArgumentError("Parameter callSetId is required.");
203 }
204
205
206 _url = 'callsets/' + common_internal.Escaper.ecapeVariable('$callSetId');
207
208 var _response = _requester.request(_url,
209 "PATCH",
210 body: _body,
211 queryParams: _queryParams,
212 uploadOptions: _uploadOptions,
213 uploadMedia: _uploadMedia,
214 downloadOptions: _downloadOptions);
215 return _response.then((data) => new CallSet.fromJson(data));
216 }
217
218 /**
219 * Gets a list of call sets matching the criteria.
220 *
221 * Implements GlobalAllianceApi.searchCallSets.
222 *
223 * [request] - The metadata request object.
224 *
225 * Request parameters:
226 *
227 * Completes with a [SearchCallSetsResponse].
228 *
229 * Completes with a [common.ApiRequestError] if the API endpoint returned an
230 * error.
231 *
232 * If the used [http.Client] completes with an error when making a REST call,
233 * this method will complete with the same error.
234 */
235 async.Future<SearchCallSetsResponse> search(SearchCallSetsRequest request) {
236 var _url = null;
237 var _queryParams = new core.Map();
238 var _uploadMedia = null;
239 var _uploadOptions = null;
240 var _downloadOptions = common.DownloadOptions.Metadata;
241 var _body = null;
242
243 if (request != null) {
244 _body = convert.JSON.encode((request).toJson());
245 }
246
247
248 _url = 'callsets/search';
249
250 var _response = _requester.request(_url,
251 "POST",
252 body: _body,
253 queryParams: _queryParams,
254 uploadOptions: _uploadOptions,
255 uploadMedia: _uploadMedia,
256 downloadOptions: _downloadOptions);
257 return _response.then((data) => new SearchCallSetsResponse.fromJson(data));
258 }
259
260 /**
261 * Updates a call set.
262 *
263 * [request] - The metadata request object.
264 *
265 * Request parameters:
266 *
267 * [callSetId] - The ID of the call set to be updated.
268 *
269 * Completes with a [CallSet].
270 *
271 * Completes with a [common.ApiRequestError] if the API endpoint returned an
272 * error.
273 *
274 * If the used [http.Client] completes with an error when making a REST call,
275 * this method will complete with the same error.
276 */
277 async.Future<CallSet> update(CallSet request, core.String callSetId) {
278 var _url = null;
279 var _queryParams = new core.Map();
280 var _uploadMedia = null;
281 var _uploadOptions = null;
282 var _downloadOptions = common.DownloadOptions.Metadata;
283 var _body = null;
284
285 if (request != null) {
286 _body = convert.JSON.encode((request).toJson());
287 }
288 if (callSetId == null) {
289 throw new core.ArgumentError("Parameter callSetId is required.");
290 }
291
292
293 _url = 'callsets/' + common_internal.Escaper.ecapeVariable('$callSetId');
294
295 var _response = _requester.request(_url,
296 "PUT",
297 body: _body,
298 queryParams: _queryParams,
299 uploadOptions: _uploadOptions,
300 uploadMedia: _uploadMedia,
301 downloadOptions: _downloadOptions);
302 return _response.then((data) => new CallSet.fromJson(data));
303 }
304
305 }
306
307
308 /** Not documented yet. */
309 class DatasetsResourceApi {
310 final common_internal.ApiRequester _requester;
311
312 DatasetsResourceApi(common_internal.ApiRequester client) :
313 _requester = client;
314
315 /**
316 * Creates a new dataset.
317 *
318 * [request] - The metadata request object.
319 *
320 * Request parameters:
321 *
322 * Completes with a [Dataset].
323 *
324 * Completes with a [common.ApiRequestError] if the API endpoint returned an
325 * error.
326 *
327 * If the used [http.Client] completes with an error when making a REST call,
328 * this method will complete with the same error.
329 */
330 async.Future<Dataset> create(Dataset request) {
331 var _url = null;
332 var _queryParams = new core.Map();
333 var _uploadMedia = null;
334 var _uploadOptions = null;
335 var _downloadOptions = common.DownloadOptions.Metadata;
336 var _body = null;
337
338 if (request != null) {
339 _body = convert.JSON.encode((request).toJson());
340 }
341
342
343 _url = 'datasets';
344
345 var _response = _requester.request(_url,
346 "POST",
347 body: _body,
348 queryParams: _queryParams,
349 uploadOptions: _uploadOptions,
350 uploadMedia: _uploadMedia,
351 downloadOptions: _downloadOptions);
352 return _response.then((data) => new Dataset.fromJson(data));
353 }
354
355 /**
356 * Deletes a dataset.
357 *
358 * Request parameters:
359 *
360 * [datasetId] - The ID of the dataset to be deleted.
361 *
362 * Completes with a [common.ApiRequestError] if the API endpoint returned an
363 * error.
364 *
365 * If the used [http.Client] completes with an error when making a REST call,
366 * this method will complete with the same error.
367 */
368 async.Future delete(core.String datasetId) {
369 var _url = null;
370 var _queryParams = new core.Map();
371 var _uploadMedia = null;
372 var _uploadOptions = null;
373 var _downloadOptions = common.DownloadOptions.Metadata;
374 var _body = null;
375
376 if (datasetId == null) {
377 throw new core.ArgumentError("Parameter datasetId is required.");
378 }
379
380 _downloadOptions = null;
381
382 _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
383
384 var _response = _requester.request(_url,
385 "DELETE",
386 body: _body,
387 queryParams: _queryParams,
388 uploadOptions: _uploadOptions,
389 uploadMedia: _uploadMedia,
390 downloadOptions: _downloadOptions);
391 return _response.then((data) => null);
392 }
393
394 /**
395 * Gets a dataset by ID.
396 *
397 * Request parameters:
398 *
399 * [datasetId] - The ID of the dataset.
400 *
401 * Completes with a [Dataset].
402 *
403 * Completes with a [common.ApiRequestError] if the API endpoint returned an
404 * error.
405 *
406 * If the used [http.Client] completes with an error when making a REST call,
407 * this method will complete with the same error.
408 */
409 async.Future<Dataset> get(core.String datasetId) {
410 var _url = null;
411 var _queryParams = new core.Map();
412 var _uploadMedia = null;
413 var _uploadOptions = null;
414 var _downloadOptions = common.DownloadOptions.Metadata;
415 var _body = null;
416
417 if (datasetId == null) {
418 throw new core.ArgumentError("Parameter datasetId is required.");
419 }
420
421
422 _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
423
424 var _response = _requester.request(_url,
425 "GET",
426 body: _body,
427 queryParams: _queryParams,
428 uploadOptions: _uploadOptions,
429 uploadMedia: _uploadMedia,
430 downloadOptions: _downloadOptions);
431 return _response.then((data) => new Dataset.fromJson(data));
432 }
433
434 /**
435 * Lists all datasets.
436 *
437 * Request parameters:
438 *
439 * [maxResults] - The maximum number of results returned by this request.
440 *
441 * [pageToken] - The continuation token, which is used to page through large
442 * result sets. To get the next page of results, set this parameter to the
443 * value of nextPageToken from the previous response.
444 *
445 * [projectId] - Only return datasets which belong to this Google Developers
446 * Console project. Only accepts project numbers. Returns all public projects
447 * if no project number is specified.
448 *
449 * Completes with a [ListDatasetsResponse].
450 *
451 * Completes with a [common.ApiRequestError] if the API endpoint returned an
452 * error.
453 *
454 * If the used [http.Client] completes with an error when making a REST call,
455 * this method will complete with the same error.
456 */
457 async.Future<ListDatasetsResponse> list({core.String maxResults, core.String p ageToken, core.String projectId}) {
458 var _url = null;
459 var _queryParams = new core.Map();
460 var _uploadMedia = null;
461 var _uploadOptions = null;
462 var _downloadOptions = common.DownloadOptions.Metadata;
463 var _body = null;
464
465 if (maxResults != null) {
466 _queryParams["maxResults"] = [maxResults];
467 }
468 if (pageToken != null) {
469 _queryParams["pageToken"] = [pageToken];
470 }
471 if (projectId != null) {
472 _queryParams["projectId"] = [projectId];
473 }
474
475
476 _url = 'datasets';
477
478 var _response = _requester.request(_url,
479 "GET",
480 body: _body,
481 queryParams: _queryParams,
482 uploadOptions: _uploadOptions,
483 uploadMedia: _uploadMedia,
484 downloadOptions: _downloadOptions);
485 return _response.then((data) => new ListDatasetsResponse.fromJson(data));
486 }
487
488 /**
489 * Updates a dataset. This method supports patch semantics.
490 *
491 * [request] - The metadata request object.
492 *
493 * Request parameters:
494 *
495 * [datasetId] - The ID of the dataset to be updated.
496 *
497 * Completes with a [Dataset].
498 *
499 * Completes with a [common.ApiRequestError] if the API endpoint returned an
500 * error.
501 *
502 * If the used [http.Client] completes with an error when making a REST call,
503 * this method will complete with the same error.
504 */
505 async.Future<Dataset> patch(Dataset request, core.String datasetId) {
506 var _url = null;
507 var _queryParams = new core.Map();
508 var _uploadMedia = null;
509 var _uploadOptions = null;
510 var _downloadOptions = common.DownloadOptions.Metadata;
511 var _body = null;
512
513 if (request != null) {
514 _body = convert.JSON.encode((request).toJson());
515 }
516 if (datasetId == null) {
517 throw new core.ArgumentError("Parameter datasetId is required.");
518 }
519
520
521 _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
522
523 var _response = _requester.request(_url,
524 "PATCH",
525 body: _body,
526 queryParams: _queryParams,
527 uploadOptions: _uploadOptions,
528 uploadMedia: _uploadMedia,
529 downloadOptions: _downloadOptions);
530 return _response.then((data) => new Dataset.fromJson(data));
531 }
532
533 /**
534 * Undeletes a dataset by restoring a dataset which was deleted via this API.
535 * This operation is only possible for a week after the deletion occurred.
536 *
537 * Request parameters:
538 *
539 * [datasetId] - The ID of the dataset to be undeleted.
540 *
541 * Completes with a [Dataset].
542 *
543 * Completes with a [common.ApiRequestError] if the API endpoint returned an
544 * error.
545 *
546 * If the used [http.Client] completes with an error when making a REST call,
547 * this method will complete with the same error.
548 */
549 async.Future<Dataset> undelete(core.String datasetId) {
550 var _url = null;
551 var _queryParams = new core.Map();
552 var _uploadMedia = null;
553 var _uploadOptions = null;
554 var _downloadOptions = common.DownloadOptions.Metadata;
555 var _body = null;
556
557 if (datasetId == null) {
558 throw new core.ArgumentError("Parameter datasetId is required.");
559 }
560
561
562 _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + ' /undelete';
563
564 var _response = _requester.request(_url,
565 "POST",
566 body: _body,
567 queryParams: _queryParams,
568 uploadOptions: _uploadOptions,
569 uploadMedia: _uploadMedia,
570 downloadOptions: _downloadOptions);
571 return _response.then((data) => new Dataset.fromJson(data));
572 }
573
574 /**
575 * Updates a dataset.
576 *
577 * [request] - The metadata request object.
578 *
579 * Request parameters:
580 *
581 * [datasetId] - The ID of the dataset to be updated.
582 *
583 * Completes with a [Dataset].
584 *
585 * Completes with a [common.ApiRequestError] if the API endpoint returned an
586 * error.
587 *
588 * If the used [http.Client] completes with an error when making a REST call,
589 * this method will complete with the same error.
590 */
591 async.Future<Dataset> update(Dataset request, core.String datasetId) {
592 var _url = null;
593 var _queryParams = new core.Map();
594 var _uploadMedia = null;
595 var _uploadOptions = null;
596 var _downloadOptions = common.DownloadOptions.Metadata;
597 var _body = null;
598
599 if (request != null) {
600 _body = convert.JSON.encode((request).toJson());
601 }
602 if (datasetId == null) {
603 throw new core.ArgumentError("Parameter datasetId is required.");
604 }
605
606
607 _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
608
609 var _response = _requester.request(_url,
610 "PUT",
611 body: _body,
612 queryParams: _queryParams,
613 uploadOptions: _uploadOptions,
614 uploadMedia: _uploadMedia,
615 downloadOptions: _downloadOptions);
616 return _response.then((data) => new Dataset.fromJson(data));
617 }
618
619 }
620
621
622 /** Not documented yet. */
623 class ExperimentalResourceApi {
624 final common_internal.ApiRequester _requester;
625
626 ExperimentalJobsResourceApi get jobs => new ExperimentalJobsResourceApi(_reque ster);
627
628 ExperimentalResourceApi(common_internal.ApiRequester client) :
629 _requester = client;
630 }
631
632
633 /** Not documented yet. */
634 class ExperimentalJobsResourceApi {
635 final common_internal.ApiRequester _requester;
636
637 ExperimentalJobsResourceApi(common_internal.ApiRequester client) :
638 _requester = client;
639
640 /**
641 * Creates and asynchronously runs an ad-hoc job. This is an experimental call
642 * and may be removed or changed at any time.
643 *
644 * [request] - The metadata request object.
645 *
646 * Request parameters:
647 *
648 * Completes with a [ExperimentalCreateJobResponse].
649 *
650 * Completes with a [common.ApiRequestError] if the API endpoint returned an
651 * error.
652 *
653 * If the used [http.Client] completes with an error when making a REST call,
654 * this method will complete with the same error.
655 */
656 async.Future<ExperimentalCreateJobResponse> create(ExperimentalCreateJobReques t request) {
657 var _url = null;
658 var _queryParams = new core.Map();
659 var _uploadMedia = null;
660 var _uploadOptions = null;
661 var _downloadOptions = common.DownloadOptions.Metadata;
662 var _body = null;
663
664 if (request != null) {
665 _body = convert.JSON.encode((request).toJson());
666 }
667
668
669 _url = 'experimental/jobs/create';
670
671 var _response = _requester.request(_url,
672 "POST",
673 body: _body,
674 queryParams: _queryParams,
675 uploadOptions: _uploadOptions,
676 uploadMedia: _uploadMedia,
677 downloadOptions: _downloadOptions);
678 return _response.then((data) => new ExperimentalCreateJobResponse.fromJson(d ata));
679 }
680
681 }
682
683
684 /** Not documented yet. */
685 class JobsResourceApi {
686 final common_internal.ApiRequester _requester;
687
688 JobsResourceApi(common_internal.ApiRequester client) :
689 _requester = client;
690
691 /**
692 * Cancels a job by ID. Note that it is possible for partial results to be
693 * generated and stored for cancelled jobs.
694 *
695 * Request parameters:
696 *
697 * [jobId] - Required. The ID of the job.
698 *
699 * Completes with a [common.ApiRequestError] if the API endpoint returned an
700 * error.
701 *
702 * If the used [http.Client] completes with an error when making a REST call,
703 * this method will complete with the same error.
704 */
705 async.Future cancel(core.String jobId) {
706 var _url = null;
707 var _queryParams = new core.Map();
708 var _uploadMedia = null;
709 var _uploadOptions = null;
710 var _downloadOptions = common.DownloadOptions.Metadata;
711 var _body = null;
712
713 if (jobId == null) {
714 throw new core.ArgumentError("Parameter jobId is required.");
715 }
716
717 _downloadOptions = null;
718
719 _url = 'jobs/' + common_internal.Escaper.ecapeVariable('$jobId') + '/cancel' ;
720
721 var _response = _requester.request(_url,
722 "POST",
723 body: _body,
724 queryParams: _queryParams,
725 uploadOptions: _uploadOptions,
726 uploadMedia: _uploadMedia,
727 downloadOptions: _downloadOptions);
728 return _response.then((data) => null);
729 }
730
731 /**
732 * Gets a job by ID.
733 *
734 * Request parameters:
735 *
736 * [jobId] - Required. The ID of the job.
737 *
738 * Completes with a [Job].
739 *
740 * Completes with a [common.ApiRequestError] if the API endpoint returned an
741 * error.
742 *
743 * If the used [http.Client] completes with an error when making a REST call,
744 * this method will complete with the same error.
745 */
746 async.Future<Job> get(core.String jobId) {
747 var _url = null;
748 var _queryParams = new core.Map();
749 var _uploadMedia = null;
750 var _uploadOptions = null;
751 var _downloadOptions = common.DownloadOptions.Metadata;
752 var _body = null;
753
754 if (jobId == null) {
755 throw new core.ArgumentError("Parameter jobId is required.");
756 }
757
758
759 _url = 'jobs/' + common_internal.Escaper.ecapeVariable('$jobId');
760
761 var _response = _requester.request(_url,
762 "GET",
763 body: _body,
764 queryParams: _queryParams,
765 uploadOptions: _uploadOptions,
766 uploadMedia: _uploadMedia,
767 downloadOptions: _downloadOptions);
768 return _response.then((data) => new Job.fromJson(data));
769 }
770
771 /**
772 * Gets a list of jobs matching the criteria.
773 *
774 * [request] - The metadata request object.
775 *
776 * Request parameters:
777 *
778 * Completes with a [SearchJobsResponse].
779 *
780 * Completes with a [common.ApiRequestError] if the API endpoint returned an
781 * error.
782 *
783 * If the used [http.Client] completes with an error when making a REST call,
784 * this method will complete with the same error.
785 */
786 async.Future<SearchJobsResponse> search(SearchJobsRequest request) {
787 var _url = null;
788 var _queryParams = new core.Map();
789 var _uploadMedia = null;
790 var _uploadOptions = null;
791 var _downloadOptions = common.DownloadOptions.Metadata;
792 var _body = null;
793
794 if (request != null) {
795 _body = convert.JSON.encode((request).toJson());
796 }
797
798
799 _url = 'jobs/search';
800
801 var _response = _requester.request(_url,
802 "POST",
803 body: _body,
804 queryParams: _queryParams,
805 uploadOptions: _uploadOptions,
806 uploadMedia: _uploadMedia,
807 downloadOptions: _downloadOptions);
808 return _response.then((data) => new SearchJobsResponse.fromJson(data));
809 }
810
811 }
812
813
814 /** Not documented yet. */
815 class ReadsResourceApi {
816 final common_internal.ApiRequester _requester;
817
818 ReadsResourceApi(common_internal.ApiRequester client) :
819 _requester = client;
820
821 /**
822 * Gets a list of reads for one or more readsets. Reads search operates over a
823 * genomic coordinate space of reference sequence & position defined over the
824 * reference sequences to which the requested readsets are aligned. If a
825 * target positional range is specified, search returns all reads whose
826 * alignment to the reference genome overlap the range. A query which
827 * specifies only readset IDs yields all reads in those readsets, including
828 * unmapped reads. All reads returned (including reads on subsequent pages)
829 * are ordered by genomic coordinate (reference sequence & position). Reads
830 * with equivalent genomic coordinates are returned in a deterministic order.
831 *
832 * [request] - The metadata request object.
833 *
834 * Request parameters:
835 *
836 * Completes with a [SearchReadsResponse].
837 *
838 * Completes with a [common.ApiRequestError] if the API endpoint returned an
839 * error.
840 *
841 * If the used [http.Client] completes with an error when making a REST call,
842 * this method will complete with the same error.
843 */
844 async.Future<SearchReadsResponse> search(SearchReadsRequest request) {
845 var _url = null;
846 var _queryParams = new core.Map();
847 var _uploadMedia = null;
848 var _uploadOptions = null;
849 var _downloadOptions = common.DownloadOptions.Metadata;
850 var _body = null;
851
852 if (request != null) {
853 _body = convert.JSON.encode((request).toJson());
854 }
855
856
857 _url = 'reads/search';
858
859 var _response = _requester.request(_url,
860 "POST",
861 body: _body,
862 queryParams: _queryParams,
863 uploadOptions: _uploadOptions,
864 uploadMedia: _uploadMedia,
865 downloadOptions: _downloadOptions);
866 return _response.then((data) => new SearchReadsResponse.fromJson(data));
867 }
868
869 }
870
871
872 /** Not documented yet. */
873 class ReadsetsResourceApi {
874 final common_internal.ApiRequester _requester;
875
876 ReadsetsCoveragebucketsResourceApi get coveragebuckets => new ReadsetsCoverage bucketsResourceApi(_requester);
877
878 ReadsetsResourceApi(common_internal.ApiRequester client) :
879 _requester = client;
880
881 /**
882 * Deletes a readset.
883 *
884 * Request parameters:
885 *
886 * [readsetId] - The ID of the readset to be deleted. The caller must have
887 * WRITE permissions to the dataset associated with this readset.
888 *
889 * Completes with a [common.ApiRequestError] if the API endpoint returned an
890 * error.
891 *
892 * If the used [http.Client] completes with an error when making a REST call,
893 * this method will complete with the same error.
894 */
895 async.Future delete(core.String readsetId) {
896 var _url = null;
897 var _queryParams = new core.Map();
898 var _uploadMedia = null;
899 var _uploadOptions = null;
900 var _downloadOptions = common.DownloadOptions.Metadata;
901 var _body = null;
902
903 if (readsetId == null) {
904 throw new core.ArgumentError("Parameter readsetId is required.");
905 }
906
907 _downloadOptions = null;
908
909 _url = 'readsets/' + common_internal.Escaper.ecapeVariable('$readsetId');
910
911 var _response = _requester.request(_url,
912 "DELETE",
913 body: _body,
914 queryParams: _queryParams,
915 uploadOptions: _uploadOptions,
916 uploadMedia: _uploadMedia,
917 downloadOptions: _downloadOptions);
918 return _response.then((data) => null);
919 }
920
921 /**
922 * Exports readsets to a BAM file in Google Cloud Storage. Note that currently
923 * there may be some differences between exported BAM files and the original
924 * BAM file at the time of import. In particular, comments in the input file
925 * header will not be preserved, and some custom tags will be converted to
926 * strings.
927 *
928 * [request] - The metadata request object.
929 *
930 * Request parameters:
931 *
932 * Completes with a [ExportReadsetsResponse].
933 *
934 * Completes with a [common.ApiRequestError] if the API endpoint returned an
935 * error.
936 *
937 * If the used [http.Client] completes with an error when making a REST call,
938 * this method will complete with the same error.
939 */
940 async.Future<ExportReadsetsResponse> export(ExportReadsetsRequest request) {
941 var _url = null;
942 var _queryParams = new core.Map();
943 var _uploadMedia = null;
944 var _uploadOptions = null;
945 var _downloadOptions = common.DownloadOptions.Metadata;
946 var _body = null;
947
948 if (request != null) {
949 _body = convert.JSON.encode((request).toJson());
950 }
951
952
953 _url = 'readsets/export';
954
955 var _response = _requester.request(_url,
956 "POST",
957 body: _body,
958 queryParams: _queryParams,
959 uploadOptions: _uploadOptions,
960 uploadMedia: _uploadMedia,
961 downloadOptions: _downloadOptions);
962 return _response.then((data) => new ExportReadsetsResponse.fromJson(data));
963 }
964
965 /**
966 * Gets a readset by ID.
967 *
968 * Request parameters:
969 *
970 * [readsetId] - The ID of the readset.
971 *
972 * Completes with a [Readset].
973 *
974 * Completes with a [common.ApiRequestError] if the API endpoint returned an
975 * error.
976 *
977 * If the used [http.Client] completes with an error when making a REST call,
978 * this method will complete with the same error.
979 */
980 async.Future<Readset> get(core.String readsetId) {
981 var _url = null;
982 var _queryParams = new core.Map();
983 var _uploadMedia = null;
984 var _uploadOptions = null;
985 var _downloadOptions = common.DownloadOptions.Metadata;
986 var _body = null;
987
988 if (readsetId == null) {
989 throw new core.ArgumentError("Parameter readsetId is required.");
990 }
991
992
993 _url = 'readsets/' + common_internal.Escaper.ecapeVariable('$readsetId');
994
995 var _response = _requester.request(_url,
996 "GET",
997 body: _body,
998 queryParams: _queryParams,
999 uploadOptions: _uploadOptions,
1000 uploadMedia: _uploadMedia,
1001 downloadOptions: _downloadOptions);
1002 return _response.then((data) => new Readset.fromJson(data));
1003 }
1004
1005 /**
1006 * Creates readsets by asynchronously importing the provided information. Note
1007 * that currently comments in the input file header are not imported and some
1008 * custom tags will be converted to strings, rather than preserving tag types.
1009 * The caller must have WRITE permissions to the dataset.
1010 *
1011 * [request] - The metadata request object.
1012 *
1013 * Request parameters:
1014 *
1015 * Completes with a [ImportReadsetsResponse].
1016 *
1017 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1018 * error.
1019 *
1020 * If the used [http.Client] completes with an error when making a REST call,
1021 * this method will complete with the same error.
1022 */
1023 async.Future<ImportReadsetsResponse> import(ImportReadsetsRequest request) {
1024 var _url = null;
1025 var _queryParams = new core.Map();
1026 var _uploadMedia = null;
1027 var _uploadOptions = null;
1028 var _downloadOptions = common.DownloadOptions.Metadata;
1029 var _body = null;
1030
1031 if (request != null) {
1032 _body = convert.JSON.encode((request).toJson());
1033 }
1034
1035
1036 _url = 'readsets/import';
1037
1038 var _response = _requester.request(_url,
1039 "POST",
1040 body: _body,
1041 queryParams: _queryParams,
1042 uploadOptions: _uploadOptions,
1043 uploadMedia: _uploadMedia,
1044 downloadOptions: _downloadOptions);
1045 return _response.then((data) => new ImportReadsetsResponse.fromJson(data));
1046 }
1047
1048 /**
1049 * Updates a readset. This method supports patch semantics.
1050 *
1051 * [request] - The metadata request object.
1052 *
1053 * Request parameters:
1054 *
1055 * [readsetId] - The ID of the readset to be updated. The caller must have
1056 * WRITE permissions to the dataset associated with this readset.
1057 *
1058 * Completes with a [Readset].
1059 *
1060 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1061 * error.
1062 *
1063 * If the used [http.Client] completes with an error when making a REST call,
1064 * this method will complete with the same error.
1065 */
1066 async.Future<Readset> patch(Readset request, core.String readsetId) {
1067 var _url = null;
1068 var _queryParams = new core.Map();
1069 var _uploadMedia = null;
1070 var _uploadOptions = null;
1071 var _downloadOptions = common.DownloadOptions.Metadata;
1072 var _body = null;
1073
1074 if (request != null) {
1075 _body = convert.JSON.encode((request).toJson());
1076 }
1077 if (readsetId == null) {
1078 throw new core.ArgumentError("Parameter readsetId is required.");
1079 }
1080
1081
1082 _url = 'readsets/' + common_internal.Escaper.ecapeVariable('$readsetId');
1083
1084 var _response = _requester.request(_url,
1085 "PATCH",
1086 body: _body,
1087 queryParams: _queryParams,
1088 uploadOptions: _uploadOptions,
1089 uploadMedia: _uploadMedia,
1090 downloadOptions: _downloadOptions);
1091 return _response.then((data) => new Readset.fromJson(data));
1092 }
1093
1094 /**
1095 * Gets a list of readsets matching the criteria.
1096 *
1097 * [request] - The metadata request object.
1098 *
1099 * Request parameters:
1100 *
1101 * Completes with a [SearchReadsetsResponse].
1102 *
1103 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1104 * error.
1105 *
1106 * If the used [http.Client] completes with an error when making a REST call,
1107 * this method will complete with the same error.
1108 */
1109 async.Future<SearchReadsetsResponse> search(SearchReadsetsRequest request) {
1110 var _url = null;
1111 var _queryParams = new core.Map();
1112 var _uploadMedia = null;
1113 var _uploadOptions = null;
1114 var _downloadOptions = common.DownloadOptions.Metadata;
1115 var _body = null;
1116
1117 if (request != null) {
1118 _body = convert.JSON.encode((request).toJson());
1119 }
1120
1121
1122 _url = 'readsets/search';
1123
1124 var _response = _requester.request(_url,
1125 "POST",
1126 body: _body,
1127 queryParams: _queryParams,
1128 uploadOptions: _uploadOptions,
1129 uploadMedia: _uploadMedia,
1130 downloadOptions: _downloadOptions);
1131 return _response.then((data) => new SearchReadsetsResponse.fromJson(data));
1132 }
1133
1134 /**
1135 * Updates a readset.
1136 *
1137 * [request] - The metadata request object.
1138 *
1139 * Request parameters:
1140 *
1141 * [readsetId] - The ID of the readset to be updated. The caller must have
1142 * WRITE permissions to the dataset associated with this readset.
1143 *
1144 * Completes with a [Readset].
1145 *
1146 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1147 * error.
1148 *
1149 * If the used [http.Client] completes with an error when making a REST call,
1150 * this method will complete with the same error.
1151 */
1152 async.Future<Readset> update(Readset request, core.String readsetId) {
1153 var _url = null;
1154 var _queryParams = new core.Map();
1155 var _uploadMedia = null;
1156 var _uploadOptions = null;
1157 var _downloadOptions = common.DownloadOptions.Metadata;
1158 var _body = null;
1159
1160 if (request != null) {
1161 _body = convert.JSON.encode((request).toJson());
1162 }
1163 if (readsetId == null) {
1164 throw new core.ArgumentError("Parameter readsetId is required.");
1165 }
1166
1167
1168 _url = 'readsets/' + common_internal.Escaper.ecapeVariable('$readsetId');
1169
1170 var _response = _requester.request(_url,
1171 "PUT",
1172 body: _body,
1173 queryParams: _queryParams,
1174 uploadOptions: _uploadOptions,
1175 uploadMedia: _uploadMedia,
1176 downloadOptions: _downloadOptions);
1177 return _response.then((data) => new Readset.fromJson(data));
1178 }
1179
1180 }
1181
1182
1183 /** Not documented yet. */
1184 class ReadsetsCoveragebucketsResourceApi {
1185 final common_internal.ApiRequester _requester;
1186
1187 ReadsetsCoveragebucketsResourceApi(common_internal.ApiRequester client) :
1188 _requester = client;
1189
1190 /**
1191 * Lists fixed width coverage buckets for a readset, each of which correspond
1192 * to a range of a reference sequence. Each bucket summarizes coverage
1193 * information across its corresponding genomic range. Coverage is defined as
1194 * the number of reads which are aligned to a given base in the reference
1195 * sequence. Coverage buckets are available at various bucket widths, enabling
1196 * various coverage "zoom levels". The caller must have READ permissions for
1197 * the target readset.
1198 *
1199 * Request parameters:
1200 *
1201 * [readsetId] - Required. The ID of the readset over which coverage is
1202 * requested.
1203 *
1204 * [maxResults] - The maximum number of results to return in a single page. If
1205 * unspecified, defaults to 1024. The maximum value is 2048.
1206 *
1207 * [pageToken] - The continuation token, which is used to page through large
1208 * result sets. To get the next page of results, set this parameter to the
1209 * value of nextPageToken from the previous response.
1210 *
1211 * [range_sequenceEnd] - The end position of the range on the reference,
1212 * 1-based exclusive. If specified, sequenceName must also be specified.
1213 *
1214 * [range_sequenceName] - The reference sequence name, for example chr1, 1, or
1215 * chrX.
1216 *
1217 * [range_sequenceStart] - The start position of the range on the reference,
1218 * 1-based inclusive. If specified, sequenceName must also be specified.
1219 *
1220 * [targetBucketWidth] - The desired width of each reported coverage bucket in
1221 * base pairs. This will be rounded down to the nearest precomputed bucket
1222 * width; the value of which is returned as bucketWidth in the response.
1223 * Defaults to infinity (each bucket spans an entire reference sequence) or
1224 * the length of the target range, if specified. The smallest precomputed
1225 * bucketWidth is currently 2048 base pairs; this is subject to change.
1226 *
1227 * Completes with a [ListCoverageBucketsResponse].
1228 *
1229 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1230 * error.
1231 *
1232 * If the used [http.Client] completes with an error when making a REST call,
1233 * this method will complete with the same error.
1234 */
1235 async.Future<ListCoverageBucketsResponse> list(core.String readsetId, {core.St ring maxResults, core.String pageToken, core.String range_sequenceEnd, core.Stri ng range_sequenceName, core.String range_sequenceStart, core.String targetBucket Width}) {
1236 var _url = null;
1237 var _queryParams = new core.Map();
1238 var _uploadMedia = null;
1239 var _uploadOptions = null;
1240 var _downloadOptions = common.DownloadOptions.Metadata;
1241 var _body = null;
1242
1243 if (readsetId == null) {
1244 throw new core.ArgumentError("Parameter readsetId is required.");
1245 }
1246 if (maxResults != null) {
1247 _queryParams["maxResults"] = [maxResults];
1248 }
1249 if (pageToken != null) {
1250 _queryParams["pageToken"] = [pageToken];
1251 }
1252 if (range_sequenceEnd != null) {
1253 _queryParams["range.sequenceEnd"] = [range_sequenceEnd];
1254 }
1255 if (range_sequenceName != null) {
1256 _queryParams["range.sequenceName"] = [range_sequenceName];
1257 }
1258 if (range_sequenceStart != null) {
1259 _queryParams["range.sequenceStart"] = [range_sequenceStart];
1260 }
1261 if (targetBucketWidth != null) {
1262 _queryParams["targetBucketWidth"] = [targetBucketWidth];
1263 }
1264
1265
1266 _url = 'readsets/' + common_internal.Escaper.ecapeVariable('$readsetId') + ' /coveragebuckets';
1267
1268 var _response = _requester.request(_url,
1269 "GET",
1270 body: _body,
1271 queryParams: _queryParams,
1272 uploadOptions: _uploadOptions,
1273 uploadMedia: _uploadMedia,
1274 downloadOptions: _downloadOptions);
1275 return _response.then((data) => new ListCoverageBucketsResponse.fromJson(dat a));
1276 }
1277
1278 }
1279
1280
1281 /** Not documented yet. */
1282 class VariantsResourceApi {
1283 final common_internal.ApiRequester _requester;
1284
1285 VariantsResourceApi(common_internal.ApiRequester client) :
1286 _requester = client;
1287
1288 /**
1289 * Creates a new variant.
1290 *
1291 * [request] - The metadata request object.
1292 *
1293 * Request parameters:
1294 *
1295 * Completes with a [Variant].
1296 *
1297 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1298 * error.
1299 *
1300 * If the used [http.Client] completes with an error when making a REST call,
1301 * this method will complete with the same error.
1302 */
1303 async.Future<Variant> create(Variant request) {
1304 var _url = null;
1305 var _queryParams = new core.Map();
1306 var _uploadMedia = null;
1307 var _uploadOptions = null;
1308 var _downloadOptions = common.DownloadOptions.Metadata;
1309 var _body = null;
1310
1311 if (request != null) {
1312 _body = convert.JSON.encode((request).toJson());
1313 }
1314
1315
1316 _url = 'variants';
1317
1318 var _response = _requester.request(_url,
1319 "POST",
1320 body: _body,
1321 queryParams: _queryParams,
1322 uploadOptions: _uploadOptions,
1323 uploadMedia: _uploadMedia,
1324 downloadOptions: _downloadOptions);
1325 return _response.then((data) => new Variant.fromJson(data));
1326 }
1327
1328 /**
1329 * Deletes a variant.
1330 *
1331 * Request parameters:
1332 *
1333 * [variantId] - The ID of the variant to be deleted.
1334 *
1335 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1336 * error.
1337 *
1338 * If the used [http.Client] completes with an error when making a REST call,
1339 * this method will complete with the same error.
1340 */
1341 async.Future delete(core.String variantId) {
1342 var _url = null;
1343 var _queryParams = new core.Map();
1344 var _uploadMedia = null;
1345 var _uploadOptions = null;
1346 var _downloadOptions = common.DownloadOptions.Metadata;
1347 var _body = null;
1348
1349 if (variantId == null) {
1350 throw new core.ArgumentError("Parameter variantId is required.");
1351 }
1352
1353 _downloadOptions = null;
1354
1355 _url = 'variants/' + common_internal.Escaper.ecapeVariable('$variantId');
1356
1357 var _response = _requester.request(_url,
1358 "DELETE",
1359 body: _body,
1360 queryParams: _queryParams,
1361 uploadOptions: _uploadOptions,
1362 uploadMedia: _uploadMedia,
1363 downloadOptions: _downloadOptions);
1364 return _response.then((data) => null);
1365 }
1366
1367 /**
1368 * Exports variant data to an external destination.
1369 *
1370 * [request] - The metadata request object.
1371 *
1372 * Request parameters:
1373 *
1374 * Completes with a [ExportVariantsResponse].
1375 *
1376 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1377 * error.
1378 *
1379 * If the used [http.Client] completes with an error when making a REST call,
1380 * this method will complete with the same error.
1381 */
1382 async.Future<ExportVariantsResponse> export(ExportVariantsRequest request) {
1383 var _url = null;
1384 var _queryParams = new core.Map();
1385 var _uploadMedia = null;
1386 var _uploadOptions = null;
1387 var _downloadOptions = common.DownloadOptions.Metadata;
1388 var _body = null;
1389
1390 if (request != null) {
1391 _body = convert.JSON.encode((request).toJson());
1392 }
1393
1394
1395 _url = 'variants/export';
1396
1397 var _response = _requester.request(_url,
1398 "POST",
1399 body: _body,
1400 queryParams: _queryParams,
1401 uploadOptions: _uploadOptions,
1402 uploadMedia: _uploadMedia,
1403 downloadOptions: _downloadOptions);
1404 return _response.then((data) => new ExportVariantsResponse.fromJson(data));
1405 }
1406
1407 /**
1408 * Gets a variant by ID.
1409 *
1410 * Request parameters:
1411 *
1412 * [variantId] - The ID of the variant.
1413 *
1414 * Completes with a [Variant].
1415 *
1416 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1417 * error.
1418 *
1419 * If the used [http.Client] completes with an error when making a REST call,
1420 * this method will complete with the same error.
1421 */
1422 async.Future<Variant> get(core.String variantId) {
1423 var _url = null;
1424 var _queryParams = new core.Map();
1425 var _uploadMedia = null;
1426 var _uploadOptions = null;
1427 var _downloadOptions = common.DownloadOptions.Metadata;
1428 var _body = null;
1429
1430 if (variantId == null) {
1431 throw new core.ArgumentError("Parameter variantId is required.");
1432 }
1433
1434
1435 _url = 'variants/' + common_internal.Escaper.ecapeVariable('$variantId');
1436
1437 var _response = _requester.request(_url,
1438 "GET",
1439 body: _body,
1440 queryParams: _queryParams,
1441 uploadOptions: _uploadOptions,
1442 uploadMedia: _uploadMedia,
1443 downloadOptions: _downloadOptions);
1444 return _response.then((data) => new Variant.fromJson(data));
1445 }
1446
1447 /**
1448 * Creates variant data by asynchronously importing the provided information.
1449 * The variants for import will be merged with any existing data and each
1450 * other according to the behavior of mergeVariants. In particular, this means
1451 * for merged VCF variants that have conflicting INFO fields, some data will
1452 * be arbitrarily discarded. As a special case, for single-sample VCF files,
1453 * QUAL and FILTER fields will be moved to the call level; these are sometimes
1454 * interpreted in a call-specific context. Imported VCF headers are appended
1455 * to the metadata already in a variant set.
1456 *
1457 * [request] - The metadata request object.
1458 *
1459 * Request parameters:
1460 *
1461 * Completes with a [ImportVariantsResponse].
1462 *
1463 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1464 * error.
1465 *
1466 * If the used [http.Client] completes with an error when making a REST call,
1467 * this method will complete with the same error.
1468 */
1469 async.Future<ImportVariantsResponse> import(ImportVariantsRequest request) {
1470 var _url = null;
1471 var _queryParams = new core.Map();
1472 var _uploadMedia = null;
1473 var _uploadOptions = null;
1474 var _downloadOptions = common.DownloadOptions.Metadata;
1475 var _body = null;
1476
1477 if (request != null) {
1478 _body = convert.JSON.encode((request).toJson());
1479 }
1480
1481
1482 _url = 'variants/import';
1483
1484 var _response = _requester.request(_url,
1485 "POST",
1486 body: _body,
1487 queryParams: _queryParams,
1488 uploadOptions: _uploadOptions,
1489 uploadMedia: _uploadMedia,
1490 downloadOptions: _downloadOptions);
1491 return _response.then((data) => new ImportVariantsResponse.fromJson(data));
1492 }
1493
1494 /**
1495 * Gets a list of variants matching the criteria.
1496 *
1497 * Implements GlobalAllianceApi.searchVariants.
1498 *
1499 * [request] - The metadata request object.
1500 *
1501 * Request parameters:
1502 *
1503 * Completes with a [SearchVariantsResponse].
1504 *
1505 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1506 * error.
1507 *
1508 * If the used [http.Client] completes with an error when making a REST call,
1509 * this method will complete with the same error.
1510 */
1511 async.Future<SearchVariantsResponse> search(SearchVariantsRequest request) {
1512 var _url = null;
1513 var _queryParams = new core.Map();
1514 var _uploadMedia = null;
1515 var _uploadOptions = null;
1516 var _downloadOptions = common.DownloadOptions.Metadata;
1517 var _body = null;
1518
1519 if (request != null) {
1520 _body = convert.JSON.encode((request).toJson());
1521 }
1522
1523
1524 _url = 'variants/search';
1525
1526 var _response = _requester.request(_url,
1527 "POST",
1528 body: _body,
1529 queryParams: _queryParams,
1530 uploadOptions: _uploadOptions,
1531 uploadMedia: _uploadMedia,
1532 downloadOptions: _downloadOptions);
1533 return _response.then((data) => new SearchVariantsResponse.fromJson(data));
1534 }
1535
1536 /**
1537 * Updates a variant's names and info fields. All other modifications are
1538 * silently ignored. Returns the modified variant without its calls.
1539 *
1540 * [request] - The metadata request object.
1541 *
1542 * Request parameters:
1543 *
1544 * [variantId] - The ID of the variant to be updated.
1545 *
1546 * Completes with a [Variant].
1547 *
1548 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1549 * error.
1550 *
1551 * If the used [http.Client] completes with an error when making a REST call,
1552 * this method will complete with the same error.
1553 */
1554 async.Future<Variant> update(Variant request, core.String variantId) {
1555 var _url = null;
1556 var _queryParams = new core.Map();
1557 var _uploadMedia = null;
1558 var _uploadOptions = null;
1559 var _downloadOptions = common.DownloadOptions.Metadata;
1560 var _body = null;
1561
1562 if (request != null) {
1563 _body = convert.JSON.encode((request).toJson());
1564 }
1565 if (variantId == null) {
1566 throw new core.ArgumentError("Parameter variantId is required.");
1567 }
1568
1569
1570 _url = 'variants/' + common_internal.Escaper.ecapeVariable('$variantId');
1571
1572 var _response = _requester.request(_url,
1573 "PUT",
1574 body: _body,
1575 queryParams: _queryParams,
1576 uploadOptions: _uploadOptions,
1577 uploadMedia: _uploadMedia,
1578 downloadOptions: _downloadOptions);
1579 return _response.then((data) => new Variant.fromJson(data));
1580 }
1581
1582 }
1583
1584
1585 /** Not documented yet. */
1586 class VariantsetsResourceApi {
1587 final common_internal.ApiRequester _requester;
1588
1589 VariantsetsResourceApi(common_internal.ApiRequester client) :
1590 _requester = client;
1591
1592 /**
1593 * Deletes the contents of a variant set. The variant set object is not
1594 * deleted.
1595 *
1596 * Request parameters:
1597 *
1598 * [variantSetId] - The ID of the variant set to be deleted.
1599 *
1600 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1601 * error.
1602 *
1603 * If the used [http.Client] completes with an error when making a REST call,
1604 * this method will complete with the same error.
1605 */
1606 async.Future delete(core.String variantSetId) {
1607 var _url = null;
1608 var _queryParams = new core.Map();
1609 var _uploadMedia = null;
1610 var _uploadOptions = null;
1611 var _downloadOptions = common.DownloadOptions.Metadata;
1612 var _body = null;
1613
1614 if (variantSetId == null) {
1615 throw new core.ArgumentError("Parameter variantSetId is required.");
1616 }
1617
1618 _downloadOptions = null;
1619
1620 _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId ');
1621
1622 var _response = _requester.request(_url,
1623 "DELETE",
1624 body: _body,
1625 queryParams: _queryParams,
1626 uploadOptions: _uploadOptions,
1627 uploadMedia: _uploadMedia,
1628 downloadOptions: _downloadOptions);
1629 return _response.then((data) => null);
1630 }
1631
1632 /**
1633 * Gets a variant set by ID.
1634 *
1635 * Request parameters:
1636 *
1637 * [variantSetId] - Required. The ID of the variant set.
1638 *
1639 * Completes with a [VariantSet].
1640 *
1641 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1642 * error.
1643 *
1644 * If the used [http.Client] completes with an error when making a REST call,
1645 * this method will complete with the same error.
1646 */
1647 async.Future<VariantSet> get(core.String variantSetId) {
1648 var _url = null;
1649 var _queryParams = new core.Map();
1650 var _uploadMedia = null;
1651 var _uploadOptions = null;
1652 var _downloadOptions = common.DownloadOptions.Metadata;
1653 var _body = null;
1654
1655 if (variantSetId == null) {
1656 throw new core.ArgumentError("Parameter variantSetId is required.");
1657 }
1658
1659
1660 _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId ');
1661
1662 var _response = _requester.request(_url,
1663 "GET",
1664 body: _body,
1665 queryParams: _queryParams,
1666 uploadOptions: _uploadOptions,
1667 uploadMedia: _uploadMedia,
1668 downloadOptions: _downloadOptions);
1669 return _response.then((data) => new VariantSet.fromJson(data));
1670 }
1671
1672 /**
1673 * Merges the given variants with existing variants. Each variant will be
1674 * merged with an existing variant that matches its reference sequence, start,
1675 * end, reference bases, and alternative bases. If no such variant exists, a
1676 * new one will be created.
1677 *
1678 * When variants are merged, the call information from the new variant is
1679 * added to the existing variant, and other fields (such as key/value pairs)
1680 * are discarded.
1681 *
1682 * [request] - The metadata request object.
1683 *
1684 * Request parameters:
1685 *
1686 * [variantSetId] - The destination variant set.
1687 *
1688 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1689 * error.
1690 *
1691 * If the used [http.Client] completes with an error when making a REST call,
1692 * this method will complete with the same error.
1693 */
1694 async.Future mergeVariants(MergeVariantsRequest request, core.String variantSe tId) {
1695 var _url = null;
1696 var _queryParams = new core.Map();
1697 var _uploadMedia = null;
1698 var _uploadOptions = null;
1699 var _downloadOptions = common.DownloadOptions.Metadata;
1700 var _body = null;
1701
1702 if (request != null) {
1703 _body = convert.JSON.encode((request).toJson());
1704 }
1705 if (variantSetId == null) {
1706 throw new core.ArgumentError("Parameter variantSetId is required.");
1707 }
1708
1709 _downloadOptions = null;
1710
1711 _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId ') + '/mergeVariants';
1712
1713 var _response = _requester.request(_url,
1714 "POST",
1715 body: _body,
1716 queryParams: _queryParams,
1717 uploadOptions: _uploadOptions,
1718 uploadMedia: _uploadMedia,
1719 downloadOptions: _downloadOptions);
1720 return _response.then((data) => null);
1721 }
1722
1723 /**
1724 * Updates a variant set's metadata. All other modifications are silently
1725 * ignored. This method supports patch semantics.
1726 *
1727 * [request] - The metadata request object.
1728 *
1729 * Request parameters:
1730 *
1731 * [variantSetId] - The ID of the variant to be updated.
1732 *
1733 * Completes with a [VariantSet].
1734 *
1735 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1736 * error.
1737 *
1738 * If the used [http.Client] completes with an error when making a REST call,
1739 * this method will complete with the same error.
1740 */
1741 async.Future<VariantSet> patch(VariantSet request, core.String variantSetId) {
1742 var _url = null;
1743 var _queryParams = new core.Map();
1744 var _uploadMedia = null;
1745 var _uploadOptions = null;
1746 var _downloadOptions = common.DownloadOptions.Metadata;
1747 var _body = null;
1748
1749 if (request != null) {
1750 _body = convert.JSON.encode((request).toJson());
1751 }
1752 if (variantSetId == null) {
1753 throw new core.ArgumentError("Parameter variantSetId is required.");
1754 }
1755
1756
1757 _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId ');
1758
1759 var _response = _requester.request(_url,
1760 "PATCH",
1761 body: _body,
1762 queryParams: _queryParams,
1763 uploadOptions: _uploadOptions,
1764 uploadMedia: _uploadMedia,
1765 downloadOptions: _downloadOptions);
1766 return _response.then((data) => new VariantSet.fromJson(data));
1767 }
1768
1769 /**
1770 * Returns a list of all variant sets matching search criteria.
1771 *
1772 * Implements GlobalAllianceApi.searchVariantSets.
1773 *
1774 * [request] - The metadata request object.
1775 *
1776 * Request parameters:
1777 *
1778 * Completes with a [SearchVariantSetsResponse].
1779 *
1780 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1781 * error.
1782 *
1783 * If the used [http.Client] completes with an error when making a REST call,
1784 * this method will complete with the same error.
1785 */
1786 async.Future<SearchVariantSetsResponse> search(SearchVariantSetsRequest reques t) {
1787 var _url = null;
1788 var _queryParams = new core.Map();
1789 var _uploadMedia = null;
1790 var _uploadOptions = null;
1791 var _downloadOptions = common.DownloadOptions.Metadata;
1792 var _body = null;
1793
1794 if (request != null) {
1795 _body = convert.JSON.encode((request).toJson());
1796 }
1797
1798
1799 _url = 'variantsets/search';
1800
1801 var _response = _requester.request(_url,
1802 "POST",
1803 body: _body,
1804 queryParams: _queryParams,
1805 uploadOptions: _uploadOptions,
1806 uploadMedia: _uploadMedia,
1807 downloadOptions: _downloadOptions);
1808 return _response.then((data) => new SearchVariantSetsResponse.fromJson(data) );
1809 }
1810
1811 /**
1812 * Updates a variant set's metadata. All other modifications are silently
1813 * ignored.
1814 *
1815 * [request] - The metadata request object.
1816 *
1817 * Request parameters:
1818 *
1819 * [variantSetId] - The ID of the variant to be updated.
1820 *
1821 * Completes with a [VariantSet].
1822 *
1823 * Completes with a [common.ApiRequestError] if the API endpoint returned an
1824 * error.
1825 *
1826 * If the used [http.Client] completes with an error when making a REST call,
1827 * this method will complete with the same error.
1828 */
1829 async.Future<VariantSet> update(VariantSet request, core.String variantSetId) {
1830 var _url = null;
1831 var _queryParams = new core.Map();
1832 var _uploadMedia = null;
1833 var _uploadOptions = null;
1834 var _downloadOptions = common.DownloadOptions.Metadata;
1835 var _body = null;
1836
1837 if (request != null) {
1838 _body = convert.JSON.encode((request).toJson());
1839 }
1840 if (variantSetId == null) {
1841 throw new core.ArgumentError("Parameter variantSetId is required.");
1842 }
1843
1844
1845 _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId ');
1846
1847 var _response = _requester.request(_url,
1848 "PUT",
1849 body: _body,
1850 queryParams: _queryParams,
1851 uploadOptions: _uploadOptions,
1852 uploadMedia: _uploadMedia,
1853 downloadOptions: _downloadOptions);
1854 return _response.then((data) => new VariantSet.fromJson(data));
1855 }
1856
1857 }
1858
1859
1860
1861 /**
1862 * A call represents the determination of genotype with respect to a particular
1863 * variant. It may include associated information such as quality and phasing.
1864 * For example, a call might assign a probability of 0.32 to the occurrence of a
1865 * SNP named rs1234 in a call set with the name NA12345.
1866 */
1867 class Call {
1868 /** The ID of the call set this variant call belongs to. */
1869 core.String callSetId;
1870
1871 /** The name of the call set this variant call belongs to. */
1872 core.String callSetName;
1873
1874 /**
1875 * The genotype of this variant call. Each value represents either the value
1876 * of the referenceBases field or a 1-based index into alternateBases. If a
1877 * variant had a referenceBases value of T and an alternateBases value of
1878 * ["A", "C"], and the genotype was [2, 1], that would mean the call
1879 * represented the heterozygous value CA for this variant. If the genotype was
1880 * instead [0, 1], the represented value would be TA. Ordering of the genotype
1881 * values is important if the phaseset is present. If a genotype is not called
1882 * (that is, a . is present in the GT string) -1 is returned.
1883 */
1884 core.List<core.int> genotype;
1885
1886 /**
1887 * The genotype likelihoods for this variant call. Each array entry represents
1888 * how likely a specific genotype is for this call. The value ordering is
1889 * defined by the GL tag in the VCF spec. If Phred-scaled genotype likelihood
1890 * scores (PL) are available and log10(P) genotype likelihood scores (GL) are
1891 * not, PL scores are converted to GL scores. If both are available, PL scores
1892 * are stored in info.
1893 */
1894 core.List<core.double> genotypeLikelihood;
1895
1896 /** A map of additional variant call information. */
1897 core.Map<core.String, core.List<core.String>> info;
1898
1899 /**
1900 * If this field is present, this variant call's genotype ordering implies the
1901 * phase of the bases and is consistent with any other variant calls in the
1902 * same reference sequence which have the same phaseset value. When importing
1903 * data from VCF, if the genotype data was phased but no phase set was
1904 * specified this field will be set to *.
1905 */
1906 core.String phaseset;
1907
1908
1909 Call();
1910
1911 Call.fromJson(core.Map _json) {
1912 if (_json.containsKey("callSetId")) {
1913 callSetId = _json["callSetId"];
1914 }
1915 if (_json.containsKey("callSetName")) {
1916 callSetName = _json["callSetName"];
1917 }
1918 if (_json.containsKey("genotype")) {
1919 genotype = _json["genotype"];
1920 }
1921 if (_json.containsKey("genotypeLikelihood")) {
1922 genotypeLikelihood = _json["genotypeLikelihood"];
1923 }
1924 if (_json.containsKey("info")) {
1925 info = _json["info"];
1926 }
1927 if (_json.containsKey("phaseset")) {
1928 phaseset = _json["phaseset"];
1929 }
1930 }
1931
1932 core.Map toJson() {
1933 var _json = new core.Map();
1934 if (callSetId != null) {
1935 _json["callSetId"] = callSetId;
1936 }
1937 if (callSetName != null) {
1938 _json["callSetName"] = callSetName;
1939 }
1940 if (genotype != null) {
1941 _json["genotype"] = genotype;
1942 }
1943 if (genotypeLikelihood != null) {
1944 _json["genotypeLikelihood"] = genotypeLikelihood;
1945 }
1946 if (info != null) {
1947 _json["info"] = info;
1948 }
1949 if (phaseset != null) {
1950 _json["phaseset"] = phaseset;
1951 }
1952 return _json;
1953 }
1954 }
1955
1956
1957 /**
1958 * A call set is a collection of variant calls, typically for one sample. It
1959 * belongs to a variant set.
1960 */
1961 class CallSet {
1962 /** The date this call set was created in milliseconds from the epoch. */
1963 core.String created;
1964
1965 /** The Google generated ID of the call set, immutable. */
1966 core.String id;
1967
1968 /** A map of additional call set information. */
1969 core.Map<core.String, core.List<core.String>> info;
1970
1971 /** The call set name. */
1972 core.String name;
1973
1974 /** The sample ID this call set corresponds to. */
1975 core.String sampleId;
1976
1977 /** The IDs of the variant sets this call set belongs to. */
1978 core.List<core.String> variantSetIds;
1979
1980
1981 CallSet();
1982
1983 CallSet.fromJson(core.Map _json) {
1984 if (_json.containsKey("created")) {
1985 created = _json["created"];
1986 }
1987 if (_json.containsKey("id")) {
1988 id = _json["id"];
1989 }
1990 if (_json.containsKey("info")) {
1991 info = _json["info"];
1992 }
1993 if (_json.containsKey("name")) {
1994 name = _json["name"];
1995 }
1996 if (_json.containsKey("sampleId")) {
1997 sampleId = _json["sampleId"];
1998 }
1999 if (_json.containsKey("variantSetIds")) {
2000 variantSetIds = _json["variantSetIds"];
2001 }
2002 }
2003
2004 core.Map toJson() {
2005 var _json = new core.Map();
2006 if (created != null) {
2007 _json["created"] = created;
2008 }
2009 if (id != null) {
2010 _json["id"] = id;
2011 }
2012 if (info != null) {
2013 _json["info"] = info;
2014 }
2015 if (name != null) {
2016 _json["name"] = name;
2017 }
2018 if (sampleId != null) {
2019 _json["sampleId"] = sampleId;
2020 }
2021 if (variantSetIds != null) {
2022 _json["variantSetIds"] = variantSetIds;
2023 }
2024 return _json;
2025 }
2026 }
2027
2028
2029 /**
2030 * A bucket over which read coverage has been precomputed. A bucket corresponds
2031 * to a specific range of the reference sequence.
2032 */
2033 class CoverageBucket {
2034 /**
2035 * The average number of reads which are aligned to each individual reference
2036 * base in this bucket.
2037 */
2038 core.double meanCoverage;
2039
2040 /** The genomic coordinate range spanned by this bucket. */
2041 GenomicRange range;
2042
2043
2044 CoverageBucket();
2045
2046 CoverageBucket.fromJson(core.Map _json) {
2047 if (_json.containsKey("meanCoverage")) {
2048 meanCoverage = _json["meanCoverage"];
2049 }
2050 if (_json.containsKey("range")) {
2051 range = new GenomicRange.fromJson(_json["range"]);
2052 }
2053 }
2054
2055 core.Map toJson() {
2056 var _json = new core.Map();
2057 if (meanCoverage != null) {
2058 _json["meanCoverage"] = meanCoverage;
2059 }
2060 if (range != null) {
2061 _json["range"] = (range).toJson();
2062 }
2063 return _json;
2064 }
2065 }
2066
2067
2068 /** A Dataset is a collection of genomic data. */
2069 class Dataset {
2070 /** The Google generated ID of the dataset, immutable. */
2071 core.String id;
2072
2073 /**
2074 * Flag indicating whether or not a dataset is publicly viewable. If a dataset
2075 * is not public, it inherits viewing permissions from its project.
2076 */
2077 core.bool isPublic;
2078
2079 /** The dataset name. */
2080 core.String name;
2081
2082 /**
2083 * The Google Developers Console project number that this dataset belongs to.
2084 */
2085 core.String projectId;
2086
2087
2088 Dataset();
2089
2090 Dataset.fromJson(core.Map _json) {
2091 if (_json.containsKey("id")) {
2092 id = _json["id"];
2093 }
2094 if (_json.containsKey("isPublic")) {
2095 isPublic = _json["isPublic"];
2096 }
2097 if (_json.containsKey("name")) {
2098 name = _json["name"];
2099 }
2100 if (_json.containsKey("projectId")) {
2101 projectId = _json["projectId"];
2102 }
2103 }
2104
2105 core.Map toJson() {
2106 var _json = new core.Map();
2107 if (id != null) {
2108 _json["id"] = id;
2109 }
2110 if (isPublic != null) {
2111 _json["isPublic"] = isPublic;
2112 }
2113 if (name != null) {
2114 _json["name"] = name;
2115 }
2116 if (projectId != null) {
2117 _json["projectId"] = projectId;
2118 }
2119 return _json;
2120 }
2121 }
2122
2123
2124 /** The job creation request. */
2125 class ExperimentalCreateJobRequest {
2126 /**
2127 * Specifies whether or not to run the alignment pipeline. Either align or
2128 * callVariants must be set.
2129 */
2130 core.bool align;
2131
2132 /**
2133 * Specifies whether or not to run the variant calling pipeline. Either align
2134 * or callVariants must be set.
2135 */
2136 core.bool callVariants;
2137
2138 /**
2139 * Specifies where to copy the results of certain pipelines. This should be in
2140 * the form of gs://bucket/path.
2141 */
2142 core.String gcsOutputPath;
2143
2144 /**
2145 * A list of Google Cloud Storage URIs of paired end .fastq files to operate
2146 * upon. If specified, this represents the second file of each paired .fastq
2147 * file. The first file of each pair should be specified in sourceUris.
2148 */
2149 core.List<core.String> pairedSourceUris;
2150
2151 /**
2152 * Required. The Google Cloud Project ID with which to associate the request.
2153 */
2154 core.String projectId;
2155
2156 /**
2157 * A list of Google Cloud Storage URIs of data files to operate upon. These
2158 * can be .bam, interleaved .fastq, or paired .fastq. If specifying paired
2159 * .fastq files, the first of each pair of files should be listed here, and
2160 * the second of each pair should be listed in pairedSourceUris.
2161 */
2162 core.List<core.String> sourceUris;
2163
2164
2165 ExperimentalCreateJobRequest();
2166
2167 ExperimentalCreateJobRequest.fromJson(core.Map _json) {
2168 if (_json.containsKey("align")) {
2169 align = _json["align"];
2170 }
2171 if (_json.containsKey("callVariants")) {
2172 callVariants = _json["callVariants"];
2173 }
2174 if (_json.containsKey("gcsOutputPath")) {
2175 gcsOutputPath = _json["gcsOutputPath"];
2176 }
2177 if (_json.containsKey("pairedSourceUris")) {
2178 pairedSourceUris = _json["pairedSourceUris"];
2179 }
2180 if (_json.containsKey("projectId")) {
2181 projectId = _json["projectId"];
2182 }
2183 if (_json.containsKey("sourceUris")) {
2184 sourceUris = _json["sourceUris"];
2185 }
2186 }
2187
2188 core.Map toJson() {
2189 var _json = new core.Map();
2190 if (align != null) {
2191 _json["align"] = align;
2192 }
2193 if (callVariants != null) {
2194 _json["callVariants"] = callVariants;
2195 }
2196 if (gcsOutputPath != null) {
2197 _json["gcsOutputPath"] = gcsOutputPath;
2198 }
2199 if (pairedSourceUris != null) {
2200 _json["pairedSourceUris"] = pairedSourceUris;
2201 }
2202 if (projectId != null) {
2203 _json["projectId"] = projectId;
2204 }
2205 if (sourceUris != null) {
2206 _json["sourceUris"] = sourceUris;
2207 }
2208 return _json;
2209 }
2210 }
2211
2212
2213 /** The job creation response. */
2214 class ExperimentalCreateJobResponse {
2215 /** A job ID that can be used to get status information. */
2216 core.String jobId;
2217
2218
2219 ExperimentalCreateJobResponse();
2220
2221 ExperimentalCreateJobResponse.fromJson(core.Map _json) {
2222 if (_json.containsKey("jobId")) {
2223 jobId = _json["jobId"];
2224 }
2225 }
2226
2227 core.Map toJson() {
2228 var _json = new core.Map();
2229 if (jobId != null) {
2230 _json["jobId"] = jobId;
2231 }
2232 return _json;
2233 }
2234 }
2235
2236
2237 /** The readset export request. */
2238 class ExportReadsetsRequest {
2239 /**
2240 * A Google Cloud Storage URI where the exported BAM file will be created. The
2241 * currently authenticated user must have write access to the new file
2242 * location. An error will be returned if the URI already contains data.
2243 */
2244 core.String exportUri;
2245
2246 /** The Google Developers Console project number that owns this export. */
2247 core.String projectId;
2248
2249 /** The IDs of the readsets to export. */
2250 core.List<core.String> readsetIds;
2251
2252 /**
2253 * The reference names to export. If this is not specified, all reference
2254 * sequences, including unmapped reads, are exported. Use * to export only
2255 * unmapped reads.
2256 */
2257 core.List<core.String> referenceNames;
2258
2259
2260 ExportReadsetsRequest();
2261
2262 ExportReadsetsRequest.fromJson(core.Map _json) {
2263 if (_json.containsKey("exportUri")) {
2264 exportUri = _json["exportUri"];
2265 }
2266 if (_json.containsKey("projectId")) {
2267 projectId = _json["projectId"];
2268 }
2269 if (_json.containsKey("readsetIds")) {
2270 readsetIds = _json["readsetIds"];
2271 }
2272 if (_json.containsKey("referenceNames")) {
2273 referenceNames = _json["referenceNames"];
2274 }
2275 }
2276
2277 core.Map toJson() {
2278 var _json = new core.Map();
2279 if (exportUri != null) {
2280 _json["exportUri"] = exportUri;
2281 }
2282 if (projectId != null) {
2283 _json["projectId"] = projectId;
2284 }
2285 if (readsetIds != null) {
2286 _json["readsetIds"] = readsetIds;
2287 }
2288 if (referenceNames != null) {
2289 _json["referenceNames"] = referenceNames;
2290 }
2291 return _json;
2292 }
2293 }
2294
2295
2296 /** The readset export response. */
2297 class ExportReadsetsResponse {
2298 /** A job ID that can be used to get status information. */
2299 core.String jobId;
2300
2301
2302 ExportReadsetsResponse();
2303
2304 ExportReadsetsResponse.fromJson(core.Map _json) {
2305 if (_json.containsKey("jobId")) {
2306 jobId = _json["jobId"];
2307 }
2308 }
2309
2310 core.Map toJson() {
2311 var _json = new core.Map();
2312 if (jobId != null) {
2313 _json["jobId"] = jobId;
2314 }
2315 return _json;
2316 }
2317 }
2318
2319
2320 /** The variant data export request. */
2321 class ExportVariantsRequest {
2322 /**
2323 * The BigQuery dataset to export data to. Note that this is distinct from the
2324 * Genomics concept of "dataset".
2325 */
2326 core.String bigqueryDataset;
2327
2328 /**
2329 * The BigQuery table to export data to. If the table doesn't exist, it will
2330 * be created. If it already exists, it will be overwritten.
2331 */
2332 core.String bigqueryTable;
2333
2334 /**
2335 * If provided, only variant call information from the specified call sets
2336 * will be exported. By default all variant calls are exported.
2337 */
2338 core.List<core.String> callSetIds;
2339
2340 /**
2341 * The format for the exported data.
2342 * Possible string values are:
2343 * - "bigquery"
2344 */
2345 core.String format;
2346
2347 /**
2348 * The Google Cloud project number that owns the destination BigQuery dataset.
2349 * The caller must have WRITE access to this project. This project will also
2350 * own the resulting export job.
2351 */
2352 core.String projectId;
2353
2354 /**
2355 * Required. The ID of the variant set that contains variant data which should
2356 * be exported. The caller must have READ access to this variant set.
2357 */
2358 core.String variantSetId;
2359
2360
2361 ExportVariantsRequest();
2362
2363 ExportVariantsRequest.fromJson(core.Map _json) {
2364 if (_json.containsKey("bigqueryDataset")) {
2365 bigqueryDataset = _json["bigqueryDataset"];
2366 }
2367 if (_json.containsKey("bigqueryTable")) {
2368 bigqueryTable = _json["bigqueryTable"];
2369 }
2370 if (_json.containsKey("callSetIds")) {
2371 callSetIds = _json["callSetIds"];
2372 }
2373 if (_json.containsKey("format")) {
2374 format = _json["format"];
2375 }
2376 if (_json.containsKey("projectId")) {
2377 projectId = _json["projectId"];
2378 }
2379 if (_json.containsKey("variantSetId")) {
2380 variantSetId = _json["variantSetId"];
2381 }
2382 }
2383
2384 core.Map toJson() {
2385 var _json = new core.Map();
2386 if (bigqueryDataset != null) {
2387 _json["bigqueryDataset"] = bigqueryDataset;
2388 }
2389 if (bigqueryTable != null) {
2390 _json["bigqueryTable"] = bigqueryTable;
2391 }
2392 if (callSetIds != null) {
2393 _json["callSetIds"] = callSetIds;
2394 }
2395 if (format != null) {
2396 _json["format"] = format;
2397 }
2398 if (projectId != null) {
2399 _json["projectId"] = projectId;
2400 }
2401 if (variantSetId != null) {
2402 _json["variantSetId"] = variantSetId;
2403 }
2404 return _json;
2405 }
2406 }
2407
2408
2409 /** The variant data export response. */
2410 class ExportVariantsResponse {
2411 /** A job ID that can be used to get status information. */
2412 core.String jobId;
2413
2414
2415 ExportVariantsResponse();
2416
2417 ExportVariantsResponse.fromJson(core.Map _json) {
2418 if (_json.containsKey("jobId")) {
2419 jobId = _json["jobId"];
2420 }
2421 }
2422
2423 core.Map toJson() {
2424 var _json = new core.Map();
2425 if (jobId != null) {
2426 _json["jobId"] = jobId;
2427 }
2428 return _json;
2429 }
2430 }
2431
2432
2433 /**
2434 * An inclusive, exclusive genomic coordinate range over a reference sequence.
2435 */
2436 class GenomicRange {
2437 /**
2438 * The end position of the range on the reference, 1-based exclusive. If
2439 * specified, sequenceName must also be specified.
2440 */
2441 core.String sequenceEnd;
2442
2443 /** The reference sequence name, for example chr1, 1, or chrX. */
2444 core.String sequenceName;
2445
2446 /**
2447 * The start position of the range on the reference, 1-based inclusive. If
2448 * specified, sequenceName must also be specified.
2449 */
2450 core.String sequenceStart;
2451
2452
2453 GenomicRange();
2454
2455 GenomicRange.fromJson(core.Map _json) {
2456 if (_json.containsKey("sequenceEnd")) {
2457 sequenceEnd = _json["sequenceEnd"];
2458 }
2459 if (_json.containsKey("sequenceName")) {
2460 sequenceName = _json["sequenceName"];
2461 }
2462 if (_json.containsKey("sequenceStart")) {
2463 sequenceStart = _json["sequenceStart"];
2464 }
2465 }
2466
2467 core.Map toJson() {
2468 var _json = new core.Map();
2469 if (sequenceEnd != null) {
2470 _json["sequenceEnd"] = sequenceEnd;
2471 }
2472 if (sequenceName != null) {
2473 _json["sequenceName"] = sequenceName;
2474 }
2475 if (sequenceStart != null) {
2476 _json["sequenceStart"] = sequenceStart;
2477 }
2478 return _json;
2479 }
2480 }
2481
2482
2483 /** Not documented yet. */
2484 class Header {
2485 /** (SO) Sorting order of alignments. */
2486 core.String sortingOrder;
2487
2488 /** (VN) BAM format version. */
2489 core.String version;
2490
2491
2492 Header();
2493
2494 Header.fromJson(core.Map _json) {
2495 if (_json.containsKey("sortingOrder")) {
2496 sortingOrder = _json["sortingOrder"];
2497 }
2498 if (_json.containsKey("version")) {
2499 version = _json["version"];
2500 }
2501 }
2502
2503 core.Map toJson() {
2504 var _json = new core.Map();
2505 if (sortingOrder != null) {
2506 _json["sortingOrder"] = sortingOrder;
2507 }
2508 if (version != null) {
2509 _json["version"] = version;
2510 }
2511 return _json;
2512 }
2513 }
2514
2515
2516 /** The header section of the BAM/SAM file. */
2517 class HeaderSection {
2518 /** (@CO) One-line text comments. */
2519 core.List<core.String> comments;
2520
2521 /**
2522 * [Deprecated] This field is deprecated and will no longer be populated.
2523 * Please use filename instead.
2524 */
2525 core.String fileUri;
2526
2527 /** The name of the file from which this data was imported. */
2528 core.String filename;
2529
2530 /** (@HD) The header line. */
2531 core.List<Header> headers;
2532
2533 /** (@PG) Programs. */
2534 core.List<Program> programs;
2535
2536 /** (@RG) Read group. */
2537 core.List<ReadGroup> readGroups;
2538
2539 /** (@SQ) Reference sequence dictionary. */
2540 core.List<ReferenceSequence> refSequences;
2541
2542
2543 HeaderSection();
2544
2545 HeaderSection.fromJson(core.Map _json) {
2546 if (_json.containsKey("comments")) {
2547 comments = _json["comments"];
2548 }
2549 if (_json.containsKey("fileUri")) {
2550 fileUri = _json["fileUri"];
2551 }
2552 if (_json.containsKey("filename")) {
2553 filename = _json["filename"];
2554 }
2555 if (_json.containsKey("headers")) {
2556 headers = _json["headers"].map((value) => new Header.fromJson(value)).toLi st();
2557 }
2558 if (_json.containsKey("programs")) {
2559 programs = _json["programs"].map((value) => new Program.fromJson(value)).t oList();
2560 }
2561 if (_json.containsKey("readGroups")) {
2562 readGroups = _json["readGroups"].map((value) => new ReadGroup.fromJson(val ue)).toList();
2563 }
2564 if (_json.containsKey("refSequences")) {
2565 refSequences = _json["refSequences"].map((value) => new ReferenceSequence. fromJson(value)).toList();
2566 }
2567 }
2568
2569 core.Map toJson() {
2570 var _json = new core.Map();
2571 if (comments != null) {
2572 _json["comments"] = comments;
2573 }
2574 if (fileUri != null) {
2575 _json["fileUri"] = fileUri;
2576 }
2577 if (filename != null) {
2578 _json["filename"] = filename;
2579 }
2580 if (headers != null) {
2581 _json["headers"] = headers.map((value) => (value).toJson()).toList();
2582 }
2583 if (programs != null) {
2584 _json["programs"] = programs.map((value) => (value).toJson()).toList();
2585 }
2586 if (readGroups != null) {
2587 _json["readGroups"] = readGroups.map((value) => (value).toJson()).toList() ;
2588 }
2589 if (refSequences != null) {
2590 _json["refSequences"] = refSequences.map((value) => (value).toJson()).toLi st();
2591 }
2592 return _json;
2593 }
2594 }
2595
2596
2597 /** The readset import request. */
2598 class ImportReadsetsRequest {
2599 /**
2600 * Required. The ID of the dataset these readsets will belong to. The caller
2601 * must have WRITE permissions to this dataset.
2602 */
2603 core.String datasetId;
2604
2605 /** A list of URIs pointing at BAM files in Google Cloud Storage. */
2606 core.List<core.String> sourceUris;
2607
2608
2609 ImportReadsetsRequest();
2610
2611 ImportReadsetsRequest.fromJson(core.Map _json) {
2612 if (_json.containsKey("datasetId")) {
2613 datasetId = _json["datasetId"];
2614 }
2615 if (_json.containsKey("sourceUris")) {
2616 sourceUris = _json["sourceUris"];
2617 }
2618 }
2619
2620 core.Map toJson() {
2621 var _json = new core.Map();
2622 if (datasetId != null) {
2623 _json["datasetId"] = datasetId;
2624 }
2625 if (sourceUris != null) {
2626 _json["sourceUris"] = sourceUris;
2627 }
2628 return _json;
2629 }
2630 }
2631
2632
2633 /** The readset import response. */
2634 class ImportReadsetsResponse {
2635 /** A job ID that can be used to get status information. */
2636 core.String jobId;
2637
2638
2639 ImportReadsetsResponse();
2640
2641 ImportReadsetsResponse.fromJson(core.Map _json) {
2642 if (_json.containsKey("jobId")) {
2643 jobId = _json["jobId"];
2644 }
2645 }
2646
2647 core.Map toJson() {
2648 var _json = new core.Map();
2649 if (jobId != null) {
2650 _json["jobId"] = jobId;
2651 }
2652 return _json;
2653 }
2654 }
2655
2656
2657 /** The variant data import request. */
2658 class ImportVariantsRequest {
2659 /**
2660 * The format of the variant data being imported.
2661 * Possible string values are:
2662 * - "completeGenomics"
2663 * - "vcf"
2664 */
2665 core.String format;
2666
2667 /**
2668 * A list of URIs pointing at VCF files in Google Cloud Storage. See the VCF
2669 * Specification for more details on the input format.
2670 */
2671 core.List<core.String> sourceUris;
2672
2673 /** Required. The variant set to which variant data should be imported. */
2674 core.String variantSetId;
2675
2676
2677 ImportVariantsRequest();
2678
2679 ImportVariantsRequest.fromJson(core.Map _json) {
2680 if (_json.containsKey("format")) {
2681 format = _json["format"];
2682 }
2683 if (_json.containsKey("sourceUris")) {
2684 sourceUris = _json["sourceUris"];
2685 }
2686 if (_json.containsKey("variantSetId")) {
2687 variantSetId = _json["variantSetId"];
2688 }
2689 }
2690
2691 core.Map toJson() {
2692 var _json = new core.Map();
2693 if (format != null) {
2694 _json["format"] = format;
2695 }
2696 if (sourceUris != null) {
2697 _json["sourceUris"] = sourceUris;
2698 }
2699 if (variantSetId != null) {
2700 _json["variantSetId"] = variantSetId;
2701 }
2702 return _json;
2703 }
2704 }
2705
2706
2707 /** The variant data import response. */
2708 class ImportVariantsResponse {
2709 /** A job ID that can be used to get status information. */
2710 core.String jobId;
2711
2712
2713 ImportVariantsResponse();
2714
2715 ImportVariantsResponse.fromJson(core.Map _json) {
2716 if (_json.containsKey("jobId")) {
2717 jobId = _json["jobId"];
2718 }
2719 }
2720
2721 core.Map toJson() {
2722 var _json = new core.Map();
2723 if (jobId != null) {
2724 _json["jobId"] = jobId;
2725 }
2726 return _json;
2727 }
2728 }
2729
2730
2731 /**
2732 * A Job represents an ongoing process that can be monitored for status
2733 * information.
2734 */
2735 class Job {
2736 /** The date this job was created, in milliseconds from the epoch. */
2737 core.String created;
2738
2739 /** A more detailed description of this job's current status. */
2740 core.String description;
2741
2742 /** Any errors that occurred during processing. */
2743 core.List<core.String> errors;
2744
2745 /** The job ID. */
2746 core.String id;
2747
2748 /**
2749 * If this Job represents an import, this field will contain the IDs of the
2750 * objects that were successfully imported.
2751 */
2752 core.List<core.String> importedIds;
2753
2754 /**
2755 * The Google Developers Console project number to which this job belongs.
2756 */
2757 core.String projectId;
2758
2759 /** A summarized representation of the original service request. */
2760 JobRequest request;
2761
2762 /**
2763 * The status of this job.
2764 * Possible string values are:
2765 * - "canceled"
2766 * - "failure"
2767 * - "new"
2768 * - "pending"
2769 * - "running"
2770 * - "success"
2771 * - "unknownStatus"
2772 */
2773 core.String status;
2774
2775 /** Any warnings that occurred during processing. */
2776 core.List<core.String> warnings;
2777
2778
2779 Job();
2780
2781 Job.fromJson(core.Map _json) {
2782 if (_json.containsKey("created")) {
2783 created = _json["created"];
2784 }
2785 if (_json.containsKey("description")) {
2786 description = _json["description"];
2787 }
2788 if (_json.containsKey("errors")) {
2789 errors = _json["errors"];
2790 }
2791 if (_json.containsKey("id")) {
2792 id = _json["id"];
2793 }
2794 if (_json.containsKey("importedIds")) {
2795 importedIds = _json["importedIds"];
2796 }
2797 if (_json.containsKey("projectId")) {
2798 projectId = _json["projectId"];
2799 }
2800 if (_json.containsKey("request")) {
2801 request = new JobRequest.fromJson(_json["request"]);
2802 }
2803 if (_json.containsKey("status")) {
2804 status = _json["status"];
2805 }
2806 if (_json.containsKey("warnings")) {
2807 warnings = _json["warnings"];
2808 }
2809 }
2810
2811 core.Map toJson() {
2812 var _json = new core.Map();
2813 if (created != null) {
2814 _json["created"] = created;
2815 }
2816 if (description != null) {
2817 _json["description"] = description;
2818 }
2819 if (errors != null) {
2820 _json["errors"] = errors;
2821 }
2822 if (id != null) {
2823 _json["id"] = id;
2824 }
2825 if (importedIds != null) {
2826 _json["importedIds"] = importedIds;
2827 }
2828 if (projectId != null) {
2829 _json["projectId"] = projectId;
2830 }
2831 if (request != null) {
2832 _json["request"] = (request).toJson();
2833 }
2834 if (status != null) {
2835 _json["status"] = status;
2836 }
2837 if (warnings != null) {
2838 _json["warnings"] = warnings;
2839 }
2840 return _json;
2841 }
2842 }
2843
2844
2845 /** A summary representation of the service request that spawned the job. */
2846 class JobRequest {
2847 /**
2848 * The data destination of the request, for example, a Google BigQuery Table
2849 * or Dataset ID.
2850 */
2851 core.List<core.String> destination;
2852
2853 /**
2854 * The data source of the request, for example, a Google Cloud Storage object
2855 * path or Readset ID.
2856 */
2857 core.List<core.String> source;
2858
2859 /**
2860 * The original request type.
2861 * Possible string values are:
2862 * - "alignReadsets"
2863 * - "callReadsets"
2864 * - "experimentalCreateJob"
2865 * - "exportReadsets"
2866 * - "exportVariants"
2867 * - "importReadsets"
2868 * - "importVariants"
2869 * - "unknownType"
2870 */
2871 core.String type;
2872
2873
2874 JobRequest();
2875
2876 JobRequest.fromJson(core.Map _json) {
2877 if (_json.containsKey("destination")) {
2878 destination = _json["destination"];
2879 }
2880 if (_json.containsKey("source")) {
2881 source = _json["source"];
2882 }
2883 if (_json.containsKey("type")) {
2884 type = _json["type"];
2885 }
2886 }
2887
2888 core.Map toJson() {
2889 var _json = new core.Map();
2890 if (destination != null) {
2891 _json["destination"] = destination;
2892 }
2893 if (source != null) {
2894 _json["source"] = source;
2895 }
2896 if (type != null) {
2897 _json["type"] = type;
2898 }
2899 return _json;
2900 }
2901 }
2902
2903
2904 /** Not documented yet. */
2905 class ListCoverageBucketsResponse {
2906 /**
2907 * The length of each coverage bucket in base pairs. Note that buckets at the
2908 * end of a reference sequence may be shorter. This value is omitted if the
2909 * bucket width is infinity (the default behaviour, with no range or
2910 * targetBucketWidth).
2911 */
2912 core.String bucketWidth;
2913
2914 /**
2915 * The coverage buckets. The list of buckets is sparse; a bucket with 0
2916 * overlapping reads is not returned. A bucket never crosses more than one
2917 * reference sequence. Each bucket has width bucketWidth, unless its end is
2918 * the end of the reference sequence.
2919 */
2920 core.List<CoverageBucket> coverageBuckets;
2921
2922 /**
2923 * The continuation token, which is used to page through large result sets.
2924 * Provide this value in a subsequent request to return the next page of
2925 * results. This field will be empty if there aren't any additional results.
2926 */
2927 core.String nextPageToken;
2928
2929
2930 ListCoverageBucketsResponse();
2931
2932 ListCoverageBucketsResponse.fromJson(core.Map _json) {
2933 if (_json.containsKey("bucketWidth")) {
2934 bucketWidth = _json["bucketWidth"];
2935 }
2936 if (_json.containsKey("coverageBuckets")) {
2937 coverageBuckets = _json["coverageBuckets"].map((value) => new CoverageBuck et.fromJson(value)).toList();
2938 }
2939 if (_json.containsKey("nextPageToken")) {
2940 nextPageToken = _json["nextPageToken"];
2941 }
2942 }
2943
2944 core.Map toJson() {
2945 var _json = new core.Map();
2946 if (bucketWidth != null) {
2947 _json["bucketWidth"] = bucketWidth;
2948 }
2949 if (coverageBuckets != null) {
2950 _json["coverageBuckets"] = coverageBuckets.map((value) => (value).toJson() ).toList();
2951 }
2952 if (nextPageToken != null) {
2953 _json["nextPageToken"] = nextPageToken;
2954 }
2955 return _json;
2956 }
2957 }
2958
2959
2960 /** The dataset list response. */
2961 class ListDatasetsResponse {
2962 /** The list of matching Datasets. */
2963 core.List<Dataset> datasets;
2964
2965 /**
2966 * The continuation token, which is used to page through large result sets.
2967 * Provide this value in a subsequent request to return the next page of
2968 * results. This field will be empty if there aren't any additional results.
2969 */
2970 core.String nextPageToken;
2971
2972
2973 ListDatasetsResponse();
2974
2975 ListDatasetsResponse.fromJson(core.Map _json) {
2976 if (_json.containsKey("datasets")) {
2977 datasets = _json["datasets"].map((value) => new Dataset.fromJson(value)).t oList();
2978 }
2979 if (_json.containsKey("nextPageToken")) {
2980 nextPageToken = _json["nextPageToken"];
2981 }
2982 }
2983
2984 core.Map toJson() {
2985 var _json = new core.Map();
2986 if (datasets != null) {
2987 _json["datasets"] = datasets.map((value) => (value).toJson()).toList();
2988 }
2989 if (nextPageToken != null) {
2990 _json["nextPageToken"] = nextPageToken;
2991 }
2992 return _json;
2993 }
2994 }
2995
2996
2997 /** Not documented yet. */
2998 class MergeVariantsRequest {
2999 /** The variants to be merged with existing variants. */
3000 core.List<Variant> variants;
3001
3002
3003 MergeVariantsRequest();
3004
3005 MergeVariantsRequest.fromJson(core.Map _json) {
3006 if (_json.containsKey("variants")) {
3007 variants = _json["variants"].map((value) => new Variant.fromJson(value)).t oList();
3008 }
3009 }
3010
3011 core.Map toJson() {
3012 var _json = new core.Map();
3013 if (variants != null) {
3014 _json["variants"] = variants.map((value) => (value).toJson()).toList();
3015 }
3016 return _json;
3017 }
3018 }
3019
3020
3021 /**
3022 * Metadata describes a single piece of variant call metadata. These data
3023 * include a top level key and either a single value string (value) or a list of
3024 * key-value pairs (info.) Value and info are mutually exclusive.
3025 */
3026 class Metadata {
3027 /** A textual description of this metadata. */
3028 core.String description;
3029
3030 /**
3031 * User-provided ID field, not enforced by this API. Two or more pieces of
3032 * structured metadata with identical id and key fields are considered
3033 * equivalent.
3034 */
3035 core.String id;
3036
3037 /** Remaining structured metadata key-value pairs. */
3038 core.Map<core.String, core.List<core.String>> info;
3039
3040 /** The top-level key. */
3041 core.String key;
3042
3043 /**
3044 * The number of values that can be included in a field described by this
3045 * metadata.
3046 */
3047 core.String number;
3048
3049 /**
3050 * The type of data. Possible types include: Integer, Float, Flag, Character,
3051 * and String.
3052 * Possible string values are:
3053 * - "character"
3054 * - "flag"
3055 * - "float"
3056 * - "integer"
3057 * - "string"
3058 * - "unknownType"
3059 */
3060 core.String type;
3061
3062 /** The value field for simple metadata */
3063 core.String value;
3064
3065
3066 Metadata();
3067
3068 Metadata.fromJson(core.Map _json) {
3069 if (_json.containsKey("description")) {
3070 description = _json["description"];
3071 }
3072 if (_json.containsKey("id")) {
3073 id = _json["id"];
3074 }
3075 if (_json.containsKey("info")) {
3076 info = _json["info"];
3077 }
3078 if (_json.containsKey("key")) {
3079 key = _json["key"];
3080 }
3081 if (_json.containsKey("number")) {
3082 number = _json["number"];
3083 }
3084 if (_json.containsKey("type")) {
3085 type = _json["type"];
3086 }
3087 if (_json.containsKey("value")) {
3088 value = _json["value"];
3089 }
3090 }
3091
3092 core.Map toJson() {
3093 var _json = new core.Map();
3094 if (description != null) {
3095 _json["description"] = description;
3096 }
3097 if (id != null) {
3098 _json["id"] = id;
3099 }
3100 if (info != null) {
3101 _json["info"] = info;
3102 }
3103 if (key != null) {
3104 _json["key"] = key;
3105 }
3106 if (number != null) {
3107 _json["number"] = number;
3108 }
3109 if (type != null) {
3110 _json["type"] = type;
3111 }
3112 if (value != null) {
3113 _json["value"] = value;
3114 }
3115 return _json;
3116 }
3117 }
3118
3119
3120 /** Not documented yet. */
3121 class Program {
3122 /** (CL) Command line. */
3123 core.String commandLine;
3124
3125 /** (ID) Program record identifier. */
3126 core.String id;
3127
3128 /** (PN) Program name. */
3129 core.String name;
3130
3131 /** (PP) Previous program ID. */
3132 core.String prevProgramId;
3133
3134 /** (VN) Program version. */
3135 core.String version;
3136
3137
3138 Program();
3139
3140 Program.fromJson(core.Map _json) {
3141 if (_json.containsKey("commandLine")) {
3142 commandLine = _json["commandLine"];
3143 }
3144 if (_json.containsKey("id")) {
3145 id = _json["id"];
3146 }
3147 if (_json.containsKey("name")) {
3148 name = _json["name"];
3149 }
3150 if (_json.containsKey("prevProgramId")) {
3151 prevProgramId = _json["prevProgramId"];
3152 }
3153 if (_json.containsKey("version")) {
3154 version = _json["version"];
3155 }
3156 }
3157
3158 core.Map toJson() {
3159 var _json = new core.Map();
3160 if (commandLine != null) {
3161 _json["commandLine"] = commandLine;
3162 }
3163 if (id != null) {
3164 _json["id"] = id;
3165 }
3166 if (name != null) {
3167 _json["name"] = name;
3168 }
3169 if (prevProgramId != null) {
3170 _json["prevProgramId"] = prevProgramId;
3171 }
3172 if (version != null) {
3173 _json["version"] = version;
3174 }
3175 return _json;
3176 }
3177 }
3178
3179
3180 /**
3181 * A Read is a group of bases that may or may not have been aligned to a
3182 * reference. It contains quality information and other metadata.
3183 */
3184 class Read {
3185 /**
3186 * The originalBases after the cigar field has been applied. Deletions are
3187 * represented with '-' and insertions are omitted.
3188 */
3189 core.String alignedBases;
3190
3191 /**
3192 * Represents the quality of each base in this read. Each character represents
3193 * one base. To get the quality, take the ASCII value of the character and
3194 * subtract 33. (QUAL)
3195 */
3196 core.String baseQuality;
3197
3198 /**
3199 * A condensed representation of how this read matches up to the reference.
3200 * (CIGAR)
3201 */
3202 core.String cigar;
3203
3204 /**
3205 * Each bit of this number has a different meaning if enabled. See the full
3206 * BAM spec for more details. (FLAG)
3207 */
3208 core.int flags;
3209
3210 /** The Google generated ID of the read, immutable. */
3211 core.String id;
3212
3213 /**
3214 * A score up to 255 that represents how likely this read's aligned position
3215 * is to be correct. A higher value is better. (MAPQ)
3216 */
3217 core.int mappingQuality;
3218
3219 /** The 1-based start position of the paired read. (PNEXT) */
3220 core.int matePosition;
3221
3222 /**
3223 * The name of the sequence that the paired read is aligned to. This is
3224 * usually the same as referenceSequenceName. (RNEXT)
3225 */
3226 core.String mateReferenceSequenceName;
3227
3228 /**
3229 * The name of the read. When imported from a BAM file, this is the query
3230 * template name. (QNAME)
3231 */
3232 core.String name;
3233
3234 /** The list of bases that this read represents (such as "CATCGA"). (SEQ) */
3235 core.String originalBases;
3236
3237 /**
3238 * The 1-based start position of the aligned read. If the first base starts at
3239 * the very beginning of the reference sequence, then the position would be
3240 * '1'. (POS)
3241 */
3242 core.int position;
3243
3244 /** The ID of the readset this read belongs to. */
3245 core.String readsetId;
3246
3247 /**
3248 * The name of the sequence that this read is aligned to. This would be, for
3249 * example, 'X' for the X Chromosome or '20' for Chromosome 20. (RNAME)
3250 */
3251 core.String referenceSequenceName;
3252
3253 /** A map of additional read information. (TAG) */
3254 core.Map<core.String, core.List<core.String>> tags;
3255
3256 /**
3257 * Length of the original piece of DNA that produced both this read and the
3258 * paired read. (TLEN)
3259 */
3260 core.int templateLength;
3261
3262
3263 Read();
3264
3265 Read.fromJson(core.Map _json) {
3266 if (_json.containsKey("alignedBases")) {
3267 alignedBases = _json["alignedBases"];
3268 }
3269 if (_json.containsKey("baseQuality")) {
3270 baseQuality = _json["baseQuality"];
3271 }
3272 if (_json.containsKey("cigar")) {
3273 cigar = _json["cigar"];
3274 }
3275 if (_json.containsKey("flags")) {
3276 flags = _json["flags"];
3277 }
3278 if (_json.containsKey("id")) {
3279 id = _json["id"];
3280 }
3281 if (_json.containsKey("mappingQuality")) {
3282 mappingQuality = _json["mappingQuality"];
3283 }
3284 if (_json.containsKey("matePosition")) {
3285 matePosition = _json["matePosition"];
3286 }
3287 if (_json.containsKey("mateReferenceSequenceName")) {
3288 mateReferenceSequenceName = _json["mateReferenceSequenceName"];
3289 }
3290 if (_json.containsKey("name")) {
3291 name = _json["name"];
3292 }
3293 if (_json.containsKey("originalBases")) {
3294 originalBases = _json["originalBases"];
3295 }
3296 if (_json.containsKey("position")) {
3297 position = _json["position"];
3298 }
3299 if (_json.containsKey("readsetId")) {
3300 readsetId = _json["readsetId"];
3301 }
3302 if (_json.containsKey("referenceSequenceName")) {
3303 referenceSequenceName = _json["referenceSequenceName"];
3304 }
3305 if (_json.containsKey("tags")) {
3306 tags = _json["tags"];
3307 }
3308 if (_json.containsKey("templateLength")) {
3309 templateLength = _json["templateLength"];
3310 }
3311 }
3312
3313 core.Map toJson() {
3314 var _json = new core.Map();
3315 if (alignedBases != null) {
3316 _json["alignedBases"] = alignedBases;
3317 }
3318 if (baseQuality != null) {
3319 _json["baseQuality"] = baseQuality;
3320 }
3321 if (cigar != null) {
3322 _json["cigar"] = cigar;
3323 }
3324 if (flags != null) {
3325 _json["flags"] = flags;
3326 }
3327 if (id != null) {
3328 _json["id"] = id;
3329 }
3330 if (mappingQuality != null) {
3331 _json["mappingQuality"] = mappingQuality;
3332 }
3333 if (matePosition != null) {
3334 _json["matePosition"] = matePosition;
3335 }
3336 if (mateReferenceSequenceName != null) {
3337 _json["mateReferenceSequenceName"] = mateReferenceSequenceName;
3338 }
3339 if (name != null) {
3340 _json["name"] = name;
3341 }
3342 if (originalBases != null) {
3343 _json["originalBases"] = originalBases;
3344 }
3345 if (position != null) {
3346 _json["position"] = position;
3347 }
3348 if (readsetId != null) {
3349 _json["readsetId"] = readsetId;
3350 }
3351 if (referenceSequenceName != null) {
3352 _json["referenceSequenceName"] = referenceSequenceName;
3353 }
3354 if (tags != null) {
3355 _json["tags"] = tags;
3356 }
3357 if (templateLength != null) {
3358 _json["templateLength"] = templateLength;
3359 }
3360 return _json;
3361 }
3362 }
3363
3364
3365 /** Not documented yet. */
3366 class ReadGroup {
3367 /** (DT) Date the run was produced (ISO8601 date or date/time). */
3368 core.String date;
3369
3370 /** (DS) Description. */
3371 core.String description;
3372
3373 /**
3374 * (FO) Flow order. The array of nucleotide bases that correspond to the
3375 * nucleotides used for each flow of each read.
3376 */
3377 core.String flowOrder;
3378
3379 /** (ID) Read group identifier. */
3380 core.String id;
3381
3382 /**
3383 * (KS) The array of nucleotide bases that correspond to the key sequence of
3384 * each read.
3385 */
3386 core.String keySequence;
3387
3388 /** (LS) Library. */
3389 core.String library;
3390
3391 /** (PU) Platform unit. */
3392 core.String platformUnit;
3393
3394 /** (PI) Predicted median insert size. */
3395 core.int predictedInsertSize;
3396
3397 /** (PG) Programs used for processing the read group. */
3398 core.String processingProgram;
3399
3400 /** (SM) Sample. */
3401 core.String sample;
3402
3403 /** (CN) Name of sequencing center producing the read. */
3404 core.String sequencingCenterName;
3405
3406 /** (PL) Platform/technology used to produce the reads. */
3407 core.String sequencingTechnology;
3408
3409
3410 ReadGroup();
3411
3412 ReadGroup.fromJson(core.Map _json) {
3413 if (_json.containsKey("date")) {
3414 date = _json["date"];
3415 }
3416 if (_json.containsKey("description")) {
3417 description = _json["description"];
3418 }
3419 if (_json.containsKey("flowOrder")) {
3420 flowOrder = _json["flowOrder"];
3421 }
3422 if (_json.containsKey("id")) {
3423 id = _json["id"];
3424 }
3425 if (_json.containsKey("keySequence")) {
3426 keySequence = _json["keySequence"];
3427 }
3428 if (_json.containsKey("library")) {
3429 library = _json["library"];
3430 }
3431 if (_json.containsKey("platformUnit")) {
3432 platformUnit = _json["platformUnit"];
3433 }
3434 if (_json.containsKey("predictedInsertSize")) {
3435 predictedInsertSize = _json["predictedInsertSize"];
3436 }
3437 if (_json.containsKey("processingProgram")) {
3438 processingProgram = _json["processingProgram"];
3439 }
3440 if (_json.containsKey("sample")) {
3441 sample = _json["sample"];
3442 }
3443 if (_json.containsKey("sequencingCenterName")) {
3444 sequencingCenterName = _json["sequencingCenterName"];
3445 }
3446 if (_json.containsKey("sequencingTechnology")) {
3447 sequencingTechnology = _json["sequencingTechnology"];
3448 }
3449 }
3450
3451 core.Map toJson() {
3452 var _json = new core.Map();
3453 if (date != null) {
3454 _json["date"] = date;
3455 }
3456 if (description != null) {
3457 _json["description"] = description;
3458 }
3459 if (flowOrder != null) {
3460 _json["flowOrder"] = flowOrder;
3461 }
3462 if (id != null) {
3463 _json["id"] = id;
3464 }
3465 if (keySequence != null) {
3466 _json["keySequence"] = keySequence;
3467 }
3468 if (library != null) {
3469 _json["library"] = library;
3470 }
3471 if (platformUnit != null) {
3472 _json["platformUnit"] = platformUnit;
3473 }
3474 if (predictedInsertSize != null) {
3475 _json["predictedInsertSize"] = predictedInsertSize;
3476 }
3477 if (processingProgram != null) {
3478 _json["processingProgram"] = processingProgram;
3479 }
3480 if (sample != null) {
3481 _json["sample"] = sample;
3482 }
3483 if (sequencingCenterName != null) {
3484 _json["sequencingCenterName"] = sequencingCenterName;
3485 }
3486 if (sequencingTechnology != null) {
3487 _json["sequencingTechnology"] = sequencingTechnology;
3488 }
3489 return _json;
3490 }
3491 }
3492
3493
3494 /** A Readset is a collection of Reads. */
3495 class Readset {
3496 /** The ID of the dataset this readset belongs to. */
3497 core.String datasetId;
3498
3499 /**
3500 * File information from the original BAM import. See the BAM format
3501 * specification for additional information on each field.
3502 */
3503 core.List<HeaderSection> fileData;
3504
3505 /** The Google generated ID of the readset, immutable. */
3506 core.String id;
3507
3508 /** The readset name, typically this is the sample name. */
3509 core.String name;
3510
3511
3512 Readset();
3513
3514 Readset.fromJson(core.Map _json) {
3515 if (_json.containsKey("datasetId")) {
3516 datasetId = _json["datasetId"];
3517 }
3518 if (_json.containsKey("fileData")) {
3519 fileData = _json["fileData"].map((value) => new HeaderSection.fromJson(val ue)).toList();
3520 }
3521 if (_json.containsKey("id")) {
3522 id = _json["id"];
3523 }
3524 if (_json.containsKey("name")) {
3525 name = _json["name"];
3526 }
3527 }
3528
3529 core.Map toJson() {
3530 var _json = new core.Map();
3531 if (datasetId != null) {
3532 _json["datasetId"] = datasetId;
3533 }
3534 if (fileData != null) {
3535 _json["fileData"] = fileData.map((value) => (value).toJson()).toList();
3536 }
3537 if (id != null) {
3538 _json["id"] = id;
3539 }
3540 if (name != null) {
3541 _json["name"] = name;
3542 }
3543 return _json;
3544 }
3545 }
3546
3547
3548 /**
3549 * ReferenceBound records an upper bound for the starting coordinate of variants
3550 * in a particular reference.
3551 */
3552 class ReferenceBound {
3553 /** The reference the bound is associate with. */
3554 core.String referenceName;
3555
3556 /**
3557 * An upper bound (inclusive) on the starting coordinate of any variant in the
3558 * reference sequence.
3559 */
3560 core.String upperBound;
3561
3562
3563 ReferenceBound();
3564
3565 ReferenceBound.fromJson(core.Map _json) {
3566 if (_json.containsKey("referenceName")) {
3567 referenceName = _json["referenceName"];
3568 }
3569 if (_json.containsKey("upperBound")) {
3570 upperBound = _json["upperBound"];
3571 }
3572 }
3573
3574 core.Map toJson() {
3575 var _json = new core.Map();
3576 if (referenceName != null) {
3577 _json["referenceName"] = referenceName;
3578 }
3579 if (upperBound != null) {
3580 _json["upperBound"] = upperBound;
3581 }
3582 return _json;
3583 }
3584 }
3585
3586
3587 /** Not documented yet. */
3588 class ReferenceSequence {
3589 /** (AS) Genome assembly identifier. */
3590 core.String assemblyId;
3591
3592 /** (LN) Reference sequence length. */
3593 core.int length;
3594
3595 /**
3596 * (M5) MD5 checksum of the sequence in the uppercase, excluding spaces but
3597 * including pads as *.
3598 */
3599 core.String md5Checksum;
3600
3601 /** (SN) Reference sequence name. */
3602 core.String name;
3603
3604 /** (SP) Species. */
3605 core.String species;
3606
3607 /** (UR) URI of the sequence. */
3608 core.String uri;
3609
3610
3611 ReferenceSequence();
3612
3613 ReferenceSequence.fromJson(core.Map _json) {
3614 if (_json.containsKey("assemblyId")) {
3615 assemblyId = _json["assemblyId"];
3616 }
3617 if (_json.containsKey("length")) {
3618 length = _json["length"];
3619 }
3620 if (_json.containsKey("md5Checksum")) {
3621 md5Checksum = _json["md5Checksum"];
3622 }
3623 if (_json.containsKey("name")) {
3624 name = _json["name"];
3625 }
3626 if (_json.containsKey("species")) {
3627 species = _json["species"];
3628 }
3629 if (_json.containsKey("uri")) {
3630 uri = _json["uri"];
3631 }
3632 }
3633
3634 core.Map toJson() {
3635 var _json = new core.Map();
3636 if (assemblyId != null) {
3637 _json["assemblyId"] = assemblyId;
3638 }
3639 if (length != null) {
3640 _json["length"] = length;
3641 }
3642 if (md5Checksum != null) {
3643 _json["md5Checksum"] = md5Checksum;
3644 }
3645 if (name != null) {
3646 _json["name"] = name;
3647 }
3648 if (species != null) {
3649 _json["species"] = species;
3650 }
3651 if (uri != null) {
3652 _json["uri"] = uri;
3653 }
3654 return _json;
3655 }
3656 }
3657
3658
3659 /** The call set search request. */
3660 class SearchCallSetsRequest {
3661 /**
3662 * Only return call sets for which a substring of the name matches this
3663 * string.
3664 */
3665 core.String name;
3666
3667 /** The maximum number of call sets to return. */
3668 core.int pageSize;
3669
3670 /**
3671 * The continuation token, which is used to page through large result sets. To
3672 * get the next page of results, set this parameter to the value of
3673 * nextPageToken from the previous response.
3674 */
3675 core.String pageToken;
3676
3677 /**
3678 * Restrict the query to call sets within the given variant sets. At least one
3679 * ID must be provided.
3680 */
3681 core.List<core.String> variantSetIds;
3682
3683
3684 SearchCallSetsRequest();
3685
3686 SearchCallSetsRequest.fromJson(core.Map _json) {
3687 if (_json.containsKey("name")) {
3688 name = _json["name"];
3689 }
3690 if (_json.containsKey("pageSize")) {
3691 pageSize = _json["pageSize"];
3692 }
3693 if (_json.containsKey("pageToken")) {
3694 pageToken = _json["pageToken"];
3695 }
3696 if (_json.containsKey("variantSetIds")) {
3697 variantSetIds = _json["variantSetIds"];
3698 }
3699 }
3700
3701 core.Map toJson() {
3702 var _json = new core.Map();
3703 if (name != null) {
3704 _json["name"] = name;
3705 }
3706 if (pageSize != null) {
3707 _json["pageSize"] = pageSize;
3708 }
3709 if (pageToken != null) {
3710 _json["pageToken"] = pageToken;
3711 }
3712 if (variantSetIds != null) {
3713 _json["variantSetIds"] = variantSetIds;
3714 }
3715 return _json;
3716 }
3717 }
3718
3719
3720 /** The call set search response. */
3721 class SearchCallSetsResponse {
3722 /** The list of matching call sets. */
3723 core.List<CallSet> callSets;
3724
3725 /**
3726 * The continuation token, which is used to page through large result sets.
3727 * Provide this value in a subsequent request to return the next page of
3728 * results. This field will be empty if there aren't any additional results.
3729 */
3730 core.String nextPageToken;
3731
3732
3733 SearchCallSetsResponse();
3734
3735 SearchCallSetsResponse.fromJson(core.Map _json) {
3736 if (_json.containsKey("callSets")) {
3737 callSets = _json["callSets"].map((value) => new CallSet.fromJson(value)).t oList();
3738 }
3739 if (_json.containsKey("nextPageToken")) {
3740 nextPageToken = _json["nextPageToken"];
3741 }
3742 }
3743
3744 core.Map toJson() {
3745 var _json = new core.Map();
3746 if (callSets != null) {
3747 _json["callSets"] = callSets.map((value) => (value).toJson()).toList();
3748 }
3749 if (nextPageToken != null) {
3750 _json["nextPageToken"] = nextPageToken;
3751 }
3752 return _json;
3753 }
3754 }
3755
3756
3757 /** The jobs search request. */
3758 class SearchJobsRequest {
3759 /**
3760 * If specified, only jobs created on or after this date, given in
3761 * milliseconds since Unix epoch, will be returned.
3762 */
3763 core.String createdAfter;
3764
3765 /**
3766 * If specified, only jobs created prior to this date, given in milliseconds
3767 * since Unix epoch, will be returned.
3768 */
3769 core.String createdBefore;
3770
3771 /**
3772 * Specifies the number of results to return in a single page. Defaults to
3773 * 128. The maximum value is 256.
3774 */
3775 core.String maxResults;
3776
3777 /**
3778 * The continuation token which is used to page through large result sets. To
3779 * get the next page of results, set this parameter to the value of the
3780 * nextPageToken from the previous response.
3781 */
3782 core.String pageToken;
3783
3784 /**
3785 * Required. Only return jobs which belong to this Google Developers Console
3786 * project.
3787 */
3788 core.String projectId;
3789
3790 /** Only return jobs which have a matching status. */
3791 core.List<core.String> status;
3792
3793
3794 SearchJobsRequest();
3795
3796 SearchJobsRequest.fromJson(core.Map _json) {
3797 if (_json.containsKey("createdAfter")) {
3798 createdAfter = _json["createdAfter"];
3799 }
3800 if (_json.containsKey("createdBefore")) {
3801 createdBefore = _json["createdBefore"];
3802 }
3803 if (_json.containsKey("maxResults")) {
3804 maxResults = _json["maxResults"];
3805 }
3806 if (_json.containsKey("pageToken")) {
3807 pageToken = _json["pageToken"];
3808 }
3809 if (_json.containsKey("projectId")) {
3810 projectId = _json["projectId"];
3811 }
3812 if (_json.containsKey("status")) {
3813 status = _json["status"];
3814 }
3815 }
3816
3817 core.Map toJson() {
3818 var _json = new core.Map();
3819 if (createdAfter != null) {
3820 _json["createdAfter"] = createdAfter;
3821 }
3822 if (createdBefore != null) {
3823 _json["createdBefore"] = createdBefore;
3824 }
3825 if (maxResults != null) {
3826 _json["maxResults"] = maxResults;
3827 }
3828 if (pageToken != null) {
3829 _json["pageToken"] = pageToken;
3830 }
3831 if (projectId != null) {
3832 _json["projectId"] = projectId;
3833 }
3834 if (status != null) {
3835 _json["status"] = status;
3836 }
3837 return _json;
3838 }
3839 }
3840
3841
3842 /** The job search response. */
3843 class SearchJobsResponse {
3844 /** The list of jobs results, ordered newest to oldest. */
3845 core.List<Job> jobs;
3846
3847 /**
3848 * The continuation token which is used to page through large result sets.
3849 * Provide this value is a subsequent request to return the next page of
3850 * results. This field will be empty if there are no more results.
3851 */
3852 core.String nextPageToken;
3853
3854
3855 SearchJobsResponse();
3856
3857 SearchJobsResponse.fromJson(core.Map _json) {
3858 if (_json.containsKey("jobs")) {
3859 jobs = _json["jobs"].map((value) => new Job.fromJson(value)).toList();
3860 }
3861 if (_json.containsKey("nextPageToken")) {
3862 nextPageToken = _json["nextPageToken"];
3863 }
3864 }
3865
3866 core.Map toJson() {
3867 var _json = new core.Map();
3868 if (jobs != null) {
3869 _json["jobs"] = jobs.map((value) => (value).toJson()).toList();
3870 }
3871 if (nextPageToken != null) {
3872 _json["nextPageToken"] = nextPageToken;
3873 }
3874 return _json;
3875 }
3876 }
3877
3878
3879 /** The read search request. */
3880 class SearchReadsRequest {
3881 /**
3882 * Specifies number of results to return in a single page. If unspecified, it
3883 * will default to 256. The maximum value is 2048.
3884 */
3885 core.String maxResults;
3886
3887 /**
3888 * The continuation token, which is used to page through large result sets. To
3889 * get the next page of results, set this parameter to the value of
3890 * nextPageToken from the previous response.
3891 */
3892 core.String pageToken;
3893
3894 /**
3895 * The readsets within which to search for reads. At least one readset ID must
3896 * be provided. All specified readsets must be aligned against a common set of
3897 * reference sequences; this defines the genomic coordinates for the query.
3898 */
3899 core.List<core.String> readsetIds;
3900
3901 /**
3902 * The end position (1-based, inclusive) of the target range. If specified,
3903 * sequenceName must also be specified. Defaults to the end of the target
3904 * reference sequence, if any.
3905 */
3906 core.String sequenceEnd;
3907
3908 /**
3909 * Restricts the results to a particular reference sequence such as 1, chr1,
3910 * or X. The set of valid references sequences depends on the readsets
3911 * specified. If set to *, only unmapped Reads are returned.
3912 */
3913 core.String sequenceName;
3914
3915 /**
3916 * The start position (1-based, inclusive) of the target range. If specified,
3917 * sequenceName must also be specified. Defaults to the start of the target
3918 * reference sequence, if any.
3919 */
3920 core.String sequenceStart;
3921
3922
3923 SearchReadsRequest();
3924
3925 SearchReadsRequest.fromJson(core.Map _json) {
3926 if (_json.containsKey("maxResults")) {
3927 maxResults = _json["maxResults"];
3928 }
3929 if (_json.containsKey("pageToken")) {
3930 pageToken = _json["pageToken"];
3931 }
3932 if (_json.containsKey("readsetIds")) {
3933 readsetIds = _json["readsetIds"];
3934 }
3935 if (_json.containsKey("sequenceEnd")) {
3936 sequenceEnd = _json["sequenceEnd"];
3937 }
3938 if (_json.containsKey("sequenceName")) {
3939 sequenceName = _json["sequenceName"];
3940 }
3941 if (_json.containsKey("sequenceStart")) {
3942 sequenceStart = _json["sequenceStart"];
3943 }
3944 }
3945
3946 core.Map toJson() {
3947 var _json = new core.Map();
3948 if (maxResults != null) {
3949 _json["maxResults"] = maxResults;
3950 }
3951 if (pageToken != null) {
3952 _json["pageToken"] = pageToken;
3953 }
3954 if (readsetIds != null) {
3955 _json["readsetIds"] = readsetIds;
3956 }
3957 if (sequenceEnd != null) {
3958 _json["sequenceEnd"] = sequenceEnd;
3959 }
3960 if (sequenceName != null) {
3961 _json["sequenceName"] = sequenceName;
3962 }
3963 if (sequenceStart != null) {
3964 _json["sequenceStart"] = sequenceStart;
3965 }
3966 return _json;
3967 }
3968 }
3969
3970
3971 /** The read search response. */
3972 class SearchReadsResponse {
3973 /**
3974 * The continuation token, which is used to page through large result sets.
3975 * Provide this value in a subsequent request to return the next page of
3976 * results. This field will be empty if there aren't any additional results.
3977 */
3978 core.String nextPageToken;
3979
3980 /**
3981 * The list of matching Reads. The resulting Reads are sorted by position; the
3982 * smallest positions are returned first. Unmapped reads, which have no
3983 * position, are returned last and are further sorted alphabetically by name.
3984 */
3985 core.List<Read> reads;
3986
3987
3988 SearchReadsResponse();
3989
3990 SearchReadsResponse.fromJson(core.Map _json) {
3991 if (_json.containsKey("nextPageToken")) {
3992 nextPageToken = _json["nextPageToken"];
3993 }
3994 if (_json.containsKey("reads")) {
3995 reads = _json["reads"].map((value) => new Read.fromJson(value)).toList();
3996 }
3997 }
3998
3999 core.Map toJson() {
4000 var _json = new core.Map();
4001 if (nextPageToken != null) {
4002 _json["nextPageToken"] = nextPageToken;
4003 }
4004 if (reads != null) {
4005 _json["reads"] = reads.map((value) => (value).toJson()).toList();
4006 }
4007 return _json;
4008 }
4009 }
4010
4011
4012 /** The readset search request. */
4013 class SearchReadsetsRequest {
4014 /**
4015 * Restricts this query to readsets within the given datasets. At least one ID
4016 * must be provided.
4017 */
4018 core.List<core.String> datasetIds;
4019
4020 /**
4021 * Specifies number of results to return in a single page. If unspecified, it
4022 * will default to 128. The maximum value is 1024.
4023 */
4024 core.String maxResults;
4025
4026 /**
4027 * Only return readsets for which a substring of the name matches this string.
4028 */
4029 core.String name;
4030
4031 /**
4032 * The continuation token, which is used to page through large result sets. To
4033 * get the next page of results, set this parameter to the value of
4034 * nextPageToken from the previous response.
4035 */
4036 core.String pageToken;
4037
4038
4039 SearchReadsetsRequest();
4040
4041 SearchReadsetsRequest.fromJson(core.Map _json) {
4042 if (_json.containsKey("datasetIds")) {
4043 datasetIds = _json["datasetIds"];
4044 }
4045 if (_json.containsKey("maxResults")) {
4046 maxResults = _json["maxResults"];
4047 }
4048 if (_json.containsKey("name")) {
4049 name = _json["name"];
4050 }
4051 if (_json.containsKey("pageToken")) {
4052 pageToken = _json["pageToken"];
4053 }
4054 }
4055
4056 core.Map toJson() {
4057 var _json = new core.Map();
4058 if (datasetIds != null) {
4059 _json["datasetIds"] = datasetIds;
4060 }
4061 if (maxResults != null) {
4062 _json["maxResults"] = maxResults;
4063 }
4064 if (name != null) {
4065 _json["name"] = name;
4066 }
4067 if (pageToken != null) {
4068 _json["pageToken"] = pageToken;
4069 }
4070 return _json;
4071 }
4072 }
4073
4074
4075 /** The readset search response. */
4076 class SearchReadsetsResponse {
4077 /**
4078 * The continuation token, which is used to page through large result sets.
4079 * Provide this value in a subsequent request to return the next page of
4080 * results. This field will be empty if there aren't any additional results.
4081 */
4082 core.String nextPageToken;
4083
4084 /** The list of matching Readsets. */
4085 core.List<Readset> readsets;
4086
4087
4088 SearchReadsetsResponse();
4089
4090 SearchReadsetsResponse.fromJson(core.Map _json) {
4091 if (_json.containsKey("nextPageToken")) {
4092 nextPageToken = _json["nextPageToken"];
4093 }
4094 if (_json.containsKey("readsets")) {
4095 readsets = _json["readsets"].map((value) => new Readset.fromJson(value)).t oList();
4096 }
4097 }
4098
4099 core.Map toJson() {
4100 var _json = new core.Map();
4101 if (nextPageToken != null) {
4102 _json["nextPageToken"] = nextPageToken;
4103 }
4104 if (readsets != null) {
4105 _json["readsets"] = readsets.map((value) => (value).toJson()).toList();
4106 }
4107 return _json;
4108 }
4109 }
4110
4111
4112 /** The search variant sets request. */
4113 class SearchVariantSetsRequest {
4114 /**
4115 * Exactly one dataset ID must be provided here. Only variant sets which
4116 * belong to this dataset will be returned.
4117 */
4118 core.List<core.String> datasetIds;
4119
4120 /** The maximum number of variant sets to return in a request. */
4121 core.int pageSize;
4122
4123 /**
4124 * The continuation token, which is used to page through large result sets. To
4125 * get the next page of results, set this parameter to the value of
4126 * nextPageToken from the previous response.
4127 */
4128 core.String pageToken;
4129
4130
4131 SearchVariantSetsRequest();
4132
4133 SearchVariantSetsRequest.fromJson(core.Map _json) {
4134 if (_json.containsKey("datasetIds")) {
4135 datasetIds = _json["datasetIds"];
4136 }
4137 if (_json.containsKey("pageSize")) {
4138 pageSize = _json["pageSize"];
4139 }
4140 if (_json.containsKey("pageToken")) {
4141 pageToken = _json["pageToken"];
4142 }
4143 }
4144
4145 core.Map toJson() {
4146 var _json = new core.Map();
4147 if (datasetIds != null) {
4148 _json["datasetIds"] = datasetIds;
4149 }
4150 if (pageSize != null) {
4151 _json["pageSize"] = pageSize;
4152 }
4153 if (pageToken != null) {
4154 _json["pageToken"] = pageToken;
4155 }
4156 return _json;
4157 }
4158 }
4159
4160
4161 /** The search variant sets response. */
4162 class SearchVariantSetsResponse {
4163 /**
4164 * The continuation token, which is used to page through large result sets.
4165 * Provide this value in a subsequent request to return the next page of
4166 * results. This field will be empty if there aren't any additional results.
4167 */
4168 core.String nextPageToken;
4169
4170 /** The variant sets belonging to the requested dataset. */
4171 core.List<VariantSet> variantSets;
4172
4173
4174 SearchVariantSetsResponse();
4175
4176 SearchVariantSetsResponse.fromJson(core.Map _json) {
4177 if (_json.containsKey("nextPageToken")) {
4178 nextPageToken = _json["nextPageToken"];
4179 }
4180 if (_json.containsKey("variantSets")) {
4181 variantSets = _json["variantSets"].map((value) => new VariantSet.fromJson( value)).toList();
4182 }
4183 }
4184
4185 core.Map toJson() {
4186 var _json = new core.Map();
4187 if (nextPageToken != null) {
4188 _json["nextPageToken"] = nextPageToken;
4189 }
4190 if (variantSets != null) {
4191 _json["variantSets"] = variantSets.map((value) => (value).toJson()).toList ();
4192 }
4193 return _json;
4194 }
4195 }
4196
4197
4198 /** The variant search request. */
4199 class SearchVariantsRequest {
4200 /**
4201 * Only return variant calls which belong to call sets with these ids. Leaving
4202 * this blank returns all variant calls. If a variant has no calls belonging
4203 * to any of these call sets, it won't be returned at all. Currently, variants
4204 * with no calls from any call set will never be returned.
4205 */
4206 core.List<core.String> callSetIds;
4207
4208 /**
4209 * Required. The end of the window (0-based, exclusive) for which overlapping
4210 * variants should be returned.
4211 */
4212 core.String end;
4213
4214 /**
4215 * The maximum number of calls to return. However, at least one variant will
4216 * always be returned, even if it has more calls than this limit.
4217 */
4218 core.int maxCalls;
4219
4220 /** The maximum number of variants to return. */
4221 core.int pageSize;
4222
4223 /**
4224 * The continuation token, which is used to page through large result sets. To
4225 * get the next page of results, set this parameter to the value of
4226 * nextPageToken from the previous response.
4227 */
4228 core.String pageToken;
4229
4230 /** Required. Only return variants in this reference sequence. */
4231 core.String referenceName;
4232
4233 /**
4234 * Required. The beginning of the window (0-based, inclusive) for which
4235 * overlapping variants should be returned.
4236 */
4237 core.String start;
4238
4239 /** Only return variants which have exactly this name. */
4240 core.String variantName;
4241
4242 /**
4243 * Exactly one variant set ID must be provided. Only variants from this
4244 * variant set will be returned.
4245 */
4246 core.List<core.String> variantSetIds;
4247
4248
4249 SearchVariantsRequest();
4250
4251 SearchVariantsRequest.fromJson(core.Map _json) {
4252 if (_json.containsKey("callSetIds")) {
4253 callSetIds = _json["callSetIds"];
4254 }
4255 if (_json.containsKey("end")) {
4256 end = _json["end"];
4257 }
4258 if (_json.containsKey("maxCalls")) {
4259 maxCalls = _json["maxCalls"];
4260 }
4261 if (_json.containsKey("pageSize")) {
4262 pageSize = _json["pageSize"];
4263 }
4264 if (_json.containsKey("pageToken")) {
4265 pageToken = _json["pageToken"];
4266 }
4267 if (_json.containsKey("referenceName")) {
4268 referenceName = _json["referenceName"];
4269 }
4270 if (_json.containsKey("start")) {
4271 start = _json["start"];
4272 }
4273 if (_json.containsKey("variantName")) {
4274 variantName = _json["variantName"];
4275 }
4276 if (_json.containsKey("variantSetIds")) {
4277 variantSetIds = _json["variantSetIds"];
4278 }
4279 }
4280
4281 core.Map toJson() {
4282 var _json = new core.Map();
4283 if (callSetIds != null) {
4284 _json["callSetIds"] = callSetIds;
4285 }
4286 if (end != null) {
4287 _json["end"] = end;
4288 }
4289 if (maxCalls != null) {
4290 _json["maxCalls"] = maxCalls;
4291 }
4292 if (pageSize != null) {
4293 _json["pageSize"] = pageSize;
4294 }
4295 if (pageToken != null) {
4296 _json["pageToken"] = pageToken;
4297 }
4298 if (referenceName != null) {
4299 _json["referenceName"] = referenceName;
4300 }
4301 if (start != null) {
4302 _json["start"] = start;
4303 }
4304 if (variantName != null) {
4305 _json["variantName"] = variantName;
4306 }
4307 if (variantSetIds != null) {
4308 _json["variantSetIds"] = variantSetIds;
4309 }
4310 return _json;
4311 }
4312 }
4313
4314
4315 /** The variant search response. */
4316 class SearchVariantsResponse {
4317 /**
4318 * The continuation token, which is used to page through large result sets.
4319 * Provide this value in a subsequent request to return the next page of
4320 * results. This field will be empty if there aren't any additional results.
4321 */
4322 core.String nextPageToken;
4323
4324 /** The list of matching Variants. */
4325 core.List<Variant> variants;
4326
4327
4328 SearchVariantsResponse();
4329
4330 SearchVariantsResponse.fromJson(core.Map _json) {
4331 if (_json.containsKey("nextPageToken")) {
4332 nextPageToken = _json["nextPageToken"];
4333 }
4334 if (_json.containsKey("variants")) {
4335 variants = _json["variants"].map((value) => new Variant.fromJson(value)).t oList();
4336 }
4337 }
4338
4339 core.Map toJson() {
4340 var _json = new core.Map();
4341 if (nextPageToken != null) {
4342 _json["nextPageToken"] = nextPageToken;
4343 }
4344 if (variants != null) {
4345 _json["variants"] = variants.map((value) => (value).toJson()).toList();
4346 }
4347 return _json;
4348 }
4349 }
4350
4351
4352 /**
4353 * A variant represents a change in DNA sequence relative to a reference
4354 * sequence. For example, a variant could represent a SNP or an insertion.
4355 * Variants belong to a variant set. Each of the calls on a variant represent a
4356 * determination of genotype with respect to that variant. For example, a call
4357 * might assign probability of 0.32 to the occurrence of a SNP named rs1234 in a
4358 * sample named NA12345. A call belongs to a call set, which contains related
4359 * calls typically from one sample.
4360 */
4361 class Variant {
4362 /** The bases that appear instead of the reference bases. */
4363 core.List<core.String> alternateBases;
4364
4365 /**
4366 * The variant calls for this particular variant. Each one represents the
4367 * determination of genotype with respect to this variant.
4368 */
4369 core.List<Call> calls;
4370
4371 /** The date this variant was created, in milliseconds from the epoch. */
4372 core.String created;
4373
4374 /**
4375 * The end position (0-based) of this variant. This corresponds to the first
4376 * base after the last base in the reference allele. So, the length of the
4377 * reference allele is (end - start). This is useful for variants that don't
4378 * explicitly give alternate bases, for example large deletions.
4379 */
4380 core.String end;
4381
4382 /**
4383 * A list of filters (normally quality filters) this variant has failed. PASS
4384 * indicates this variant has passed all filters.
4385 */
4386 core.List<core.String> filter;
4387
4388 /** The Google generated ID of the variant, immutable. */
4389 core.String id;
4390
4391 /** A map of additional variant information. */
4392 core.Map<core.String, core.List<core.String>> info;
4393
4394 /** Names for the variant, for example a RefSNP ID. */
4395 core.List<core.String> names;
4396
4397 /**
4398 * A measure of how likely this variant is to be real. A higher value is
4399 * better.
4400 */
4401 core.double quality;
4402
4403 /**
4404 * The reference bases for this variant. They start at the given position.
4405 */
4406 core.String referenceBases;
4407
4408 /** The reference on which this variant occurs. (such as chr20 or X) */
4409 core.String referenceName;
4410
4411 /**
4412 * The position at which this variant occurs (0-based). This corresponds to
4413 * the first base of the string of reference bases.
4414 */
4415 core.String start;
4416
4417 /** The ID of the variant set this variant belongs to. */
4418 core.String variantSetId;
4419
4420
4421 Variant();
4422
4423 Variant.fromJson(core.Map _json) {
4424 if (_json.containsKey("alternateBases")) {
4425 alternateBases = _json["alternateBases"];
4426 }
4427 if (_json.containsKey("calls")) {
4428 calls = _json["calls"].map((value) => new Call.fromJson(value)).toList();
4429 }
4430 if (_json.containsKey("created")) {
4431 created = _json["created"];
4432 }
4433 if (_json.containsKey("end")) {
4434 end = _json["end"];
4435 }
4436 if (_json.containsKey("filter")) {
4437 filter = _json["filter"];
4438 }
4439 if (_json.containsKey("id")) {
4440 id = _json["id"];
4441 }
4442 if (_json.containsKey("info")) {
4443 info = _json["info"];
4444 }
4445 if (_json.containsKey("names")) {
4446 names = _json["names"];
4447 }
4448 if (_json.containsKey("quality")) {
4449 quality = _json["quality"];
4450 }
4451 if (_json.containsKey("referenceBases")) {
4452 referenceBases = _json["referenceBases"];
4453 }
4454 if (_json.containsKey("referenceName")) {
4455 referenceName = _json["referenceName"];
4456 }
4457 if (_json.containsKey("start")) {
4458 start = _json["start"];
4459 }
4460 if (_json.containsKey("variantSetId")) {
4461 variantSetId = _json["variantSetId"];
4462 }
4463 }
4464
4465 core.Map toJson() {
4466 var _json = new core.Map();
4467 if (alternateBases != null) {
4468 _json["alternateBases"] = alternateBases;
4469 }
4470 if (calls != null) {
4471 _json["calls"] = calls.map((value) => (value).toJson()).toList();
4472 }
4473 if (created != null) {
4474 _json["created"] = created;
4475 }
4476 if (end != null) {
4477 _json["end"] = end;
4478 }
4479 if (filter != null) {
4480 _json["filter"] = filter;
4481 }
4482 if (id != null) {
4483 _json["id"] = id;
4484 }
4485 if (info != null) {
4486 _json["info"] = info;
4487 }
4488 if (names != null) {
4489 _json["names"] = names;
4490 }
4491 if (quality != null) {
4492 _json["quality"] = quality;
4493 }
4494 if (referenceBases != null) {
4495 _json["referenceBases"] = referenceBases;
4496 }
4497 if (referenceName != null) {
4498 _json["referenceName"] = referenceName;
4499 }
4500 if (start != null) {
4501 _json["start"] = start;
4502 }
4503 if (variantSetId != null) {
4504 _json["variantSetId"] = variantSetId;
4505 }
4506 return _json;
4507 }
4508 }
4509
4510
4511 /**
4512 * A variant set is a collection of call sets and variants. It contains summary
4513 * statistics of those contents. A variant set belongs to a dataset.
4514 */
4515 class VariantSet {
4516 /** The dataset to which this variant set belongs. Immutable. */
4517 core.String datasetId;
4518
4519 /** The Google-generated ID of the variant set. Immutable. */
4520 core.String id;
4521
4522 /** The metadata associated with this variant set. */
4523 core.List<Metadata> metadata;
4524
4525 /**
4526 * A list of all references used by the variants in a variant set with
4527 * associated coordinate upper bounds for each one.
4528 */
4529 core.List<ReferenceBound> referenceBounds;
4530
4531
4532 VariantSet();
4533
4534 VariantSet.fromJson(core.Map _json) {
4535 if (_json.containsKey("datasetId")) {
4536 datasetId = _json["datasetId"];
4537 }
4538 if (_json.containsKey("id")) {
4539 id = _json["id"];
4540 }
4541 if (_json.containsKey("metadata")) {
4542 metadata = _json["metadata"].map((value) => new Metadata.fromJson(value)). toList();
4543 }
4544 if (_json.containsKey("referenceBounds")) {
4545 referenceBounds = _json["referenceBounds"].map((value) => new ReferenceBou nd.fromJson(value)).toList();
4546 }
4547 }
4548
4549 core.Map toJson() {
4550 var _json = new core.Map();
4551 if (datasetId != null) {
4552 _json["datasetId"] = datasetId;
4553 }
4554 if (id != null) {
4555 _json["id"] = id;
4556 }
4557 if (metadata != null) {
4558 _json["metadata"] = metadata.map((value) => (value).toJson()).toList();
4559 }
4560 if (referenceBounds != null) {
4561 _json["referenceBounds"] = referenceBounds.map((value) => (value).toJson() ).toList();
4562 }
4563 return _json;
4564 }
4565 }
4566
4567
OLDNEW
« no previous file with comments | « generated/googleapis_beta/lib/dns/v1beta1.dart ('k') | generated/googleapis_beta/lib/genomics/v1beta2.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698