Api roll 2: 2014-09-29

generated/googleapis_beta/lib/genomics/v1beta.dart

 library googleapis_beta.genomics.v1beta;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import "package:crypto/crypto.dart" as crypto;
 import 'package:http/http.dart' as http;
 import '../src/common_internal.dart' as common_internal;
@@ skipping 1493 matching lines @@
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Variant.fromJson(data));
   }
 
   /**
    * Creates variant data by asynchronously importing the provided information.
+   * If the destination variant set already contains data, new variants will be
+   * merged according to the behavior of mergeVariants.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [ImportVariantsResponse].
    *
    * Completes with a [common.ApiRequestError] if the API endpoint returned an
    * error.
    *
@@ skipping 195 matching lines @@
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new VariantSet.fromJson(data));
   }
 
   /**
+   * Merges the given variants with existing variants. Each variant will be
+   * merged with an existing variant that matches its reference sequence, start,
+   * end, reference bases, and alternative bases. If no such variant exists, a
+   * new one will be created.
+   *
+   * When variants are merged, the call information from the new variant is
+   * added to the existing variant, and other fields (such as key/value pairs)
+   * are discarded.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [variantSetId] - The destination variant set.
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future mergeVariants(Variant request, core.String variantSetId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+    if (variantSetId == null) {
+      throw new core.ArgumentError("Parameter variantSetId is required.");
+    }
+
+    _downloadOptions = null;
+
+    _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId') + '/mergeVariants';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => null);
+  }
+
+  /**
    * Returns a list of all variant sets matching search criteria.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchVariantSetsResponse].
    *
    * Completes with a [common.ApiRequestError] if the API endpoint returned an
    * error.
@@ skipping 307 matching lines @@
       _json["name"] = name;
     }
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     return _json;
   }
 }
 
 
-/** The job creation request. */
+/** The job creation request. Next ID: 12 */
 class ExperimentalCreateJobRequest {
   /**
    * Specifies whether or not to run the alignment pipeline. At least one of
    * align or callVariants must be provided.
    */
   core.bool align;
 
   /**
    * Specifies whether or not to run the variant calling pipeline. If specified,
    * alignment will be performed first and the aligned BAMs will passed as input
    * to the variant caller. At least one of align or callVariants must be
    * provided.
    */
   core.bool callVariants;
 
   /**
    * Specifies where to copy the results of certain pipelines. This should be in
    * the form of gs://bucket/path.
    */
   core.String gcsOutputPath;
 
+  /** For alignment from FASTQ files, this specifies the library name. */
+  core.String libraryName;
+
   /**
    * A list of Google Cloud Storage URIs of paired end .fastq files to operate
    * upon. If specified, this represents the second file of each paired .fastq
    * file. The first file of each pair should be specified in sourceUris.
    */
   core.List<core.String> pairedSourceUris;
 
+  /** For alignment from FASTQ files, this specifies the platform name. */
+  core.String platformName;
+
+  /** For alignment from FASTQ files, this specifies the platform unit. */
+  core.String platformUnit;
+
   /**
    * Required. The Google Cloud Project ID with which to associate the request.
    */
   core.String projectId;
 
+  /** For alignment from FASTQ files, this specifies the read group ID. */
+  core.String readGroupId;
+
+  /** For alignment from FASTQ files, this specifies the sample name. */
+  core.String sampleName;
+
   /**
    * A list of Google Cloud Storage URIs of data files to operate upon. These
    * can be .bam, interleaved .fastq, or paired .fastq. If specifying paired
    * .fastq files, the first of each pair of files should be listed here, and
    * the second of each pair should be listed in pairedSourceUris.
    */
   core.List<core.String> sourceUris;
 
 
   ExperimentalCreateJobRequest();
 
   ExperimentalCreateJobRequest.fromJson(core.Map _json) {
     if (_json.containsKey("align")) {
       align = _json["align"];
     }
     if (_json.containsKey("callVariants")) {
       callVariants = _json["callVariants"];
     }
     if (_json.containsKey("gcsOutputPath")) {
       gcsOutputPath = _json["gcsOutputPath"];
     }
+    if (_json.containsKey("libraryName")) {
+      libraryName = _json["libraryName"];
+    }
     if (_json.containsKey("pairedSourceUris")) {
       pairedSourceUris = _json["pairedSourceUris"];
     }
+    if (_json.containsKey("platformName")) {
+      platformName = _json["platformName"];
+    }
+    if (_json.containsKey("platformUnit")) {
+      platformUnit = _json["platformUnit"];
+    }
     if (_json.containsKey("projectId")) {
       projectId = _json["projectId"];
     }
+    if (_json.containsKey("readGroupId")) {
+      readGroupId = _json["readGroupId"];
+    }
+    if (_json.containsKey("sampleName")) {
+      sampleName = _json["sampleName"];
+    }
     if (_json.containsKey("sourceUris")) {
       sourceUris = _json["sourceUris"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (align != null) {
       _json["align"] = align;
     }
     if (callVariants != null) {
       _json["callVariants"] = callVariants;
     }
     if (gcsOutputPath != null) {
       _json["gcsOutputPath"] = gcsOutputPath;
     }
+    if (libraryName != null) {
+      _json["libraryName"] = libraryName;
+    }
     if (pairedSourceUris != null) {
       _json["pairedSourceUris"] = pairedSourceUris;
     }
+    if (platformName != null) {
+      _json["platformName"] = platformName;
+    }
+    if (platformUnit != null) {
+      _json["platformUnit"] = platformUnit;
+    }
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
+    if (readGroupId != null) {
+      _json["readGroupId"] = readGroupId;
+    }
+    if (sampleName != null) {
+      _json["sampleName"] = sampleName;
+    }
     if (sourceUris != null) {
       _json["sourceUris"] = sourceUris;
     }
     return _json;
   }
 }
 
 
 /** The job creation response. */
 class ExperimentalCreateJobResponse {
@@ skipping 21 matching lines @@
 
 /** The readset export request. */
 class ExportReadsetsRequest {
   /**
    * A Google Cloud Storage URI where the exported BAM file will be created. The
    * currently authenticated user must have write access to the new file
    * location. An error will be returned if the URI already contains data.
    */
   core.String exportUri;
 
-  /**
-   * The Google Developers Console project number that owns this export. This is
-   * the project that will be billed.
-   */
+  /** The Google Developers Console project number that owns this export. */
   core.String projectId;
 
   /** The IDs of the readsets to export. */
   core.List<core.String> readsetIds;
 
   /**
    * The reference names to export. If this is not specified, all reference
    * sequences, including unmapped reads, are exported. Use * to export only
    * unmapped reads.
    */
@@ skipping 57 matching lines @@
     }
     return _json;
   }
 }
 
 
 /** The variant data export request. */
 class ExportVariantsRequest {
   /**
    * The BigQuery dataset to export data to. Note that this is distinct from the
-   * Genomics concept of "dataset". The caller must have WRITE access to this
-   * BigQuery dataset.
+   * Genomics concept of "dataset".
    */
   core.String bigqueryDataset;
 
   /**
-   * The BigQuery table to export data to. The caller must have WRITE access to
-   * this BigQuery table.
+   * The BigQuery table to export data to. If the table doesn't exist, it will
+   * be created. If it already exists, it will be overwritten.
    */
   core.String bigqueryTable;
 
   /**
    * If provided, only variant call information from the specified call sets
    * will be exported. By default all variant calls are exported.
    */
   core.List<core.String> callSetIds;
 
   /**
    * The format for the exported data.
    * Possible string values are:
    * - "bigquery"
    */
   core.String format;
 
   /**
-   * The Google Cloud project number that owns this export. This is the project
-   * that will be billed.
+   * The Google Cloud project number that owns the destination BigQuery dataset.
+   * The caller must have WRITE access to this project. This project will also
+   * own the resulting export job.
    */
   core.String projectId;
 
   /**
    * Required. The ID of the variant set that contains variant data which should
    * be exported. The caller must have READ access to this variant set.
    */
   core.String variantSetId;
 
 
@@ skipping 1976 matching lines @@
   core.String created;
 
   /**
    * The end position (0-based) of this variant. This corresponds to the first
    * base after the last base in the reference allele. So, the length of the
    * reference allele is (end - start). This is useful for variants that don't
    * explicitly give alternate bases, for example large deletions.
    */
   core.String end;
 
+  /**
+   * A list of filters (normally quality filters) this variant has failed. PASS
+   * indicates this variant has passed all filters.
+   */
+  core.List<core.String> filter;
+
   /** The Google generated ID of the variant, immutable. */
   core.String id;
 
   /** A map of additional variant information. */
   core.Map<core.String, core.List<core.String>> info;
 
   /** Names for the variant, for example a RefSNP ID. */
   core.List<core.String> names;
 
   /**
+   * A measure of how likely this variant is to be real. A higher value is
+   * better.
+   */
+  core.double quality;
+
+  /**
    * The reference bases for this variant. They start at the given position.
    */
   core.String referenceBases;
 
   /** The reference on which this variant occurs. (such as chr20 or X) */
   core.String referenceName;
 
   /**
    * The position at which this variant occurs (0-based). This corresponds to
    * the first base of the string of reference bases.
@@ skipping 12 matching lines @@
     }
     if (_json.containsKey("calls")) {
       calls = _json["calls"].map((value) => new Call.fromJson(value)).toList();
     }
     if (_json.containsKey("created")) {
       created = _json["created"];
     }
     if (_json.containsKey("end")) {
       end = _json["end"];
     }
+    if (_json.containsKey("filter")) {
+      filter = _json["filter"];
+    }
     if (_json.containsKey("id")) {
       id = _json["id"];
     }
     if (_json.containsKey("info")) {
       info = _json["info"];
     }
     if (_json.containsKey("names")) {
       names = _json["names"];
     }
+    if (_json.containsKey("quality")) {
+      quality = _json["quality"];
+    }
     if (_json.containsKey("referenceBases")) {
       referenceBases = _json["referenceBases"];
     }
     if (_json.containsKey("referenceName")) {
       referenceName = _json["referenceName"];
     }
     if (_json.containsKey("start")) {
       start = _json["start"];
     }
     if (_json.containsKey("variantSetId")) {
       variantSetId = _json["variantSetId"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (alternateBases != null) {
       _json["alternateBases"] = alternateBases;
     }
     if (calls != null) {
       _json["calls"] = calls.map((value) => (value).toJson()).toList();
     }
     if (created != null) {
       _json["created"] = created;
     }
     if (end != null) {
       _json["end"] = end;
     }
+    if (filter != null) {
+      _json["filter"] = filter;
+    }
     if (id != null) {
       _json["id"] = id;
     }
     if (info != null) {
       _json["info"] = info;
     }
     if (names != null) {
       _json["names"] = names;
     }
+    if (quality != null) {
+      _json["quality"] = quality;
+    }
     if (referenceBases != null) {
       _json["referenceBases"] = referenceBases;
     }
     if (referenceName != null) {
       _json["referenceName"] = referenceName;
     }
     if (start != null) {
       _json["start"] = start;
     }
     if (variantSetId != null) {
@@ skipping 54 matching lines @@
       _json["metadata"] = metadata.map((value) => (value).toJson()).toList();
     }
     if (referenceBounds != null) {
       _json["referenceBounds"] = referenceBounds.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }