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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 2571553005: Api-roll 43: 2016-12-13 (Closed)
Patch Set: Created 4 years 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/datastore/v1beta3.dart ('k') | generated/googleapis_beta/lib/language/v1beta1.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 // This is a generated file (see the discoveryapis_generator project).
2
3 library googleapis_beta.genomics.v1beta2;
4
5 import 'dart:core' as core;
6 import 'dart:async' as async;
7 import 'dart:convert' as convert;
8
9 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
10 import 'package:http/http.dart' as http;
11
12 export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
13 ApiRequestError, DetailedApiRequestError;
14
15 const core.String USER_AGENT = 'dart-api-client genomics/v1beta2';
16
17 /** Provides access to Genomics data. */
18 class GenomicsApi {
19 /** View and manage your data in Google BigQuery */
20 static const BigqueryScope = "https://www.googleapis.com/auth/bigquery";
21
22 /** View and manage your data across Google Cloud Platform services */
23 static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platf orm";
24
25 /** Manage your data in Google Cloud Storage */
26 static const DevstorageReadWriteScope = "https://www.googleapis.com/auth/devst orage.read_write";
27
28 /** View and manage Genomics data */
29 static const GenomicsScope = "https://www.googleapis.com/auth/genomics";
30
31 /** View Genomics data */
32 static const GenomicsReadonlyScope = "https://www.googleapis.com/auth/genomics .readonly";
33
34
35 final commons.ApiRequester _requester;
36
37 AnnotationSetsResourceApi get annotationSets => new AnnotationSetsResourceApi( _requester);
38 AnnotationsResourceApi get annotations => new AnnotationsResourceApi(_requeste r);
39 CallsetsResourceApi get callsets => new CallsetsResourceApi(_requester);
40 DatasetsResourceApi get datasets => new DatasetsResourceApi(_requester);
41 ExperimentalResourceApi get experimental => new ExperimentalResourceApi(_reque ster);
42 JobsResourceApi get jobs => new JobsResourceApi(_requester);
43 ReadgroupsetsResourceApi get readgroupsets => new ReadgroupsetsResourceApi(_re quester);
44 ReadsResourceApi get reads => new ReadsResourceApi(_requester);
45 ReferencesResourceApi get references => new ReferencesResourceApi(_requester);
46 ReferencesetsResourceApi get referencesets => new ReferencesetsResourceApi(_re quester);
47 VariantsResourceApi get variants => new VariantsResourceApi(_requester);
48 VariantsetsResourceApi get variantsets => new VariantsetsResourceApi(_requeste r);
49
50 GenomicsApi(http.Client client, {core.String rootUrl: "https://www.googleapis. com/", core.String servicePath: "genomics/v1beta2/"}) :
51 _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_A GENT);
52 }
53
54
55 class AnnotationSetsResourceApi {
56 final commons.ApiRequester _requester;
57
58 AnnotationSetsResourceApi(commons.ApiRequester client) :
59 _requester = client;
60
61 /**
62 * Creates a new annotation set. Caller must have WRITE permission for the
63 * associated dataset.
64 *
65 * The following fields must be provided when creating an annotation set:
66 * - datasetId
67 * - referenceSetId
68 * All other fields may be optionally specified, unless documented as being
69 * server-generated (for example, the id field).
70 *
71 * [request] - The metadata request object.
72 *
73 * Request parameters:
74 *
75 * Completes with a [AnnotationSet].
76 *
77 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
78 * error.
79 *
80 * If the used [http.Client] completes with an error when making a REST call,
81 * this method will complete with the same error.
82 */
83 async.Future<AnnotationSet> create(AnnotationSet request) {
84 var _url = null;
85 var _queryParams = new core.Map();
86 var _uploadMedia = null;
87 var _uploadOptions = null;
88 var _downloadOptions = commons.DownloadOptions.Metadata;
89 var _body = null;
90
91 if (request != null) {
92 _body = convert.JSON.encode((request).toJson());
93 }
94
95 _url = 'annotationSets';
96
97 var _response = _requester.request(_url,
98 "POST",
99 body: _body,
100 queryParams: _queryParams,
101 uploadOptions: _uploadOptions,
102 uploadMedia: _uploadMedia,
103 downloadOptions: _downloadOptions);
104 return _response.then((data) => new AnnotationSet.fromJson(data));
105 }
106
107 /**
108 * Deletes an annotation set. Caller must have WRITE permission for the
109 * associated annotation set.
110 *
111 * Request parameters:
112 *
113 * [annotationSetId] - The ID of the annotation set to be deleted.
114 *
115 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
116 * error.
117 *
118 * If the used [http.Client] completes with an error when making a REST call,
119 * this method will complete with the same error.
120 */
121 async.Future delete(core.String annotationSetId) {
122 var _url = null;
123 var _queryParams = new core.Map();
124 var _uploadMedia = null;
125 var _uploadOptions = null;
126 var _downloadOptions = commons.DownloadOptions.Metadata;
127 var _body = null;
128
129 if (annotationSetId == null) {
130 throw new core.ArgumentError("Parameter annotationSetId is required.");
131 }
132
133 _downloadOptions = null;
134
135 _url = 'annotationSets/' + commons.Escaper.ecapeVariable('$annotationSetId') ;
136
137 var _response = _requester.request(_url,
138 "DELETE",
139 body: _body,
140 queryParams: _queryParams,
141 uploadOptions: _uploadOptions,
142 uploadMedia: _uploadMedia,
143 downloadOptions: _downloadOptions);
144 return _response.then((data) => null);
145 }
146
147 /**
148 * Gets an annotation set. Caller must have READ permission for the associated
149 * dataset.
150 *
151 * Request parameters:
152 *
153 * [annotationSetId] - The ID of the annotation set to be retrieved.
154 *
155 * Completes with a [AnnotationSet].
156 *
157 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
158 * error.
159 *
160 * If the used [http.Client] completes with an error when making a REST call,
161 * this method will complete with the same error.
162 */
163 async.Future<AnnotationSet> get(core.String annotationSetId) {
164 var _url = null;
165 var _queryParams = new core.Map();
166 var _uploadMedia = null;
167 var _uploadOptions = null;
168 var _downloadOptions = commons.DownloadOptions.Metadata;
169 var _body = null;
170
171 if (annotationSetId == null) {
172 throw new core.ArgumentError("Parameter annotationSetId is required.");
173 }
174
175 _url = 'annotationSets/' + commons.Escaper.ecapeVariable('$annotationSetId') ;
176
177 var _response = _requester.request(_url,
178 "GET",
179 body: _body,
180 queryParams: _queryParams,
181 uploadOptions: _uploadOptions,
182 uploadMedia: _uploadMedia,
183 downloadOptions: _downloadOptions);
184 return _response.then((data) => new AnnotationSet.fromJson(data));
185 }
186
187 /**
188 * Updates an annotation set. The update must respect all mutability
189 * restrictions and other invariants described on the annotation set resource.
190 * Caller must have WRITE permission for the associated dataset. This method
191 * supports patch semantics.
192 *
193 * [request] - The metadata request object.
194 *
195 * Request parameters:
196 *
197 * [annotationSetId] - The ID of the annotation set to be updated.
198 *
199 * Completes with a [AnnotationSet].
200 *
201 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
202 * error.
203 *
204 * If the used [http.Client] completes with an error when making a REST call,
205 * this method will complete with the same error.
206 */
207 async.Future<AnnotationSet> patch(AnnotationSet request, core.String annotatio nSetId) {
208 var _url = null;
209 var _queryParams = new core.Map();
210 var _uploadMedia = null;
211 var _uploadOptions = null;
212 var _downloadOptions = commons.DownloadOptions.Metadata;
213 var _body = null;
214
215 if (request != null) {
216 _body = convert.JSON.encode((request).toJson());
217 }
218 if (annotationSetId == null) {
219 throw new core.ArgumentError("Parameter annotationSetId is required.");
220 }
221
222 _url = 'annotationSets/' + commons.Escaper.ecapeVariable('$annotationSetId') ;
223
224 var _response = _requester.request(_url,
225 "PATCH",
226 body: _body,
227 queryParams: _queryParams,
228 uploadOptions: _uploadOptions,
229 uploadMedia: _uploadMedia,
230 downloadOptions: _downloadOptions);
231 return _response.then((data) => new AnnotationSet.fromJson(data));
232 }
233
234 /**
235 * Searches for annotation sets that match the given criteria. Annotation sets
236 * are returned in an unspecified order. This order is consistent, such that
237 * two queries for the same content (regardless of page size) yield annotation
238 * sets in the same order across their respective streams of paginated
239 * responses. Caller must have READ permission for the queried datasets.
240 *
241 * [request] - The metadata request object.
242 *
243 * Request parameters:
244 *
245 * Completes with a [SearchAnnotationSetsResponse].
246 *
247 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
248 * error.
249 *
250 * If the used [http.Client] completes with an error when making a REST call,
251 * this method will complete with the same error.
252 */
253 async.Future<SearchAnnotationSetsResponse> search(SearchAnnotationSetsRequest request) {
254 var _url = null;
255 var _queryParams = new core.Map();
256 var _uploadMedia = null;
257 var _uploadOptions = null;
258 var _downloadOptions = commons.DownloadOptions.Metadata;
259 var _body = null;
260
261 if (request != null) {
262 _body = convert.JSON.encode((request).toJson());
263 }
264
265 _url = 'annotationSets/search';
266
267 var _response = _requester.request(_url,
268 "POST",
269 body: _body,
270 queryParams: _queryParams,
271 uploadOptions: _uploadOptions,
272 uploadMedia: _uploadMedia,
273 downloadOptions: _downloadOptions);
274 return _response.then((data) => new SearchAnnotationSetsResponse.fromJson(da ta));
275 }
276
277 /**
278 * Updates an annotation set. The update must respect all mutability
279 * restrictions and other invariants described on the annotation set resource.
280 * Caller must have WRITE permission for the associated dataset.
281 *
282 * [request] - The metadata request object.
283 *
284 * Request parameters:
285 *
286 * [annotationSetId] - The ID of the annotation set to be updated.
287 *
288 * Completes with a [AnnotationSet].
289 *
290 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
291 * error.
292 *
293 * If the used [http.Client] completes with an error when making a REST call,
294 * this method will complete with the same error.
295 */
296 async.Future<AnnotationSet> update(AnnotationSet request, core.String annotati onSetId) {
297 var _url = null;
298 var _queryParams = new core.Map();
299 var _uploadMedia = null;
300 var _uploadOptions = null;
301 var _downloadOptions = commons.DownloadOptions.Metadata;
302 var _body = null;
303
304 if (request != null) {
305 _body = convert.JSON.encode((request).toJson());
306 }
307 if (annotationSetId == null) {
308 throw new core.ArgumentError("Parameter annotationSetId is required.");
309 }
310
311 _url = 'annotationSets/' + commons.Escaper.ecapeVariable('$annotationSetId') ;
312
313 var _response = _requester.request(_url,
314 "PUT",
315 body: _body,
316 queryParams: _queryParams,
317 uploadOptions: _uploadOptions,
318 uploadMedia: _uploadMedia,
319 downloadOptions: _downloadOptions);
320 return _response.then((data) => new AnnotationSet.fromJson(data));
321 }
322
323 }
324
325
326 class AnnotationsResourceApi {
327 final commons.ApiRequester _requester;
328
329 AnnotationsResourceApi(commons.ApiRequester client) :
330 _requester = client;
331
332 /**
333 * Creates one or more new annotations atomically. All annotations must belong
334 * to the same annotation set. Caller must have WRITE permission for this
335 * annotation set. For optimal performance, batch positionally adjacent
336 * annotations together.
337 *
338 *
339 * If the request has a systemic issue, such as an attempt to write to an
340 * inaccessible annotation set, the entire RPC will fail accordingly. For
341 * lesser data issues, when possible an error will be isolated to the
342 * corresponding batch entry in the response; the remaining well formed
343 * annotations will be created normally.
344 *
345 *
346 * For details on the requirements for each individual annotation resource,
347 * see annotations.create.
348 *
349 * [request] - The metadata request object.
350 *
351 * Request parameters:
352 *
353 * Completes with a [BatchAnnotationsResponse].
354 *
355 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
356 * error.
357 *
358 * If the used [http.Client] completes with an error when making a REST call,
359 * this method will complete with the same error.
360 */
361 async.Future<BatchAnnotationsResponse> batchCreate(BatchCreateAnnotationsReque st request) {
362 var _url = null;
363 var _queryParams = new core.Map();
364 var _uploadMedia = null;
365 var _uploadOptions = null;
366 var _downloadOptions = commons.DownloadOptions.Metadata;
367 var _body = null;
368
369 if (request != null) {
370 _body = convert.JSON.encode((request).toJson());
371 }
372
373 _url = 'annotations:batchCreate';
374
375 var _response = _requester.request(_url,
376 "POST",
377 body: _body,
378 queryParams: _queryParams,
379 uploadOptions: _uploadOptions,
380 uploadMedia: _uploadMedia,
381 downloadOptions: _downloadOptions);
382 return _response.then((data) => new BatchAnnotationsResponse.fromJson(data)) ;
383 }
384
385 /**
386 * Creates a new annotation. Caller must have WRITE permission for the
387 * associated annotation set.
388 *
389 *
390 * The following fields must be provided when creating an annotation:
391 * - annotationSetId
392 * - position.referenceName or position.referenceId Transcripts
393 * For annotations of type TRANSCRIPT, the following fields of
394 * annotation.transcript must be provided:
395 * - exons.start
396 * - exons.end
397 * All other fields may be optionally specified, unless documented as being
398 * server-generated (for example, the id field). The annotated range must be
399 * no longer than 100Mbp (mega base pairs). See the annotation resource for
400 * additional restrictions on each field.
401 *
402 * [request] - The metadata request object.
403 *
404 * Request parameters:
405 *
406 * Completes with a [Annotation].
407 *
408 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
409 * error.
410 *
411 * If the used [http.Client] completes with an error when making a REST call,
412 * this method will complete with the same error.
413 */
414 async.Future<Annotation> create(Annotation request) {
415 var _url = null;
416 var _queryParams = new core.Map();
417 var _uploadMedia = null;
418 var _uploadOptions = null;
419 var _downloadOptions = commons.DownloadOptions.Metadata;
420 var _body = null;
421
422 if (request != null) {
423 _body = convert.JSON.encode((request).toJson());
424 }
425
426 _url = 'annotations';
427
428 var _response = _requester.request(_url,
429 "POST",
430 body: _body,
431 queryParams: _queryParams,
432 uploadOptions: _uploadOptions,
433 uploadMedia: _uploadMedia,
434 downloadOptions: _downloadOptions);
435 return _response.then((data) => new Annotation.fromJson(data));
436 }
437
438 /**
439 * Deletes an annotation. Caller must have WRITE permission for the associated
440 * annotation set.
441 *
442 * Request parameters:
443 *
444 * [annotationId] - The ID of the annotation to be deleted.
445 *
446 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
447 * error.
448 *
449 * If the used [http.Client] completes with an error when making a REST call,
450 * this method will complete with the same error.
451 */
452 async.Future delete(core.String annotationId) {
453 var _url = null;
454 var _queryParams = new core.Map();
455 var _uploadMedia = null;
456 var _uploadOptions = null;
457 var _downloadOptions = commons.DownloadOptions.Metadata;
458 var _body = null;
459
460 if (annotationId == null) {
461 throw new core.ArgumentError("Parameter annotationId is required.");
462 }
463
464 _downloadOptions = null;
465
466 _url = 'annotations/' + commons.Escaper.ecapeVariable('$annotationId');
467
468 var _response = _requester.request(_url,
469 "DELETE",
470 body: _body,
471 queryParams: _queryParams,
472 uploadOptions: _uploadOptions,
473 uploadMedia: _uploadMedia,
474 downloadOptions: _downloadOptions);
475 return _response.then((data) => null);
476 }
477
478 /**
479 * Gets an annotation. Caller must have READ permission for the associated
480 * annotation set.
481 *
482 * Request parameters:
483 *
484 * [annotationId] - The ID of the annotation to be retrieved.
485 *
486 * Completes with a [Annotation].
487 *
488 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
489 * error.
490 *
491 * If the used [http.Client] completes with an error when making a REST call,
492 * this method will complete with the same error.
493 */
494 async.Future<Annotation> get(core.String annotationId) {
495 var _url = null;
496 var _queryParams = new core.Map();
497 var _uploadMedia = null;
498 var _uploadOptions = null;
499 var _downloadOptions = commons.DownloadOptions.Metadata;
500 var _body = null;
501
502 if (annotationId == null) {
503 throw new core.ArgumentError("Parameter annotationId is required.");
504 }
505
506 _url = 'annotations/' + commons.Escaper.ecapeVariable('$annotationId');
507
508 var _response = _requester.request(_url,
509 "GET",
510 body: _body,
511 queryParams: _queryParams,
512 uploadOptions: _uploadOptions,
513 uploadMedia: _uploadMedia,
514 downloadOptions: _downloadOptions);
515 return _response.then((data) => new Annotation.fromJson(data));
516 }
517
518 /**
519 * Updates an annotation. The update must respect all mutability restrictions
520 * and other invariants described on the annotation resource. Caller must have
521 * WRITE permission for the associated dataset. This method supports patch
522 * semantics.
523 *
524 * [request] - The metadata request object.
525 *
526 * Request parameters:
527 *
528 * [annotationId] - The ID of the annotation to be updated.
529 *
530 * Completes with a [Annotation].
531 *
532 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
533 * error.
534 *
535 * If the used [http.Client] completes with an error when making a REST call,
536 * this method will complete with the same error.
537 */
538 async.Future<Annotation> patch(Annotation request, core.String annotationId) {
539 var _url = null;
540 var _queryParams = new core.Map();
541 var _uploadMedia = null;
542 var _uploadOptions = null;
543 var _downloadOptions = commons.DownloadOptions.Metadata;
544 var _body = null;
545
546 if (request != null) {
547 _body = convert.JSON.encode((request).toJson());
548 }
549 if (annotationId == null) {
550 throw new core.ArgumentError("Parameter annotationId is required.");
551 }
552
553 _url = 'annotations/' + commons.Escaper.ecapeVariable('$annotationId');
554
555 var _response = _requester.request(_url,
556 "PATCH",
557 body: _body,
558 queryParams: _queryParams,
559 uploadOptions: _uploadOptions,
560 uploadMedia: _uploadMedia,
561 downloadOptions: _downloadOptions);
562 return _response.then((data) => new Annotation.fromJson(data));
563 }
564
565 /**
566 * Searches for annotations that match the given criteria. Results are ordered
567 * by genomic coordinate (by reference sequence, then position). Annotations
568 * with equivalent genomic coordinates are returned in an unspecified order.
569 * This order is consistent, such that two queries for the same content
570 * (regardless of page size) yield annotations in the same order across their
571 * respective streams of paginated responses. Caller must have READ permission
572 * for the queried annotation sets.
573 *
574 * [request] - The metadata request object.
575 *
576 * Request parameters:
577 *
578 * Completes with a [SearchAnnotationsResponse].
579 *
580 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
581 * error.
582 *
583 * If the used [http.Client] completes with an error when making a REST call,
584 * this method will complete with the same error.
585 */
586 async.Future<SearchAnnotationsResponse> search(SearchAnnotationsRequest reques t) {
587 var _url = null;
588 var _queryParams = new core.Map();
589 var _uploadMedia = null;
590 var _uploadOptions = null;
591 var _downloadOptions = commons.DownloadOptions.Metadata;
592 var _body = null;
593
594 if (request != null) {
595 _body = convert.JSON.encode((request).toJson());
596 }
597
598 _url = 'annotations/search';
599
600 var _response = _requester.request(_url,
601 "POST",
602 body: _body,
603 queryParams: _queryParams,
604 uploadOptions: _uploadOptions,
605 uploadMedia: _uploadMedia,
606 downloadOptions: _downloadOptions);
607 return _response.then((data) => new SearchAnnotationsResponse.fromJson(data) );
608 }
609
610 /**
611 * Updates an annotation. The update must respect all mutability restrictions
612 * and other invariants described on the annotation resource. Caller must have
613 * WRITE permission for the associated dataset.
614 *
615 * [request] - The metadata request object.
616 *
617 * Request parameters:
618 *
619 * [annotationId] - The ID of the annotation to be updated.
620 *
621 * Completes with a [Annotation].
622 *
623 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
624 * error.
625 *
626 * If the used [http.Client] completes with an error when making a REST call,
627 * this method will complete with the same error.
628 */
629 async.Future<Annotation> update(Annotation request, core.String annotationId) {
630 var _url = null;
631 var _queryParams = new core.Map();
632 var _uploadMedia = null;
633 var _uploadOptions = null;
634 var _downloadOptions = commons.DownloadOptions.Metadata;
635 var _body = null;
636
637 if (request != null) {
638 _body = convert.JSON.encode((request).toJson());
639 }
640 if (annotationId == null) {
641 throw new core.ArgumentError("Parameter annotationId is required.");
642 }
643
644 _url = 'annotations/' + commons.Escaper.ecapeVariable('$annotationId');
645
646 var _response = _requester.request(_url,
647 "PUT",
648 body: _body,
649 queryParams: _queryParams,
650 uploadOptions: _uploadOptions,
651 uploadMedia: _uploadMedia,
652 downloadOptions: _downloadOptions);
653 return _response.then((data) => new Annotation.fromJson(data));
654 }
655
656 }
657
658
659 class CallsetsResourceApi {
660 final commons.ApiRequester _requester;
661
662 CallsetsResourceApi(commons.ApiRequester client) :
663 _requester = client;
664
665 /**
666 * Creates a new call set.
667 *
668 * [request] - The metadata request object.
669 *
670 * Request parameters:
671 *
672 * Completes with a [CallSet].
673 *
674 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
675 * error.
676 *
677 * If the used [http.Client] completes with an error when making a REST call,
678 * this method will complete with the same error.
679 */
680 async.Future<CallSet> create(CallSet request) {
681 var _url = null;
682 var _queryParams = new core.Map();
683 var _uploadMedia = null;
684 var _uploadOptions = null;
685 var _downloadOptions = commons.DownloadOptions.Metadata;
686 var _body = null;
687
688 if (request != null) {
689 _body = convert.JSON.encode((request).toJson());
690 }
691
692 _url = 'callsets';
693
694 var _response = _requester.request(_url,
695 "POST",
696 body: _body,
697 queryParams: _queryParams,
698 uploadOptions: _uploadOptions,
699 uploadMedia: _uploadMedia,
700 downloadOptions: _downloadOptions);
701 return _response.then((data) => new CallSet.fromJson(data));
702 }
703
704 /**
705 * Deletes a call set.
706 *
707 * Request parameters:
708 *
709 * [callSetId] - The ID of the call set to be deleted.
710 *
711 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
712 * error.
713 *
714 * If the used [http.Client] completes with an error when making a REST call,
715 * this method will complete with the same error.
716 */
717 async.Future delete(core.String callSetId) {
718 var _url = null;
719 var _queryParams = new core.Map();
720 var _uploadMedia = null;
721 var _uploadOptions = null;
722 var _downloadOptions = commons.DownloadOptions.Metadata;
723 var _body = null;
724
725 if (callSetId == null) {
726 throw new core.ArgumentError("Parameter callSetId is required.");
727 }
728
729 _downloadOptions = null;
730
731 _url = 'callsets/' + commons.Escaper.ecapeVariable('$callSetId');
732
733 var _response = _requester.request(_url,
734 "DELETE",
735 body: _body,
736 queryParams: _queryParams,
737 uploadOptions: _uploadOptions,
738 uploadMedia: _uploadMedia,
739 downloadOptions: _downloadOptions);
740 return _response.then((data) => null);
741 }
742
743 /**
744 * Gets a call set by ID.
745 *
746 * Request parameters:
747 *
748 * [callSetId] - The ID of the call set.
749 *
750 * Completes with a [CallSet].
751 *
752 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
753 * error.
754 *
755 * If the used [http.Client] completes with an error when making a REST call,
756 * this method will complete with the same error.
757 */
758 async.Future<CallSet> get(core.String callSetId) {
759 var _url = null;
760 var _queryParams = new core.Map();
761 var _uploadMedia = null;
762 var _uploadOptions = null;
763 var _downloadOptions = commons.DownloadOptions.Metadata;
764 var _body = null;
765
766 if (callSetId == null) {
767 throw new core.ArgumentError("Parameter callSetId is required.");
768 }
769
770 _url = 'callsets/' + commons.Escaper.ecapeVariable('$callSetId');
771
772 var _response = _requester.request(_url,
773 "GET",
774 body: _body,
775 queryParams: _queryParams,
776 uploadOptions: _uploadOptions,
777 uploadMedia: _uploadMedia,
778 downloadOptions: _downloadOptions);
779 return _response.then((data) => new CallSet.fromJson(data));
780 }
781
782 /**
783 * Updates a call set. This method supports patch semantics.
784 *
785 * [request] - The metadata request object.
786 *
787 * Request parameters:
788 *
789 * [callSetId] - Required. The ID of the call set to be updated.
790 *
791 * Completes with a [CallSet].
792 *
793 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
794 * error.
795 *
796 * If the used [http.Client] completes with an error when making a REST call,
797 * this method will complete with the same error.
798 */
799 async.Future<CallSet> patch(CallSet request, core.String callSetId) {
800 var _url = null;
801 var _queryParams = new core.Map();
802 var _uploadMedia = null;
803 var _uploadOptions = null;
804 var _downloadOptions = commons.DownloadOptions.Metadata;
805 var _body = null;
806
807 if (request != null) {
808 _body = convert.JSON.encode((request).toJson());
809 }
810 if (callSetId == null) {
811 throw new core.ArgumentError("Parameter callSetId is required.");
812 }
813
814 _url = 'callsets/' + commons.Escaper.ecapeVariable('$callSetId');
815
816 var _response = _requester.request(_url,
817 "PATCH",
818 body: _body,
819 queryParams: _queryParams,
820 uploadOptions: _uploadOptions,
821 uploadMedia: _uploadMedia,
822 downloadOptions: _downloadOptions);
823 return _response.then((data) => new CallSet.fromJson(data));
824 }
825
826 /**
827 * Gets a list of call sets matching the criteria.
828 *
829 * Implements GlobalAllianceApi.searchCallSets.
830 *
831 * [request] - The metadata request object.
832 *
833 * Request parameters:
834 *
835 * Completes with a [SearchCallSetsResponse].
836 *
837 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
838 * error.
839 *
840 * If the used [http.Client] completes with an error when making a REST call,
841 * this method will complete with the same error.
842 */
843 async.Future<SearchCallSetsResponse> search(SearchCallSetsRequest request) {
844 var _url = null;
845 var _queryParams = new core.Map();
846 var _uploadMedia = null;
847 var _uploadOptions = null;
848 var _downloadOptions = commons.DownloadOptions.Metadata;
849 var _body = null;
850
851 if (request != null) {
852 _body = convert.JSON.encode((request).toJson());
853 }
854
855 _url = 'callsets/search';
856
857 var _response = _requester.request(_url,
858 "POST",
859 body: _body,
860 queryParams: _queryParams,
861 uploadOptions: _uploadOptions,
862 uploadMedia: _uploadMedia,
863 downloadOptions: _downloadOptions);
864 return _response.then((data) => new SearchCallSetsResponse.fromJson(data));
865 }
866
867 /**
868 * Updates a call set.
869 *
870 * [request] - The metadata request object.
871 *
872 * Request parameters:
873 *
874 * [callSetId] - Required. The ID of the call set to be updated.
875 *
876 * Completes with a [CallSet].
877 *
878 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
879 * error.
880 *
881 * If the used [http.Client] completes with an error when making a REST call,
882 * this method will complete with the same error.
883 */
884 async.Future<CallSet> update(CallSet request, core.String callSetId) {
885 var _url = null;
886 var _queryParams = new core.Map();
887 var _uploadMedia = null;
888 var _uploadOptions = null;
889 var _downloadOptions = commons.DownloadOptions.Metadata;
890 var _body = null;
891
892 if (request != null) {
893 _body = convert.JSON.encode((request).toJson());
894 }
895 if (callSetId == null) {
896 throw new core.ArgumentError("Parameter callSetId is required.");
897 }
898
899 _url = 'callsets/' + commons.Escaper.ecapeVariable('$callSetId');
900
901 var _response = _requester.request(_url,
902 "PUT",
903 body: _body,
904 queryParams: _queryParams,
905 uploadOptions: _uploadOptions,
906 uploadMedia: _uploadMedia,
907 downloadOptions: _downloadOptions);
908 return _response.then((data) => new CallSet.fromJson(data));
909 }
910
911 }
912
913
914 class DatasetsResourceApi {
915 final commons.ApiRequester _requester;
916
917 DatasetsResourceApi(commons.ApiRequester client) :
918 _requester = client;
919
920 /**
921 * Creates a new dataset.
922 *
923 * [request] - The metadata request object.
924 *
925 * Request parameters:
926 *
927 * Completes with a [Dataset].
928 *
929 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
930 * error.
931 *
932 * If the used [http.Client] completes with an error when making a REST call,
933 * this method will complete with the same error.
934 */
935 async.Future<Dataset> create(Dataset request) {
936 var _url = null;
937 var _queryParams = new core.Map();
938 var _uploadMedia = null;
939 var _uploadOptions = null;
940 var _downloadOptions = commons.DownloadOptions.Metadata;
941 var _body = null;
942
943 if (request != null) {
944 _body = convert.JSON.encode((request).toJson());
945 }
946
947 _url = 'datasets';
948
949 var _response = _requester.request(_url,
950 "POST",
951 body: _body,
952 queryParams: _queryParams,
953 uploadOptions: _uploadOptions,
954 uploadMedia: _uploadMedia,
955 downloadOptions: _downloadOptions);
956 return _response.then((data) => new Dataset.fromJson(data));
957 }
958
959 /**
960 * Deletes a dataset and all of its contents (all read group sets, reference
961 * sets, variant sets, call sets, annotation sets, etc.) This is reversible
962 * (up to one week after the deletion) via the UndeleteDataset operation.
963 *
964 * Request parameters:
965 *
966 * [datasetId] - The ID of the dataset to be deleted.
967 *
968 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
969 * error.
970 *
971 * If the used [http.Client] completes with an error when making a REST call,
972 * this method will complete with the same error.
973 */
974 async.Future delete(core.String datasetId) {
975 var _url = null;
976 var _queryParams = new core.Map();
977 var _uploadMedia = null;
978 var _uploadOptions = null;
979 var _downloadOptions = commons.DownloadOptions.Metadata;
980 var _body = null;
981
982 if (datasetId == null) {
983 throw new core.ArgumentError("Parameter datasetId is required.");
984 }
985
986 _downloadOptions = null;
987
988 _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId');
989
990 var _response = _requester.request(_url,
991 "DELETE",
992 body: _body,
993 queryParams: _queryParams,
994 uploadOptions: _uploadOptions,
995 uploadMedia: _uploadMedia,
996 downloadOptions: _downloadOptions);
997 return _response.then((data) => null);
998 }
999
1000 /**
1001 * Gets a dataset by ID.
1002 *
1003 * Request parameters:
1004 *
1005 * [datasetId] - The ID of the dataset.
1006 *
1007 * Completes with a [Dataset].
1008 *
1009 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1010 * error.
1011 *
1012 * If the used [http.Client] completes with an error when making a REST call,
1013 * this method will complete with the same error.
1014 */
1015 async.Future<Dataset> get(core.String datasetId) {
1016 var _url = null;
1017 var _queryParams = new core.Map();
1018 var _uploadMedia = null;
1019 var _uploadOptions = null;
1020 var _downloadOptions = commons.DownloadOptions.Metadata;
1021 var _body = null;
1022
1023 if (datasetId == null) {
1024 throw new core.ArgumentError("Parameter datasetId is required.");
1025 }
1026
1027 _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId');
1028
1029 var _response = _requester.request(_url,
1030 "GET",
1031 body: _body,
1032 queryParams: _queryParams,
1033 uploadOptions: _uploadOptions,
1034 uploadMedia: _uploadMedia,
1035 downloadOptions: _downloadOptions);
1036 return _response.then((data) => new Dataset.fromJson(data));
1037 }
1038
1039 /**
1040 * Lists datasets within a project.
1041 *
1042 * Request parameters:
1043 *
1044 * [pageSize] - The maximum number of results to return in a single page. If
1045 * unspecified, defaults to 50. The maximum value is 1024.
1046 *
1047 * [pageToken] - The continuation token, which is used to page through large
1048 * result sets. To get the next page of results, set this parameter to the
1049 * value of nextPageToken from the previous response.
1050 *
1051 * [projectNumber] - Required. The project to list datasets for.
1052 *
1053 * Completes with a [ListDatasetsResponse].
1054 *
1055 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1056 * error.
1057 *
1058 * If the used [http.Client] completes with an error when making a REST call,
1059 * this method will complete with the same error.
1060 */
1061 async.Future<ListDatasetsResponse> list({core.int pageSize, core.String pageTo ken, core.String projectNumber}) {
1062 var _url = null;
1063 var _queryParams = new core.Map();
1064 var _uploadMedia = null;
1065 var _uploadOptions = null;
1066 var _downloadOptions = commons.DownloadOptions.Metadata;
1067 var _body = null;
1068
1069 if (pageSize != null) {
1070 _queryParams["pageSize"] = ["${pageSize}"];
1071 }
1072 if (pageToken != null) {
1073 _queryParams["pageToken"] = [pageToken];
1074 }
1075 if (projectNumber != null) {
1076 _queryParams["projectNumber"] = [projectNumber];
1077 }
1078
1079 _url = 'datasets';
1080
1081 var _response = _requester.request(_url,
1082 "GET",
1083 body: _body,
1084 queryParams: _queryParams,
1085 uploadOptions: _uploadOptions,
1086 uploadMedia: _uploadMedia,
1087 downloadOptions: _downloadOptions);
1088 return _response.then((data) => new ListDatasetsResponse.fromJson(data));
1089 }
1090
1091 /**
1092 * Updates a dataset. This method supports patch semantics.
1093 *
1094 * [request] - The metadata request object.
1095 *
1096 * Request parameters:
1097 *
1098 * [datasetId] - The ID of the dataset to be updated.
1099 *
1100 * Completes with a [Dataset].
1101 *
1102 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1103 * error.
1104 *
1105 * If the used [http.Client] completes with an error when making a REST call,
1106 * this method will complete with the same error.
1107 */
1108 async.Future<Dataset> patch(Dataset request, core.String datasetId) {
1109 var _url = null;
1110 var _queryParams = new core.Map();
1111 var _uploadMedia = null;
1112 var _uploadOptions = null;
1113 var _downloadOptions = commons.DownloadOptions.Metadata;
1114 var _body = null;
1115
1116 if (request != null) {
1117 _body = convert.JSON.encode((request).toJson());
1118 }
1119 if (datasetId == null) {
1120 throw new core.ArgumentError("Parameter datasetId is required.");
1121 }
1122
1123 _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId');
1124
1125 var _response = _requester.request(_url,
1126 "PATCH",
1127 body: _body,
1128 queryParams: _queryParams,
1129 uploadOptions: _uploadOptions,
1130 uploadMedia: _uploadMedia,
1131 downloadOptions: _downloadOptions);
1132 return _response.then((data) => new Dataset.fromJson(data));
1133 }
1134
1135 /**
1136 * Undeletes a dataset by restoring a dataset which was deleted via this API.
1137 * This operation is only possible for a week after the deletion occurred.
1138 *
1139 * Request parameters:
1140 *
1141 * [datasetId] - The ID of the dataset to be undeleted.
1142 *
1143 * Completes with a [Dataset].
1144 *
1145 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1146 * error.
1147 *
1148 * If the used [http.Client] completes with an error when making a REST call,
1149 * this method will complete with the same error.
1150 */
1151 async.Future<Dataset> undelete(core.String datasetId) {
1152 var _url = null;
1153 var _queryParams = new core.Map();
1154 var _uploadMedia = null;
1155 var _uploadOptions = null;
1156 var _downloadOptions = commons.DownloadOptions.Metadata;
1157 var _body = null;
1158
1159 if (datasetId == null) {
1160 throw new core.ArgumentError("Parameter datasetId is required.");
1161 }
1162
1163 _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/undelet e';
1164
1165 var _response = _requester.request(_url,
1166 "POST",
1167 body: _body,
1168 queryParams: _queryParams,
1169 uploadOptions: _uploadOptions,
1170 uploadMedia: _uploadMedia,
1171 downloadOptions: _downloadOptions);
1172 return _response.then((data) => new Dataset.fromJson(data));
1173 }
1174
1175 /**
1176 * Updates a dataset.
1177 *
1178 * [request] - The metadata request object.
1179 *
1180 * Request parameters:
1181 *
1182 * [datasetId] - The ID of the dataset to be updated.
1183 *
1184 * Completes with a [Dataset].
1185 *
1186 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1187 * error.
1188 *
1189 * If the used [http.Client] completes with an error when making a REST call,
1190 * this method will complete with the same error.
1191 */
1192 async.Future<Dataset> update(Dataset request, core.String datasetId) {
1193 var _url = null;
1194 var _queryParams = new core.Map();
1195 var _uploadMedia = null;
1196 var _uploadOptions = null;
1197 var _downloadOptions = commons.DownloadOptions.Metadata;
1198 var _body = null;
1199
1200 if (request != null) {
1201 _body = convert.JSON.encode((request).toJson());
1202 }
1203 if (datasetId == null) {
1204 throw new core.ArgumentError("Parameter datasetId is required.");
1205 }
1206
1207 _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId');
1208
1209 var _response = _requester.request(_url,
1210 "PUT",
1211 body: _body,
1212 queryParams: _queryParams,
1213 uploadOptions: _uploadOptions,
1214 uploadMedia: _uploadMedia,
1215 downloadOptions: _downloadOptions);
1216 return _response.then((data) => new Dataset.fromJson(data));
1217 }
1218
1219 }
1220
1221
1222 class ExperimentalResourceApi {
1223 final commons.ApiRequester _requester;
1224
1225 ExperimentalJobsResourceApi get jobs => new ExperimentalJobsResourceApi(_reque ster);
1226
1227 ExperimentalResourceApi(commons.ApiRequester client) :
1228 _requester = client;
1229 }
1230
1231
1232 class ExperimentalJobsResourceApi {
1233 final commons.ApiRequester _requester;
1234
1235 ExperimentalJobsResourceApi(commons.ApiRequester client) :
1236 _requester = client;
1237
1238 /**
1239 * Creates and asynchronously runs an ad-hoc job. This is an experimental call
1240 * and may be removed or changed at any time.
1241 *
1242 * [request] - The metadata request object.
1243 *
1244 * Request parameters:
1245 *
1246 * Completes with a [ExperimentalCreateJobResponse].
1247 *
1248 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1249 * error.
1250 *
1251 * If the used [http.Client] completes with an error when making a REST call,
1252 * this method will complete with the same error.
1253 */
1254 async.Future<ExperimentalCreateJobResponse> create(ExperimentalCreateJobReques t request) {
1255 var _url = null;
1256 var _queryParams = new core.Map();
1257 var _uploadMedia = null;
1258 var _uploadOptions = null;
1259 var _downloadOptions = commons.DownloadOptions.Metadata;
1260 var _body = null;
1261
1262 if (request != null) {
1263 _body = convert.JSON.encode((request).toJson());
1264 }
1265
1266 _url = 'experimental/jobs/create';
1267
1268 var _response = _requester.request(_url,
1269 "POST",
1270 body: _body,
1271 queryParams: _queryParams,
1272 uploadOptions: _uploadOptions,
1273 uploadMedia: _uploadMedia,
1274 downloadOptions: _downloadOptions);
1275 return _response.then((data) => new ExperimentalCreateJobResponse.fromJson(d ata));
1276 }
1277
1278 }
1279
1280
1281 class JobsResourceApi {
1282 final commons.ApiRequester _requester;
1283
1284 JobsResourceApi(commons.ApiRequester client) :
1285 _requester = client;
1286
1287 /**
1288 * Cancels a job by ID. Note that it is possible for partial results to be
1289 * generated and stored for cancelled jobs.
1290 *
1291 * Request parameters:
1292 *
1293 * [jobId] - Required. The ID of the job.
1294 *
1295 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1296 * error.
1297 *
1298 * If the used [http.Client] completes with an error when making a REST call,
1299 * this method will complete with the same error.
1300 */
1301 async.Future cancel(core.String jobId) {
1302 var _url = null;
1303 var _queryParams = new core.Map();
1304 var _uploadMedia = null;
1305 var _uploadOptions = null;
1306 var _downloadOptions = commons.DownloadOptions.Metadata;
1307 var _body = null;
1308
1309 if (jobId == null) {
1310 throw new core.ArgumentError("Parameter jobId is required.");
1311 }
1312
1313 _downloadOptions = null;
1314
1315 _url = 'jobs/' + commons.Escaper.ecapeVariable('$jobId') + '/cancel';
1316
1317 var _response = _requester.request(_url,
1318 "POST",
1319 body: _body,
1320 queryParams: _queryParams,
1321 uploadOptions: _uploadOptions,
1322 uploadMedia: _uploadMedia,
1323 downloadOptions: _downloadOptions);
1324 return _response.then((data) => null);
1325 }
1326
1327 /**
1328 * Gets a job by ID.
1329 *
1330 * Request parameters:
1331 *
1332 * [jobId] - Required. The ID of the job.
1333 *
1334 * Completes with a [Job].
1335 *
1336 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1337 * error.
1338 *
1339 * If the used [http.Client] completes with an error when making a REST call,
1340 * this method will complete with the same error.
1341 */
1342 async.Future<Job> get(core.String jobId) {
1343 var _url = null;
1344 var _queryParams = new core.Map();
1345 var _uploadMedia = null;
1346 var _uploadOptions = null;
1347 var _downloadOptions = commons.DownloadOptions.Metadata;
1348 var _body = null;
1349
1350 if (jobId == null) {
1351 throw new core.ArgumentError("Parameter jobId is required.");
1352 }
1353
1354 _url = 'jobs/' + commons.Escaper.ecapeVariable('$jobId');
1355
1356 var _response = _requester.request(_url,
1357 "GET",
1358 body: _body,
1359 queryParams: _queryParams,
1360 uploadOptions: _uploadOptions,
1361 uploadMedia: _uploadMedia,
1362 downloadOptions: _downloadOptions);
1363 return _response.then((data) => new Job.fromJson(data));
1364 }
1365
1366 /**
1367 * Gets a list of jobs matching the criteria.
1368 *
1369 * [request] - The metadata request object.
1370 *
1371 * Request parameters:
1372 *
1373 * Completes with a [SearchJobsResponse].
1374 *
1375 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1376 * error.
1377 *
1378 * If the used [http.Client] completes with an error when making a REST call,
1379 * this method will complete with the same error.
1380 */
1381 async.Future<SearchJobsResponse> search(SearchJobsRequest request) {
1382 var _url = null;
1383 var _queryParams = new core.Map();
1384 var _uploadMedia = null;
1385 var _uploadOptions = null;
1386 var _downloadOptions = commons.DownloadOptions.Metadata;
1387 var _body = null;
1388
1389 if (request != null) {
1390 _body = convert.JSON.encode((request).toJson());
1391 }
1392
1393 _url = 'jobs/search';
1394
1395 var _response = _requester.request(_url,
1396 "POST",
1397 body: _body,
1398 queryParams: _queryParams,
1399 uploadOptions: _uploadOptions,
1400 uploadMedia: _uploadMedia,
1401 downloadOptions: _downloadOptions);
1402 return _response.then((data) => new SearchJobsResponse.fromJson(data));
1403 }
1404
1405 }
1406
1407
1408 class ReadgroupsetsResourceApi {
1409 final commons.ApiRequester _requester;
1410
1411 ReadgroupsetsCoveragebucketsResourceApi get coveragebuckets => new Readgroupse tsCoveragebucketsResourceApi(_requester);
1412
1413 ReadgroupsetsResourceApi(commons.ApiRequester client) :
1414 _requester = client;
1415
1416 /**
1417 * Deletes a read group set.
1418 *
1419 * Request parameters:
1420 *
1421 * [readGroupSetId] - The ID of the read group set to be deleted. The caller
1422 * must have WRITE permissions to the dataset associated with this read group
1423 * set.
1424 *
1425 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1426 * error.
1427 *
1428 * If the used [http.Client] completes with an error when making a REST call,
1429 * this method will complete with the same error.
1430 */
1431 async.Future delete(core.String readGroupSetId) {
1432 var _url = null;
1433 var _queryParams = new core.Map();
1434 var _uploadMedia = null;
1435 var _uploadOptions = null;
1436 var _downloadOptions = commons.DownloadOptions.Metadata;
1437 var _body = null;
1438
1439 if (readGroupSetId == null) {
1440 throw new core.ArgumentError("Parameter readGroupSetId is required.");
1441 }
1442
1443 _downloadOptions = null;
1444
1445 _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId');
1446
1447 var _response = _requester.request(_url,
1448 "DELETE",
1449 body: _body,
1450 queryParams: _queryParams,
1451 uploadOptions: _uploadOptions,
1452 uploadMedia: _uploadMedia,
1453 downloadOptions: _downloadOptions);
1454 return _response.then((data) => null);
1455 }
1456
1457 /**
1458 * Exports read group sets to a BAM file in Google Cloud Storage.
1459 *
1460 * Note that currently there may be some differences between exported BAM
1461 * files and the original BAM file at the time of import. See
1462 * ImportReadGroupSets for details.
1463 *
1464 * [request] - The metadata request object.
1465 *
1466 * Request parameters:
1467 *
1468 * Completes with a [ExportReadGroupSetsResponse].
1469 *
1470 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1471 * error.
1472 *
1473 * If the used [http.Client] completes with an error when making a REST call,
1474 * this method will complete with the same error.
1475 */
1476 async.Future<ExportReadGroupSetsResponse> export(ExportReadGroupSetsRequest re quest) {
1477 var _url = null;
1478 var _queryParams = new core.Map();
1479 var _uploadMedia = null;
1480 var _uploadOptions = null;
1481 var _downloadOptions = commons.DownloadOptions.Metadata;
1482 var _body = null;
1483
1484 if (request != null) {
1485 _body = convert.JSON.encode((request).toJson());
1486 }
1487
1488 _url = 'readgroupsets/export';
1489
1490 var _response = _requester.request(_url,
1491 "POST",
1492 body: _body,
1493 queryParams: _queryParams,
1494 uploadOptions: _uploadOptions,
1495 uploadMedia: _uploadMedia,
1496 downloadOptions: _downloadOptions);
1497 return _response.then((data) => new ExportReadGroupSetsResponse.fromJson(dat a));
1498 }
1499
1500 /**
1501 * Gets a read group set by ID.
1502 *
1503 * Request parameters:
1504 *
1505 * [readGroupSetId] - The ID of the read group set.
1506 *
1507 * Completes with a [ReadGroupSet].
1508 *
1509 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1510 * error.
1511 *
1512 * If the used [http.Client] completes with an error when making a REST call,
1513 * this method will complete with the same error.
1514 */
1515 async.Future<ReadGroupSet> get(core.String readGroupSetId) {
1516 var _url = null;
1517 var _queryParams = new core.Map();
1518 var _uploadMedia = null;
1519 var _uploadOptions = null;
1520 var _downloadOptions = commons.DownloadOptions.Metadata;
1521 var _body = null;
1522
1523 if (readGroupSetId == null) {
1524 throw new core.ArgumentError("Parameter readGroupSetId is required.");
1525 }
1526
1527 _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId');
1528
1529 var _response = _requester.request(_url,
1530 "GET",
1531 body: _body,
1532 queryParams: _queryParams,
1533 uploadOptions: _uploadOptions,
1534 uploadMedia: _uploadMedia,
1535 downloadOptions: _downloadOptions);
1536 return _response.then((data) => new ReadGroupSet.fromJson(data));
1537 }
1538
1539 /**
1540 * Creates read group sets by asynchronously importing the provided
1541 * information. The caller must have WRITE permissions to the dataset.
1542 *
1543 * Notes on BAM import:
1544 * - Tags will be converted to strings - tag types are not preserved
1545 * - Comments (@CO) in the input file header are not imported
1546 * - Original order of reference headers is not preserved
1547 * - Any reverse stranded unmapped reads will be reverse complemented, and
1548 * their qualities (also the "BQ" and "OQ" tags, if any) will be reversed
1549 * - Unmapped reads will be stripped of positional information (referenceName
1550 * and position)
1551 *
1552 * [request] - The metadata request object.
1553 *
1554 * Request parameters:
1555 *
1556 * Completes with a [ImportReadGroupSetsResponse].
1557 *
1558 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1559 * error.
1560 *
1561 * If the used [http.Client] completes with an error when making a REST call,
1562 * this method will complete with the same error.
1563 */
1564 async.Future<ImportReadGroupSetsResponse> import(ImportReadGroupSetsRequest re quest) {
1565 var _url = null;
1566 var _queryParams = new core.Map();
1567 var _uploadMedia = null;
1568 var _uploadOptions = null;
1569 var _downloadOptions = commons.DownloadOptions.Metadata;
1570 var _body = null;
1571
1572 if (request != null) {
1573 _body = convert.JSON.encode((request).toJson());
1574 }
1575
1576 _url = 'readgroupsets/import';
1577
1578 var _response = _requester.request(_url,
1579 "POST",
1580 body: _body,
1581 queryParams: _queryParams,
1582 uploadOptions: _uploadOptions,
1583 uploadMedia: _uploadMedia,
1584 downloadOptions: _downloadOptions);
1585 return _response.then((data) => new ImportReadGroupSetsResponse.fromJson(dat a));
1586 }
1587
1588 /**
1589 * Updates a read group set. This method supports patch semantics.
1590 *
1591 * [request] - The metadata request object.
1592 *
1593 * Request parameters:
1594 *
1595 * [readGroupSetId] - The ID of the read group set to be updated. The caller
1596 * must have WRITE permissions to the dataset associated with this read group
1597 * set.
1598 *
1599 * Completes with a [ReadGroupSet].
1600 *
1601 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1602 * error.
1603 *
1604 * If the used [http.Client] completes with an error when making a REST call,
1605 * this method will complete with the same error.
1606 */
1607 async.Future<ReadGroupSet> patch(ReadGroupSet request, core.String readGroupSe tId) {
1608 var _url = null;
1609 var _queryParams = new core.Map();
1610 var _uploadMedia = null;
1611 var _uploadOptions = null;
1612 var _downloadOptions = commons.DownloadOptions.Metadata;
1613 var _body = null;
1614
1615 if (request != null) {
1616 _body = convert.JSON.encode((request).toJson());
1617 }
1618 if (readGroupSetId == null) {
1619 throw new core.ArgumentError("Parameter readGroupSetId is required.");
1620 }
1621
1622 _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId');
1623
1624 var _response = _requester.request(_url,
1625 "PATCH",
1626 body: _body,
1627 queryParams: _queryParams,
1628 uploadOptions: _uploadOptions,
1629 uploadMedia: _uploadMedia,
1630 downloadOptions: _downloadOptions);
1631 return _response.then((data) => new ReadGroupSet.fromJson(data));
1632 }
1633
1634 /**
1635 * Searches for read group sets matching the criteria.
1636 *
1637 * Implements GlobalAllianceApi.searchReadGroupSets.
1638 *
1639 * [request] - The metadata request object.
1640 *
1641 * Request parameters:
1642 *
1643 * Completes with a [SearchReadGroupSetsResponse].
1644 *
1645 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1646 * error.
1647 *
1648 * If the used [http.Client] completes with an error when making a REST call,
1649 * this method will complete with the same error.
1650 */
1651 async.Future<SearchReadGroupSetsResponse> search(SearchReadGroupSetsRequest re quest) {
1652 var _url = null;
1653 var _queryParams = new core.Map();
1654 var _uploadMedia = null;
1655 var _uploadOptions = null;
1656 var _downloadOptions = commons.DownloadOptions.Metadata;
1657 var _body = null;
1658
1659 if (request != null) {
1660 _body = convert.JSON.encode((request).toJson());
1661 }
1662
1663 _url = 'readgroupsets/search';
1664
1665 var _response = _requester.request(_url,
1666 "POST",
1667 body: _body,
1668 queryParams: _queryParams,
1669 uploadOptions: _uploadOptions,
1670 uploadMedia: _uploadMedia,
1671 downloadOptions: _downloadOptions);
1672 return _response.then((data) => new SearchReadGroupSetsResponse.fromJson(dat a));
1673 }
1674
1675 /**
1676 * Updates a read group set.
1677 *
1678 * [request] - The metadata request object.
1679 *
1680 * Request parameters:
1681 *
1682 * [readGroupSetId] - The ID of the read group set to be updated. The caller
1683 * must have WRITE permissions to the dataset associated with this read group
1684 * set.
1685 *
1686 * Completes with a [ReadGroupSet].
1687 *
1688 * Completes with a [commons.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<ReadGroupSet> update(ReadGroupSet request, core.String readGroupS etId) {
1695 var _url = null;
1696 var _queryParams = new core.Map();
1697 var _uploadMedia = null;
1698 var _uploadOptions = null;
1699 var _downloadOptions = commons.DownloadOptions.Metadata;
1700 var _body = null;
1701
1702 if (request != null) {
1703 _body = convert.JSON.encode((request).toJson());
1704 }
1705 if (readGroupSetId == null) {
1706 throw new core.ArgumentError("Parameter readGroupSetId is required.");
1707 }
1708
1709 _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId');
1710
1711 var _response = _requester.request(_url,
1712 "PUT",
1713 body: _body,
1714 queryParams: _queryParams,
1715 uploadOptions: _uploadOptions,
1716 uploadMedia: _uploadMedia,
1717 downloadOptions: _downloadOptions);
1718 return _response.then((data) => new ReadGroupSet.fromJson(data));
1719 }
1720
1721 }
1722
1723
1724 class ReadgroupsetsCoveragebucketsResourceApi {
1725 final commons.ApiRequester _requester;
1726
1727 ReadgroupsetsCoveragebucketsResourceApi(commons.ApiRequester client) :
1728 _requester = client;
1729
1730 /**
1731 * Lists fixed width coverage buckets for a read group set, each of which
1732 * correspond to a range of a reference sequence. Each bucket summarizes
1733 * coverage information across its corresponding genomic range.
1734 *
1735 * Coverage is defined as the number of reads which are aligned to a given
1736 * base in the reference sequence. Coverage buckets are available at several
1737 * precomputed bucket widths, enabling retrieval of various coverage 'zoom
1738 * levels'. The caller must have READ permissions for the target read group
1739 * set.
1740 *
1741 * Request parameters:
1742 *
1743 * [readGroupSetId] - Required. The ID of the read group set over which
1744 * coverage is requested.
1745 *
1746 * [pageSize] - The maximum number of results to return in a single page. If
1747 * unspecified, defaults to 1024. The maximum value is 2048.
1748 *
1749 * [pageToken] - The continuation token, which is used to page through large
1750 * result sets. To get the next page of results, set this parameter to the
1751 * value of nextPageToken from the previous response.
1752 *
1753 * [range_end] - The end position of the range on the reference, 0-based
1754 * exclusive. If specified, referenceName must also be specified.
1755 *
1756 * [range_referenceName] - The reference sequence name, for example chr1, 1,
1757 * or chrX.
1758 *
1759 * [range_start] - The start position of the range on the reference, 0-based
1760 * inclusive. If specified, referenceName must also be specified.
1761 *
1762 * [targetBucketWidth] - The desired width of each reported coverage bucket in
1763 * base pairs. This will be rounded down to the nearest precomputed bucket
1764 * width; the value of which is returned as bucketWidth in the response.
1765 * Defaults to infinity (each bucket spans an entire reference sequence) or
1766 * the length of the target range, if specified. The smallest precomputed
1767 * bucketWidth is currently 2048 base pairs; this is subject to change.
1768 *
1769 * Completes with a [ListCoverageBucketsResponse].
1770 *
1771 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1772 * error.
1773 *
1774 * If the used [http.Client] completes with an error when making a REST call,
1775 * this method will complete with the same error.
1776 */
1777 async.Future<ListCoverageBucketsResponse> list(core.String readGroupSetId, {co re.int pageSize, core.String pageToken, core.String range_end, core.String range _referenceName, core.String range_start, core.String targetBucketWidth}) {
1778 var _url = null;
1779 var _queryParams = new core.Map();
1780 var _uploadMedia = null;
1781 var _uploadOptions = null;
1782 var _downloadOptions = commons.DownloadOptions.Metadata;
1783 var _body = null;
1784
1785 if (readGroupSetId == null) {
1786 throw new core.ArgumentError("Parameter readGroupSetId is required.");
1787 }
1788 if (pageSize != null) {
1789 _queryParams["pageSize"] = ["${pageSize}"];
1790 }
1791 if (pageToken != null) {
1792 _queryParams["pageToken"] = [pageToken];
1793 }
1794 if (range_end != null) {
1795 _queryParams["range.end"] = [range_end];
1796 }
1797 if (range_referenceName != null) {
1798 _queryParams["range.referenceName"] = [range_referenceName];
1799 }
1800 if (range_start != null) {
1801 _queryParams["range.start"] = [range_start];
1802 }
1803 if (targetBucketWidth != null) {
1804 _queryParams["targetBucketWidth"] = [targetBucketWidth];
1805 }
1806
1807 _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId') + '/coveragebuckets';
1808
1809 var _response = _requester.request(_url,
1810 "GET",
1811 body: _body,
1812 queryParams: _queryParams,
1813 uploadOptions: _uploadOptions,
1814 uploadMedia: _uploadMedia,
1815 downloadOptions: _downloadOptions);
1816 return _response.then((data) => new ListCoverageBucketsResponse.fromJson(dat a));
1817 }
1818
1819 }
1820
1821
1822 class ReadsResourceApi {
1823 final commons.ApiRequester _requester;
1824
1825 ReadsResourceApi(commons.ApiRequester client) :
1826 _requester = client;
1827
1828 /**
1829 * Gets a list of reads for one or more read group sets. Reads search operates
1830 * over a genomic coordinate space of reference sequence & position defined
1831 * over the reference sequences to which the requested read group sets are
1832 * aligned.
1833 *
1834 * If a target positional range is specified, search returns all reads whose
1835 * alignment to the reference genome overlap the range. A query which
1836 * specifies only read group set IDs yields all reads in those read group
1837 * sets, including unmapped reads.
1838 *
1839 * All reads returned (including reads on subsequent pages) are ordered by
1840 * genomic coordinate (by reference sequence, then position). Reads with
1841 * equivalent genomic coordinates are returned in an unspecified order. This
1842 * order is consistent, such that two queries for the same content (regardless
1843 * of page size) yield reads in the same order across their respective streams
1844 * of paginated responses.
1845 *
1846 * Implements GlobalAllianceApi.searchReads.
1847 *
1848 * [request] - The metadata request object.
1849 *
1850 * Request parameters:
1851 *
1852 * Completes with a [SearchReadsResponse].
1853 *
1854 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1855 * error.
1856 *
1857 * If the used [http.Client] completes with an error when making a REST call,
1858 * this method will complete with the same error.
1859 */
1860 async.Future<SearchReadsResponse> search(SearchReadsRequest request) {
1861 var _url = null;
1862 var _queryParams = new core.Map();
1863 var _uploadMedia = null;
1864 var _uploadOptions = null;
1865 var _downloadOptions = commons.DownloadOptions.Metadata;
1866 var _body = null;
1867
1868 if (request != null) {
1869 _body = convert.JSON.encode((request).toJson());
1870 }
1871
1872 _url = 'reads/search';
1873
1874 var _response = _requester.request(_url,
1875 "POST",
1876 body: _body,
1877 queryParams: _queryParams,
1878 uploadOptions: _uploadOptions,
1879 uploadMedia: _uploadMedia,
1880 downloadOptions: _downloadOptions);
1881 return _response.then((data) => new SearchReadsResponse.fromJson(data));
1882 }
1883
1884 }
1885
1886
1887 class ReferencesResourceApi {
1888 final commons.ApiRequester _requester;
1889
1890 ReferencesBasesResourceApi get bases => new ReferencesBasesResourceApi(_reques ter);
1891
1892 ReferencesResourceApi(commons.ApiRequester client) :
1893 _requester = client;
1894
1895 /**
1896 * Gets a reference.
1897 *
1898 * Implements GlobalAllianceApi.getReference.
1899 *
1900 * Request parameters:
1901 *
1902 * [referenceId] - The ID of the reference.
1903 *
1904 * Completes with a [Reference].
1905 *
1906 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1907 * error.
1908 *
1909 * If the used [http.Client] completes with an error when making a REST call,
1910 * this method will complete with the same error.
1911 */
1912 async.Future<Reference> get(core.String referenceId) {
1913 var _url = null;
1914 var _queryParams = new core.Map();
1915 var _uploadMedia = null;
1916 var _uploadOptions = null;
1917 var _downloadOptions = commons.DownloadOptions.Metadata;
1918 var _body = null;
1919
1920 if (referenceId == null) {
1921 throw new core.ArgumentError("Parameter referenceId is required.");
1922 }
1923
1924 _url = 'references/' + commons.Escaper.ecapeVariable('$referenceId');
1925
1926 var _response = _requester.request(_url,
1927 "GET",
1928 body: _body,
1929 queryParams: _queryParams,
1930 uploadOptions: _uploadOptions,
1931 uploadMedia: _uploadMedia,
1932 downloadOptions: _downloadOptions);
1933 return _response.then((data) => new Reference.fromJson(data));
1934 }
1935
1936 /**
1937 * Searches for references which match the given criteria.
1938 *
1939 * Implements GlobalAllianceApi.searchReferences.
1940 *
1941 * [request] - The metadata request object.
1942 *
1943 * Request parameters:
1944 *
1945 * Completes with a [SearchReferencesResponse].
1946 *
1947 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
1948 * error.
1949 *
1950 * If the used [http.Client] completes with an error when making a REST call,
1951 * this method will complete with the same error.
1952 */
1953 async.Future<SearchReferencesResponse> search(SearchReferencesRequest request) {
1954 var _url = null;
1955 var _queryParams = new core.Map();
1956 var _uploadMedia = null;
1957 var _uploadOptions = null;
1958 var _downloadOptions = commons.DownloadOptions.Metadata;
1959 var _body = null;
1960
1961 if (request != null) {
1962 _body = convert.JSON.encode((request).toJson());
1963 }
1964
1965 _url = 'references/search';
1966
1967 var _response = _requester.request(_url,
1968 "POST",
1969 body: _body,
1970 queryParams: _queryParams,
1971 uploadOptions: _uploadOptions,
1972 uploadMedia: _uploadMedia,
1973 downloadOptions: _downloadOptions);
1974 return _response.then((data) => new SearchReferencesResponse.fromJson(data)) ;
1975 }
1976
1977 }
1978
1979
1980 class ReferencesBasesResourceApi {
1981 final commons.ApiRequester _requester;
1982
1983 ReferencesBasesResourceApi(commons.ApiRequester client) :
1984 _requester = client;
1985
1986 /**
1987 * Lists the bases in a reference, optionally restricted to a range.
1988 *
1989 * Implements GlobalAllianceApi.getReferenceBases.
1990 *
1991 * Request parameters:
1992 *
1993 * [referenceId] - The ID of the reference.
1994 *
1995 * [end] - The end position (0-based, exclusive) of this query. Defaults to
1996 * the length of this reference.
1997 *
1998 * [pageSize] - The maximum number of bases to return in a single page. If
1999 * unspecified, defaults to 200Kbp (kilo base pairs). The maximum value is
2000 * 10Mbp (mega base pairs).
2001 *
2002 * [pageToken] - The continuation token, which is used to page through large
2003 * result sets. To get the next page of results, set this parameter to the
2004 * value of nextPageToken from the previous response.
2005 *
2006 * [start] - The start position (0-based) of this query. Defaults to 0.
2007 *
2008 * Completes with a [ListBasesResponse].
2009 *
2010 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2011 * error.
2012 *
2013 * If the used [http.Client] completes with an error when making a REST call,
2014 * this method will complete with the same error.
2015 */
2016 async.Future<ListBasesResponse> list(core.String referenceId, {core.String end , core.int pageSize, core.String pageToken, core.String start}) {
2017 var _url = null;
2018 var _queryParams = new core.Map();
2019 var _uploadMedia = null;
2020 var _uploadOptions = null;
2021 var _downloadOptions = commons.DownloadOptions.Metadata;
2022 var _body = null;
2023
2024 if (referenceId == null) {
2025 throw new core.ArgumentError("Parameter referenceId is required.");
2026 }
2027 if (end != null) {
2028 _queryParams["end"] = [end];
2029 }
2030 if (pageSize != null) {
2031 _queryParams["pageSize"] = ["${pageSize}"];
2032 }
2033 if (pageToken != null) {
2034 _queryParams["pageToken"] = [pageToken];
2035 }
2036 if (start != null) {
2037 _queryParams["start"] = [start];
2038 }
2039
2040 _url = 'references/' + commons.Escaper.ecapeVariable('$referenceId') + '/bas es';
2041
2042 var _response = _requester.request(_url,
2043 "GET",
2044 body: _body,
2045 queryParams: _queryParams,
2046 uploadOptions: _uploadOptions,
2047 uploadMedia: _uploadMedia,
2048 downloadOptions: _downloadOptions);
2049 return _response.then((data) => new ListBasesResponse.fromJson(data));
2050 }
2051
2052 }
2053
2054
2055 class ReferencesetsResourceApi {
2056 final commons.ApiRequester _requester;
2057
2058 ReferencesetsResourceApi(commons.ApiRequester client) :
2059 _requester = client;
2060
2061 /**
2062 * Gets a reference set.
2063 *
2064 * Implements GlobalAllianceApi.getReferenceSet.
2065 *
2066 * Request parameters:
2067 *
2068 * [referenceSetId] - The ID of the reference set.
2069 *
2070 * Completes with a [ReferenceSet].
2071 *
2072 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2073 * error.
2074 *
2075 * If the used [http.Client] completes with an error when making a REST call,
2076 * this method will complete with the same error.
2077 */
2078 async.Future<ReferenceSet> get(core.String referenceSetId) {
2079 var _url = null;
2080 var _queryParams = new core.Map();
2081 var _uploadMedia = null;
2082 var _uploadOptions = null;
2083 var _downloadOptions = commons.DownloadOptions.Metadata;
2084 var _body = null;
2085
2086 if (referenceSetId == null) {
2087 throw new core.ArgumentError("Parameter referenceSetId is required.");
2088 }
2089
2090 _url = 'referencesets/' + commons.Escaper.ecapeVariable('$referenceSetId');
2091
2092 var _response = _requester.request(_url,
2093 "GET",
2094 body: _body,
2095 queryParams: _queryParams,
2096 uploadOptions: _uploadOptions,
2097 uploadMedia: _uploadMedia,
2098 downloadOptions: _downloadOptions);
2099 return _response.then((data) => new ReferenceSet.fromJson(data));
2100 }
2101
2102 /**
2103 * Searches for reference sets which match the given criteria.
2104 *
2105 * Implements GlobalAllianceApi.searchReferenceSets.
2106 *
2107 * [request] - The metadata request object.
2108 *
2109 * Request parameters:
2110 *
2111 * Completes with a [SearchReferenceSetsResponse].
2112 *
2113 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2114 * error.
2115 *
2116 * If the used [http.Client] completes with an error when making a REST call,
2117 * this method will complete with the same error.
2118 */
2119 async.Future<SearchReferenceSetsResponse> search(SearchReferenceSetsRequest re quest) {
2120 var _url = null;
2121 var _queryParams = new core.Map();
2122 var _uploadMedia = null;
2123 var _uploadOptions = null;
2124 var _downloadOptions = commons.DownloadOptions.Metadata;
2125 var _body = null;
2126
2127 if (request != null) {
2128 _body = convert.JSON.encode((request).toJson());
2129 }
2130
2131 _url = 'referencesets/search';
2132
2133 var _response = _requester.request(_url,
2134 "POST",
2135 body: _body,
2136 queryParams: _queryParams,
2137 uploadOptions: _uploadOptions,
2138 uploadMedia: _uploadMedia,
2139 downloadOptions: _downloadOptions);
2140 return _response.then((data) => new SearchReferenceSetsResponse.fromJson(dat a));
2141 }
2142
2143 }
2144
2145
2146 class VariantsResourceApi {
2147 final commons.ApiRequester _requester;
2148
2149 VariantsResourceApi(commons.ApiRequester client) :
2150 _requester = client;
2151
2152 /**
2153 * Creates a new variant.
2154 *
2155 * [request] - The metadata request object.
2156 *
2157 * Request parameters:
2158 *
2159 * Completes with a [Variant].
2160 *
2161 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2162 * error.
2163 *
2164 * If the used [http.Client] completes with an error when making a REST call,
2165 * this method will complete with the same error.
2166 */
2167 async.Future<Variant> create(Variant request) {
2168 var _url = null;
2169 var _queryParams = new core.Map();
2170 var _uploadMedia = null;
2171 var _uploadOptions = null;
2172 var _downloadOptions = commons.DownloadOptions.Metadata;
2173 var _body = null;
2174
2175 if (request != null) {
2176 _body = convert.JSON.encode((request).toJson());
2177 }
2178
2179 _url = 'variants';
2180
2181 var _response = _requester.request(_url,
2182 "POST",
2183 body: _body,
2184 queryParams: _queryParams,
2185 uploadOptions: _uploadOptions,
2186 uploadMedia: _uploadMedia,
2187 downloadOptions: _downloadOptions);
2188 return _response.then((data) => new Variant.fromJson(data));
2189 }
2190
2191 /**
2192 * Deletes a variant.
2193 *
2194 * Request parameters:
2195 *
2196 * [variantId] - The ID of the variant to be deleted.
2197 *
2198 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2199 * error.
2200 *
2201 * If the used [http.Client] completes with an error when making a REST call,
2202 * this method will complete with the same error.
2203 */
2204 async.Future delete(core.String variantId) {
2205 var _url = null;
2206 var _queryParams = new core.Map();
2207 var _uploadMedia = null;
2208 var _uploadOptions = null;
2209 var _downloadOptions = commons.DownloadOptions.Metadata;
2210 var _body = null;
2211
2212 if (variantId == null) {
2213 throw new core.ArgumentError("Parameter variantId is required.");
2214 }
2215
2216 _downloadOptions = null;
2217
2218 _url = 'variants/' + commons.Escaper.ecapeVariable('$variantId');
2219
2220 var _response = _requester.request(_url,
2221 "DELETE",
2222 body: _body,
2223 queryParams: _queryParams,
2224 uploadOptions: _uploadOptions,
2225 uploadMedia: _uploadMedia,
2226 downloadOptions: _downloadOptions);
2227 return _response.then((data) => null);
2228 }
2229
2230 /**
2231 * Gets a variant by ID.
2232 *
2233 * Request parameters:
2234 *
2235 * [variantId] - Required.
2236 *
2237 * Completes with a [Variant].
2238 *
2239 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2240 * error.
2241 *
2242 * If the used [http.Client] completes with an error when making a REST call,
2243 * this method will complete with the same error.
2244 */
2245 async.Future<Variant> get(core.String variantId) {
2246 var _url = null;
2247 var _queryParams = new core.Map();
2248 var _uploadMedia = null;
2249 var _uploadOptions = null;
2250 var _downloadOptions = commons.DownloadOptions.Metadata;
2251 var _body = null;
2252
2253 if (variantId == null) {
2254 throw new core.ArgumentError("Parameter variantId is required.");
2255 }
2256
2257 _url = 'variants/' + commons.Escaper.ecapeVariable('$variantId');
2258
2259 var _response = _requester.request(_url,
2260 "GET",
2261 body: _body,
2262 queryParams: _queryParams,
2263 uploadOptions: _uploadOptions,
2264 uploadMedia: _uploadMedia,
2265 downloadOptions: _downloadOptions);
2266 return _response.then((data) => new Variant.fromJson(data));
2267 }
2268
2269 /**
2270 * Gets a list of variants matching the criteria.
2271 *
2272 * Implements GlobalAllianceApi.searchVariants.
2273 *
2274 * [request] - The metadata request object.
2275 *
2276 * Request parameters:
2277 *
2278 * Completes with a [SearchVariantsResponse].
2279 *
2280 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2281 * error.
2282 *
2283 * If the used [http.Client] completes with an error when making a REST call,
2284 * this method will complete with the same error.
2285 */
2286 async.Future<SearchVariantsResponse> search(SearchVariantsRequest request) {
2287 var _url = null;
2288 var _queryParams = new core.Map();
2289 var _uploadMedia = null;
2290 var _uploadOptions = null;
2291 var _downloadOptions = commons.DownloadOptions.Metadata;
2292 var _body = null;
2293
2294 if (request != null) {
2295 _body = convert.JSON.encode((request).toJson());
2296 }
2297
2298 _url = 'variants/search';
2299
2300 var _response = _requester.request(_url,
2301 "POST",
2302 body: _body,
2303 queryParams: _queryParams,
2304 uploadOptions: _uploadOptions,
2305 uploadMedia: _uploadMedia,
2306 downloadOptions: _downloadOptions);
2307 return _response.then((data) => new SearchVariantsResponse.fromJson(data));
2308 }
2309
2310 /**
2311 * Updates a variant's names and info fields. All other modifications are
2312 * silently ignored. Returns the modified variant without its calls.
2313 *
2314 * [request] - The metadata request object.
2315 *
2316 * Request parameters:
2317 *
2318 * [variantId] - The ID of the variant to be updated.
2319 *
2320 * Completes with a [Variant].
2321 *
2322 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2323 * error.
2324 *
2325 * If the used [http.Client] completes with an error when making a REST call,
2326 * this method will complete with the same error.
2327 */
2328 async.Future<Variant> update(Variant request, core.String variantId) {
2329 var _url = null;
2330 var _queryParams = new core.Map();
2331 var _uploadMedia = null;
2332 var _uploadOptions = null;
2333 var _downloadOptions = commons.DownloadOptions.Metadata;
2334 var _body = null;
2335
2336 if (request != null) {
2337 _body = convert.JSON.encode((request).toJson());
2338 }
2339 if (variantId == null) {
2340 throw new core.ArgumentError("Parameter variantId is required.");
2341 }
2342
2343 _url = 'variants/' + commons.Escaper.ecapeVariable('$variantId');
2344
2345 var _response = _requester.request(_url,
2346 "PUT",
2347 body: _body,
2348 queryParams: _queryParams,
2349 uploadOptions: _uploadOptions,
2350 uploadMedia: _uploadMedia,
2351 downloadOptions: _downloadOptions);
2352 return _response.then((data) => new Variant.fromJson(data));
2353 }
2354
2355 }
2356
2357
2358 class VariantsetsResourceApi {
2359 final commons.ApiRequester _requester;
2360
2361 VariantsetsResourceApi(commons.ApiRequester client) :
2362 _requester = client;
2363
2364 /**
2365 * Creates a new variant set (only necessary in v1).
2366 *
2367 * The provided variant set must have a valid datasetId set - all other fields
2368 * are optional. Note that the id field will be ignored, as this is assigned
2369 * by the server.
2370 *
2371 * [request] - The metadata request object.
2372 *
2373 * Request parameters:
2374 *
2375 * Completes with a [VariantSet].
2376 *
2377 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2378 * error.
2379 *
2380 * If the used [http.Client] completes with an error when making a REST call,
2381 * this method will complete with the same error.
2382 */
2383 async.Future<VariantSet> create(VariantSet request) {
2384 var _url = null;
2385 var _queryParams = new core.Map();
2386 var _uploadMedia = null;
2387 var _uploadOptions = null;
2388 var _downloadOptions = commons.DownloadOptions.Metadata;
2389 var _body = null;
2390
2391 if (request != null) {
2392 _body = convert.JSON.encode((request).toJson());
2393 }
2394
2395 _url = 'variantsets';
2396
2397 var _response = _requester.request(_url,
2398 "POST",
2399 body: _body,
2400 queryParams: _queryParams,
2401 uploadOptions: _uploadOptions,
2402 uploadMedia: _uploadMedia,
2403 downloadOptions: _downloadOptions);
2404 return _response.then((data) => new VariantSet.fromJson(data));
2405 }
2406
2407 /**
2408 * Deletes a variant set including all variants, call sets, and calls within.
2409 * This is not reversible.
2410 *
2411 * Request parameters:
2412 *
2413 * [variantSetId] - The ID of the variant set to be deleted. Required.
2414 *
2415 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2416 * error.
2417 *
2418 * If the used [http.Client] completes with an error when making a REST call,
2419 * this method will complete with the same error.
2420 */
2421 async.Future delete(core.String variantSetId) {
2422 var _url = null;
2423 var _queryParams = new core.Map();
2424 var _uploadMedia = null;
2425 var _uploadOptions = null;
2426 var _downloadOptions = commons.DownloadOptions.Metadata;
2427 var _body = null;
2428
2429 if (variantSetId == null) {
2430 throw new core.ArgumentError("Parameter variantSetId is required.");
2431 }
2432
2433 _downloadOptions = null;
2434
2435 _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId');
2436
2437 var _response = _requester.request(_url,
2438 "DELETE",
2439 body: _body,
2440 queryParams: _queryParams,
2441 uploadOptions: _uploadOptions,
2442 uploadMedia: _uploadMedia,
2443 downloadOptions: _downloadOptions);
2444 return _response.then((data) => null);
2445 }
2446
2447 /**
2448 * Exports variant set data to an external destination.
2449 *
2450 * [request] - The metadata request object.
2451 *
2452 * Request parameters:
2453 *
2454 * [variantSetId] - The ID of the variant set that contains variant data which
2455 * should be exported. Required. The caller must have READ access to this
2456 * variant set.
2457 *
2458 * Completes with a [ExportVariantSetResponse].
2459 *
2460 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2461 * error.
2462 *
2463 * If the used [http.Client] completes with an error when making a REST call,
2464 * this method will complete with the same error.
2465 */
2466 async.Future<ExportVariantSetResponse> export(ExportVariantSetRequest request, core.String variantSetId) {
2467 var _url = null;
2468 var _queryParams = new core.Map();
2469 var _uploadMedia = null;
2470 var _uploadOptions = null;
2471 var _downloadOptions = commons.DownloadOptions.Metadata;
2472 var _body = null;
2473
2474 if (request != null) {
2475 _body = convert.JSON.encode((request).toJson());
2476 }
2477 if (variantSetId == null) {
2478 throw new core.ArgumentError("Parameter variantSetId is required.");
2479 }
2480
2481 _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId') + '/e xport';
2482
2483 var _response = _requester.request(_url,
2484 "POST",
2485 body: _body,
2486 queryParams: _queryParams,
2487 uploadOptions: _uploadOptions,
2488 uploadMedia: _uploadMedia,
2489 downloadOptions: _downloadOptions);
2490 return _response.then((data) => new ExportVariantSetResponse.fromJson(data)) ;
2491 }
2492
2493 /**
2494 * Gets a variant set by ID.
2495 *
2496 * Request parameters:
2497 *
2498 * [variantSetId] - The ID of the variant set. Required.
2499 *
2500 * Completes with a [VariantSet].
2501 *
2502 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2503 * error.
2504 *
2505 * If the used [http.Client] completes with an error when making a REST call,
2506 * this method will complete with the same error.
2507 */
2508 async.Future<VariantSet> get(core.String variantSetId) {
2509 var _url = null;
2510 var _queryParams = new core.Map();
2511 var _uploadMedia = null;
2512 var _uploadOptions = null;
2513 var _downloadOptions = commons.DownloadOptions.Metadata;
2514 var _body = null;
2515
2516 if (variantSetId == null) {
2517 throw new core.ArgumentError("Parameter variantSetId is required.");
2518 }
2519
2520 _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId');
2521
2522 var _response = _requester.request(_url,
2523 "GET",
2524 body: _body,
2525 queryParams: _queryParams,
2526 uploadOptions: _uploadOptions,
2527 uploadMedia: _uploadMedia,
2528 downloadOptions: _downloadOptions);
2529 return _response.then((data) => new VariantSet.fromJson(data));
2530 }
2531
2532 /**
2533 * Creates variant data by asynchronously importing the provided information.
2534 *
2535 * The variants for import will be merged with any existing data and each
2536 * other according to the behavior of mergeVariants. In particular, this means
2537 * for merged VCF variants that have conflicting info fields, some data will
2538 * be arbitrarily discarded unless otherwise specified in the InfoMergeConfig
2539 * field of ImportVariantsRequest. As a special case, for single-sample VCF
2540 * files, QUAL and FILTER fields will be moved to the call level; these are
2541 * sometimes interpreted in a call-specific context. Imported VCF headers are
2542 * appended to the metadata already in a variant set.
2543 *
2544 * [request] - The metadata request object.
2545 *
2546 * Request parameters:
2547 *
2548 * [variantSetId] - Required. The variant set to which variant data should be
2549 * imported.
2550 *
2551 * Completes with a [ImportVariantsResponse].
2552 *
2553 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2554 * error.
2555 *
2556 * If the used [http.Client] completes with an error when making a REST call,
2557 * this method will complete with the same error.
2558 */
2559 async.Future<ImportVariantsResponse> importVariants(ImportVariantsRequest requ est, core.String variantSetId) {
2560 var _url = null;
2561 var _queryParams = new core.Map();
2562 var _uploadMedia = null;
2563 var _uploadOptions = null;
2564 var _downloadOptions = commons.DownloadOptions.Metadata;
2565 var _body = null;
2566
2567 if (request != null) {
2568 _body = convert.JSON.encode((request).toJson());
2569 }
2570 if (variantSetId == null) {
2571 throw new core.ArgumentError("Parameter variantSetId is required.");
2572 }
2573
2574 _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId') + '/i mportVariants';
2575
2576 var _response = _requester.request(_url,
2577 "POST",
2578 body: _body,
2579 queryParams: _queryParams,
2580 uploadOptions: _uploadOptions,
2581 uploadMedia: _uploadMedia,
2582 downloadOptions: _downloadOptions);
2583 return _response.then((data) => new ImportVariantsResponse.fromJson(data));
2584 }
2585
2586 /**
2587 * Merges the given variants with existing variants. Each variant will be
2588 * merged with an existing variant that matches its reference sequence, start,
2589 * end, reference bases, and alternative bases. If no such variant exists, a
2590 * new one will be created.
2591 *
2592 * When variants are merged, the call information from the new variant is
2593 * added to the existing variant. Variant info fields are merged as specified
2594 * in the InfoMergeConfig field of the MergeVariantsRequest.
2595 *
2596 * [request] - The metadata request object.
2597 *
2598 * Request parameters:
2599 *
2600 * [variantSetId] - The destination variant set.
2601 *
2602 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2603 * error.
2604 *
2605 * If the used [http.Client] completes with an error when making a REST call,
2606 * this method will complete with the same error.
2607 */
2608 async.Future mergeVariants(MergeVariantsRequest request, core.String variantSe tId) {
2609 var _url = null;
2610 var _queryParams = new core.Map();
2611 var _uploadMedia = null;
2612 var _uploadOptions = null;
2613 var _downloadOptions = commons.DownloadOptions.Metadata;
2614 var _body = null;
2615
2616 if (request != null) {
2617 _body = convert.JSON.encode((request).toJson());
2618 }
2619 if (variantSetId == null) {
2620 throw new core.ArgumentError("Parameter variantSetId is required.");
2621 }
2622
2623 _downloadOptions = null;
2624
2625 _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId') + '/m ergeVariants';
2626
2627 var _response = _requester.request(_url,
2628 "POST",
2629 body: _body,
2630 queryParams: _queryParams,
2631 uploadOptions: _uploadOptions,
2632 uploadMedia: _uploadMedia,
2633 downloadOptions: _downloadOptions);
2634 return _response.then((data) => null);
2635 }
2636
2637 /**
2638 * Updates a variant set's metadata. All other modifications are silently
2639 * ignored. This method supports patch semantics.
2640 *
2641 * [request] - The metadata request object.
2642 *
2643 * Request parameters:
2644 *
2645 * [variantSetId] - The ID of the variant set to be updated (must already
2646 * exist).
2647 *
2648 * Completes with a [VariantSet].
2649 *
2650 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2651 * error.
2652 *
2653 * If the used [http.Client] completes with an error when making a REST call,
2654 * this method will complete with the same error.
2655 */
2656 async.Future<VariantSet> patch(VariantSet request, core.String variantSetId) {
2657 var _url = null;
2658 var _queryParams = new core.Map();
2659 var _uploadMedia = null;
2660 var _uploadOptions = null;
2661 var _downloadOptions = commons.DownloadOptions.Metadata;
2662 var _body = null;
2663
2664 if (request != null) {
2665 _body = convert.JSON.encode((request).toJson());
2666 }
2667 if (variantSetId == null) {
2668 throw new core.ArgumentError("Parameter variantSetId is required.");
2669 }
2670
2671 _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId');
2672
2673 var _response = _requester.request(_url,
2674 "PATCH",
2675 body: _body,
2676 queryParams: _queryParams,
2677 uploadOptions: _uploadOptions,
2678 uploadMedia: _uploadMedia,
2679 downloadOptions: _downloadOptions);
2680 return _response.then((data) => new VariantSet.fromJson(data));
2681 }
2682
2683 /**
2684 * Returns a list of all variant sets matching search criteria.
2685 *
2686 * Implements GlobalAllianceApi.searchVariantSets.
2687 *
2688 * [request] - The metadata request object.
2689 *
2690 * Request parameters:
2691 *
2692 * Completes with a [SearchVariantSetsResponse].
2693 *
2694 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2695 * error.
2696 *
2697 * If the used [http.Client] completes with an error when making a REST call,
2698 * this method will complete with the same error.
2699 */
2700 async.Future<SearchVariantSetsResponse> search(SearchVariantSetsRequest reques t) {
2701 var _url = null;
2702 var _queryParams = new core.Map();
2703 var _uploadMedia = null;
2704 var _uploadOptions = null;
2705 var _downloadOptions = commons.DownloadOptions.Metadata;
2706 var _body = null;
2707
2708 if (request != null) {
2709 _body = convert.JSON.encode((request).toJson());
2710 }
2711
2712 _url = 'variantsets/search';
2713
2714 var _response = _requester.request(_url,
2715 "POST",
2716 body: _body,
2717 queryParams: _queryParams,
2718 uploadOptions: _uploadOptions,
2719 uploadMedia: _uploadMedia,
2720 downloadOptions: _downloadOptions);
2721 return _response.then((data) => new SearchVariantSetsResponse.fromJson(data) );
2722 }
2723
2724 /**
2725 * Updates a variant set's metadata. All other modifications are silently
2726 * ignored.
2727 *
2728 * [request] - The metadata request object.
2729 *
2730 * Request parameters:
2731 *
2732 * [variantSetId] - The ID of the variant set to be updated (must already
2733 * exist).
2734 *
2735 * Completes with a [VariantSet].
2736 *
2737 * Completes with a [commons.ApiRequestError] if the API endpoint returned an
2738 * error.
2739 *
2740 * If the used [http.Client] completes with an error when making a REST call,
2741 * this method will complete with the same error.
2742 */
2743 async.Future<VariantSet> update(VariantSet request, core.String variantSetId) {
2744 var _url = null;
2745 var _queryParams = new core.Map();
2746 var _uploadMedia = null;
2747 var _uploadOptions = null;
2748 var _downloadOptions = commons.DownloadOptions.Metadata;
2749 var _body = null;
2750
2751 if (request != null) {
2752 _body = convert.JSON.encode((request).toJson());
2753 }
2754 if (variantSetId == null) {
2755 throw new core.ArgumentError("Parameter variantSetId is required.");
2756 }
2757
2758 _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId');
2759
2760 var _response = _requester.request(_url,
2761 "PUT",
2762 body: _body,
2763 queryParams: _queryParams,
2764 uploadOptions: _uploadOptions,
2765 uploadMedia: _uploadMedia,
2766 downloadOptions: _downloadOptions);
2767 return _response.then((data) => new VariantSet.fromJson(data));
2768 }
2769
2770 }
2771
2772
2773
2774 /**
2775 * An annotation describes a region of reference genome. The value of an
2776 * annotation may be one of several canonical types, supplemented by arbitrary
2777 * info tags. An annotation is not inherently associated with a specific sample
2778 * or individual (though a client could choose to use annotations in this way).
2779 * Example canonical annotation types are GENE and VARIANT.
2780 */
2781 class Annotation {
2782 /** The annotation set to which this annotation belongs. */
2783 core.String annotationSetId;
2784 /** The server-generated annotation ID, unique across all annotations. */
2785 core.String id;
2786 /** A string which maps to an array of values. */
2787 core.Map<core.String, core.List<core.String>> info;
2788 /** The display name of this annotation. */
2789 core.String name;
2790 /** The position of this annotation on the reference sequence. */
2791 RangePosition position;
2792 /**
2793 * A transcript value represents the assertion that a particular region of the
2794 * reference genome may be transcribed as RNA. An alternative splicing pattern
2795 * would be represented as a separate transcript object. This field is only
2796 * set for annotations of type TRANSCRIPT.
2797 */
2798 Transcript transcript;
2799 /**
2800 * The data type for this annotation. Must match the containing annotation
2801 * set's type.
2802 * Possible string values are:
2803 * - "GENE"
2804 * - "GENERIC"
2805 * - "TRANSCRIPT"
2806 * - "VARIANT"
2807 */
2808 core.String type;
2809 /**
2810 * A variant annotation, which describes the effect of a variant on the
2811 * genome, the coding sequence, and/or higher level consequences at the
2812 * organism level e.g. pathogenicity. This field is only set for annotations
2813 * of type VARIANT.
2814 */
2815 VariantAnnotation variant;
2816
2817 Annotation();
2818
2819 Annotation.fromJson(core.Map _json) {
2820 if (_json.containsKey("annotationSetId")) {
2821 annotationSetId = _json["annotationSetId"];
2822 }
2823 if (_json.containsKey("id")) {
2824 id = _json["id"];
2825 }
2826 if (_json.containsKey("info")) {
2827 info = _json["info"];
2828 }
2829 if (_json.containsKey("name")) {
2830 name = _json["name"];
2831 }
2832 if (_json.containsKey("position")) {
2833 position = new RangePosition.fromJson(_json["position"]);
2834 }
2835 if (_json.containsKey("transcript")) {
2836 transcript = new Transcript.fromJson(_json["transcript"]);
2837 }
2838 if (_json.containsKey("type")) {
2839 type = _json["type"];
2840 }
2841 if (_json.containsKey("variant")) {
2842 variant = new VariantAnnotation.fromJson(_json["variant"]);
2843 }
2844 }
2845
2846 core.Map toJson() {
2847 var _json = new core.Map();
2848 if (annotationSetId != null) {
2849 _json["annotationSetId"] = annotationSetId;
2850 }
2851 if (id != null) {
2852 _json["id"] = id;
2853 }
2854 if (info != null) {
2855 _json["info"] = info;
2856 }
2857 if (name != null) {
2858 _json["name"] = name;
2859 }
2860 if (position != null) {
2861 _json["position"] = (position).toJson();
2862 }
2863 if (transcript != null) {
2864 _json["transcript"] = (transcript).toJson();
2865 }
2866 if (type != null) {
2867 _json["type"] = type;
2868 }
2869 if (variant != null) {
2870 _json["variant"] = (variant).toJson();
2871 }
2872 return _json;
2873 }
2874 }
2875
2876 /**
2877 * An annotation set is a logical grouping of annotations that share consistent
2878 * type information and provenance. Examples of annotation sets include 'all
2879 * genes from refseq', and 'all variant annotations from ClinVar'.
2880 */
2881 class AnnotationSet {
2882 /** The dataset to which this annotation set belongs. */
2883 core.String datasetId;
2884 /**
2885 * The server-generated annotation set ID, unique across all annotation sets.
2886 */
2887 core.String id;
2888 /** A string which maps to an array of values. */
2889 core.Map<core.String, core.List<core.String>> info;
2890 /** The display name for this annotation set. */
2891 core.String name;
2892 /**
2893 * The ID of the reference set that defines the coordinate space for this
2894 * set's annotations.
2895 */
2896 core.String referenceSetId;
2897 /**
2898 * The source URI describing the file from which this annotation set was
2899 * generated, if any.
2900 */
2901 core.String sourceUri;
2902 /**
2903 * The type of annotations contained within this set.
2904 * Possible string values are:
2905 * - "GENE"
2906 * - "GENERIC"
2907 * - "TRANSCRIPT"
2908 * - "VARIANT"
2909 */
2910 core.String type;
2911
2912 AnnotationSet();
2913
2914 AnnotationSet.fromJson(core.Map _json) {
2915 if (_json.containsKey("datasetId")) {
2916 datasetId = _json["datasetId"];
2917 }
2918 if (_json.containsKey("id")) {
2919 id = _json["id"];
2920 }
2921 if (_json.containsKey("info")) {
2922 info = _json["info"];
2923 }
2924 if (_json.containsKey("name")) {
2925 name = _json["name"];
2926 }
2927 if (_json.containsKey("referenceSetId")) {
2928 referenceSetId = _json["referenceSetId"];
2929 }
2930 if (_json.containsKey("sourceUri")) {
2931 sourceUri = _json["sourceUri"];
2932 }
2933 if (_json.containsKey("type")) {
2934 type = _json["type"];
2935 }
2936 }
2937
2938 core.Map toJson() {
2939 var _json = new core.Map();
2940 if (datasetId != null) {
2941 _json["datasetId"] = datasetId;
2942 }
2943 if (id != null) {
2944 _json["id"] = id;
2945 }
2946 if (info != null) {
2947 _json["info"] = info;
2948 }
2949 if (name != null) {
2950 _json["name"] = name;
2951 }
2952 if (referenceSetId != null) {
2953 _json["referenceSetId"] = referenceSetId;
2954 }
2955 if (sourceUri != null) {
2956 _json["sourceUri"] = sourceUri;
2957 }
2958 if (type != null) {
2959 _json["type"] = type;
2960 }
2961 return _json;
2962 }
2963 }
2964
2965 class BatchAnnotationsResponse {
2966 /**
2967 * The resulting per-annotation entries, ordered consistently with the
2968 * original request.
2969 */
2970 core.List<BatchAnnotationsResponseEntry> entries;
2971
2972 BatchAnnotationsResponse();
2973
2974 BatchAnnotationsResponse.fromJson(core.Map _json) {
2975 if (_json.containsKey("entries")) {
2976 entries = _json["entries"].map((value) => new BatchAnnotationsResponseEntr y.fromJson(value)).toList();
2977 }
2978 }
2979
2980 core.Map toJson() {
2981 var _json = new core.Map();
2982 if (entries != null) {
2983 _json["entries"] = entries.map((value) => (value).toJson()).toList();
2984 }
2985 return _json;
2986 }
2987 }
2988
2989 class BatchAnnotationsResponseEntry {
2990 /** The annotation, if any. */
2991 Annotation annotation;
2992 /** The resulting status for this annotation operation. */
2993 BatchAnnotationsResponseEntryStatus status;
2994
2995 BatchAnnotationsResponseEntry();
2996
2997 BatchAnnotationsResponseEntry.fromJson(core.Map _json) {
2998 if (_json.containsKey("annotation")) {
2999 annotation = new Annotation.fromJson(_json["annotation"]);
3000 }
3001 if (_json.containsKey("status")) {
3002 status = new BatchAnnotationsResponseEntryStatus.fromJson(_json["status"]) ;
3003 }
3004 }
3005
3006 core.Map toJson() {
3007 var _json = new core.Map();
3008 if (annotation != null) {
3009 _json["annotation"] = (annotation).toJson();
3010 }
3011 if (status != null) {
3012 _json["status"] = (status).toJson();
3013 }
3014 return _json;
3015 }
3016 }
3017
3018 class BatchAnnotationsResponseEntryStatus {
3019 /** The HTTP status code for this operation. */
3020 core.int code;
3021 /** Error message for this status, if any. */
3022 core.String message;
3023
3024 BatchAnnotationsResponseEntryStatus();
3025
3026 BatchAnnotationsResponseEntryStatus.fromJson(core.Map _json) {
3027 if (_json.containsKey("code")) {
3028 code = _json["code"];
3029 }
3030 if (_json.containsKey("message")) {
3031 message = _json["message"];
3032 }
3033 }
3034
3035 core.Map toJson() {
3036 var _json = new core.Map();
3037 if (code != null) {
3038 _json["code"] = code;
3039 }
3040 if (message != null) {
3041 _json["message"] = message;
3042 }
3043 return _json;
3044 }
3045 }
3046
3047 class BatchCreateAnnotationsRequest {
3048 /**
3049 * The annotations to be created. At most 4096 can be specified in a single
3050 * request.
3051 */
3052 core.List<Annotation> annotations;
3053
3054 BatchCreateAnnotationsRequest();
3055
3056 BatchCreateAnnotationsRequest.fromJson(core.Map _json) {
3057 if (_json.containsKey("annotations")) {
3058 annotations = _json["annotations"].map((value) => new Annotation.fromJson( value)).toList();
3059 }
3060 }
3061
3062 core.Map toJson() {
3063 var _json = new core.Map();
3064 if (annotations != null) {
3065 _json["annotations"] = annotations.map((value) => (value).toJson()).toList ();
3066 }
3067 return _json;
3068 }
3069 }
3070
3071 /**
3072 * A call represents the determination of genotype with respect to a particular
3073 * variant. It may include associated information such as quality and phasing.
3074 * For example, a call might assign a probability of 0.32 to the occurrence of a
3075 * SNP named rs1234 in a call set with the name NA12345.
3076 */
3077 class Call {
3078 /** The ID of the call set this variant call belongs to. */
3079 core.String callSetId;
3080 /** The name of the call set this variant call belongs to. */
3081 core.String callSetName;
3082 /**
3083 * The genotype of this variant call. Each value represents either the value
3084 * of the referenceBases field or a 1-based index into alternateBases. If a
3085 * variant had a referenceBases value of T and an alternateBases value of
3086 * ["A", "C"], and the genotype was [2, 1], that would mean the call
3087 * represented the heterozygous value CA for this variant. If the genotype was
3088 * instead [0, 1], the represented value would be TA. Ordering of the genotype
3089 * values is important if the phaseset is present. If a genotype is not called
3090 * (that is, a . is present in the GT string) -1 is returned.
3091 */
3092 core.List<core.int> genotype;
3093 /**
3094 * The genotype likelihoods for this variant call. Each array entry represents
3095 * how likely a specific genotype is for this call. The value ordering is
3096 * defined by the GL tag in the VCF spec. If Phred-scaled genotype likelihood
3097 * scores (PL) are available and log10(P) genotype likelihood scores (GL) are
3098 * not, PL scores are converted to GL scores. If both are available, PL scores
3099 * are stored in info.
3100 */
3101 core.List<core.double> genotypeLikelihood;
3102 /** A string which maps to an array of values. */
3103 core.Map<core.String, core.List<core.String>> info;
3104 /**
3105 * If this field is present, this variant call's genotype ordering implies the
3106 * phase of the bases and is consistent with any other variant calls in the
3107 * same reference sequence which have the same phaseset value. When importing
3108 * data from VCF, if the genotype data was phased but no phase set was
3109 * specified this field will be set to *.
3110 */
3111 core.String phaseset;
3112
3113 Call();
3114
3115 Call.fromJson(core.Map _json) {
3116 if (_json.containsKey("callSetId")) {
3117 callSetId = _json["callSetId"];
3118 }
3119 if (_json.containsKey("callSetName")) {
3120 callSetName = _json["callSetName"];
3121 }
3122 if (_json.containsKey("genotype")) {
3123 genotype = _json["genotype"];
3124 }
3125 if (_json.containsKey("genotypeLikelihood")) {
3126 genotypeLikelihood = _json["genotypeLikelihood"];
3127 }
3128 if (_json.containsKey("info")) {
3129 info = _json["info"];
3130 }
3131 if (_json.containsKey("phaseset")) {
3132 phaseset = _json["phaseset"];
3133 }
3134 }
3135
3136 core.Map toJson() {
3137 var _json = new core.Map();
3138 if (callSetId != null) {
3139 _json["callSetId"] = callSetId;
3140 }
3141 if (callSetName != null) {
3142 _json["callSetName"] = callSetName;
3143 }
3144 if (genotype != null) {
3145 _json["genotype"] = genotype;
3146 }
3147 if (genotypeLikelihood != null) {
3148 _json["genotypeLikelihood"] = genotypeLikelihood;
3149 }
3150 if (info != null) {
3151 _json["info"] = info;
3152 }
3153 if (phaseset != null) {
3154 _json["phaseset"] = phaseset;
3155 }
3156 return _json;
3157 }
3158 }
3159
3160 /**
3161 * A call set is a collection of variant calls, typically for one sample. It
3162 * belongs to a variant set.
3163 */
3164 class CallSet {
3165 /** The date this call set was created in milliseconds from the epoch. */
3166 core.String created;
3167 /** The Google generated ID of the call set, immutable. */
3168 core.String id;
3169 /** A string which maps to an array of values. */
3170 core.Map<core.String, core.List<core.String>> info;
3171 /** The call set name. */
3172 core.String name;
3173 /** The sample ID this call set corresponds to. */
3174 core.String sampleId;
3175 /** The IDs of the variant sets this call set belongs to. */
3176 core.List<core.String> variantSetIds;
3177
3178 CallSet();
3179
3180 CallSet.fromJson(core.Map _json) {
3181 if (_json.containsKey("created")) {
3182 created = _json["created"];
3183 }
3184 if (_json.containsKey("id")) {
3185 id = _json["id"];
3186 }
3187 if (_json.containsKey("info")) {
3188 info = _json["info"];
3189 }
3190 if (_json.containsKey("name")) {
3191 name = _json["name"];
3192 }
3193 if (_json.containsKey("sampleId")) {
3194 sampleId = _json["sampleId"];
3195 }
3196 if (_json.containsKey("variantSetIds")) {
3197 variantSetIds = _json["variantSetIds"];
3198 }
3199 }
3200
3201 core.Map toJson() {
3202 var _json = new core.Map();
3203 if (created != null) {
3204 _json["created"] = created;
3205 }
3206 if (id != null) {
3207 _json["id"] = id;
3208 }
3209 if (info != null) {
3210 _json["info"] = info;
3211 }
3212 if (name != null) {
3213 _json["name"] = name;
3214 }
3215 if (sampleId != null) {
3216 _json["sampleId"] = sampleId;
3217 }
3218 if (variantSetIds != null) {
3219 _json["variantSetIds"] = variantSetIds;
3220 }
3221 return _json;
3222 }
3223 }
3224
3225 /** A single CIGAR operation. */
3226 class CigarUnit {
3227 /**
3228 *
3229 * Possible string values are:
3230 * - "ALIGNMENT_MATCH"
3231 * - "CLIP_HARD"
3232 * - "CLIP_SOFT"
3233 * - "DELETE"
3234 * - "INSERT"
3235 * - "OPERATION_UNSPECIFIED"
3236 * - "PAD"
3237 * - "SEQUENCE_MATCH"
3238 * - "SEQUENCE_MISMATCH"
3239 * - "SKIP"
3240 */
3241 core.String operation;
3242 /** The number of bases that the operation runs for. Required. */
3243 core.String operationLength;
3244 /**
3245 * referenceSequence is only used at mismatches (SEQUENCE_MISMATCH) and
3246 * deletions (DELETE). Filling this field replaces SAM's MD tag. If the
3247 * relevant information is not available, this field is unset.
3248 */
3249 core.String referenceSequence;
3250
3251 CigarUnit();
3252
3253 CigarUnit.fromJson(core.Map _json) {
3254 if (_json.containsKey("operation")) {
3255 operation = _json["operation"];
3256 }
3257 if (_json.containsKey("operationLength")) {
3258 operationLength = _json["operationLength"];
3259 }
3260 if (_json.containsKey("referenceSequence")) {
3261 referenceSequence = _json["referenceSequence"];
3262 }
3263 }
3264
3265 core.Map toJson() {
3266 var _json = new core.Map();
3267 if (operation != null) {
3268 _json["operation"] = operation;
3269 }
3270 if (operationLength != null) {
3271 _json["operationLength"] = operationLength;
3272 }
3273 if (referenceSequence != null) {
3274 _json["referenceSequence"] = referenceSequence;
3275 }
3276 return _json;
3277 }
3278 }
3279
3280 /**
3281 * A bucket over which read coverage has been precomputed. A bucket corresponds
3282 * to a specific range of the reference sequence.
3283 */
3284 class CoverageBucket {
3285 /**
3286 * The average number of reads which are aligned to each individual reference
3287 * base in this bucket.
3288 */
3289 core.double meanCoverage;
3290 /** The genomic coordinate range spanned by this bucket. */
3291 Range range;
3292
3293 CoverageBucket();
3294
3295 CoverageBucket.fromJson(core.Map _json) {
3296 if (_json.containsKey("meanCoverage")) {
3297 meanCoverage = _json["meanCoverage"];
3298 }
3299 if (_json.containsKey("range")) {
3300 range = new Range.fromJson(_json["range"]);
3301 }
3302 }
3303
3304 core.Map toJson() {
3305 var _json = new core.Map();
3306 if (meanCoverage != null) {
3307 _json["meanCoverage"] = meanCoverage;
3308 }
3309 if (range != null) {
3310 _json["range"] = (range).toJson();
3311 }
3312 return _json;
3313 }
3314 }
3315
3316 /** A Dataset is a collection of genomic data. */
3317 class Dataset {
3318 /** The time this dataset was created, in seconds from the epoch. */
3319 core.String createTime;
3320 /** The Google generated ID of the dataset, immutable. */
3321 core.String id;
3322 /**
3323 * Flag indicating whether or not a dataset is publicly viewable. If a dataset
3324 * is not public, it inherits viewing permissions from its project.
3325 */
3326 core.bool isPublic;
3327 /** The dataset name. */
3328 core.String name;
3329 /**
3330 * The Google Developers Console project number that this dataset belongs to.
3331 */
3332 core.String projectNumber;
3333
3334 Dataset();
3335
3336 Dataset.fromJson(core.Map _json) {
3337 if (_json.containsKey("createTime")) {
3338 createTime = _json["createTime"];
3339 }
3340 if (_json.containsKey("id")) {
3341 id = _json["id"];
3342 }
3343 if (_json.containsKey("isPublic")) {
3344 isPublic = _json["isPublic"];
3345 }
3346 if (_json.containsKey("name")) {
3347 name = _json["name"];
3348 }
3349 if (_json.containsKey("projectNumber")) {
3350 projectNumber = _json["projectNumber"];
3351 }
3352 }
3353
3354 core.Map toJson() {
3355 var _json = new core.Map();
3356 if (createTime != null) {
3357 _json["createTime"] = createTime;
3358 }
3359 if (id != null) {
3360 _json["id"] = id;
3361 }
3362 if (isPublic != null) {
3363 _json["isPublic"] = isPublic;
3364 }
3365 if (name != null) {
3366 _json["name"] = name;
3367 }
3368 if (projectNumber != null) {
3369 _json["projectNumber"] = projectNumber;
3370 }
3371 return _json;
3372 }
3373 }
3374
3375 /** The job creation request. */
3376 class ExperimentalCreateJobRequest {
3377 /**
3378 * Specifies whether or not to run the alignment pipeline. Either align or
3379 * callVariants must be set.
3380 */
3381 core.bool align;
3382 /**
3383 * Specifies whether or not to run the variant calling pipeline. Either align
3384 * or callVariants must be set.
3385 */
3386 core.bool callVariants;
3387 /**
3388 * Specifies where to copy the results of certain pipelines. This should be in
3389 * the form of gs://bucket/path.
3390 */
3391 core.String gcsOutputPath;
3392 /**
3393 * A list of Google Cloud Storage URIs of paired end .fastq files to operate
3394 * upon. If specified, this represents the second file of each paired .fastq
3395 * file. The first file of each pair should be specified in sourceUris.
3396 */
3397 core.List<core.String> pairedSourceUris;
3398 /**
3399 * Required. The Google Cloud Project ID with which to associate the request.
3400 */
3401 core.String projectNumber;
3402 /**
3403 * A list of Google Cloud Storage URIs of data files to operate upon. These
3404 * can be .bam, interleaved .fastq, or paired .fastq. If specifying paired
3405 * .fastq files, the first of each pair of files should be listed here, and
3406 * the second of each pair should be listed in pairedSourceUris.
3407 */
3408 core.List<core.String> sourceUris;
3409
3410 ExperimentalCreateJobRequest();
3411
3412 ExperimentalCreateJobRequest.fromJson(core.Map _json) {
3413 if (_json.containsKey("align")) {
3414 align = _json["align"];
3415 }
3416 if (_json.containsKey("callVariants")) {
3417 callVariants = _json["callVariants"];
3418 }
3419 if (_json.containsKey("gcsOutputPath")) {
3420 gcsOutputPath = _json["gcsOutputPath"];
3421 }
3422 if (_json.containsKey("pairedSourceUris")) {
3423 pairedSourceUris = _json["pairedSourceUris"];
3424 }
3425 if (_json.containsKey("projectNumber")) {
3426 projectNumber = _json["projectNumber"];
3427 }
3428 if (_json.containsKey("sourceUris")) {
3429 sourceUris = _json["sourceUris"];
3430 }
3431 }
3432
3433 core.Map toJson() {
3434 var _json = new core.Map();
3435 if (align != null) {
3436 _json["align"] = align;
3437 }
3438 if (callVariants != null) {
3439 _json["callVariants"] = callVariants;
3440 }
3441 if (gcsOutputPath != null) {
3442 _json["gcsOutputPath"] = gcsOutputPath;
3443 }
3444 if (pairedSourceUris != null) {
3445 _json["pairedSourceUris"] = pairedSourceUris;
3446 }
3447 if (projectNumber != null) {
3448 _json["projectNumber"] = projectNumber;
3449 }
3450 if (sourceUris != null) {
3451 _json["sourceUris"] = sourceUris;
3452 }
3453 return _json;
3454 }
3455 }
3456
3457 /** The job creation response. */
3458 class ExperimentalCreateJobResponse {
3459 /** A job ID that can be used to get status information. */
3460 core.String jobId;
3461
3462 ExperimentalCreateJobResponse();
3463
3464 ExperimentalCreateJobResponse.fromJson(core.Map _json) {
3465 if (_json.containsKey("jobId")) {
3466 jobId = _json["jobId"];
3467 }
3468 }
3469
3470 core.Map toJson() {
3471 var _json = new core.Map();
3472 if (jobId != null) {
3473 _json["jobId"] = jobId;
3474 }
3475 return _json;
3476 }
3477 }
3478
3479 /** The read group set export request. */
3480 class ExportReadGroupSetsRequest {
3481 /**
3482 * Required. A Google Cloud Storage URI for the exported BAM file. The
3483 * currently authenticated user must have write access to the new file. An
3484 * error will be returned if the URI already contains data.
3485 */
3486 core.String exportUri;
3487 /**
3488 * Required. The Google Developers Console project number that owns this
3489 * export. The caller must have WRITE access to this project.
3490 */
3491 core.String projectNumber;
3492 /**
3493 * Required. The IDs of the read group sets to export. The caller must have
3494 * READ access to these read group sets.
3495 */
3496 core.List<core.String> readGroupSetIds;
3497 /**
3498 * The reference names to export. If this is not specified, all reference
3499 * sequences, including unmapped reads, are exported. Use * to export only
3500 * unmapped reads.
3501 */
3502 core.List<core.String> referenceNames;
3503
3504 ExportReadGroupSetsRequest();
3505
3506 ExportReadGroupSetsRequest.fromJson(core.Map _json) {
3507 if (_json.containsKey("exportUri")) {
3508 exportUri = _json["exportUri"];
3509 }
3510 if (_json.containsKey("projectNumber")) {
3511 projectNumber = _json["projectNumber"];
3512 }
3513 if (_json.containsKey("readGroupSetIds")) {
3514 readGroupSetIds = _json["readGroupSetIds"];
3515 }
3516 if (_json.containsKey("referenceNames")) {
3517 referenceNames = _json["referenceNames"];
3518 }
3519 }
3520
3521 core.Map toJson() {
3522 var _json = new core.Map();
3523 if (exportUri != null) {
3524 _json["exportUri"] = exportUri;
3525 }
3526 if (projectNumber != null) {
3527 _json["projectNumber"] = projectNumber;
3528 }
3529 if (readGroupSetIds != null) {
3530 _json["readGroupSetIds"] = readGroupSetIds;
3531 }
3532 if (referenceNames != null) {
3533 _json["referenceNames"] = referenceNames;
3534 }
3535 return _json;
3536 }
3537 }
3538
3539 /** The read group set export response. */
3540 class ExportReadGroupSetsResponse {
3541 /** A job ID that can be used to get status information. */
3542 core.String jobId;
3543
3544 ExportReadGroupSetsResponse();
3545
3546 ExportReadGroupSetsResponse.fromJson(core.Map _json) {
3547 if (_json.containsKey("jobId")) {
3548 jobId = _json["jobId"];
3549 }
3550 }
3551
3552 core.Map toJson() {
3553 var _json = new core.Map();
3554 if (jobId != null) {
3555 _json["jobId"] = jobId;
3556 }
3557 return _json;
3558 }
3559 }
3560
3561 /** The variant data export request. */
3562 class ExportVariantSetRequest {
3563 /**
3564 * Required. The BigQuery dataset to export data to. This dataset must already
3565 * exist. Note that this is distinct from the Genomics concept of "dataset".
3566 */
3567 core.String bigqueryDataset;
3568 /**
3569 * Required. The BigQuery table to export data to. If the table doesn't exist,
3570 * it will be created. If it already exists, it will be overwritten.
3571 */
3572 core.String bigqueryTable;
3573 /**
3574 * If provided, only variant call information from the specified call sets
3575 * will be exported. By default all variant calls are exported.
3576 */
3577 core.List<core.String> callSetIds;
3578 /**
3579 * The format for the exported data.
3580 * Possible string values are:
3581 * - "BIGQUERY"
3582 */
3583 core.String format;
3584 /**
3585 * Required. The Google Cloud project number that owns the destination
3586 * BigQuery dataset. The caller must have WRITE access to this project. This
3587 * project will also own the resulting export job.
3588 */
3589 core.String projectNumber;
3590
3591 ExportVariantSetRequest();
3592
3593 ExportVariantSetRequest.fromJson(core.Map _json) {
3594 if (_json.containsKey("bigqueryDataset")) {
3595 bigqueryDataset = _json["bigqueryDataset"];
3596 }
3597 if (_json.containsKey("bigqueryTable")) {
3598 bigqueryTable = _json["bigqueryTable"];
3599 }
3600 if (_json.containsKey("callSetIds")) {
3601 callSetIds = _json["callSetIds"];
3602 }
3603 if (_json.containsKey("format")) {
3604 format = _json["format"];
3605 }
3606 if (_json.containsKey("projectNumber")) {
3607 projectNumber = _json["projectNumber"];
3608 }
3609 }
3610
3611 core.Map toJson() {
3612 var _json = new core.Map();
3613 if (bigqueryDataset != null) {
3614 _json["bigqueryDataset"] = bigqueryDataset;
3615 }
3616 if (bigqueryTable != null) {
3617 _json["bigqueryTable"] = bigqueryTable;
3618 }
3619 if (callSetIds != null) {
3620 _json["callSetIds"] = callSetIds;
3621 }
3622 if (format != null) {
3623 _json["format"] = format;
3624 }
3625 if (projectNumber != null) {
3626 _json["projectNumber"] = projectNumber;
3627 }
3628 return _json;
3629 }
3630 }
3631
3632 /** The variant data export response. */
3633 class ExportVariantSetResponse {
3634 /** A job ID that can be used to get status information. */
3635 core.String jobId;
3636
3637 ExportVariantSetResponse();
3638
3639 ExportVariantSetResponse.fromJson(core.Map _json) {
3640 if (_json.containsKey("jobId")) {
3641 jobId = _json["jobId"];
3642 }
3643 }
3644
3645 core.Map toJson() {
3646 var _json = new core.Map();
3647 if (jobId != null) {
3648 _json["jobId"] = jobId;
3649 }
3650 return _json;
3651 }
3652 }
3653
3654 class ExternalId {
3655 /** The id used by the source of this data. */
3656 core.String id;
3657 /** The name of the source of this data. */
3658 core.String sourceName;
3659
3660 ExternalId();
3661
3662 ExternalId.fromJson(core.Map _json) {
3663 if (_json.containsKey("id")) {
3664 id = _json["id"];
3665 }
3666 if (_json.containsKey("sourceName")) {
3667 sourceName = _json["sourceName"];
3668 }
3669 }
3670
3671 core.Map toJson() {
3672 var _json = new core.Map();
3673 if (id != null) {
3674 _json["id"] = id;
3675 }
3676 if (sourceName != null) {
3677 _json["sourceName"] = sourceName;
3678 }
3679 return _json;
3680 }
3681 }
3682
3683 /** The read group set import request. */
3684 class ImportReadGroupSetsRequest {
3685 /**
3686 * Required. The ID of the dataset these read group sets will belong to. The
3687 * caller must have WRITE permissions to this dataset.
3688 */
3689 core.String datasetId;
3690 /**
3691 * The partition strategy describes how read groups are partitioned into read
3692 * group sets.
3693 * Possible string values are:
3694 * - "MERGE_ALL"
3695 * - "PER_FILE_PER_SAMPLE"
3696 */
3697 core.String partitionStrategy;
3698 /**
3699 * The reference set to which the imported read group sets are aligned to, if
3700 * any. The reference names of this reference set must be a superset of those
3701 * found in the imported file headers. If no reference set id is provided, a
3702 * best effort is made to associate with a matching reference set.
3703 */
3704 core.String referenceSetId;
3705 /** A list of URIs pointing at BAM files in Google Cloud Storage. */
3706 core.List<core.String> sourceUris;
3707
3708 ImportReadGroupSetsRequest();
3709
3710 ImportReadGroupSetsRequest.fromJson(core.Map _json) {
3711 if (_json.containsKey("datasetId")) {
3712 datasetId = _json["datasetId"];
3713 }
3714 if (_json.containsKey("partitionStrategy")) {
3715 partitionStrategy = _json["partitionStrategy"];
3716 }
3717 if (_json.containsKey("referenceSetId")) {
3718 referenceSetId = _json["referenceSetId"];
3719 }
3720 if (_json.containsKey("sourceUris")) {
3721 sourceUris = _json["sourceUris"];
3722 }
3723 }
3724
3725 core.Map toJson() {
3726 var _json = new core.Map();
3727 if (datasetId != null) {
3728 _json["datasetId"] = datasetId;
3729 }
3730 if (partitionStrategy != null) {
3731 _json["partitionStrategy"] = partitionStrategy;
3732 }
3733 if (referenceSetId != null) {
3734 _json["referenceSetId"] = referenceSetId;
3735 }
3736 if (sourceUris != null) {
3737 _json["sourceUris"] = sourceUris;
3738 }
3739 return _json;
3740 }
3741 }
3742
3743 /** The read group set import response. */
3744 class ImportReadGroupSetsResponse {
3745 /** A job ID that can be used to get status information. */
3746 core.String jobId;
3747
3748 ImportReadGroupSetsResponse();
3749
3750 ImportReadGroupSetsResponse.fromJson(core.Map _json) {
3751 if (_json.containsKey("jobId")) {
3752 jobId = _json["jobId"];
3753 }
3754 }
3755
3756 core.Map toJson() {
3757 var _json = new core.Map();
3758 if (jobId != null) {
3759 _json["jobId"] = jobId;
3760 }
3761 return _json;
3762 }
3763 }
3764
3765 /** The variant data import request. */
3766 class ImportVariantsRequest {
3767 /**
3768 * The format of the variant data being imported. If unspecified, defaults to
3769 * "VCF".
3770 * Possible string values are:
3771 * - "COMPLETE_GENOMICS"
3772 * - "VCF"
3773 */
3774 core.String format;
3775 /**
3776 * Convert reference names to the canonical representation. hg19 haploytypes
3777 * (those reference names containing "_hap") are not modified in any way. All
3778 * other reference names are modified according to the following rules: The
3779 * reference name is capitalized. The "chr" prefix is dropped for all
3780 * autosomes and sex chromsomes. For example "chr17" becomes "17" and "chrX"
3781 * becomes "X". All mitochondrial chromosomes ("chrM", "chrMT", etc) become
3782 * "MT".
3783 */
3784 core.bool normalizeReferenceNames;
3785 /**
3786 * A list of URIs referencing variant files in Google Cloud Storage. URIs can
3787 * include wildcards as described here. Note that recursive wildcards ('**')
3788 * are not supported.
3789 */
3790 core.List<core.String> sourceUris;
3791
3792 ImportVariantsRequest();
3793
3794 ImportVariantsRequest.fromJson(core.Map _json) {
3795 if (_json.containsKey("format")) {
3796 format = _json["format"];
3797 }
3798 if (_json.containsKey("normalizeReferenceNames")) {
3799 normalizeReferenceNames = _json["normalizeReferenceNames"];
3800 }
3801 if (_json.containsKey("sourceUris")) {
3802 sourceUris = _json["sourceUris"];
3803 }
3804 }
3805
3806 core.Map toJson() {
3807 var _json = new core.Map();
3808 if (format != null) {
3809 _json["format"] = format;
3810 }
3811 if (normalizeReferenceNames != null) {
3812 _json["normalizeReferenceNames"] = normalizeReferenceNames;
3813 }
3814 if (sourceUris != null) {
3815 _json["sourceUris"] = sourceUris;
3816 }
3817 return _json;
3818 }
3819 }
3820
3821 /** The variant data import response. */
3822 class ImportVariantsResponse {
3823 /** A job ID that can be used to get status information. */
3824 core.String jobId;
3825
3826 ImportVariantsResponse();
3827
3828 ImportVariantsResponse.fromJson(core.Map _json) {
3829 if (_json.containsKey("jobId")) {
3830 jobId = _json["jobId"];
3831 }
3832 }
3833
3834 core.Map toJson() {
3835 var _json = new core.Map();
3836 if (jobId != null) {
3837 _json["jobId"] = jobId;
3838 }
3839 return _json;
3840 }
3841 }
3842
3843 /**
3844 * Wrapper message for `int32`.
3845 *
3846 * The JSON representation for `Int32Value` is JSON number.
3847 */
3848 class Int32Value {
3849 /** The int32 value. */
3850 core.int value;
3851
3852 Int32Value();
3853
3854 Int32Value.fromJson(core.Map _json) {
3855 if (_json.containsKey("value")) {
3856 value = _json["value"];
3857 }
3858 }
3859
3860 core.Map toJson() {
3861 var _json = new core.Map();
3862 if (value != null) {
3863 _json["value"] = value;
3864 }
3865 return _json;
3866 }
3867 }
3868
3869 /**
3870 * A Job represents an ongoing process that can be monitored for status
3871 * information.
3872 */
3873 class Job {
3874 /** The date this job was created, in milliseconds from the epoch. */
3875 core.String created;
3876 /** A more detailed description of this job's current status. */
3877 core.String detailedStatus;
3878 /** Any errors that occurred during processing. */
3879 core.List<core.String> errors;
3880 /** The job ID. */
3881 core.String id;
3882 /**
3883 * If this Job represents an import, this field will contain the IDs of the
3884 * objects that were successfully imported.
3885 */
3886 core.List<core.String> importedIds;
3887 /**
3888 * The Google Developers Console project number to which this job belongs.
3889 */
3890 core.String projectNumber;
3891 /** A summarized representation of the original service request. */
3892 JobRequest request;
3893 /**
3894 * The status of this job.
3895 * Possible string values are:
3896 * - "CANCELED"
3897 * - "FAILURE"
3898 * - "NEW"
3899 * - "PENDING"
3900 * - "RUNNING"
3901 * - "SUCCESS"
3902 * - "UNKNOWN_STATUS"
3903 */
3904 core.String status;
3905 /** Any warnings that occurred during processing. */
3906 core.List<core.String> warnings;
3907
3908 Job();
3909
3910 Job.fromJson(core.Map _json) {
3911 if (_json.containsKey("created")) {
3912 created = _json["created"];
3913 }
3914 if (_json.containsKey("detailedStatus")) {
3915 detailedStatus = _json["detailedStatus"];
3916 }
3917 if (_json.containsKey("errors")) {
3918 errors = _json["errors"];
3919 }
3920 if (_json.containsKey("id")) {
3921 id = _json["id"];
3922 }
3923 if (_json.containsKey("importedIds")) {
3924 importedIds = _json["importedIds"];
3925 }
3926 if (_json.containsKey("projectNumber")) {
3927 projectNumber = _json["projectNumber"];
3928 }
3929 if (_json.containsKey("request")) {
3930 request = new JobRequest.fromJson(_json["request"]);
3931 }
3932 if (_json.containsKey("status")) {
3933 status = _json["status"];
3934 }
3935 if (_json.containsKey("warnings")) {
3936 warnings = _json["warnings"];
3937 }
3938 }
3939
3940 core.Map toJson() {
3941 var _json = new core.Map();
3942 if (created != null) {
3943 _json["created"] = created;
3944 }
3945 if (detailedStatus != null) {
3946 _json["detailedStatus"] = detailedStatus;
3947 }
3948 if (errors != null) {
3949 _json["errors"] = errors;
3950 }
3951 if (id != null) {
3952 _json["id"] = id;
3953 }
3954 if (importedIds != null) {
3955 _json["importedIds"] = importedIds;
3956 }
3957 if (projectNumber != null) {
3958 _json["projectNumber"] = projectNumber;
3959 }
3960 if (request != null) {
3961 _json["request"] = (request).toJson();
3962 }
3963 if (status != null) {
3964 _json["status"] = status;
3965 }
3966 if (warnings != null) {
3967 _json["warnings"] = warnings;
3968 }
3969 return _json;
3970 }
3971 }
3972
3973 /** A summary representation of the service request that spawned the job. */
3974 class JobRequest {
3975 /**
3976 * The data destination of the request, for example, a Google BigQuery Table
3977 * or Dataset ID.
3978 */
3979 core.List<core.String> destination;
3980 /**
3981 * The data source of the request, for example, a Google Cloud Storage object
3982 * path or Readset ID.
3983 */
3984 core.List<core.String> source;
3985 /**
3986 * The original request type.
3987 * Possible string values are:
3988 * - "ALIGN_READSETS"
3989 * - "CALL_READSETS"
3990 * - "EXPERIMENTAL_CREATE_JOB"
3991 * - "EXPORT_READSETS"
3992 * - "EXPORT_VARIANTS"
3993 * - "IMPORT_READSETS"
3994 * - "IMPORT_VARIANTS"
3995 * - "UNKNOWN_TYPE"
3996 */
3997 core.String type;
3998
3999 JobRequest();
4000
4001 JobRequest.fromJson(core.Map _json) {
4002 if (_json.containsKey("destination")) {
4003 destination = _json["destination"];
4004 }
4005 if (_json.containsKey("source")) {
4006 source = _json["source"];
4007 }
4008 if (_json.containsKey("type")) {
4009 type = _json["type"];
4010 }
4011 }
4012
4013 core.Map toJson() {
4014 var _json = new core.Map();
4015 if (destination != null) {
4016 _json["destination"] = destination;
4017 }
4018 if (source != null) {
4019 _json["source"] = source;
4020 }
4021 if (type != null) {
4022 _json["type"] = type;
4023 }
4024 return _json;
4025 }
4026 }
4027
4028 /** Used to hold basic key value information. */
4029 class KeyValue {
4030 /** A string which maps to an array of values. */
4031 core.String key;
4032 /** The string values. */
4033 core.List<core.String> value;
4034
4035 KeyValue();
4036
4037 KeyValue.fromJson(core.Map _json) {
4038 if (_json.containsKey("key")) {
4039 key = _json["key"];
4040 }
4041 if (_json.containsKey("value")) {
4042 value = _json["value"];
4043 }
4044 }
4045
4046 core.Map toJson() {
4047 var _json = new core.Map();
4048 if (key != null) {
4049 _json["key"] = key;
4050 }
4051 if (value != null) {
4052 _json["value"] = value;
4053 }
4054 return _json;
4055 }
4056 }
4057
4058 /**
4059 * A linear alignment can be represented by one CIGAR string. Describes the
4060 * mapped position and local alignment of the read to the reference.
4061 */
4062 class LinearAlignment {
4063 /**
4064 * Represents the local alignment of this sequence (alignment matches, indels,
4065 * etc) against the reference.
4066 */
4067 core.List<CigarUnit> cigar;
4068 /**
4069 * The mapping quality of this alignment. Represents how likely the read maps
4070 * to this position as opposed to other locations.
4071 *
4072 * Specifically, this is -10 log10 Pr(mapping position is wrong), rounded to
4073 * the nearest integer.
4074 */
4075 core.int mappingQuality;
4076 /** The position of this alignment. */
4077 Position position;
4078
4079 LinearAlignment();
4080
4081 LinearAlignment.fromJson(core.Map _json) {
4082 if (_json.containsKey("cigar")) {
4083 cigar = _json["cigar"].map((value) => new CigarUnit.fromJson(value)).toLis t();
4084 }
4085 if (_json.containsKey("mappingQuality")) {
4086 mappingQuality = _json["mappingQuality"];
4087 }
4088 if (_json.containsKey("position")) {
4089 position = new Position.fromJson(_json["position"]);
4090 }
4091 }
4092
4093 core.Map toJson() {
4094 var _json = new core.Map();
4095 if (cigar != null) {
4096 _json["cigar"] = cigar.map((value) => (value).toJson()).toList();
4097 }
4098 if (mappingQuality != null) {
4099 _json["mappingQuality"] = mappingQuality;
4100 }
4101 if (position != null) {
4102 _json["position"] = (position).toJson();
4103 }
4104 return _json;
4105 }
4106 }
4107
4108 class ListBasesResponse {
4109 /**
4110 * The continuation token, which is used to page through large result sets.
4111 * Provide this value in a subsequent request to return the next page of
4112 * results. This field will be empty if there aren't any additional results.
4113 */
4114 core.String nextPageToken;
4115 /**
4116 * The offset position (0-based) of the given sequence from the start of this
4117 * Reference. This value will differ for each page in a paginated request.
4118 */
4119 core.String offset;
4120 /** A substring of the bases that make up this reference. */
4121 core.String sequence;
4122
4123 ListBasesResponse();
4124
4125 ListBasesResponse.fromJson(core.Map _json) {
4126 if (_json.containsKey("nextPageToken")) {
4127 nextPageToken = _json["nextPageToken"];
4128 }
4129 if (_json.containsKey("offset")) {
4130 offset = _json["offset"];
4131 }
4132 if (_json.containsKey("sequence")) {
4133 sequence = _json["sequence"];
4134 }
4135 }
4136
4137 core.Map toJson() {
4138 var _json = new core.Map();
4139 if (nextPageToken != null) {
4140 _json["nextPageToken"] = nextPageToken;
4141 }
4142 if (offset != null) {
4143 _json["offset"] = offset;
4144 }
4145 if (sequence != null) {
4146 _json["sequence"] = sequence;
4147 }
4148 return _json;
4149 }
4150 }
4151
4152 class ListCoverageBucketsResponse {
4153 /**
4154 * The length of each coverage bucket in base pairs. Note that buckets at the
4155 * end of a reference sequence may be shorter. This value is omitted if the
4156 * bucket width is infinity (the default behaviour, with no range or
4157 * targetBucketWidth).
4158 */
4159 core.String bucketWidth;
4160 /**
4161 * The coverage buckets. The list of buckets is sparse; a bucket with 0
4162 * overlapping reads is not returned. A bucket never crosses more than one
4163 * reference sequence. Each bucket has width bucketWidth, unless its end is
4164 * the end of the reference sequence.
4165 */
4166 core.List<CoverageBucket> coverageBuckets;
4167 /**
4168 * The continuation token, which is used to page through large result sets.
4169 * Provide this value in a subsequent request to return the next page of
4170 * results. This field will be empty if there aren't any additional results.
4171 */
4172 core.String nextPageToken;
4173
4174 ListCoverageBucketsResponse();
4175
4176 ListCoverageBucketsResponse.fromJson(core.Map _json) {
4177 if (_json.containsKey("bucketWidth")) {
4178 bucketWidth = _json["bucketWidth"];
4179 }
4180 if (_json.containsKey("coverageBuckets")) {
4181 coverageBuckets = _json["coverageBuckets"].map((value) => new CoverageBuck et.fromJson(value)).toList();
4182 }
4183 if (_json.containsKey("nextPageToken")) {
4184 nextPageToken = _json["nextPageToken"];
4185 }
4186 }
4187
4188 core.Map toJson() {
4189 var _json = new core.Map();
4190 if (bucketWidth != null) {
4191 _json["bucketWidth"] = bucketWidth;
4192 }
4193 if (coverageBuckets != null) {
4194 _json["coverageBuckets"] = coverageBuckets.map((value) => (value).toJson() ).toList();
4195 }
4196 if (nextPageToken != null) {
4197 _json["nextPageToken"] = nextPageToken;
4198 }
4199 return _json;
4200 }
4201 }
4202
4203 /** The dataset list response. */
4204 class ListDatasetsResponse {
4205 /** The list of matching Datasets. */
4206 core.List<Dataset> datasets;
4207 /**
4208 * The continuation token, which is used to page through large result sets.
4209 * Provide this value in a subsequent request to return the next page of
4210 * results. This field will be empty if there aren't any additional results.
4211 */
4212 core.String nextPageToken;
4213
4214 ListDatasetsResponse();
4215
4216 ListDatasetsResponse.fromJson(core.Map _json) {
4217 if (_json.containsKey("datasets")) {
4218 datasets = _json["datasets"].map((value) => new Dataset.fromJson(value)).t oList();
4219 }
4220 if (_json.containsKey("nextPageToken")) {
4221 nextPageToken = _json["nextPageToken"];
4222 }
4223 }
4224
4225 core.Map toJson() {
4226 var _json = new core.Map();
4227 if (datasets != null) {
4228 _json["datasets"] = datasets.map((value) => (value).toJson()).toList();
4229 }
4230 if (nextPageToken != null) {
4231 _json["nextPageToken"] = nextPageToken;
4232 }
4233 return _json;
4234 }
4235 }
4236
4237 class MergeVariantsRequest {
4238 /** The variants to be merged with existing variants. */
4239 core.List<Variant> variants;
4240
4241 MergeVariantsRequest();
4242
4243 MergeVariantsRequest.fromJson(core.Map _json) {
4244 if (_json.containsKey("variants")) {
4245 variants = _json["variants"].map((value) => new Variant.fromJson(value)).t oList();
4246 }
4247 }
4248
4249 core.Map toJson() {
4250 var _json = new core.Map();
4251 if (variants != null) {
4252 _json["variants"] = variants.map((value) => (value).toJson()).toList();
4253 }
4254 return _json;
4255 }
4256 }
4257
4258 /**
4259 * Metadata describes a single piece of variant call metadata. These data
4260 * include a top level key and either a single value string (value) or a list of
4261 * key-value pairs (info.) Value and info are mutually exclusive.
4262 */
4263 class Metadata {
4264 /** A textual description of this metadata. */
4265 core.String description;
4266 /**
4267 * User-provided ID field, not enforced by this API. Two or more pieces of
4268 * structured metadata with identical id and key fields are considered
4269 * equivalent.
4270 */
4271 core.String id;
4272 /** A string which maps to an array of values. */
4273 core.Map<core.String, core.List<core.String>> info;
4274 /** The top-level key. */
4275 core.String key;
4276 /**
4277 * The number of values that can be included in a field described by this
4278 * metadata.
4279 */
4280 core.String number;
4281 /**
4282 * The type of data. Possible types include: Integer, Float, Flag, Character,
4283 * and String.
4284 * Possible string values are:
4285 * - "CHARACTER"
4286 * - "FLAG"
4287 * - "FLOAT"
4288 * - "INTEGER"
4289 * - "STRING"
4290 * - "UNKNOWN_TYPE"
4291 */
4292 core.String type;
4293 /** The value field for simple metadata */
4294 core.String value;
4295
4296 Metadata();
4297
4298 Metadata.fromJson(core.Map _json) {
4299 if (_json.containsKey("description")) {
4300 description = _json["description"];
4301 }
4302 if (_json.containsKey("id")) {
4303 id = _json["id"];
4304 }
4305 if (_json.containsKey("info")) {
4306 info = _json["info"];
4307 }
4308 if (_json.containsKey("key")) {
4309 key = _json["key"];
4310 }
4311 if (_json.containsKey("number")) {
4312 number = _json["number"];
4313 }
4314 if (_json.containsKey("type")) {
4315 type = _json["type"];
4316 }
4317 if (_json.containsKey("value")) {
4318 value = _json["value"];
4319 }
4320 }
4321
4322 core.Map toJson() {
4323 var _json = new core.Map();
4324 if (description != null) {
4325 _json["description"] = description;
4326 }
4327 if (id != null) {
4328 _json["id"] = id;
4329 }
4330 if (info != null) {
4331 _json["info"] = info;
4332 }
4333 if (key != null) {
4334 _json["key"] = key;
4335 }
4336 if (number != null) {
4337 _json["number"] = number;
4338 }
4339 if (type != null) {
4340 _json["type"] = type;
4341 }
4342 if (value != null) {
4343 _json["value"] = value;
4344 }
4345 return _json;
4346 }
4347 }
4348
4349 /**
4350 * An abstraction for referring to a genomic position, in relation to some
4351 * already known reference. For now, represents a genomic position as a
4352 * reference name, a base number on that reference (0-based), and a
4353 * determination of forward or reverse strand.
4354 */
4355 class Position {
4356 /**
4357 * The 0-based offset from the start of the forward strand for that reference.
4358 */
4359 core.String position;
4360 /** The name of the reference in whatever reference set is being used. */
4361 core.String referenceName;
4362 /**
4363 * Whether this position is on the reverse strand, as opposed to the forward
4364 * strand.
4365 */
4366 core.bool reverseStrand;
4367
4368 Position();
4369
4370 Position.fromJson(core.Map _json) {
4371 if (_json.containsKey("position")) {
4372 position = _json["position"];
4373 }
4374 if (_json.containsKey("referenceName")) {
4375 referenceName = _json["referenceName"];
4376 }
4377 if (_json.containsKey("reverseStrand")) {
4378 reverseStrand = _json["reverseStrand"];
4379 }
4380 }
4381
4382 core.Map toJson() {
4383 var _json = new core.Map();
4384 if (position != null) {
4385 _json["position"] = position;
4386 }
4387 if (referenceName != null) {
4388 _json["referenceName"] = referenceName;
4389 }
4390 if (reverseStrand != null) {
4391 _json["reverseStrand"] = reverseStrand;
4392 }
4393 return _json;
4394 }
4395 }
4396
4397 /**
4398 * A 0-based half-open genomic coordinate range for search requests.
4399 * reference_id or reference_name must be set.
4400 */
4401 class QueryRange {
4402 /**
4403 * The end position of the range on the reference, 0-based exclusive. If
4404 * specified, referenceId or referenceName must also be specified. If unset or
4405 * 0, defaults to the length of the reference.
4406 */
4407 core.String end;
4408 /** The ID of the reference to query. */
4409 core.String referenceId;
4410 /**
4411 * The name of the reference to query, within the reference set associated
4412 * with this query.
4413 */
4414 core.String referenceName;
4415 /**
4416 * The start position of the range on the reference, 0-based inclusive. If
4417 * specified, referenceId or referenceName must also be specified. Defaults to
4418 * 0.
4419 */
4420 core.String start;
4421
4422 QueryRange();
4423
4424 QueryRange.fromJson(core.Map _json) {
4425 if (_json.containsKey("end")) {
4426 end = _json["end"];
4427 }
4428 if (_json.containsKey("referenceId")) {
4429 referenceId = _json["referenceId"];
4430 }
4431 if (_json.containsKey("referenceName")) {
4432 referenceName = _json["referenceName"];
4433 }
4434 if (_json.containsKey("start")) {
4435 start = _json["start"];
4436 }
4437 }
4438
4439 core.Map toJson() {
4440 var _json = new core.Map();
4441 if (end != null) {
4442 _json["end"] = end;
4443 }
4444 if (referenceId != null) {
4445 _json["referenceId"] = referenceId;
4446 }
4447 if (referenceName != null) {
4448 _json["referenceName"] = referenceName;
4449 }
4450 if (start != null) {
4451 _json["start"] = start;
4452 }
4453 return _json;
4454 }
4455 }
4456
4457 /** A 0-based half-open genomic coordinate range over a reference sequence. */
4458 class Range {
4459 /**
4460 * The end position of the range on the reference, 0-based exclusive. If
4461 * specified, referenceName must also be specified.
4462 */
4463 core.String end;
4464 /** The reference sequence name, for example chr1, 1, or chrX. */
4465 core.String referenceName;
4466 /**
4467 * The start position of the range on the reference, 0-based inclusive. If
4468 * specified, referenceName must also be specified.
4469 */
4470 core.String start;
4471
4472 Range();
4473
4474 Range.fromJson(core.Map _json) {
4475 if (_json.containsKey("end")) {
4476 end = _json["end"];
4477 }
4478 if (_json.containsKey("referenceName")) {
4479 referenceName = _json["referenceName"];
4480 }
4481 if (_json.containsKey("start")) {
4482 start = _json["start"];
4483 }
4484 }
4485
4486 core.Map toJson() {
4487 var _json = new core.Map();
4488 if (end != null) {
4489 _json["end"] = end;
4490 }
4491 if (referenceName != null) {
4492 _json["referenceName"] = referenceName;
4493 }
4494 if (start != null) {
4495 _json["start"] = start;
4496 }
4497 return _json;
4498 }
4499 }
4500
4501 /**
4502 * A 0-based half-open genomic coordinate range over a reference sequence, for
4503 * representing the position of a genomic resource.
4504 */
4505 class RangePosition {
4506 /** The end position of the range on the reference, 0-based exclusive. */
4507 core.String end;
4508 /** The ID of the Google Genomics reference associated with this range. */
4509 core.String referenceId;
4510 /**
4511 * The display name corresponding to the reference specified by referenceId,
4512 * for example chr1, 1, or chrX.
4513 */
4514 core.String referenceName;
4515 /**
4516 * Whether this range refers to the reverse strand, as opposed to the forward
4517 * strand. Note that regardless of this field, the start/end position of the
4518 * range always refer to the forward strand.
4519 */
4520 core.bool reverseStrand;
4521 /** The start position of the range on the reference, 0-based inclusive. */
4522 core.String start;
4523
4524 RangePosition();
4525
4526 RangePosition.fromJson(core.Map _json) {
4527 if (_json.containsKey("end")) {
4528 end = _json["end"];
4529 }
4530 if (_json.containsKey("referenceId")) {
4531 referenceId = _json["referenceId"];
4532 }
4533 if (_json.containsKey("referenceName")) {
4534 referenceName = _json["referenceName"];
4535 }
4536 if (_json.containsKey("reverseStrand")) {
4537 reverseStrand = _json["reverseStrand"];
4538 }
4539 if (_json.containsKey("start")) {
4540 start = _json["start"];
4541 }
4542 }
4543
4544 core.Map toJson() {
4545 var _json = new core.Map();
4546 if (end != null) {
4547 _json["end"] = end;
4548 }
4549 if (referenceId != null) {
4550 _json["referenceId"] = referenceId;
4551 }
4552 if (referenceName != null) {
4553 _json["referenceName"] = referenceName;
4554 }
4555 if (reverseStrand != null) {
4556 _json["reverseStrand"] = reverseStrand;
4557 }
4558 if (start != null) {
4559 _json["start"] = start;
4560 }
4561 return _json;
4562 }
4563 }
4564
4565 /**
4566 * A read alignment describes a linear alignment of a string of DNA to a
4567 * reference sequence, in addition to metadata about the fragment (the molecule
4568 * of DNA sequenced) and the read (the bases which were read by the sequencer).
4569 * A read is equivalent to a line in a SAM file. A read belongs to exactly one
4570 * read group and exactly one read group set. Generating a reference-aligned
4571 * sequence string When interacting with mapped reads, it's often useful to
4572 * produce a string representing the local alignment of the read to reference.
4573 * The following pseudocode demonstrates one way of doing this:
4574 * out = "" offset = 0 for c in read.alignment.cigar { switch c.operation { case
4575 * "ALIGNMENT_MATCH", "SEQUENCE_MATCH", "SEQUENCE_MISMATCH": out +=
4576 * read.alignedSequence[offset:offset+c.operationLength] offset +=
4577 * c.operationLength break case "CLIP_SOFT", "INSERT": offset +=
4578 * c.operationLength break case "PAD": out += repeat("*", c.operationLength)
4579 * break case "DELETE": out += repeat("-", c.operationLength) break case "SKIP":
4580 * out += repeat(" ", c.operationLength) break case "CLIP_HARD": break } }
4581 * return out
4582 * Converting to SAM's CIGAR string The following pseudocode generates a SAM
4583 * CIGAR string from the cigar field. Note that this is a lossy conversion
4584 * (cigar.referenceSequence is lost).
4585 * cigarMap = { "ALIGNMENT_MATCH": "M", "INSERT": "I", "DELETE": "D", "SKIP":
4586 * "N", "CLIP_SOFT": "S", "CLIP_HARD": "H", "PAD": "P", "SEQUENCE_MATCH": "=",
4587 * "SEQUENCE_MISMATCH": "X", } cigarStr = "" for c in read.alignment.cigar {
4588 * cigarStr += c.operationLength + cigarMap[c.operation] } return cigarStr
4589 */
4590 class Read {
4591 /**
4592 * The quality of the read sequence contained in this alignment record.
4593 * (equivalent to QUAL in SAM). alignedSequence and alignedQuality may be
4594 * shorter than the full read sequence and quality. This will occur if the
4595 * alignment is part of a chimeric alignment, or if the read was trimmed. When
4596 * this occurs, the CIGAR for this read will begin/end with a hard clip
4597 * operator that will indicate the length of the excised sequence.
4598 */
4599 core.List<core.int> alignedQuality;
4600 /**
4601 * The bases of the read sequence contained in this alignment record, without
4602 * CIGAR operations applied (equivalent to SEQ in SAM). alignedSequence and
4603 * alignedQuality may be shorter than the full read sequence and quality. This
4604 * will occur if the alignment is part of a chimeric alignment, or if the read
4605 * was trimmed. When this occurs, the CIGAR for this read will begin/end with
4606 * a hard clip operator that will indicate the length of the excised sequence.
4607 */
4608 core.String alignedSequence;
4609 /**
4610 * The linear alignment for this alignment record. This field is null for
4611 * unmapped reads.
4612 */
4613 LinearAlignment alignment;
4614 /** The fragment is a PCR or optical duplicate (SAM flag 0x400). */
4615 core.bool duplicateFragment;
4616 /**
4617 * Whether this read did not pass filters, such as platform or vendor quality
4618 * controls (SAM flag 0x200).
4619 */
4620 core.bool failedVendorQualityChecks;
4621 /** The observed length of the fragment, equivalent to TLEN in SAM. */
4622 core.int fragmentLength;
4623 /** The fragment name. Equivalent to QNAME (query template name) in SAM. */
4624 core.String fragmentName;
4625 /**
4626 * The unique ID for this read. This is a generated unique ID, not to be
4627 * confused with fragmentName.
4628 */
4629 core.String id;
4630 /** A string which maps to an array of values. */
4631 core.Map<core.String, core.List<core.String>> info;
4632 /**
4633 * The position of the primary alignment of the (readNumber+1)%numberReads
4634 * read in the fragment. It replaces mate position and mate strand in SAM.
4635 * This field will be unset if that read is unmapped or if the fragment only
4636 * has a single read.
4637 */
4638 Position nextMatePosition;
4639 /** The number of reads in the fragment (extension to SAM flag 0x1). */
4640 core.int numberReads;
4641 /**
4642 * The orientation and the distance between reads from the fragment are
4643 * consistent with the sequencing protocol (SAM flag 0x2).
4644 */
4645 core.bool properPlacement;
4646 /**
4647 * The ID of the read group this read belongs to. A read belongs to exactly
4648 * one read group. This is a server-generated ID (not SAM's RG tag).
4649 */
4650 core.String readGroupId;
4651 /**
4652 * The ID of the read group set this read belongs to. A read belongs to
4653 * exactly one read group set.
4654 */
4655 core.String readGroupSetId;
4656 /**
4657 * The read number in sequencing. 0-based and less than numberReads. This
4658 * field replaces SAM flag 0x40 and 0x80.
4659 */
4660 core.int readNumber;
4661 /**
4662 * Whether this alignment is secondary. Equivalent to SAM flag 0x100. A
4663 * secondary alignment represents an alternative to the primary alignment for
4664 * this read. Aligners may return secondary alignments if a read can map
4665 * ambiguously to multiple coordinates in the genome. By convention, each read
4666 * has one and only one alignment where both secondaryAlignment and
4667 * supplementaryAlignment are false.
4668 */
4669 core.bool secondaryAlignment;
4670 /**
4671 * Whether this alignment is supplementary. Equivalent to SAM flag 0x800.
4672 * Supplementary alignments are used in the representation of a chimeric
4673 * alignment. In a chimeric alignment, a read is split into multiple linear
4674 * alignments that map to different reference contigs. The first linear
4675 * alignment in the read will be designated as the representative alignment;
4676 * the remaining linear alignments will be designated as supplementary
4677 * alignments. These alignments may have different mapping quality scores. In
4678 * each linear alignment in a chimeric alignment, the read will be hard
4679 * clipped. The alignedSequence and alignedQuality fields in the alignment
4680 * record will only represent the bases for its respective linear alignment.
4681 */
4682 core.bool supplementaryAlignment;
4683
4684 Read();
4685
4686 Read.fromJson(core.Map _json) {
4687 if (_json.containsKey("alignedQuality")) {
4688 alignedQuality = _json["alignedQuality"];
4689 }
4690 if (_json.containsKey("alignedSequence")) {
4691 alignedSequence = _json["alignedSequence"];
4692 }
4693 if (_json.containsKey("alignment")) {
4694 alignment = new LinearAlignment.fromJson(_json["alignment"]);
4695 }
4696 if (_json.containsKey("duplicateFragment")) {
4697 duplicateFragment = _json["duplicateFragment"];
4698 }
4699 if (_json.containsKey("failedVendorQualityChecks")) {
4700 failedVendorQualityChecks = _json["failedVendorQualityChecks"];
4701 }
4702 if (_json.containsKey("fragmentLength")) {
4703 fragmentLength = _json["fragmentLength"];
4704 }
4705 if (_json.containsKey("fragmentName")) {
4706 fragmentName = _json["fragmentName"];
4707 }
4708 if (_json.containsKey("id")) {
4709 id = _json["id"];
4710 }
4711 if (_json.containsKey("info")) {
4712 info = _json["info"];
4713 }
4714 if (_json.containsKey("nextMatePosition")) {
4715 nextMatePosition = new Position.fromJson(_json["nextMatePosition"]);
4716 }
4717 if (_json.containsKey("numberReads")) {
4718 numberReads = _json["numberReads"];
4719 }
4720 if (_json.containsKey("properPlacement")) {
4721 properPlacement = _json["properPlacement"];
4722 }
4723 if (_json.containsKey("readGroupId")) {
4724 readGroupId = _json["readGroupId"];
4725 }
4726 if (_json.containsKey("readGroupSetId")) {
4727 readGroupSetId = _json["readGroupSetId"];
4728 }
4729 if (_json.containsKey("readNumber")) {
4730 readNumber = _json["readNumber"];
4731 }
4732 if (_json.containsKey("secondaryAlignment")) {
4733 secondaryAlignment = _json["secondaryAlignment"];
4734 }
4735 if (_json.containsKey("supplementaryAlignment")) {
4736 supplementaryAlignment = _json["supplementaryAlignment"];
4737 }
4738 }
4739
4740 core.Map toJson() {
4741 var _json = new core.Map();
4742 if (alignedQuality != null) {
4743 _json["alignedQuality"] = alignedQuality;
4744 }
4745 if (alignedSequence != null) {
4746 _json["alignedSequence"] = alignedSequence;
4747 }
4748 if (alignment != null) {
4749 _json["alignment"] = (alignment).toJson();
4750 }
4751 if (duplicateFragment != null) {
4752 _json["duplicateFragment"] = duplicateFragment;
4753 }
4754 if (failedVendorQualityChecks != null) {
4755 _json["failedVendorQualityChecks"] = failedVendorQualityChecks;
4756 }
4757 if (fragmentLength != null) {
4758 _json["fragmentLength"] = fragmentLength;
4759 }
4760 if (fragmentName != null) {
4761 _json["fragmentName"] = fragmentName;
4762 }
4763 if (id != null) {
4764 _json["id"] = id;
4765 }
4766 if (info != null) {
4767 _json["info"] = info;
4768 }
4769 if (nextMatePosition != null) {
4770 _json["nextMatePosition"] = (nextMatePosition).toJson();
4771 }
4772 if (numberReads != null) {
4773 _json["numberReads"] = numberReads;
4774 }
4775 if (properPlacement != null) {
4776 _json["properPlacement"] = properPlacement;
4777 }
4778 if (readGroupId != null) {
4779 _json["readGroupId"] = readGroupId;
4780 }
4781 if (readGroupSetId != null) {
4782 _json["readGroupSetId"] = readGroupSetId;
4783 }
4784 if (readNumber != null) {
4785 _json["readNumber"] = readNumber;
4786 }
4787 if (secondaryAlignment != null) {
4788 _json["secondaryAlignment"] = secondaryAlignment;
4789 }
4790 if (supplementaryAlignment != null) {
4791 _json["supplementaryAlignment"] = supplementaryAlignment;
4792 }
4793 return _json;
4794 }
4795 }
4796
4797 /**
4798 * A read group is all the data that's processed the same way by the sequencer.
4799 */
4800 class ReadGroup {
4801 /** The ID of the dataset this read group belongs to. */
4802 core.String datasetId;
4803 /** A free-form text description of this read group. */
4804 core.String description;
4805 /** The experiment used to generate this read group. */
4806 ReadGroupExperiment experiment;
4807 /**
4808 * The generated unique read group ID. Note: This is different than the @RG ID
4809 * field in the SAM spec. For that value, see the name field.
4810 */
4811 core.String id;
4812 /** A string which maps to an array of values. */
4813 core.Map<core.String, core.List<core.String>> info;
4814 /**
4815 * The read group name. This corresponds to the @RG ID field in the SAM spec.
4816 */
4817 core.String name;
4818 /**
4819 * The predicted insert size of this read group. The insert size is the length
4820 * the sequenced DNA fragment from end-to-end, not including the adapters.
4821 */
4822 core.int predictedInsertSize;
4823 /**
4824 * The programs used to generate this read group. Programs are always
4825 * identical for all read groups within a read group set. For this reason,
4826 * only the first read group in a returned set will have this field populated.
4827 */
4828 core.List<ReadGroupProgram> programs;
4829 /** The reference set to which the reads in this read group are aligned. */
4830 core.String referenceSetId;
4831 /**
4832 * The sample this read group's data was generated from. Note: This is not an
4833 * actual ID within this repository, but rather an identifier for a sample
4834 * which may be meaningful to some external system.
4835 */
4836 core.String sampleId;
4837
4838 ReadGroup();
4839
4840 ReadGroup.fromJson(core.Map _json) {
4841 if (_json.containsKey("datasetId")) {
4842 datasetId = _json["datasetId"];
4843 }
4844 if (_json.containsKey("description")) {
4845 description = _json["description"];
4846 }
4847 if (_json.containsKey("experiment")) {
4848 experiment = new ReadGroupExperiment.fromJson(_json["experiment"]);
4849 }
4850 if (_json.containsKey("id")) {
4851 id = _json["id"];
4852 }
4853 if (_json.containsKey("info")) {
4854 info = _json["info"];
4855 }
4856 if (_json.containsKey("name")) {
4857 name = _json["name"];
4858 }
4859 if (_json.containsKey("predictedInsertSize")) {
4860 predictedInsertSize = _json["predictedInsertSize"];
4861 }
4862 if (_json.containsKey("programs")) {
4863 programs = _json["programs"].map((value) => new ReadGroupProgram.fromJson( value)).toList();
4864 }
4865 if (_json.containsKey("referenceSetId")) {
4866 referenceSetId = _json["referenceSetId"];
4867 }
4868 if (_json.containsKey("sampleId")) {
4869 sampleId = _json["sampleId"];
4870 }
4871 }
4872
4873 core.Map toJson() {
4874 var _json = new core.Map();
4875 if (datasetId != null) {
4876 _json["datasetId"] = datasetId;
4877 }
4878 if (description != null) {
4879 _json["description"] = description;
4880 }
4881 if (experiment != null) {
4882 _json["experiment"] = (experiment).toJson();
4883 }
4884 if (id != null) {
4885 _json["id"] = id;
4886 }
4887 if (info != null) {
4888 _json["info"] = info;
4889 }
4890 if (name != null) {
4891 _json["name"] = name;
4892 }
4893 if (predictedInsertSize != null) {
4894 _json["predictedInsertSize"] = predictedInsertSize;
4895 }
4896 if (programs != null) {
4897 _json["programs"] = programs.map((value) => (value).toJson()).toList();
4898 }
4899 if (referenceSetId != null) {
4900 _json["referenceSetId"] = referenceSetId;
4901 }
4902 if (sampleId != null) {
4903 _json["sampleId"] = sampleId;
4904 }
4905 return _json;
4906 }
4907 }
4908
4909 class ReadGroupExperiment {
4910 /**
4911 * The instrument model used as part of this experiment. This maps to
4912 * sequencing technology in BAM.
4913 */
4914 core.String instrumentModel;
4915 /**
4916 * The library used as part of this experiment. Note: This is not an actual ID
4917 * within this repository, but rather an identifier for a library which may be
4918 * meaningful to some external system.
4919 */
4920 core.String libraryId;
4921 /**
4922 * The platform unit used as part of this experiment e.g.
4923 * flowcell-barcode.lane for Illumina or slide for SOLiD. Corresponds to the
4924 */
4925 core.String platformUnit;
4926 /** The sequencing center used as part of this experiment. */
4927 core.String sequencingCenter;
4928
4929 ReadGroupExperiment();
4930
4931 ReadGroupExperiment.fromJson(core.Map _json) {
4932 if (_json.containsKey("instrumentModel")) {
4933 instrumentModel = _json["instrumentModel"];
4934 }
4935 if (_json.containsKey("libraryId")) {
4936 libraryId = _json["libraryId"];
4937 }
4938 if (_json.containsKey("platformUnit")) {
4939 platformUnit = _json["platformUnit"];
4940 }
4941 if (_json.containsKey("sequencingCenter")) {
4942 sequencingCenter = _json["sequencingCenter"];
4943 }
4944 }
4945
4946 core.Map toJson() {
4947 var _json = new core.Map();
4948 if (instrumentModel != null) {
4949 _json["instrumentModel"] = instrumentModel;
4950 }
4951 if (libraryId != null) {
4952 _json["libraryId"] = libraryId;
4953 }
4954 if (platformUnit != null) {
4955 _json["platformUnit"] = platformUnit;
4956 }
4957 if (sequencingCenter != null) {
4958 _json["sequencingCenter"] = sequencingCenter;
4959 }
4960 return _json;
4961 }
4962 }
4963
4964 class ReadGroupProgram {
4965 /** The command line used to run this program. */
4966 core.String commandLine;
4967 /**
4968 * The user specified locally unique ID of the program. Used along with
4969 * prevProgramId to define an ordering between programs.
4970 */
4971 core.String id;
4972 /**
4973 * The display name of the program. This is typically the colloquial name of
4974 * the tool used, for example 'bwa' or 'picard'.
4975 */
4976 core.String name;
4977 /** The ID of the program run before this one. */
4978 core.String prevProgramId;
4979 /** The version of the program run. */
4980 core.String version;
4981
4982 ReadGroupProgram();
4983
4984 ReadGroupProgram.fromJson(core.Map _json) {
4985 if (_json.containsKey("commandLine")) {
4986 commandLine = _json["commandLine"];
4987 }
4988 if (_json.containsKey("id")) {
4989 id = _json["id"];
4990 }
4991 if (_json.containsKey("name")) {
4992 name = _json["name"];
4993 }
4994 if (_json.containsKey("prevProgramId")) {
4995 prevProgramId = _json["prevProgramId"];
4996 }
4997 if (_json.containsKey("version")) {
4998 version = _json["version"];
4999 }
5000 }
5001
5002 core.Map toJson() {
5003 var _json = new core.Map();
5004 if (commandLine != null) {
5005 _json["commandLine"] = commandLine;
5006 }
5007 if (id != null) {
5008 _json["id"] = id;
5009 }
5010 if (name != null) {
5011 _json["name"] = name;
5012 }
5013 if (prevProgramId != null) {
5014 _json["prevProgramId"] = prevProgramId;
5015 }
5016 if (version != null) {
5017 _json["version"] = version;
5018 }
5019 return _json;
5020 }
5021 }
5022
5023 /**
5024 * A read group set is a logical collection of read groups, which are
5025 * collections of reads produced by a sequencer. A read group set typically
5026 * models reads corresponding to one sample, sequenced one way, and aligned one
5027 * way.
5028 * - A read group set belongs to one dataset.
5029 * - A read group belongs to one read group set.
5030 * - A read belongs to one read group.
5031 */
5032 class ReadGroupSet {
5033 /** The dataset ID. */
5034 core.String datasetId;
5035 /**
5036 * The filename of the original source file for this read group set, if any.
5037 */
5038 core.String filename;
5039 /** The read group set ID. */
5040 core.String id;
5041 /** A string which maps to an array of values. */
5042 core.Map<core.String, core.List<core.String>> info;
5043 /**
5044 * The read group set name. By default this will be initialized to the sample
5045 * name of the sequenced data contained in this set.
5046 */
5047 core.String name;
5048 /**
5049 * The read groups in this set. There are typically 1-10 read groups in a read
5050 * group set.
5051 */
5052 core.List<ReadGroup> readGroups;
5053 /** The reference set the reads in this read group set are aligned to. */
5054 core.String referenceSetId;
5055
5056 ReadGroupSet();
5057
5058 ReadGroupSet.fromJson(core.Map _json) {
5059 if (_json.containsKey("datasetId")) {
5060 datasetId = _json["datasetId"];
5061 }
5062 if (_json.containsKey("filename")) {
5063 filename = _json["filename"];
5064 }
5065 if (_json.containsKey("id")) {
5066 id = _json["id"];
5067 }
5068 if (_json.containsKey("info")) {
5069 info = _json["info"];
5070 }
5071 if (_json.containsKey("name")) {
5072 name = _json["name"];
5073 }
5074 if (_json.containsKey("readGroups")) {
5075 readGroups = _json["readGroups"].map((value) => new ReadGroup.fromJson(val ue)).toList();
5076 }
5077 if (_json.containsKey("referenceSetId")) {
5078 referenceSetId = _json["referenceSetId"];
5079 }
5080 }
5081
5082 core.Map toJson() {
5083 var _json = new core.Map();
5084 if (datasetId != null) {
5085 _json["datasetId"] = datasetId;
5086 }
5087 if (filename != null) {
5088 _json["filename"] = filename;
5089 }
5090 if (id != null) {
5091 _json["id"] = id;
5092 }
5093 if (info != null) {
5094 _json["info"] = info;
5095 }
5096 if (name != null) {
5097 _json["name"] = name;
5098 }
5099 if (readGroups != null) {
5100 _json["readGroups"] = readGroups.map((value) => (value).toJson()).toList() ;
5101 }
5102 if (referenceSetId != null) {
5103 _json["referenceSetId"] = referenceSetId;
5104 }
5105 return _json;
5106 }
5107 }
5108
5109 /**
5110 * A reference is a canonical assembled DNA sequence, intended to act as a
5111 * reference coordinate space for other genomic annotations. A single reference
5112 * might represent the human chromosome 1 or mitochandrial DNA, for instance. A
5113 * reference belongs to one or more reference sets.
5114 */
5115 class Reference {
5116 /** The Google generated immutable ID of the reference. */
5117 core.String id;
5118 /** The length of this reference's sequence. */
5119 core.String length;
5120 /**
5121 * MD5 of the upper-case sequence excluding all whitespace characters (this is
5122 * equivalent to SQ:M5 in SAM). This value is represented in lower case
5123 * hexadecimal format.
5124 */
5125 core.String md5checksum;
5126 /** The name of this reference, for example 22. */
5127 core.String name;
5128 /**
5129 * ID from http://www.ncbi.nlm.nih.gov/taxonomy. For example, 9606 for human.
5130 */
5131 core.int ncbiTaxonId;
5132 /**
5133 * All known corresponding accession IDs in INSDC (GenBank/ENA/DDBJ) ideally
5134 * with a version number, for example GCF_000001405.26.
5135 */
5136 core.List<core.String> sourceAccessions;
5137 /**
5138 * The URI from which the sequence was obtained. Typically specifies a FASTA
5139 * format file.
5140 */
5141 core.String sourceURI;
5142
5143 Reference();
5144
5145 Reference.fromJson(core.Map _json) {
5146 if (_json.containsKey("id")) {
5147 id = _json["id"];
5148 }
5149 if (_json.containsKey("length")) {
5150 length = _json["length"];
5151 }
5152 if (_json.containsKey("md5checksum")) {
5153 md5checksum = _json["md5checksum"];
5154 }
5155 if (_json.containsKey("name")) {
5156 name = _json["name"];
5157 }
5158 if (_json.containsKey("ncbiTaxonId")) {
5159 ncbiTaxonId = _json["ncbiTaxonId"];
5160 }
5161 if (_json.containsKey("sourceAccessions")) {
5162 sourceAccessions = _json["sourceAccessions"];
5163 }
5164 if (_json.containsKey("sourceURI")) {
5165 sourceURI = _json["sourceURI"];
5166 }
5167 }
5168
5169 core.Map toJson() {
5170 var _json = new core.Map();
5171 if (id != null) {
5172 _json["id"] = id;
5173 }
5174 if (length != null) {
5175 _json["length"] = length;
5176 }
5177 if (md5checksum != null) {
5178 _json["md5checksum"] = md5checksum;
5179 }
5180 if (name != null) {
5181 _json["name"] = name;
5182 }
5183 if (ncbiTaxonId != null) {
5184 _json["ncbiTaxonId"] = ncbiTaxonId;
5185 }
5186 if (sourceAccessions != null) {
5187 _json["sourceAccessions"] = sourceAccessions;
5188 }
5189 if (sourceURI != null) {
5190 _json["sourceURI"] = sourceURI;
5191 }
5192 return _json;
5193 }
5194 }
5195
5196 /**
5197 * ReferenceBound records an upper bound for the starting coordinate of variants
5198 * in a particular reference.
5199 */
5200 class ReferenceBound {
5201 /** The name of the reference associated with this reference bound. */
5202 core.String referenceName;
5203 /**
5204 * An upper bound (inclusive) on the starting coordinate of any variant in the
5205 * reference sequence.
5206 */
5207 core.String upperBound;
5208
5209 ReferenceBound();
5210
5211 ReferenceBound.fromJson(core.Map _json) {
5212 if (_json.containsKey("referenceName")) {
5213 referenceName = _json["referenceName"];
5214 }
5215 if (_json.containsKey("upperBound")) {
5216 upperBound = _json["upperBound"];
5217 }
5218 }
5219
5220 core.Map toJson() {
5221 var _json = new core.Map();
5222 if (referenceName != null) {
5223 _json["referenceName"] = referenceName;
5224 }
5225 if (upperBound != null) {
5226 _json["upperBound"] = upperBound;
5227 }
5228 return _json;
5229 }
5230 }
5231
5232 /**
5233 * A reference set is a set of references which typically comprise a reference
5234 * assembly for a species, such as GRCh38 which is representative of the human
5235 * genome. A reference set defines a common coordinate space for comparing
5236 * reference-aligned experimental data. A reference set contains 1 or more
5237 * references.
5238 */
5239 class ReferenceSet {
5240 /** Public id of this reference set, such as GRCh37. */
5241 core.String assemblyId;
5242 /** Free text description of this reference set. */
5243 core.String description;
5244 /** The Google generated immutable ID of the reference set. */
5245 core.String id;
5246 /**
5247 * Order-independent MD5 checksum which identifies this reference set. The
5248 * checksum is computed by sorting all lower case hexidecimal string
5249 * reference.md5checksum (for all reference in this set) in ascending
5250 * lexicographic order, concatenating, and taking the MD5 of that value. The
5251 * resulting value is represented in lower case hexadecimal format.
5252 */
5253 core.String md5checksum;
5254 /**
5255 * ID from http://www.ncbi.nlm.nih.gov/taxonomy (for example, 9606 for human)
5256 * indicating the species which this reference set is intended to model. Note
5257 * that contained references may specify a different ncbiTaxonId, as
5258 * assemblies may contain reference sequences which do not belong to the
5259 * modeled species, for example EBV in a human reference genome.
5260 */
5261 core.int ncbiTaxonId;
5262 /**
5263 * The IDs of the reference objects that are part of this set.
5264 * Reference.md5checksum must be unique within this set.
5265 */
5266 core.List<core.String> referenceIds;
5267 /**
5268 * All known corresponding accession IDs in INSDC (GenBank/ENA/DDBJ) ideally
5269 * with a version number, for example NC_000001.11.
5270 */
5271 core.List<core.String> sourceAccessions;
5272 /** The URI from which the references were obtained. */
5273 core.String sourceURI;
5274
5275 ReferenceSet();
5276
5277 ReferenceSet.fromJson(core.Map _json) {
5278 if (_json.containsKey("assemblyId")) {
5279 assemblyId = _json["assemblyId"];
5280 }
5281 if (_json.containsKey("description")) {
5282 description = _json["description"];
5283 }
5284 if (_json.containsKey("id")) {
5285 id = _json["id"];
5286 }
5287 if (_json.containsKey("md5checksum")) {
5288 md5checksum = _json["md5checksum"];
5289 }
5290 if (_json.containsKey("ncbiTaxonId")) {
5291 ncbiTaxonId = _json["ncbiTaxonId"];
5292 }
5293 if (_json.containsKey("referenceIds")) {
5294 referenceIds = _json["referenceIds"];
5295 }
5296 if (_json.containsKey("sourceAccessions")) {
5297 sourceAccessions = _json["sourceAccessions"];
5298 }
5299 if (_json.containsKey("sourceURI")) {
5300 sourceURI = _json["sourceURI"];
5301 }
5302 }
5303
5304 core.Map toJson() {
5305 var _json = new core.Map();
5306 if (assemblyId != null) {
5307 _json["assemblyId"] = assemblyId;
5308 }
5309 if (description != null) {
5310 _json["description"] = description;
5311 }
5312 if (id != null) {
5313 _json["id"] = id;
5314 }
5315 if (md5checksum != null) {
5316 _json["md5checksum"] = md5checksum;
5317 }
5318 if (ncbiTaxonId != null) {
5319 _json["ncbiTaxonId"] = ncbiTaxonId;
5320 }
5321 if (referenceIds != null) {
5322 _json["referenceIds"] = referenceIds;
5323 }
5324 if (sourceAccessions != null) {
5325 _json["sourceAccessions"] = sourceAccessions;
5326 }
5327 if (sourceURI != null) {
5328 _json["sourceURI"] = sourceURI;
5329 }
5330 return _json;
5331 }
5332 }
5333
5334 class SearchAnnotationSetsRequest {
5335 /**
5336 * The dataset IDs to search within. Caller must have READ access to these
5337 * datasets.
5338 */
5339 core.List<core.String> datasetIds;
5340 /**
5341 * Only return annotations sets for which a substring of the name matches this
5342 * string (case insensitive).
5343 */
5344 core.String name;
5345 /**
5346 * The maximum number of results to return in a single page. If unspecified,
5347 * defaults to 128. The maximum value is 1024.
5348 */
5349 core.int pageSize;
5350 /**
5351 * The continuation token, which is used to page through large result sets. To
5352 * get the next page of results, set this parameter to the value of
5353 * nextPageToken from the previous response.
5354 */
5355 core.String pageToken;
5356 /**
5357 * If specified, only annotation sets associated with the given reference set
5358 * are returned.
5359 */
5360 core.String referenceSetId;
5361 /**
5362 * If specified, only annotation sets that have any of these types are
5363 * returned.
5364 */
5365 core.List<core.String> types;
5366
5367 SearchAnnotationSetsRequest();
5368
5369 SearchAnnotationSetsRequest.fromJson(core.Map _json) {
5370 if (_json.containsKey("datasetIds")) {
5371 datasetIds = _json["datasetIds"];
5372 }
5373 if (_json.containsKey("name")) {
5374 name = _json["name"];
5375 }
5376 if (_json.containsKey("pageSize")) {
5377 pageSize = _json["pageSize"];
5378 }
5379 if (_json.containsKey("pageToken")) {
5380 pageToken = _json["pageToken"];
5381 }
5382 if (_json.containsKey("referenceSetId")) {
5383 referenceSetId = _json["referenceSetId"];
5384 }
5385 if (_json.containsKey("types")) {
5386 types = _json["types"];
5387 }
5388 }
5389
5390 core.Map toJson() {
5391 var _json = new core.Map();
5392 if (datasetIds != null) {
5393 _json["datasetIds"] = datasetIds;
5394 }
5395 if (name != null) {
5396 _json["name"] = name;
5397 }
5398 if (pageSize != null) {
5399 _json["pageSize"] = pageSize;
5400 }
5401 if (pageToken != null) {
5402 _json["pageToken"] = pageToken;
5403 }
5404 if (referenceSetId != null) {
5405 _json["referenceSetId"] = referenceSetId;
5406 }
5407 if (types != null) {
5408 _json["types"] = types;
5409 }
5410 return _json;
5411 }
5412 }
5413
5414 class SearchAnnotationSetsResponse {
5415 /** The matching annotation sets. */
5416 core.List<AnnotationSet> annotationSets;
5417 /**
5418 * The continuation token, which is used to page through large result sets.
5419 * Provide this value in a subsequent request to return the next page of
5420 * results. This field will be empty if there aren't any additional results.
5421 */
5422 core.String nextPageToken;
5423
5424 SearchAnnotationSetsResponse();
5425
5426 SearchAnnotationSetsResponse.fromJson(core.Map _json) {
5427 if (_json.containsKey("annotationSets")) {
5428 annotationSets = _json["annotationSets"].map((value) => new AnnotationSet. fromJson(value)).toList();
5429 }
5430 if (_json.containsKey("nextPageToken")) {
5431 nextPageToken = _json["nextPageToken"];
5432 }
5433 }
5434
5435 core.Map toJson() {
5436 var _json = new core.Map();
5437 if (annotationSets != null) {
5438 _json["annotationSets"] = annotationSets.map((value) => (value).toJson()). toList();
5439 }
5440 if (nextPageToken != null) {
5441 _json["nextPageToken"] = nextPageToken;
5442 }
5443 return _json;
5444 }
5445 }
5446
5447 class SearchAnnotationsRequest {
5448 /**
5449 * The annotation sets to search within. The caller must have READ access to
5450 * these annotation sets. Required. All queried annotation sets must have the
5451 * same type.
5452 */
5453 core.List<core.String> annotationSetIds;
5454 /**
5455 * The maximum number of results to return in a single page. If unspecified,
5456 * defaults to 256. The maximum value is 2048.
5457 */
5458 core.int pageSize;
5459 /**
5460 * The continuation token, which is used to page through large result sets. To
5461 * get the next page of results, set this parameter to the value of
5462 * nextPageToken from the previous response.
5463 */
5464 core.String pageToken;
5465 /**
5466 * If specified, this query matches only annotations that overlap this range.
5467 */
5468 QueryRange range;
5469
5470 SearchAnnotationsRequest();
5471
5472 SearchAnnotationsRequest.fromJson(core.Map _json) {
5473 if (_json.containsKey("annotationSetIds")) {
5474 annotationSetIds = _json["annotationSetIds"];
5475 }
5476 if (_json.containsKey("pageSize")) {
5477 pageSize = _json["pageSize"];
5478 }
5479 if (_json.containsKey("pageToken")) {
5480 pageToken = _json["pageToken"];
5481 }
5482 if (_json.containsKey("range")) {
5483 range = new QueryRange.fromJson(_json["range"]);
5484 }
5485 }
5486
5487 core.Map toJson() {
5488 var _json = new core.Map();
5489 if (annotationSetIds != null) {
5490 _json["annotationSetIds"] = annotationSetIds;
5491 }
5492 if (pageSize != null) {
5493 _json["pageSize"] = pageSize;
5494 }
5495 if (pageToken != null) {
5496 _json["pageToken"] = pageToken;
5497 }
5498 if (range != null) {
5499 _json["range"] = (range).toJson();
5500 }
5501 return _json;
5502 }
5503 }
5504
5505 class SearchAnnotationsResponse {
5506 /** The matching annotations. */
5507 core.List<Annotation> annotations;
5508 /**
5509 * The continuation token, which is used to page through large result sets.
5510 * Provide this value in a subsequent request to return the next page of
5511 * results. This field will be empty if there aren't any additional results.
5512 */
5513 core.String nextPageToken;
5514
5515 SearchAnnotationsResponse();
5516
5517 SearchAnnotationsResponse.fromJson(core.Map _json) {
5518 if (_json.containsKey("annotations")) {
5519 annotations = _json["annotations"].map((value) => new Annotation.fromJson( value)).toList();
5520 }
5521 if (_json.containsKey("nextPageToken")) {
5522 nextPageToken = _json["nextPageToken"];
5523 }
5524 }
5525
5526 core.Map toJson() {
5527 var _json = new core.Map();
5528 if (annotations != null) {
5529 _json["annotations"] = annotations.map((value) => (value).toJson()).toList ();
5530 }
5531 if (nextPageToken != null) {
5532 _json["nextPageToken"] = nextPageToken;
5533 }
5534 return _json;
5535 }
5536 }
5537
5538 /** The call set search request. */
5539 class SearchCallSetsRequest {
5540 /**
5541 * Only return call sets for which a substring of the name matches this
5542 * string.
5543 */
5544 core.String name;
5545 /**
5546 * The maximum number of results to return in a single page. If unspecified,
5547 * defaults to 1024.
5548 */
5549 core.int pageSize;
5550 /**
5551 * The continuation token, which is used to page through large result sets. To
5552 * get the next page of results, set this parameter to the value of
5553 * nextPageToken from the previous response.
5554 */
5555 core.String pageToken;
5556 /**
5557 * Restrict the query to call sets within the given variant sets. At least one
5558 * ID must be provided.
5559 */
5560 core.List<core.String> variantSetIds;
5561
5562 SearchCallSetsRequest();
5563
5564 SearchCallSetsRequest.fromJson(core.Map _json) {
5565 if (_json.containsKey("name")) {
5566 name = _json["name"];
5567 }
5568 if (_json.containsKey("pageSize")) {
5569 pageSize = _json["pageSize"];
5570 }
5571 if (_json.containsKey("pageToken")) {
5572 pageToken = _json["pageToken"];
5573 }
5574 if (_json.containsKey("variantSetIds")) {
5575 variantSetIds = _json["variantSetIds"];
5576 }
5577 }
5578
5579 core.Map toJson() {
5580 var _json = new core.Map();
5581 if (name != null) {
5582 _json["name"] = name;
5583 }
5584 if (pageSize != null) {
5585 _json["pageSize"] = pageSize;
5586 }
5587 if (pageToken != null) {
5588 _json["pageToken"] = pageToken;
5589 }
5590 if (variantSetIds != null) {
5591 _json["variantSetIds"] = variantSetIds;
5592 }
5593 return _json;
5594 }
5595 }
5596
5597 /** The call set search response. */
5598 class SearchCallSetsResponse {
5599 /** The list of matching call sets. */
5600 core.List<CallSet> callSets;
5601 /**
5602 * The continuation token, which is used to page through large result sets.
5603 * Provide this value in a subsequent request to return the next page of
5604 * results. This field will be empty if there aren't any additional results.
5605 */
5606 core.String nextPageToken;
5607
5608 SearchCallSetsResponse();
5609
5610 SearchCallSetsResponse.fromJson(core.Map _json) {
5611 if (_json.containsKey("callSets")) {
5612 callSets = _json["callSets"].map((value) => new CallSet.fromJson(value)).t oList();
5613 }
5614 if (_json.containsKey("nextPageToken")) {
5615 nextPageToken = _json["nextPageToken"];
5616 }
5617 }
5618
5619 core.Map toJson() {
5620 var _json = new core.Map();
5621 if (callSets != null) {
5622 _json["callSets"] = callSets.map((value) => (value).toJson()).toList();
5623 }
5624 if (nextPageToken != null) {
5625 _json["nextPageToken"] = nextPageToken;
5626 }
5627 return _json;
5628 }
5629 }
5630
5631 /** The jobs search request. */
5632 class SearchJobsRequest {
5633 /**
5634 * If specified, only jobs created on or after this date, given in
5635 * milliseconds since Unix epoch, will be returned.
5636 */
5637 core.String createdAfter;
5638 /**
5639 * If specified, only jobs created prior to this date, given in milliseconds
5640 * since Unix epoch, will be returned.
5641 */
5642 core.String createdBefore;
5643 /**
5644 * The maximum number of results to return in a single page. If unspecified,
5645 * defaults to 128. The maximum value is 256.
5646 */
5647 core.int pageSize;
5648 /**
5649 * The continuation token which is used to page through large result sets. To
5650 * get the next page of results, set this parameter to the value of the
5651 * nextPageToken from the previous response.
5652 */
5653 core.String pageToken;
5654 /**
5655 * Required. Only return jobs which belong to this Google Developers Console
5656 * project.
5657 */
5658 core.String projectNumber;
5659 /** Only return jobs which have a matching status. */
5660 core.List<core.String> status;
5661
5662 SearchJobsRequest();
5663
5664 SearchJobsRequest.fromJson(core.Map _json) {
5665 if (_json.containsKey("createdAfter")) {
5666 createdAfter = _json["createdAfter"];
5667 }
5668 if (_json.containsKey("createdBefore")) {
5669 createdBefore = _json["createdBefore"];
5670 }
5671 if (_json.containsKey("pageSize")) {
5672 pageSize = _json["pageSize"];
5673 }
5674 if (_json.containsKey("pageToken")) {
5675 pageToken = _json["pageToken"];
5676 }
5677 if (_json.containsKey("projectNumber")) {
5678 projectNumber = _json["projectNumber"];
5679 }
5680 if (_json.containsKey("status")) {
5681 status = _json["status"];
5682 }
5683 }
5684
5685 core.Map toJson() {
5686 var _json = new core.Map();
5687 if (createdAfter != null) {
5688 _json["createdAfter"] = createdAfter;
5689 }
5690 if (createdBefore != null) {
5691 _json["createdBefore"] = createdBefore;
5692 }
5693 if (pageSize != null) {
5694 _json["pageSize"] = pageSize;
5695 }
5696 if (pageToken != null) {
5697 _json["pageToken"] = pageToken;
5698 }
5699 if (projectNumber != null) {
5700 _json["projectNumber"] = projectNumber;
5701 }
5702 if (status != null) {
5703 _json["status"] = status;
5704 }
5705 return _json;
5706 }
5707 }
5708
5709 /** The job search response. */
5710 class SearchJobsResponse {
5711 /** The list of jobs results, ordered newest to oldest. */
5712 core.List<Job> jobs;
5713 /**
5714 * The continuation token which is used to page through large result sets.
5715 * Provide this value is a subsequent request to return the next page of
5716 * results. This field will be empty if there are no more results.
5717 */
5718 core.String nextPageToken;
5719
5720 SearchJobsResponse();
5721
5722 SearchJobsResponse.fromJson(core.Map _json) {
5723 if (_json.containsKey("jobs")) {
5724 jobs = _json["jobs"].map((value) => new Job.fromJson(value)).toList();
5725 }
5726 if (_json.containsKey("nextPageToken")) {
5727 nextPageToken = _json["nextPageToken"];
5728 }
5729 }
5730
5731 core.Map toJson() {
5732 var _json = new core.Map();
5733 if (jobs != null) {
5734 _json["jobs"] = jobs.map((value) => (value).toJson()).toList();
5735 }
5736 if (nextPageToken != null) {
5737 _json["nextPageToken"] = nextPageToken;
5738 }
5739 return _json;
5740 }
5741 }
5742
5743 /** The read group set search request. */
5744 class SearchReadGroupSetsRequest {
5745 /**
5746 * Restricts this query to read group sets within the given datasets. At least
5747 * one ID must be provided.
5748 */
5749 core.List<core.String> datasetIds;
5750 /**
5751 * Only return read group sets for which a substring of the name matches this
5752 * string.
5753 */
5754 core.String name;
5755 /**
5756 * The maximum number of results to return in a single page. If unspecified,
5757 * defaults to 256. The maximum value is 1024.
5758 */
5759 core.int pageSize;
5760 /**
5761 * The continuation token, which is used to page through large result sets. To
5762 * get the next page of results, set this parameter to the value of
5763 * nextPageToken from the previous response.
5764 */
5765 core.String pageToken;
5766
5767 SearchReadGroupSetsRequest();
5768
5769 SearchReadGroupSetsRequest.fromJson(core.Map _json) {
5770 if (_json.containsKey("datasetIds")) {
5771 datasetIds = _json["datasetIds"];
5772 }
5773 if (_json.containsKey("name")) {
5774 name = _json["name"];
5775 }
5776 if (_json.containsKey("pageSize")) {
5777 pageSize = _json["pageSize"];
5778 }
5779 if (_json.containsKey("pageToken")) {
5780 pageToken = _json["pageToken"];
5781 }
5782 }
5783
5784 core.Map toJson() {
5785 var _json = new core.Map();
5786 if (datasetIds != null) {
5787 _json["datasetIds"] = datasetIds;
5788 }
5789 if (name != null) {
5790 _json["name"] = name;
5791 }
5792 if (pageSize != null) {
5793 _json["pageSize"] = pageSize;
5794 }
5795 if (pageToken != null) {
5796 _json["pageToken"] = pageToken;
5797 }
5798 return _json;
5799 }
5800 }
5801
5802 /** The read group set search response. */
5803 class SearchReadGroupSetsResponse {
5804 /**
5805 * The continuation token, which is used to page through large result sets.
5806 * Provide this value in a subsequent request to return the next page of
5807 * results. This field will be empty if there aren't any additional results.
5808 */
5809 core.String nextPageToken;
5810 /** The list of matching read group sets. */
5811 core.List<ReadGroupSet> readGroupSets;
5812
5813 SearchReadGroupSetsResponse();
5814
5815 SearchReadGroupSetsResponse.fromJson(core.Map _json) {
5816 if (_json.containsKey("nextPageToken")) {
5817 nextPageToken = _json["nextPageToken"];
5818 }
5819 if (_json.containsKey("readGroupSets")) {
5820 readGroupSets = _json["readGroupSets"].map((value) => new ReadGroupSet.fro mJson(value)).toList();
5821 }
5822 }
5823
5824 core.Map toJson() {
5825 var _json = new core.Map();
5826 if (nextPageToken != null) {
5827 _json["nextPageToken"] = nextPageToken;
5828 }
5829 if (readGroupSets != null) {
5830 _json["readGroupSets"] = readGroupSets.map((value) => (value).toJson()).to List();
5831 }
5832 return _json;
5833 }
5834 }
5835
5836 /** The read search request. */
5837 class SearchReadsRequest {
5838 /**
5839 * The end position of the range on the reference, 0-based exclusive. If
5840 * specified, referenceName must also be specified.
5841 */
5842 core.String end;
5843 /**
5844 * The maximum number of results to return in a single page. If unspecified,
5845 * defaults to 256. The maximum value is 2048.
5846 */
5847 core.int pageSize;
5848 /**
5849 * The continuation token, which is used to page through large result sets. To
5850 * get the next page of results, set this parameter to the value of
5851 * nextPageToken from the previous response.
5852 */
5853 core.String pageToken;
5854 /**
5855 * The IDs of the read groups within which to search for reads. All specified
5856 * read groups must belong to the same read group sets. Must specify one of
5857 * readGroupSetIds or readGroupIds.
5858 */
5859 core.List<core.String> readGroupIds;
5860 /**
5861 * The IDs of the read groups sets within which to search for reads. All
5862 * specified read group sets must be aligned against a common set of reference
5863 * sequences; this defines the genomic coordinates for the query. Must specify
5864 * one of readGroupSetIds or readGroupIds.
5865 */
5866 core.List<core.String> readGroupSetIds;
5867 /**
5868 * The reference sequence name, for example chr1, 1, or chrX. If set to *,
5869 * only unmapped reads are returned. If unspecified, all reads (mapped and
5870 * unmapped) returned.
5871 */
5872 core.String referenceName;
5873 /**
5874 * The start position of the range on the reference, 0-based inclusive. If
5875 * specified, referenceName must also be specified.
5876 */
5877 core.String start;
5878
5879 SearchReadsRequest();
5880
5881 SearchReadsRequest.fromJson(core.Map _json) {
5882 if (_json.containsKey("end")) {
5883 end = _json["end"];
5884 }
5885 if (_json.containsKey("pageSize")) {
5886 pageSize = _json["pageSize"];
5887 }
5888 if (_json.containsKey("pageToken")) {
5889 pageToken = _json["pageToken"];
5890 }
5891 if (_json.containsKey("readGroupIds")) {
5892 readGroupIds = _json["readGroupIds"];
5893 }
5894 if (_json.containsKey("readGroupSetIds")) {
5895 readGroupSetIds = _json["readGroupSetIds"];
5896 }
5897 if (_json.containsKey("referenceName")) {
5898 referenceName = _json["referenceName"];
5899 }
5900 if (_json.containsKey("start")) {
5901 start = _json["start"];
5902 }
5903 }
5904
5905 core.Map toJson() {
5906 var _json = new core.Map();
5907 if (end != null) {
5908 _json["end"] = end;
5909 }
5910 if (pageSize != null) {
5911 _json["pageSize"] = pageSize;
5912 }
5913 if (pageToken != null) {
5914 _json["pageToken"] = pageToken;
5915 }
5916 if (readGroupIds != null) {
5917 _json["readGroupIds"] = readGroupIds;
5918 }
5919 if (readGroupSetIds != null) {
5920 _json["readGroupSetIds"] = readGroupSetIds;
5921 }
5922 if (referenceName != null) {
5923 _json["referenceName"] = referenceName;
5924 }
5925 if (start != null) {
5926 _json["start"] = start;
5927 }
5928 return _json;
5929 }
5930 }
5931
5932 /** The read search response. */
5933 class SearchReadsResponse {
5934 /**
5935 * The list of matching alignments sorted by mapped genomic coordinate, if
5936 * any, ascending in position within the same reference. Unmapped reads, which
5937 * have no position, are returned contiguously and are sorted in ascending
5938 * lexicographic order by fragment name.
5939 */
5940 core.List<Read> alignments;
5941 /**
5942 * The continuation token, which is used to page through large result sets.
5943 * Provide this value in a subsequent request to return the next page of
5944 * results. This field will be empty if there aren't any additional results.
5945 */
5946 core.String nextPageToken;
5947
5948 SearchReadsResponse();
5949
5950 SearchReadsResponse.fromJson(core.Map _json) {
5951 if (_json.containsKey("alignments")) {
5952 alignments = _json["alignments"].map((value) => new Read.fromJson(value)). toList();
5953 }
5954 if (_json.containsKey("nextPageToken")) {
5955 nextPageToken = _json["nextPageToken"];
5956 }
5957 }
5958
5959 core.Map toJson() {
5960 var _json = new core.Map();
5961 if (alignments != null) {
5962 _json["alignments"] = alignments.map((value) => (value).toJson()).toList() ;
5963 }
5964 if (nextPageToken != null) {
5965 _json["nextPageToken"] = nextPageToken;
5966 }
5967 return _json;
5968 }
5969 }
5970
5971 class SearchReferenceSetsRequest {
5972 /**
5973 * If present, return references for which the accession matches any of these
5974 * strings. Best to give a version number, for example GCF_000001405.26. If
5975 * only the main accession number is given then all records with that main
5976 * accession will be returned, whichever version. Note that different versions
5977 * will have different sequences.
5978 */
5979 core.List<core.String> accessions;
5980 /**
5981 * If present, return reference sets for which a substring of their assemblyId
5982 * matches this string (case insensitive).
5983 */
5984 core.String assemblyId;
5985 /**
5986 * If present, return references for which the md5checksum matches. See
5987 * ReferenceSet.md5checksum for details.
5988 */
5989 core.List<core.String> md5checksums;
5990 /**
5991 * The maximum number of results to return in a single page. If unspecified,
5992 * defaults to 1024. The maximum value is 4096.
5993 */
5994 core.int pageSize;
5995 /**
5996 * The continuation token, which is used to page through large result sets. To
5997 * get the next page of results, set this parameter to the value of
5998 * nextPageToken from the previous response.
5999 */
6000 core.String pageToken;
6001
6002 SearchReferenceSetsRequest();
6003
6004 SearchReferenceSetsRequest.fromJson(core.Map _json) {
6005 if (_json.containsKey("accessions")) {
6006 accessions = _json["accessions"];
6007 }
6008 if (_json.containsKey("assemblyId")) {
6009 assemblyId = _json["assemblyId"];
6010 }
6011 if (_json.containsKey("md5checksums")) {
6012 md5checksums = _json["md5checksums"];
6013 }
6014 if (_json.containsKey("pageSize")) {
6015 pageSize = _json["pageSize"];
6016 }
6017 if (_json.containsKey("pageToken")) {
6018 pageToken = _json["pageToken"];
6019 }
6020 }
6021
6022 core.Map toJson() {
6023 var _json = new core.Map();
6024 if (accessions != null) {
6025 _json["accessions"] = accessions;
6026 }
6027 if (assemblyId != null) {
6028 _json["assemblyId"] = assemblyId;
6029 }
6030 if (md5checksums != null) {
6031 _json["md5checksums"] = md5checksums;
6032 }
6033 if (pageSize != null) {
6034 _json["pageSize"] = pageSize;
6035 }
6036 if (pageToken != null) {
6037 _json["pageToken"] = pageToken;
6038 }
6039 return _json;
6040 }
6041 }
6042
6043 class SearchReferenceSetsResponse {
6044 /**
6045 * The continuation token, which is used to page through large result sets.
6046 * Provide this value in a subsequent request to return the next page of
6047 * results. This field will be empty if there aren't any additional results.
6048 */
6049 core.String nextPageToken;
6050 /** The matching references sets. */
6051 core.List<ReferenceSet> referenceSets;
6052
6053 SearchReferenceSetsResponse();
6054
6055 SearchReferenceSetsResponse.fromJson(core.Map _json) {
6056 if (_json.containsKey("nextPageToken")) {
6057 nextPageToken = _json["nextPageToken"];
6058 }
6059 if (_json.containsKey("referenceSets")) {
6060 referenceSets = _json["referenceSets"].map((value) => new ReferenceSet.fro mJson(value)).toList();
6061 }
6062 }
6063
6064 core.Map toJson() {
6065 var _json = new core.Map();
6066 if (nextPageToken != null) {
6067 _json["nextPageToken"] = nextPageToken;
6068 }
6069 if (referenceSets != null) {
6070 _json["referenceSets"] = referenceSets.map((value) => (value).toJson()).to List();
6071 }
6072 return _json;
6073 }
6074 }
6075
6076 class SearchReferencesRequest {
6077 /**
6078 * If present, return references for which the accession matches this string.
6079 * Best to give a version number, for example GCF_000001405.26. If only the
6080 * main accession number is given then all records with that main accession
6081 * will be returned, whichever version. Note that different versions will have
6082 * different sequences.
6083 */
6084 core.List<core.String> accessions;
6085 /**
6086 * If present, return references for which the md5checksum matches. See
6087 * Reference.md5checksum for construction details.
6088 */
6089 core.List<core.String> md5checksums;
6090 /**
6091 * The maximum number of results to return in a single page. If unspecified,
6092 * defaults to 1024. The maximum value is 4096.
6093 */
6094 core.int pageSize;
6095 /**
6096 * The continuation token, which is used to page through large result sets. To
6097 * get the next page of results, set this parameter to the value of
6098 * nextPageToken from the previous response.
6099 */
6100 core.String pageToken;
6101 /** If present, return only references which belong to this reference set. */
6102 core.String referenceSetId;
6103
6104 SearchReferencesRequest();
6105
6106 SearchReferencesRequest.fromJson(core.Map _json) {
6107 if (_json.containsKey("accessions")) {
6108 accessions = _json["accessions"];
6109 }
6110 if (_json.containsKey("md5checksums")) {
6111 md5checksums = _json["md5checksums"];
6112 }
6113 if (_json.containsKey("pageSize")) {
6114 pageSize = _json["pageSize"];
6115 }
6116 if (_json.containsKey("pageToken")) {
6117 pageToken = _json["pageToken"];
6118 }
6119 if (_json.containsKey("referenceSetId")) {
6120 referenceSetId = _json["referenceSetId"];
6121 }
6122 }
6123
6124 core.Map toJson() {
6125 var _json = new core.Map();
6126 if (accessions != null) {
6127 _json["accessions"] = accessions;
6128 }
6129 if (md5checksums != null) {
6130 _json["md5checksums"] = md5checksums;
6131 }
6132 if (pageSize != null) {
6133 _json["pageSize"] = pageSize;
6134 }
6135 if (pageToken != null) {
6136 _json["pageToken"] = pageToken;
6137 }
6138 if (referenceSetId != null) {
6139 _json["referenceSetId"] = referenceSetId;
6140 }
6141 return _json;
6142 }
6143 }
6144
6145 class SearchReferencesResponse {
6146 /**
6147 * The continuation token, which is used to page through large result sets.
6148 * Provide this value in a subsequent request to return the next page of
6149 * results. This field will be empty if there aren't any additional results.
6150 */
6151 core.String nextPageToken;
6152 /** The matching references. */
6153 core.List<Reference> references;
6154
6155 SearchReferencesResponse();
6156
6157 SearchReferencesResponse.fromJson(core.Map _json) {
6158 if (_json.containsKey("nextPageToken")) {
6159 nextPageToken = _json["nextPageToken"];
6160 }
6161 if (_json.containsKey("references")) {
6162 references = _json["references"].map((value) => new Reference.fromJson(val ue)).toList();
6163 }
6164 }
6165
6166 core.Map toJson() {
6167 var _json = new core.Map();
6168 if (nextPageToken != null) {
6169 _json["nextPageToken"] = nextPageToken;
6170 }
6171 if (references != null) {
6172 _json["references"] = references.map((value) => (value).toJson()).toList() ;
6173 }
6174 return _json;
6175 }
6176 }
6177
6178 /** The search variant sets request. */
6179 class SearchVariantSetsRequest {
6180 /**
6181 * Exactly one dataset ID must be provided here. Only variant sets which
6182 * belong to this dataset will be returned.
6183 */
6184 core.List<core.String> datasetIds;
6185 /**
6186 * The maximum number of results to return in a single page. If unspecified,
6187 * defaults to 1024.
6188 */
6189 core.int pageSize;
6190 /**
6191 * The continuation token, which is used to page through large result sets. To
6192 * get the next page of results, set this parameter to the value of
6193 * nextPageToken from the previous response.
6194 */
6195 core.String pageToken;
6196
6197 SearchVariantSetsRequest();
6198
6199 SearchVariantSetsRequest.fromJson(core.Map _json) {
6200 if (_json.containsKey("datasetIds")) {
6201 datasetIds = _json["datasetIds"];
6202 }
6203 if (_json.containsKey("pageSize")) {
6204 pageSize = _json["pageSize"];
6205 }
6206 if (_json.containsKey("pageToken")) {
6207 pageToken = _json["pageToken"];
6208 }
6209 }
6210
6211 core.Map toJson() {
6212 var _json = new core.Map();
6213 if (datasetIds != null) {
6214 _json["datasetIds"] = datasetIds;
6215 }
6216 if (pageSize != null) {
6217 _json["pageSize"] = pageSize;
6218 }
6219 if (pageToken != null) {
6220 _json["pageToken"] = pageToken;
6221 }
6222 return _json;
6223 }
6224 }
6225
6226 /** The search variant sets response. */
6227 class SearchVariantSetsResponse {
6228 /**
6229 * The continuation token, which is used to page through large result sets.
6230 * Provide this value in a subsequent request to return the next page of
6231 * results. This field will be empty if there aren't any additional results.
6232 */
6233 core.String nextPageToken;
6234 /** The variant sets belonging to the requested dataset. */
6235 core.List<VariantSet> variantSets;
6236
6237 SearchVariantSetsResponse();
6238
6239 SearchVariantSetsResponse.fromJson(core.Map _json) {
6240 if (_json.containsKey("nextPageToken")) {
6241 nextPageToken = _json["nextPageToken"];
6242 }
6243 if (_json.containsKey("variantSets")) {
6244 variantSets = _json["variantSets"].map((value) => new VariantSet.fromJson( value)).toList();
6245 }
6246 }
6247
6248 core.Map toJson() {
6249 var _json = new core.Map();
6250 if (nextPageToken != null) {
6251 _json["nextPageToken"] = nextPageToken;
6252 }
6253 if (variantSets != null) {
6254 _json["variantSets"] = variantSets.map((value) => (value).toJson()).toList ();
6255 }
6256 return _json;
6257 }
6258 }
6259
6260 /** The variant search request. */
6261 class SearchVariantsRequest {
6262 /**
6263 * Only return variant calls which belong to call sets with these ids. Leaving
6264 * this blank returns all variant calls. If a variant has no calls belonging
6265 * to any of these call sets, it won't be returned at all.
6266 */
6267 core.List<core.String> callSetIds;
6268 /**
6269 * The end of the window, 0-based exclusive. If unspecified or 0, defaults to
6270 * the length of the reference.
6271 */
6272 core.String end;
6273 /**
6274 * The maximum number of calls to return in a single page. Note that this
6275 * limit may be exceeded in the event that a matching variant contains more
6276 * calls than the requested maximum. If unspecified, defaults to 5000. The
6277 * maximum value is 10000.
6278 */
6279 core.int maxCalls;
6280 /**
6281 * The maximum number of variants to return in a single page. If unspecified,
6282 * defaults to 5000. The maximum value is 10000.
6283 */
6284 core.int pageSize;
6285 /**
6286 * The continuation token, which is used to page through large result sets. To
6287 * get the next page of results, set this parameter to the value of
6288 * nextPageToken from the previous response.
6289 */
6290 core.String pageToken;
6291 /** Required. Only return variants in this reference sequence. */
6292 core.String referenceName;
6293 /**
6294 * The beginning of the window (0-based, inclusive) for which overlapping
6295 * variants should be returned. If unspecified, defaults to 0.
6296 */
6297 core.String start;
6298 /** Only return variants which have exactly this name. */
6299 core.String variantName;
6300 /**
6301 * At most one variant set ID must be provided. Only variants from this
6302 * variant set will be returned. If omitted, a call set id must be included in
6303 * the request. Both this and call_set_ids may be set.
6304 */
6305 core.List<core.String> variantSetIds;
6306
6307 SearchVariantsRequest();
6308
6309 SearchVariantsRequest.fromJson(core.Map _json) {
6310 if (_json.containsKey("callSetIds")) {
6311 callSetIds = _json["callSetIds"];
6312 }
6313 if (_json.containsKey("end")) {
6314 end = _json["end"];
6315 }
6316 if (_json.containsKey("maxCalls")) {
6317 maxCalls = _json["maxCalls"];
6318 }
6319 if (_json.containsKey("pageSize")) {
6320 pageSize = _json["pageSize"];
6321 }
6322 if (_json.containsKey("pageToken")) {
6323 pageToken = _json["pageToken"];
6324 }
6325 if (_json.containsKey("referenceName")) {
6326 referenceName = _json["referenceName"];
6327 }
6328 if (_json.containsKey("start")) {
6329 start = _json["start"];
6330 }
6331 if (_json.containsKey("variantName")) {
6332 variantName = _json["variantName"];
6333 }
6334 if (_json.containsKey("variantSetIds")) {
6335 variantSetIds = _json["variantSetIds"];
6336 }
6337 }
6338
6339 core.Map toJson() {
6340 var _json = new core.Map();
6341 if (callSetIds != null) {
6342 _json["callSetIds"] = callSetIds;
6343 }
6344 if (end != null) {
6345 _json["end"] = end;
6346 }
6347 if (maxCalls != null) {
6348 _json["maxCalls"] = maxCalls;
6349 }
6350 if (pageSize != null) {
6351 _json["pageSize"] = pageSize;
6352 }
6353 if (pageToken != null) {
6354 _json["pageToken"] = pageToken;
6355 }
6356 if (referenceName != null) {
6357 _json["referenceName"] = referenceName;
6358 }
6359 if (start != null) {
6360 _json["start"] = start;
6361 }
6362 if (variantName != null) {
6363 _json["variantName"] = variantName;
6364 }
6365 if (variantSetIds != null) {
6366 _json["variantSetIds"] = variantSetIds;
6367 }
6368 return _json;
6369 }
6370 }
6371
6372 /** The variant search response. */
6373 class SearchVariantsResponse {
6374 /**
6375 * The continuation token, which is used to page through large result sets.
6376 * Provide this value in a subsequent request to return the next page of
6377 * results. This field will be empty if there aren't any additional results.
6378 */
6379 core.String nextPageToken;
6380 /** The list of matching Variants. */
6381 core.List<Variant> variants;
6382
6383 SearchVariantsResponse();
6384
6385 SearchVariantsResponse.fromJson(core.Map _json) {
6386 if (_json.containsKey("nextPageToken")) {
6387 nextPageToken = _json["nextPageToken"];
6388 }
6389 if (_json.containsKey("variants")) {
6390 variants = _json["variants"].map((value) => new Variant.fromJson(value)).t oList();
6391 }
6392 }
6393
6394 core.Map toJson() {
6395 var _json = new core.Map();
6396 if (nextPageToken != null) {
6397 _json["nextPageToken"] = nextPageToken;
6398 }
6399 if (variants != null) {
6400 _json["variants"] = variants.map((value) => (value).toJson()).toList();
6401 }
6402 return _json;
6403 }
6404 }
6405
6406 /**
6407 * A transcript represents the assertion that a particular region of the
6408 * reference genome may be transcribed as RNA.
6409 */
6410 class Transcript {
6411 /**
6412 * The range of the coding sequence for this transcript, if any. To determine
6413 * the exact ranges of coding sequence, intersect this range with those of the
6414 * exons, if any. If there are any exons, the codingSequence must start and
6415 * end within them.
6416 *
6417 * Note that in some cases, the reference genome will not exactly match the
6418 * observed mRNA transcript e.g. due to variance in the source genome from
6419 * reference. In these cases, exon.frame will not necessarily match the
6420 * expected reference reading frame and coding exon reference bases cannot
6421 * necessarily be concatenated to produce the original transcript mRNA.
6422 */
6423 TranscriptCodingSequence codingSequence;
6424 /**
6425 * The exons that compose this transcript. This field should be unset for
6426 * genomes where transcript splicing does not occur, for example prokaryotes.
6427 *
6428 *
6429 * Introns are regions of the transcript that are not included in the spliced
6430 * RNA product. Though not explicitly modeled here, intron ranges can be
6431 * deduced; all regions of this transcript that are not exons are introns.
6432 *
6433 *
6434 * Exonic sequences do not necessarily code for a translational product (amino
6435 * acids). Only the regions of exons bounded by the codingSequence correspond
6436 * to coding DNA sequence.
6437 *
6438 *
6439 * Exons are ordered by start position and may not overlap.
6440 */
6441 core.List<TranscriptExon> exons;
6442 /**
6443 * The annotation ID of the gene from which this transcript is transcribed.
6444 */
6445 core.String geneId;
6446
6447 Transcript();
6448
6449 Transcript.fromJson(core.Map _json) {
6450 if (_json.containsKey("codingSequence")) {
6451 codingSequence = new TranscriptCodingSequence.fromJson(_json["codingSequen ce"]);
6452 }
6453 if (_json.containsKey("exons")) {
6454 exons = _json["exons"].map((value) => new TranscriptExon.fromJson(value)). toList();
6455 }
6456 if (_json.containsKey("geneId")) {
6457 geneId = _json["geneId"];
6458 }
6459 }
6460
6461 core.Map toJson() {
6462 var _json = new core.Map();
6463 if (codingSequence != null) {
6464 _json["codingSequence"] = (codingSequence).toJson();
6465 }
6466 if (exons != null) {
6467 _json["exons"] = exons.map((value) => (value).toJson()).toList();
6468 }
6469 if (geneId != null) {
6470 _json["geneId"] = geneId;
6471 }
6472 return _json;
6473 }
6474 }
6475
6476 class TranscriptCodingSequence {
6477 /**
6478 * The end of the coding sequence on this annotation's reference sequence,
6479 * 0-based exclusive. Note that this position is relative to the reference
6480 * start, and not the containing annotation start.
6481 */
6482 core.String end;
6483 /**
6484 * The start of the coding sequence on this annotation's reference sequence,
6485 * 0-based inclusive. Note that this position is relative to the reference
6486 * start, and not the containing annotation start.
6487 */
6488 core.String start;
6489
6490 TranscriptCodingSequence();
6491
6492 TranscriptCodingSequence.fromJson(core.Map _json) {
6493 if (_json.containsKey("end")) {
6494 end = _json["end"];
6495 }
6496 if (_json.containsKey("start")) {
6497 start = _json["start"];
6498 }
6499 }
6500
6501 core.Map toJson() {
6502 var _json = new core.Map();
6503 if (end != null) {
6504 _json["end"] = end;
6505 }
6506 if (start != null) {
6507 _json["start"] = start;
6508 }
6509 return _json;
6510 }
6511 }
6512
6513 class TranscriptExon {
6514 /**
6515 * The end position of the exon on this annotation's reference sequence,
6516 * 0-based exclusive. Note that this is relative to the reference start, and
6517 * not the containing annotation start.
6518 */
6519 core.String end;
6520 /**
6521 * The frame of this exon. Contains a value of 0, 1, or 2, which indicates the
6522 * offset of the first coding base of the exon within the reading frame of the
6523 * coding DNA sequence, if any. This field is dependent on the strandedness of
6524 * this annotation (see Annotation.position.reverseStrand). For forward
6525 * stranded annotations, this offset is relative to the exon.start. For
6526 * reverse strand annotations, this offset is relative to the exon.end-1.
6527 *
6528 * Unset if this exon does not intersect the coding sequence. Upon creation of
6529 * a transcript, the frame must be populated for all or none of the coding
6530 * exons.
6531 */
6532 Int32Value frame;
6533 /**
6534 * The start position of the exon on this annotation's reference sequence,
6535 * 0-based inclusive. Note that this is relative to the reference start, and
6536 * not the containing annotation start.
6537 */
6538 core.String start;
6539
6540 TranscriptExon();
6541
6542 TranscriptExon.fromJson(core.Map _json) {
6543 if (_json.containsKey("end")) {
6544 end = _json["end"];
6545 }
6546 if (_json.containsKey("frame")) {
6547 frame = new Int32Value.fromJson(_json["frame"]);
6548 }
6549 if (_json.containsKey("start")) {
6550 start = _json["start"];
6551 }
6552 }
6553
6554 core.Map toJson() {
6555 var _json = new core.Map();
6556 if (end != null) {
6557 _json["end"] = end;
6558 }
6559 if (frame != null) {
6560 _json["frame"] = (frame).toJson();
6561 }
6562 if (start != null) {
6563 _json["start"] = start;
6564 }
6565 return _json;
6566 }
6567 }
6568
6569 /**
6570 * A variant represents a change in DNA sequence relative to a reference
6571 * sequence. For example, a variant could represent a SNP or an insertion.
6572 * Variants belong to a variant set. Each of the calls on a variant represent a
6573 * determination of genotype with respect to that variant. For example, a call
6574 * might assign probability of 0.32 to the occurrence of a SNP named rs1234 in a
6575 * sample named NA12345. A call belongs to a call set, which contains related
6576 * calls typically from one sample.
6577 */
6578 class Variant {
6579 /** The bases that appear instead of the reference bases. */
6580 core.List<core.String> alternateBases;
6581 /**
6582 * The variant calls for this particular variant. Each one represents the
6583 * determination of genotype with respect to this variant.
6584 */
6585 core.List<Call> calls;
6586 /** The date this variant was created, in milliseconds from the epoch. */
6587 core.String created;
6588 /**
6589 * The end position (0-based) of this variant. This corresponds to the first
6590 * base after the last base in the reference allele. So, the length of the
6591 * reference allele is (end - start). This is useful for variants that don't
6592 * explicitly give alternate bases, for example large deletions.
6593 */
6594 core.String end;
6595 /**
6596 * A list of filters (normally quality filters) this variant has failed. PASS
6597 * indicates this variant has passed all filters.
6598 */
6599 core.List<core.String> filter;
6600 /** The Google generated ID of the variant, immutable. */
6601 core.String id;
6602 /** A string which maps to an array of values. */
6603 core.Map<core.String, core.List<core.String>> info;
6604 /** Names for the variant, for example a RefSNP ID. */
6605 core.List<core.String> names;
6606 /**
6607 * A measure of how likely this variant is to be real. A higher value is
6608 * better.
6609 */
6610 core.double quality;
6611 /**
6612 * The reference bases for this variant. They start at the given position.
6613 */
6614 core.String referenceBases;
6615 /** The reference on which this variant occurs. (such as chr20 or X) */
6616 core.String referenceName;
6617 /**
6618 * The position at which this variant occurs (0-based). This corresponds to
6619 * the first base of the string of reference bases.
6620 */
6621 core.String start;
6622 /** The ID of the variant set this variant belongs to. */
6623 core.String variantSetId;
6624
6625 Variant();
6626
6627 Variant.fromJson(core.Map _json) {
6628 if (_json.containsKey("alternateBases")) {
6629 alternateBases = _json["alternateBases"];
6630 }
6631 if (_json.containsKey("calls")) {
6632 calls = _json["calls"].map((value) => new Call.fromJson(value)).toList();
6633 }
6634 if (_json.containsKey("created")) {
6635 created = _json["created"];
6636 }
6637 if (_json.containsKey("end")) {
6638 end = _json["end"];
6639 }
6640 if (_json.containsKey("filter")) {
6641 filter = _json["filter"];
6642 }
6643 if (_json.containsKey("id")) {
6644 id = _json["id"];
6645 }
6646 if (_json.containsKey("info")) {
6647 info = _json["info"];
6648 }
6649 if (_json.containsKey("names")) {
6650 names = _json["names"];
6651 }
6652 if (_json.containsKey("quality")) {
6653 quality = _json["quality"];
6654 }
6655 if (_json.containsKey("referenceBases")) {
6656 referenceBases = _json["referenceBases"];
6657 }
6658 if (_json.containsKey("referenceName")) {
6659 referenceName = _json["referenceName"];
6660 }
6661 if (_json.containsKey("start")) {
6662 start = _json["start"];
6663 }
6664 if (_json.containsKey("variantSetId")) {
6665 variantSetId = _json["variantSetId"];
6666 }
6667 }
6668
6669 core.Map toJson() {
6670 var _json = new core.Map();
6671 if (alternateBases != null) {
6672 _json["alternateBases"] = alternateBases;
6673 }
6674 if (calls != null) {
6675 _json["calls"] = calls.map((value) => (value).toJson()).toList();
6676 }
6677 if (created != null) {
6678 _json["created"] = created;
6679 }
6680 if (end != null) {
6681 _json["end"] = end;
6682 }
6683 if (filter != null) {
6684 _json["filter"] = filter;
6685 }
6686 if (id != null) {
6687 _json["id"] = id;
6688 }
6689 if (info != null) {
6690 _json["info"] = info;
6691 }
6692 if (names != null) {
6693 _json["names"] = names;
6694 }
6695 if (quality != null) {
6696 _json["quality"] = quality;
6697 }
6698 if (referenceBases != null) {
6699 _json["referenceBases"] = referenceBases;
6700 }
6701 if (referenceName != null) {
6702 _json["referenceName"] = referenceName;
6703 }
6704 if (start != null) {
6705 _json["start"] = start;
6706 }
6707 if (variantSetId != null) {
6708 _json["variantSetId"] = variantSetId;
6709 }
6710 return _json;
6711 }
6712 }
6713
6714 /** A Variant annotation. */
6715 class VariantAnnotation {
6716 /**
6717 * The alternate allele for this variant. If multiple alternate alleles exist
6718 * at this location, create a separate variant for each one, as they may
6719 * represent distinct conditions.
6720 */
6721 core.String alternateBases;
6722 /**
6723 * Describes the clinical significance of a variant. It is adapted from the
6724 * ClinVar controlled vocabulary for clinical significance described at:
6725 * http://www.ncbi.nlm.nih.gov/clinvar/docs/clinsig/
6726 * Possible string values are:
6727 * - "ASSOCIATION"
6728 * - "BENIGN"
6729 * - "CLINICAL_SIGNIFICANCE_UNSPECIFIED"
6730 * - "CONFERS_SENSITIVITY"
6731 * - "DRUG_RESPONSE"
6732 * - "HISTOCOMPATIBILITY"
6733 * - "LIKELY_BENIGN"
6734 * - "LIKELY_PATHOGENIC"
6735 * - "MULTIPLE_REPORTED"
6736 * - "OTHER"
6737 * - "PATHOGENIC"
6738 * - "PROTECTIVE"
6739 * - "RISK_FACTOR"
6740 * - "UNCERTAIN"
6741 */
6742 core.String clinicalSignificance;
6743 /**
6744 * The set of conditions associated with this variant. A condition describes
6745 * the way a variant influences human health.
6746 */
6747 core.List<VariantAnnotationCondition> conditions;
6748 /**
6749 * Effect of the variant on the coding sequence.
6750 * Possible string values are:
6751 * - "EFFECT_UNSPECIFIED"
6752 * - "FRAMESHIFT"
6753 * - "FRAME_PRESERVING_INDEL"
6754 * - "NONSYNONYMOUS_SNP"
6755 * - "OTHER"
6756 * - "SPLICE_SITE_DISRUPTION"
6757 * - "STOP_GAIN"
6758 * - "STOP_LOSS"
6759 * - "SYNONYMOUS_SNP"
6760 */
6761 core.String effect;
6762 /**
6763 * Google annotation ID of the gene affected by this variant. This should be
6764 * provided when the variant is created.
6765 */
6766 core.String geneId;
6767 /**
6768 * Google annotation IDs of the transcripts affected by this variant. These
6769 * should be provided when the variant is created.
6770 */
6771 core.List<core.String> transcriptIds;
6772 /**
6773 * Type has been adapted from ClinVar's list of variant types.
6774 * Possible string values are:
6775 * - "CNV"
6776 * - "DELETION"
6777 * - "INSERTION"
6778 * - "OTHER"
6779 * - "SNP"
6780 * - "STRUCTURAL"
6781 * - "SUBSTITUTION"
6782 * - "TYPE_UNSPECIFIED"
6783 */
6784 core.String type;
6785
6786 VariantAnnotation();
6787
6788 VariantAnnotation.fromJson(core.Map _json) {
6789 if (_json.containsKey("alternateBases")) {
6790 alternateBases = _json["alternateBases"];
6791 }
6792 if (_json.containsKey("clinicalSignificance")) {
6793 clinicalSignificance = _json["clinicalSignificance"];
6794 }
6795 if (_json.containsKey("conditions")) {
6796 conditions = _json["conditions"].map((value) => new VariantAnnotationCondi tion.fromJson(value)).toList();
6797 }
6798 if (_json.containsKey("effect")) {
6799 effect = _json["effect"];
6800 }
6801 if (_json.containsKey("geneId")) {
6802 geneId = _json["geneId"];
6803 }
6804 if (_json.containsKey("transcriptIds")) {
6805 transcriptIds = _json["transcriptIds"];
6806 }
6807 if (_json.containsKey("type")) {
6808 type = _json["type"];
6809 }
6810 }
6811
6812 core.Map toJson() {
6813 var _json = new core.Map();
6814 if (alternateBases != null) {
6815 _json["alternateBases"] = alternateBases;
6816 }
6817 if (clinicalSignificance != null) {
6818 _json["clinicalSignificance"] = clinicalSignificance;
6819 }
6820 if (conditions != null) {
6821 _json["conditions"] = conditions.map((value) => (value).toJson()).toList() ;
6822 }
6823 if (effect != null) {
6824 _json["effect"] = effect;
6825 }
6826 if (geneId != null) {
6827 _json["geneId"] = geneId;
6828 }
6829 if (transcriptIds != null) {
6830 _json["transcriptIds"] = transcriptIds;
6831 }
6832 if (type != null) {
6833 _json["type"] = type;
6834 }
6835 return _json;
6836 }
6837 }
6838
6839 class VariantAnnotationCondition {
6840 /**
6841 * The MedGen concept id associated with this gene. Search for these IDs at
6842 * http://www.ncbi.nlm.nih.gov/medgen/
6843 */
6844 core.String conceptId;
6845 /** The set of external IDs for this condition. */
6846 core.List<ExternalId> externalIds;
6847 /** A set of names for the condition. */
6848 core.List<core.String> names;
6849 /**
6850 * The OMIM id for this condition. Search for these IDs at http://omim.org/
6851 */
6852 core.String omimId;
6853
6854 VariantAnnotationCondition();
6855
6856 VariantAnnotationCondition.fromJson(core.Map _json) {
6857 if (_json.containsKey("conceptId")) {
6858 conceptId = _json["conceptId"];
6859 }
6860 if (_json.containsKey("externalIds")) {
6861 externalIds = _json["externalIds"].map((value) => new ExternalId.fromJson( value)).toList();
6862 }
6863 if (_json.containsKey("names")) {
6864 names = _json["names"];
6865 }
6866 if (_json.containsKey("omimId")) {
6867 omimId = _json["omimId"];
6868 }
6869 }
6870
6871 core.Map toJson() {
6872 var _json = new core.Map();
6873 if (conceptId != null) {
6874 _json["conceptId"] = conceptId;
6875 }
6876 if (externalIds != null) {
6877 _json["externalIds"] = externalIds.map((value) => (value).toJson()).toList ();
6878 }
6879 if (names != null) {
6880 _json["names"] = names;
6881 }
6882 if (omimId != null) {
6883 _json["omimId"] = omimId;
6884 }
6885 return _json;
6886 }
6887 }
6888
6889 /**
6890 * A variant set is a collection of call sets and variants. It contains summary
6891 * statistics of those contents. A variant set belongs to a dataset.
6892 */
6893 class VariantSet {
6894 /** The dataset to which this variant set belongs. Immutable. */
6895 core.String datasetId;
6896 /** A textual description of this variant set. */
6897 core.String description;
6898 /** The Google-generated ID of the variant set. Immutable. */
6899 core.String id;
6900 /** The metadata associated with this variant set. */
6901 core.List<Metadata> metadata;
6902 /** User-specified, mutable name. */
6903 core.String name;
6904 /**
6905 * A list of all references used by the variants in a variant set with
6906 * associated coordinate upper bounds for each one.
6907 */
6908 core.List<ReferenceBound> referenceBounds;
6909 /**
6910 * The reference set to which the variant set is mapped. The reference set
6911 * describes the alignment provenance of the variant set, while the
6912 * referenceBounds describe the shape of the actual variant data. The
6913 * reference set's reference names are a superset of those found in the
6914 * referenceBounds.
6915 *
6916 * For example, given a variant set that is mapped to the GRCh38 reference set
6917 * and contains a single variant on reference 'X', referenceBounds would
6918 * contain only an entry for 'X', while the associated reference set
6919 * enumerates all possible references: '1', '2', 'X', 'Y', 'MT', etc.
6920 */
6921 core.String referenceSetId;
6922
6923 VariantSet();
6924
6925 VariantSet.fromJson(core.Map _json) {
6926 if (_json.containsKey("datasetId")) {
6927 datasetId = _json["datasetId"];
6928 }
6929 if (_json.containsKey("description")) {
6930 description = _json["description"];
6931 }
6932 if (_json.containsKey("id")) {
6933 id = _json["id"];
6934 }
6935 if (_json.containsKey("metadata")) {
6936 metadata = _json["metadata"].map((value) => new Metadata.fromJson(value)). toList();
6937 }
6938 if (_json.containsKey("name")) {
6939 name = _json["name"];
6940 }
6941 if (_json.containsKey("referenceBounds")) {
6942 referenceBounds = _json["referenceBounds"].map((value) => new ReferenceBou nd.fromJson(value)).toList();
6943 }
6944 if (_json.containsKey("referenceSetId")) {
6945 referenceSetId = _json["referenceSetId"];
6946 }
6947 }
6948
6949 core.Map toJson() {
6950 var _json = new core.Map();
6951 if (datasetId != null) {
6952 _json["datasetId"] = datasetId;
6953 }
6954 if (description != null) {
6955 _json["description"] = description;
6956 }
6957 if (id != null) {
6958 _json["id"] = id;
6959 }
6960 if (metadata != null) {
6961 _json["metadata"] = metadata.map((value) => (value).toJson()).toList();
6962 }
6963 if (name != null) {
6964 _json["name"] = name;
6965 }
6966 if (referenceBounds != null) {
6967 _json["referenceBounds"] = referenceBounds.map((value) => (value).toJson() ).toList();
6968 }
6969 if (referenceSetId != null) {
6970 _json["referenceSetId"] = referenceSetId;
6971 }
6972 return _json;
6973 }
6974 }
OLDNEW
« no previous file with comments | « generated/googleapis_beta/lib/datastore/v1beta3.dart ('k') | generated/googleapis_beta/lib/language/v1beta1.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698