Roll of googleapis as of 4/7/2015.

generated/googleapis_beta/lib/genomics/v1beta2.dart

+// This is a generated file (see the discoveryapis_generator project).
+
 library googleapis_beta.genomics.v1beta2;
 
-import "dart:core" as core;
-import "dart:collection" as collection;
-import "dart:async" as async;
-import "dart:convert" as convert;
+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:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
+import 'package:crypto/crypto.dart' as crypto;
 import 'package:http/http.dart' as http;
-import '../src/common_internal.dart' as common_internal;
-import '../common/common.dart' as common;
 
-export '../common/common.dart' show ApiRequestError;
-export '../common/common.dart' show DetailedApiRequestError;
+export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
+    ApiRequestError, DetailedApiRequestError;
+
+const core.String USER_AGENT = 'dart-api-client genomics/v1beta2';
 
 /** Provides access to Genomics data. */
 class GenomicsApi {
   /** View and manage your data in Google BigQuery */
   static const BigqueryScope = "https://www.googleapis.com/auth/bigquery";
 
   /** Manage your data in Google Cloud Storage */
   static const DevstorageReadWriteScope = "https://www.googleapis.com/auth/devstorage.read_write";
 
   /** View and manage Genomics data */
   static const GenomicsScope = "https://www.googleapis.com/auth/genomics";
 
   /** View Genomics data */
   static const GenomicsReadonlyScope = "https://www.googleapis.com/auth/genomics.readonly";
 
 
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   AnnotationSetsResourceApi get annotationSets => new AnnotationSetsResourceApi(_requester);
   AnnotationsResourceApi get annotations => new AnnotationsResourceApi(_requester);
   CallsetsResourceApi get callsets => new CallsetsResourceApi(_requester);
   DatasetsResourceApi get datasets => new DatasetsResourceApi(_requester);
   ExperimentalResourceApi get experimental => new ExperimentalResourceApi(_requester);
   JobsResourceApi get jobs => new JobsResourceApi(_requester);
   ReadgroupsetsResourceApi get readgroupsets => new ReadgroupsetsResourceApi(_requester);
   ReadsResourceApi get reads => new ReadsResourceApi(_requester);
   ReferencesResourceApi get references => new ReferencesResourceApi(_requester);
   ReferencesetsResourceApi get referencesets => new ReferencesetsResourceApi(_requester);
+  StreamingVariantStoreResourceApi get streamingVariantStore => new StreamingVariantStoreResourceApi(_requester);
   VariantsResourceApi get variants => new VariantsResourceApi(_requester);
   VariantsetsResourceApi get variantsets => new VariantsetsResourceApi(_requester);
 
   GenomicsApi(http.Client client, {core.String rootUrl: "https://www.googleapis.com/", core.String servicePath: "genomics/v1beta2/"}) :
-      _requester = new common_internal.ApiRequester(client, rootUrl, servicePath);
+      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
 
-/** Not documented yet. */
 class AnnotationSetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  AnnotationSetsResourceApi(common_internal.ApiRequester client) : 
+  AnnotationSetsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Creates a new annotation set. Caller must have WRITE permission for the
    * associated dataset.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [AnnotationSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<AnnotationSet> create(AnnotationSet request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'annotationSets';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AnnotationSet.fromJson(data));
   }
 
   /**
    * Deletes an annotation set. Caller must have WRITE permission for the
    * associated annotation set.
    *
    * Request parameters:
    *
    * [annotationSetId] - The ID of the annotation set to be deleted.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 delete(core.String annotationSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (annotationSetId == null) {
       throw new core.ArgumentError("Parameter annotationSetId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'annotationSets/' + common_internal.Escaper.ecapeVariable('$annotationSetId');
+    _url = 'annotationSets/' + commons.Escaper.ecapeVariable('$annotationSetId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Gets an annotation set. Caller must have READ permission for the associated
    * dataset.
    *
    * Request parameters:
    *
    * [annotationSetId] - The ID of the annotation set to be retrieved.
    *
    * Completes with a [AnnotationSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<AnnotationSet> get(core.String annotationSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (annotationSetId == null) {
       throw new core.ArgumentError("Parameter annotationSetId is required.");
     }
 
 
-    _url = 'annotationSets/' + common_internal.Escaper.ecapeVariable('$annotationSetId');
+    _url = 'annotationSets/' + commons.Escaper.ecapeVariable('$annotationSetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AnnotationSet.fromJson(data));
   }
 
   /**
    * Updates an annotation set. The update must respect all mutability
    * restrictions and other invariants described on the annotation set resource.
    * Caller must have WRITE permission for the associated dataset. This method
    * supports patch semantics.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [annotationSetId] - The ID of the annotation set to be updated.
    *
    * Completes with a [AnnotationSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<AnnotationSet> patch(AnnotationSet request, core.String annotationSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (annotationSetId == null) {
       throw new core.ArgumentError("Parameter annotationSetId is required.");
     }
 
 
-    _url = 'annotationSets/' + common_internal.Escaper.ecapeVariable('$annotationSetId');
+    _url = 'annotationSets/' + commons.Escaper.ecapeVariable('$annotationSetId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AnnotationSet.fromJson(data));
   }
 
   /**
-   * Searches for annotation sets which match the given criteria. Results are
+   * Searches for annotation sets that match the given criteria. Results are
    * returned in a deterministic order. Caller must have READ permission for the
    * queried datasets.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchAnnotationSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchAnnotationSetsResponse> search(SearchAnnotationSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'annotationSets/search';
 
     var _response = _requester.request(_url,
@@ skipping 12 matching lines @@
    * Caller must have WRITE permission for the associated dataset.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [annotationSetId] - The ID of the annotation set to be updated.
    *
    * Completes with a [AnnotationSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<AnnotationSet> update(AnnotationSet request, core.String annotationSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (annotationSetId == null) {
       throw new core.ArgumentError("Parameter annotationSetId is required.");
     }
 
 
-    _url = 'annotationSets/' + common_internal.Escaper.ecapeVariable('$annotationSetId');
+    _url = 'annotationSets/' + commons.Escaper.ecapeVariable('$annotationSetId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AnnotationSet.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class AnnotationsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  AnnotationsResourceApi(common_internal.ApiRequester client) : 
+  AnnotationsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Creates one or more new annotations atomically. All annotations must belong
    * to the same annotation set. Caller must have WRITE permission for this
    * annotation set. For optimal performance, batch positionally adjacent
    * annotations together.
    *
    *
    * If the request has a systemic issue, such as an attempt to write to an
    * inaccessible annotation set, the entire RPC will fail accordingly. For
    * lesser data issues, when possible an error will be isolated to the
    * corresponding batch entry in the response; the remaining well formed
    * annotations will be created normally.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [BatchAnnotationsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<BatchAnnotationsResponse> batchCreate(BatchCreateAnnotationsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'annotations:batchCreate';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new BatchAnnotationsResponse.fromJson(data));
   }
 
   /**
    * Creates a new annotation. Caller must have WRITE permission for the
    * associated annotation set.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [Annotation].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Annotation> create(Annotation request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'annotations';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Annotation.fromJson(data));
   }
 
   /**
    * Deletes an annotation. Caller must have WRITE permission for the associated
    * annotation set.
    *
    * Request parameters:
    *
    * [annotationId] - The ID of the annotation set to be deleted.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 delete(core.String annotationId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (annotationId == null) {
       throw new core.ArgumentError("Parameter annotationId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'annotations/' + common_internal.Escaper.ecapeVariable('$annotationId');
+    _url = 'annotations/' + commons.Escaper.ecapeVariable('$annotationId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Gets an annotation. Caller must have READ permission for the associated
    * annotation set.
    *
    * Request parameters:
    *
    * [annotationId] - The ID of the annotation set to be retrieved.
    *
    * Completes with a [Annotation].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Annotation> get(core.String annotationId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (annotationId == null) {
       throw new core.ArgumentError("Parameter annotationId is required.");
     }
 
 
-    _url = 'annotations/' + common_internal.Escaper.ecapeVariable('$annotationId');
+    _url = 'annotations/' + commons.Escaper.ecapeVariable('$annotationId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Annotation.fromJson(data));
   }
 
   /**
    * Updates an annotation. The update must respect all mutability restrictions
    * and other invariants described on the annotation resource. Caller must have
    * WRITE permission for the associated dataset. This method supports patch
    * semantics.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [annotationId] - The ID of the annotation set to be updated.
    *
    * Completes with a [Annotation].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Annotation> patch(Annotation request, core.String annotationId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (annotationId == null) {
       throw new core.ArgumentError("Parameter annotationId is required.");
     }
 
 
-    _url = 'annotations/' + common_internal.Escaper.ecapeVariable('$annotationId');
+    _url = 'annotations/' + commons.Escaper.ecapeVariable('$annotationId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Annotation.fromJson(data));
   }
 
   /**
-   * Searches for annotations which match the given criteria. Results are
-   * returned ordered by start position. Annotations which have matching start
+   * Searches for annotations that match the given criteria. Results are
+   * returned ordered by start position. Annotations that have matching start
    * positions are ordered deterministically. Caller must have READ permission
    * for the queried annotation sets.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchAnnotationsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchAnnotationsResponse> search(SearchAnnotationsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'annotations/search';
 
     var _response = _requester.request(_url,
@@ skipping 12 matching lines @@
    * WRITE permission for the associated dataset.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [annotationId] - The ID of the annotation set to be updated.
    *
    * Completes with a [Annotation].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Annotation> update(Annotation request, core.String annotationId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (annotationId == null) {
       throw new core.ArgumentError("Parameter annotationId is required.");
     }
 
 
-    _url = 'annotations/' + common_internal.Escaper.ecapeVariable('$annotationId');
+    _url = 'annotations/' + commons.Escaper.ecapeVariable('$annotationId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Annotation.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class CallsetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  CallsetsResourceApi(common_internal.ApiRequester client) : 
+  CallsetsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Creates a new call set.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [CallSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<CallSet> create(CallSet request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'callsets';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new CallSet.fromJson(data));
   }
 
   /**
    * Deletes a call set.
    *
    * Request parameters:
    *
    * [callSetId] - The ID of the call set to be deleted.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 delete(core.String callSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (callSetId == null) {
       throw new core.ArgumentError("Parameter callSetId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'callsets/' + common_internal.Escaper.ecapeVariable('$callSetId');
+    _url = 'callsets/' + commons.Escaper.ecapeVariable('$callSetId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Gets a call set by ID.
    *
    * Request parameters:
    *
    * [callSetId] - The ID of the call set.
    *
    * Completes with a [CallSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<CallSet> get(core.String callSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (callSetId == null) {
       throw new core.ArgumentError("Parameter callSetId is required.");
     }
 
 
-    _url = 'callsets/' + common_internal.Escaper.ecapeVariable('$callSetId');
+    _url = 'callsets/' + commons.Escaper.ecapeVariable('$callSetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new CallSet.fromJson(data));
   }
 
   /**
    * Updates a call set. This method supports patch semantics.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [callSetId] - The ID of the call set to be updated.
    *
    * Completes with a [CallSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<CallSet> patch(CallSet request, core.String callSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (callSetId == null) {
       throw new core.ArgumentError("Parameter callSetId is required.");
     }
 
 
-    _url = 'callsets/' + common_internal.Escaper.ecapeVariable('$callSetId');
+    _url = 'callsets/' + commons.Escaper.ecapeVariable('$callSetId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new CallSet.fromJson(data));
   }
 
   /**
    * Gets a list of call sets matching the criteria.
    *
    * Implements GlobalAllianceApi.searchCallSets.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchCallSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchCallSetsResponse> search(SearchCallSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'callsets/search';
 
     var _response = _requester.request(_url,
@@ skipping 10 matching lines @@
    * Updates a call set.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [callSetId] - The ID of the call set to be updated.
    *
    * Completes with a [CallSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<CallSet> update(CallSet request, core.String callSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (callSetId == null) {
       throw new core.ArgumentError("Parameter callSetId is required.");
     }
 
 
-    _url = 'callsets/' + common_internal.Escaper.ecapeVariable('$callSetId');
+    _url = 'callsets/' + commons.Escaper.ecapeVariable('$callSetId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new CallSet.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class DatasetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  DatasetsResourceApi(common_internal.ApiRequester client) : 
+  DatasetsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Creates a new dataset.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> create(Dataset request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'datasets';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
   /**
    * Deletes a dataset.
    *
    * Request parameters:
    *
    * [datasetId] - The ID of the dataset to be deleted.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 delete(core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Gets a dataset by ID.
    *
    * Request parameters:
    *
    * [datasetId] - The ID of the dataset.
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> get(core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
 
-    _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
   /**
-   * Lists all datasets.
+   * Lists datasets within a project.
    *
    * Request parameters:
    *
-   * [pageSize] - The maximum number of results returned by this request.
+   * [pageSize] - The maximum number of results returned by this request. If
+   * unspecified, defaults to 50.
    *
    * [pageToken] - The continuation token, which is used to page through large
    * result sets. To get the next page of results, set this parameter to the
    * value of nextPageToken from the previous response.
    *
-   * [projectNumber] - Only return datasets which belong to this Google
-   * Developers Console project. Only accepts project numbers. Returns all
-   * public projects if no project number is specified.
+   * [projectNumber] - The project to list datasets for.
    *
    * Completes with a [ListDatasetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ListDatasetsResponse> list({core.int pageSize, core.String pageToken, core.String projectNumber}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (projectNumber != null) {
       _queryParams["projectNumber"] = [projectNumber];
@@ skipping 16 matching lines @@
    * Updates a dataset. This method supports patch semantics.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [datasetId] - The ID of the dataset to be updated.
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> patch(Dataset request, core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
 
-    _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
   /**
    * Undeletes a dataset by restoring a dataset which was deleted via this API.
    * This operation is only possible for a week after the deletion occurred.
    *
    * Request parameters:
    *
    * [datasetId] - The ID of the dataset to be undeleted.
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> undelete(core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
 
-    _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/undelete';
+    _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/undelete';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
   /**
    * Updates a dataset.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [datasetId] - The ID of the dataset to be updated.
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> update(Dataset request, core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
 
-    _url = 'datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = 'datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ExperimentalResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   ExperimentalJobsResourceApi get jobs => new ExperimentalJobsResourceApi(_requester);
 
-  ExperimentalResourceApi(common_internal.ApiRequester client) : 
+  ExperimentalResourceApi(commons.ApiRequester client) : 
       _requester = client;
 }
 
 
-/** Not documented yet. */
 class ExperimentalJobsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  ExperimentalJobsResourceApi(common_internal.ApiRequester client) : 
+  ExperimentalJobsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Creates and asynchronously runs an ad-hoc job. This is an experimental call
    * and may be removed or changed at any time.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [ExperimentalCreateJobResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ExperimentalCreateJobResponse> create(ExperimentalCreateJobRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'experimental/jobs/create';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ExperimentalCreateJobResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class JobsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  JobsResourceApi(common_internal.ApiRequester client) : 
+  JobsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Cancels a job by ID. Note that it is possible for partial results to be
    * generated and stored for cancelled jobs.
    *
    * Request parameters:
    *
    * [jobId] - Required. The ID of the job.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 cancel(core.String jobId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (jobId == null) {
       throw new core.ArgumentError("Parameter jobId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'jobs/' + common_internal.Escaper.ecapeVariable('$jobId') + '/cancel';
+    _url = 'jobs/' + commons.Escaper.ecapeVariable('$jobId') + '/cancel';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Gets a job by ID.
    *
    * Request parameters:
    *
    * [jobId] - Required. The ID of the job.
    *
    * Completes with a [Job].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Job> get(core.String jobId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (jobId == null) {
       throw new core.ArgumentError("Parameter jobId is required.");
     }
 
 
-    _url = 'jobs/' + common_internal.Escaper.ecapeVariable('$jobId');
+    _url = 'jobs/' + commons.Escaper.ecapeVariable('$jobId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Job.fromJson(data));
   }
 
   /**
    * Gets a list of jobs matching the criteria.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchJobsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchJobsResponse> search(SearchJobsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'jobs/search';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new SearchJobsResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ReadgroupsetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   ReadgroupsetsCoveragebucketsResourceApi get coveragebuckets => new ReadgroupsetsCoveragebucketsResourceApi(_requester);
 
-  ReadgroupsetsResourceApi(common_internal.ApiRequester client) : 
+  ReadgroupsetsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Aligns read data from existing read group sets or files from Google Cloud
    * Storage. See the  alignment and variant calling documentation for more
    * details.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [AlignReadGroupSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<AlignReadGroupSetsResponse> align(AlignReadGroupSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'readgroupsets/align';
 
     var _response = _requester.request(_url,
@@ skipping 10 matching lines @@
    * Calls variants on read data from existing read group sets or files from
    * Google Cloud Storage. See the  alignment and variant calling documentation
    * for more details.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [CallReadGroupSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<CallReadGroupSetsResponse> call(CallReadGroupSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'readgroupsets/call';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new CallReadGroupSetsResponse.fromJson(data));
   }
 
   /**
    * Deletes a read group set.
    *
    * Request parameters:
    *
    * [readGroupSetId] - The ID of the read group set to be deleted. The caller
    * must have WRITE permissions to the dataset associated with this read group
    * set.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 delete(core.String readGroupSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (readGroupSetId == null) {
       throw new core.ArgumentError("Parameter readGroupSetId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'readgroupsets/' + common_internal.Escaper.ecapeVariable('$readGroupSetId');
+    _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Exports read group sets to a BAM file in Google Cloud Storage.
    *
    * Note that currently there may be some differences between exported BAM
    * files and the original BAM file at the time of import. In particular,
    * comments in the input file header will not be preserved, some custom tags
    * will be converted to strings, and original reference sequence order is not
    * necessarily preserved.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [ExportReadGroupSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ExportReadGroupSetsResponse> export(ExportReadGroupSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'readgroupsets/export';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ExportReadGroupSetsResponse.fromJson(data));
   }
 
   /**
    * Gets a read group set by ID.
    *
    * Request parameters:
    *
    * [readGroupSetId] - The ID of the read group set.
    *
    * Completes with a [ReadGroupSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ReadGroupSet> get(core.String readGroupSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (readGroupSetId == null) {
       throw new core.ArgumentError("Parameter readGroupSetId is required.");
     }
 
 
-    _url = 'readgroupsets/' + common_internal.Escaper.ecapeVariable('$readGroupSetId');
+    _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ReadGroupSet.fromJson(data));
   }
 
   /**
    * Creates read group sets by asynchronously importing the provided
    * information.
    *
    * Note that currently comments in the input file header are not imported and
    * some custom tags will be converted to strings, rather than preserving tag
    * types. The caller must have WRITE permissions to the dataset.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [ImportReadGroupSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ImportReadGroupSetsResponse> import(ImportReadGroupSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'readgroupsets/import';
 
     var _response = _requester.request(_url,
@@ skipping 12 matching lines @@
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [readGroupSetId] - The ID of the read group set to be updated. The caller
    * must have WRITE permissions to the dataset associated with this read group
    * set.
    *
    * Completes with a [ReadGroupSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ReadGroupSet> patch(ReadGroupSet request, core.String readGroupSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (readGroupSetId == null) {
       throw new core.ArgumentError("Parameter readGroupSetId is required.");
     }
 
 
-    _url = 'readgroupsets/' + common_internal.Escaper.ecapeVariable('$readGroupSetId');
+    _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ReadGroupSet.fromJson(data));
   }
 
   /**
    * Searches for read group sets matching the criteria.
    *
    * Implements GlobalAllianceApi.searchReadGroupSets.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchReadGroupSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchReadGroupSetsResponse> search(SearchReadGroupSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'readgroupsets/search';
 
     var _response = _requester.request(_url,
@@ skipping 12 matching lines @@
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [readGroupSetId] - The ID of the read group set to be updated. The caller
    * must have WRITE permissions to the dataset associated with this read group
    * set.
    *
    * Completes with a [ReadGroupSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ReadGroupSet> update(ReadGroupSet request, core.String readGroupSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (readGroupSetId == null) {
       throw new core.ArgumentError("Parameter readGroupSetId is required.");
     }
 
 
-    _url = 'readgroupsets/' + common_internal.Escaper.ecapeVariable('$readGroupSetId');
+    _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ReadGroupSet.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ReadgroupsetsCoveragebucketsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  ReadgroupsetsCoveragebucketsResourceApi(common_internal.ApiRequester client) : 
+  ReadgroupsetsCoveragebucketsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Lists fixed width coverage buckets for a read group set, each of which
    * correspond to a range of a reference sequence. Each bucket summarizes
    * coverage information across its corresponding genomic range.
    *
    * Coverage is defined as the number of reads which are aligned to a given
    * base in the reference sequence. Coverage buckets are available at several
    * precomputed bucket widths, enabling retrieval of various coverage 'zoom
@@ skipping 23 matching lines @@
    *
    * [targetBucketWidth] - The desired width of each reported coverage bucket in
    * base pairs. This will be rounded down to the nearest precomputed bucket
    * width; the value of which is returned as bucketWidth in the response.
    * Defaults to infinity (each bucket spans an entire reference sequence) or
    * the length of the target range, if specified. The smallest precomputed
    * bucketWidth is currently 2048 base pairs; this is subject to change.
    *
    * Completes with a [ListCoverageBucketsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ListCoverageBucketsResponse> list(core.String readGroupSetId, {core.int pageSize, core.String pageToken, core.String range_end, core.String range_referenceName, core.String range_start, core.String targetBucketWidth}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (readGroupSetId == null) {
       throw new core.ArgumentError("Parameter readGroupSetId is required.");
     }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (range_end != null) {
       _queryParams["range.end"] = [range_end];
     }
     if (range_referenceName != null) {
       _queryParams["range.referenceName"] = [range_referenceName];
     }
     if (range_start != null) {
       _queryParams["range.start"] = [range_start];
     }
     if (targetBucketWidth != null) {
       _queryParams["targetBucketWidth"] = [targetBucketWidth];
     }
 
 
-    _url = 'readgroupsets/' + common_internal.Escaper.ecapeVariable('$readGroupSetId') + '/coveragebuckets';
+    _url = 'readgroupsets/' + commons.Escaper.ecapeVariable('$readGroupSetId') + '/coveragebuckets';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListCoverageBucketsResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ReadsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  ReadsResourceApi(common_internal.ApiRequester client) : 
+  ReadsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Gets a list of reads for one or more read group sets. Reads search operates
    * over a genomic coordinate space of reference sequence & position defined
    * over the reference sequences to which the requested read group sets are
    * aligned.
    *
    * If a target positional range is specified, search returns all reads whose
    * alignment to the reference genome overlap the range. A query which
    * specifies only read group set IDs yields all reads in those read group
    * sets, including unmapped reads.
    *
    * All reads returned (including reads on subsequent pages) are ordered by
    * genomic coordinate (reference sequence & position). Reads with equivalent
    * genomic coordinates are returned in a deterministic order.
    *
    * Implements GlobalAllianceApi.searchReads.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchReadsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchReadsResponse> search(SearchReadsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'reads/search';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new SearchReadsResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ReferencesResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   ReferencesBasesResourceApi get bases => new ReferencesBasesResourceApi(_requester);
 
-  ReferencesResourceApi(common_internal.ApiRequester client) : 
+  ReferencesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Gets a reference.
    *
    * Implements GlobalAllianceApi.getReference.
    *
    * Request parameters:
    *
    * [referenceId] - The ID of the reference.
    *
    * Completes with a [Reference].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Reference> get(core.String referenceId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (referenceId == null) {
       throw new core.ArgumentError("Parameter referenceId is required.");
     }
 
 
-    _url = 'references/' + common_internal.Escaper.ecapeVariable('$referenceId');
+    _url = 'references/' + commons.Escaper.ecapeVariable('$referenceId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Reference.fromJson(data));
   }
 
   /**
    * Searches for references which match the given criteria.
    *
    * Implements GlobalAllianceApi.searchReferences.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchReferencesResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchReferencesResponse> search(SearchReferencesRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'references/search';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new SearchReferencesResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ReferencesBasesResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  ReferencesBasesResourceApi(common_internal.ApiRequester client) : 
+  ReferencesBasesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Lists the bases in a reference, optionally restricted to a range.
    *
    * Implements GlobalAllianceApi.getReferenceBases.
    *
    * Request parameters:
    *
    * [referenceId] - The ID of the reference.
    *
    * [end] - The end position (0-based, exclusive) of this query. Defaults to
    * the length of this reference.
    *
    * [pageSize] - Specifies the maximum number of bases to return in a single
    * page.
    *
    * [pageToken] - The continuation token, which is used to page through large
    * result sets. To get the next page of results, set this parameter to the
    * value of nextPageToken from the previous response.
    *
    * [start] - The start position (0-based) of this query. Defaults to 0.
    *
    * Completes with a [ListBasesResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ListBasesResponse> list(core.String referenceId, {core.String end, core.int pageSize, core.String pageToken, core.String start}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (referenceId == null) {
       throw new core.ArgumentError("Parameter referenceId is required.");
     }
     if (end != null) {
       _queryParams["end"] = [end];
     }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (start != null) {
       _queryParams["start"] = [start];
     }
 
 
-    _url = 'references/' + common_internal.Escaper.ecapeVariable('$referenceId') + '/bases';
+    _url = 'references/' + commons.Escaper.ecapeVariable('$referenceId') + '/bases';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListBasesResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ReferencesetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  ReferencesetsResourceApi(common_internal.ApiRequester client) : 
+  ReferencesetsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Gets a reference set.
    *
    * Implements GlobalAllianceApi.getReferenceSet.
    *
    * Request parameters:
    *
    * [referenceSetId] - The ID of the reference set.
    *
    * Completes with a [ReferenceSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ReferenceSet> get(core.String referenceSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (referenceSetId == null) {
       throw new core.ArgumentError("Parameter referenceSetId is required.");
     }
 
 
-    _url = 'referencesets/' + common_internal.Escaper.ecapeVariable('$referenceSetId');
+    _url = 'referencesets/' + commons.Escaper.ecapeVariable('$referenceSetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ReferenceSet.fromJson(data));
   }
 
   /**
    * Searches for reference sets which match the given criteria.
    *
    * Implements GlobalAllianceApi.searchReferenceSets.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchReferenceSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchReferenceSetsResponse> search(SearchReferenceSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'referencesets/search';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new SearchReferenceSetsResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
-class VariantsResourceApi {
-  final common_internal.ApiRequester _requester;
+class StreamingVariantStoreResourceApi {
+  final commons.ApiRequester _requester;
 
-  VariantsResourceApi(common_internal.ApiRequester client) : 
+  StreamingVariantStoreResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
+   * Returns a stream of all the variants matching the search request, ordered
+   * by reference name, position, and ID.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * Completes with a [Variant].
+   *
+   * Completes with a [commons.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<Variant> streamvariants(StreamVariantsRequest request) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (request != null) {
+      _body = convert.JSON.encode((request).toJson());
+    }
+
+
+    _url = 'streamingVariantStore/streamvariants';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Variant.fromJson(data));
+  }
+
+}
+
+
+class VariantsResourceApi {
+  final commons.ApiRequester _requester;
+
+  VariantsResourceApi(commons.ApiRequester client) : 
+      _requester = client;
+
+  /**
    * Creates a new variant.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [Variant].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Variant> create(Variant request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'variants';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Variant.fromJson(data));
   }
 
   /**
    * Deletes a variant.
    *
    * Request parameters:
    *
    * [variantId] - The ID of the variant to be deleted.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 delete(core.String variantId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (variantId == null) {
       throw new core.ArgumentError("Parameter variantId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'variants/' + common_internal.Escaper.ecapeVariable('$variantId');
+    _url = 'variants/' + commons.Escaper.ecapeVariable('$variantId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Gets a variant by ID.
    *
    * Request parameters:
    *
    * [variantId] - The ID of the variant.
    *
    * Completes with a [Variant].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Variant> get(core.String variantId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (variantId == null) {
       throw new core.ArgumentError("Parameter variantId is required.");
     }
 
 
-    _url = 'variants/' + common_internal.Escaper.ecapeVariable('$variantId');
+    _url = 'variants/' + commons.Escaper.ecapeVariable('$variantId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Variant.fromJson(data));
   }
 
   /**
    * Gets a list of variants matching the criteria.
    *
    * Implements GlobalAllianceApi.searchVariants.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchVariantsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchVariantsResponse> search(SearchVariantsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'variants/search';
 
     var _response = _requester.request(_url,
@@ skipping 11 matching lines @@
    * silently ignored. Returns the modified variant without its calls.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [variantId] - The ID of the variant to be updated.
    *
    * Completes with a [Variant].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Variant> update(Variant request, core.String variantId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (variantId == null) {
       throw new core.ArgumentError("Parameter variantId is required.");
     }
 
 
-    _url = 'variants/' + common_internal.Escaper.ecapeVariable('$variantId');
+    _url = 'variants/' + commons.Escaper.ecapeVariable('$variantId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Variant.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class VariantsetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  VariantsetsResourceApi(common_internal.ApiRequester client) : 
+  VariantsetsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Deletes the contents of a variant set. The variant set object is not
    * deleted.
    *
    * Request parameters:
    *
    * [variantSetId] - The ID of the variant set to be deleted.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 delete(core.String variantSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (variantSetId == null) {
       throw new core.ArgumentError("Parameter variantSetId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId');
+    _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Exports variant set data to an external destination.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [variantSetId] - 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.
    *
    * Completes with a [ExportVariantSetResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ExportVariantSetResponse> export(ExportVariantSetRequest request, core.String variantSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.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.");
     }
 
 
-    _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId') + '/export';
+    _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId') + '/export';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ExportVariantSetResponse.fromJson(data));
   }
 
   /**
    * Gets a variant set by ID.
    *
    * Request parameters:
    *
    * [variantSetId] - Required. The ID of the variant set.
    *
    * Completes with a [VariantSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<VariantSet> get(core.String variantSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (variantSetId == null) {
       throw new core.ArgumentError("Parameter variantSetId is required.");
     }
 
 
-    _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId');
+    _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new VariantSet.fromJson(data));
   }
@@ skipping 11 matching lines @@
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [variantSetId] - Required. The variant set to which variant data should be
    * imported.
    *
    * Completes with a [ImportVariantsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ImportVariantsResponse> importVariants(ImportVariantsRequest request, core.String variantSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.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.");
     }
 
 
-    _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId') + '/importVariants';
+    _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId') + '/importVariants';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ImportVariantsResponse.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
+   * Completes with a [commons.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(MergeVariantsRequest request, core.String variantSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.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';
+    _url = 'variantsets/' + commons.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);
   }
 
   /**
    * Updates a variant set's metadata. All other modifications are silently
    * ignored. This method supports patch semantics.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [variantSetId] - The ID of the variant to be updated.
    *
    * Completes with a [VariantSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<VariantSet> patch(VariantSet request, core.String variantSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.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.");
     }
 
 
-    _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId');
+    _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new VariantSet.fromJson(data));
   }
 
   /**
    * Returns a list of all variant sets matching search criteria.
    *
    * Implements GlobalAllianceApi.searchVariantSets.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [SearchVariantSetsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<SearchVariantSetsResponse> search(SearchVariantSetsRequest request) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
 
 
     _url = 'variantsets/search';
 
     var _response = _requester.request(_url,
@@ skipping 11 matching lines @@
    * ignored.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [variantSetId] - The ID of the variant to be updated.
    *
    * Completes with a [VariantSet].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<VariantSet> update(VariantSet request, core.String variantSetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.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.");
     }
 
 
-    _url = 'variantsets/' + common_internal.Escaper.ecapeVariable('$variantSetId');
+    _url = 'variantsets/' + commons.Escaper.ecapeVariable('$variantSetId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new VariantSet.fromJson(data));
   }
@@ skipping 107 matching lines @@
     return _json;
   }
 }
 
 
 /**
  * An annotation describes a region of reference genome. The value of an
  * annotation may be one of several canonical types, supplemented by arbitrary
  * info tags. A variant annotation is represented by one or more of these
  * canonical types. An annotation is not inherently associated with a specific
- * sample/individual (though a client could choose to use annotations in this
+ * sample or individual (though a client could choose to use annotations in this
  * way). Example canonical annotation types are 'Gene' and 'Variant'.
  */
 class Annotation {
   /** The ID of the containing annotation set. */
   core.String annotationSetId;
 
   /** The generated unique ID for this annotation. */
   core.String id;
 
   /** A map of additional data for this annotation. */
   core.Map<core.String, core.List<core.String>> info;
 
   /** The display name of this annotation. */
   core.String name;
 
   /** The position of this annotation on the reference sequence. */
   RangePosition position;
 
   /**
    * A transcript value represents the assertion that a particular region of the
-   * reference genome may be transcribed as RNA. An alternate splicing pattern
-   * would be represented as separate transcript object. This field is only set
-   * for annotations of type TRANSCRIPT.
+   * reference genome may be transcribed as RNA. An alternative splicing pattern
+   * would be represented as a separate transcript object. This field is only
+   * set for annotations of type TRANSCRIPT.
    */
   Transcript transcript;
 
   /**
    * The data type for this annotation. Must match the containing annotation
    * set's type.
    * Possible string values are:
    * - "GENE"
    * - "GENERIC"
    * - "TRANSCRIPT"
    * - "VARIANT"
    */
   core.String type;
 
   /**
-   * A variant annotation which describes the effect of a variant on the genome,
-   * the coding sequence, and/or higher level consequences at the organism level
-   * e.g. pathogenicity. This field is only set for annotations of type VARIANT.
+   * A variant annotation, which describes the effect of a variant on the
+   * genome, the coding sequence, and/or higher level consequences at the
+   * organism level e.g. pathogenicity. This field is only set for annotations
+   * of type VARIANT.
    */
   VariantAnnotation variant;
 
 
   Annotation();
 
   Annotation.fromJson(core.Map _json) {
     if (_json.containsKey("annotationSetId")) {
       annotationSetId = _json["annotationSetId"];
     }
@@ skipping 45 matching lines @@
     }
     if (variant != null) {
       _json["variant"] = (variant).toJson();
     }
     return _json;
   }
 }
 
 
 /**
- * An annotation set is a logical grouping of annotations which share consistent
- * type information and provenance. An example would be 'all genes from refseq',
- * or 'all variant annotations from ClinVar'.
+ * An annotation set is a logical grouping of annotations that share consistent
+ * type information and provenance. Examples of annotation sets include 'all
+ * genes from refseq', and 'all variant annotations from ClinVar'.
  */
 class AnnotationSet {
   /** The ID of the containing dataset. */
   core.String datasetId;
 
   /** The generated unique ID for this annotation set. */
   core.String id;
 
   /** A map of additional data for this annotation set. */
   core.Map<core.String, core.List<core.String>> info;
 
   /** The display name for this annotation set. */
   core.String name;
 
   /**
-   * The ID of the reference set which defines the coordinate-space for this
+   * The ID of the reference set that defines the coordinate space for this
    * set's annotations.
    */
   core.String referenceSetId;
 
   /**
    * The source URI describing the file from which this annotation set was
    * generated, if any.
    */
   core.String sourceUri;
 
@@ skipping 55 matching lines @@
       _json["sourceUri"] = sourceUri;
     }
     if (type != null) {
       _json["type"] = type;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class BatchAnnotationsResponse {
   /**
    * The resulting per-annotation entries, ordered consistently with the
    * original request.
    */
   core.List<BatchAnnotationsResponseEntry> entries;
 
 
   BatchAnnotationsResponse();
 
   BatchAnnotationsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("entries")) {
       entries = _json["entries"].map((value) => new BatchAnnotationsResponseEntry.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (entries != null) {
       _json["entries"] = entries.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class BatchAnnotationsResponseEntry {
   /** The annotation, if any. */
   Annotation annotation;
 
   /** The resulting status for this annotation operation. */
   BatchAnnotationsResponseEntryStatus status;
 
 
   BatchAnnotationsResponseEntry();
 
@@ skipping 12 matching lines @@
       _json["annotation"] = (annotation).toJson();
     }
     if (status != null) {
       _json["status"] = (status).toJson();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class BatchAnnotationsResponseEntryStatus {
   /** The HTTP status code for this operation. */
   core.int code;
 
   /** Error message for this status, if any. */
   core.String message;
 
 
   BatchAnnotationsResponseEntryStatus();
 
@@ skipping 12 matching lines @@
       _json["code"] = code;
     }
     if (message != null) {
       _json["message"] = message;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class BatchCreateAnnotationsRequest {
   /**
    * The annotations to be created. At most 4096 can be specified in a single
    * request.
    */
   core.List<Annotation> annotations;
 
 
   BatchCreateAnnotationsRequest();
 
@@ skipping 254 matching lines @@
       _json["variantSetIds"] = variantSetIds;
     }
     return _json;
   }
 }
 
 
 /** A single CIGAR operation. */
 class CigarUnit {
   /**
-   * Not documented yet.
+   *
    * Possible string values are:
    * - "ALIGNMENT_MATCH"
    * - "CLIP_HARD"
    * - "CLIP_SOFT"
    * - "DELETE"
    * - "INSERT"
    * - "PAD"
    * - "SEQUENCE_MATCH"
    * - "SEQUENCE_MISMATCH"
    * - "SKIP"
@@ skipping 245 matching lines @@
       _json["jobId"] = jobId;
     }
     return _json;
   }
 }
 
 
 /** The read group set export request. */
 class ExportReadGroupSetsRequest {
   /**
-   * 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.
+   * A Google Cloud Storage URI for the exported BAM file. The currently
+   * authenticated user must have write access to the new file. An error will be
+   * returned if the URI already contains data.
    */
   core.String exportUri;
 
   /** The Google Developers Console project number that owns this export. */
   core.String projectNumber;
 
   /** The IDs of the read group sets to export. */
   core.List<core.String> readGroupSetIds;
 
   /**
@@ skipping 158 matching lines @@
   core.Map toJson() {
     var _json = new core.Map();
     if (jobId != null) {
       _json["jobId"] = jobId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ExternalId {
   /** The id used by the source of this data. */
   core.String id;
 
   /** The name of the source of this data. */
   core.String sourceName;
 
 
   ExternalId();
 
@@ skipping 12 matching lines @@
       _json["id"] = id;
     }
     if (sourceName != null) {
       _json["sourceName"] = sourceName;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class FastqMetadata {
   /** Optionally specifies the library name for alignment from FASTQ. */
   core.String libraryName;
 
   /**
    * Optionally specifies the platform name for alignment from FASTQ. For
    * example: CAPILLARY, LS454, ILLUMINA, SOLID, HELICOS, IONTORRENT, PACBIO.
    */
   core.String platformName;
 
@@ skipping 487 matching lines @@
       _json["mappingQuality"] = mappingQuality;
     }
     if (position != null) {
       _json["position"] = (position).toJson();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ListBasesResponse {
   /**
    * The continuation token, which is used to page through large result sets.
    * Provide this value in a subsequent request to return the next page of
    * results. This field will be empty if there aren't any additional results.
    */
   core.String nextPageToken;
 
   /**
    * The offset position (0-based) of the given sequence from the start of this
@@ skipping 28 matching lines @@
       _json["offset"] = offset;
     }
     if (sequence != null) {
       _json["sequence"] = sequence;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ListCoverageBucketsResponse {
   /**
    * The length of each coverage bucket in base pairs. Note that buckets at the
    * end of a reference sequence may be shorter. This value is omitted if the
    * bucket width is infinity (the default behaviour, with no range or
    * targetBucketWidth).
    */
   core.String bucketWidth;
 
   /**
@@ skipping 72 matching lines @@
       _json["datasets"] = datasets.map((value) => (value).toJson()).toList();
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class MergeVariantsRequest {
   /** The variants to be merged with existing variants. */
   core.List<Variant> variants;
 
 
   MergeVariantsRequest();
 
   MergeVariantsRequest.fromJson(core.Map _json) {
     if (_json.containsKey("variants")) {
       variants = _json["variants"].map((value) => new Variant.fromJson(value)).toList();
@@ skipping 768 matching lines @@
       _json["referenceSetId"] = referenceSetId;
     }
     if (sampleId != null) {
       _json["sampleId"] = sampleId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ReadGroupExperiment {
   /**
    * The instrument model used as part of this experiment. This maps to
    * sequencing technology in BAM.
    */
   core.String instrumentModel;
 
   /**
    * The library used as part of this experiment. Note: This is not an actual ID
    * within this repository, but rather an identifier for a library which may be
@@ skipping 40 matching lines @@
       _json["platformUnit"] = platformUnit;
     }
     if (sequencingCenter != null) {
       _json["sequencingCenter"] = sequencingCenter;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ReadGroupProgram {
   /** The command line used to run this program. */
   core.String commandLine;
 
   /**
    * The user specified locally unique ID of the program. Used along with
    * prevProgramId to define an ordering between programs.
    */
   core.String id;
 
@@ skipping 282 matching lines @@
  * A reference set is a set of references which typically comprise a reference
  * assembly for a species, such as GRCh38 which is representative of the human
  * genome. A reference set defines a common coordinate space for comparing
  * reference-aligned experimental data. A reference set contains 1 or more
  * references.
  */
 class ReferenceSet {
   /** Public id of this reference set, such as GRCh37. */
   core.String assemblyId;
 
-  /** Optional free text description of this reference set. */
+  /** Free text description of this reference set. */
   core.String description;
 
   /** The Google generated immutable ID of the reference set. */
   core.String id;
 
   /**
    * Order-independent MD5 checksum which identifies this reference set. The
    * checksum is computed by sorting all lower case hexidecimal string
    * reference.md5checksum (for all reference in this set) in ascending
    * lexicographic order, concatenating, and taking the MD5 of that value. The
@@ skipping 79 matching lines @@
       _json["sourceAccessions"] = sourceAccessions;
     }
     if (sourceURI != null) {
       _json["sourceURI"] = sourceURI;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class SearchAnnotationSetsRequest {
   /**
    * The dataset IDs to search within. Caller must have READ access to these
    * datasets.
    */
   core.List<core.String> datasetIds;
 
   /**
    * Only return annotations sets for which a substring of the name matches this
    * string (case insensitive).
@@ skipping 13 matching lines @@
    */
   core.String pageToken;
 
   /**
    * If specified, only annotation sets associated with the given reference set
    * are returned.
    */
   core.String referenceSetId;
 
   /**
-   * If specified, only annotation sets which have any of these types are
+   * If specified, only annotation sets that have any of these types are
    * returned.
    */
   core.List<core.String> types;
 
 
   SearchAnnotationSetsRequest();
 
   SearchAnnotationSetsRequest.fromJson(core.Map _json) {
     if (_json.containsKey("datasetIds")) {
       datasetIds = _json["datasetIds"];
@@ skipping 33 matching lines @@
       _json["referenceSetId"] = referenceSetId;
     }
     if (types != null) {
       _json["types"] = types;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class SearchAnnotationSetsResponse {
   /** The matching annotation sets. */
   core.List<AnnotationSet> annotationSets;
 
   /**
    * The continuation token, which is used to page through large result sets.
    * Provide this value in a subsequent request to return the next page of
    * results. This field will be empty if there aren't any additional results.
    */
   core.String nextPageToken;
@@ skipping 16 matching lines @@
       _json["annotationSets"] = annotationSets.map((value) => (value).toJson()).toList();
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class SearchAnnotationsRequest {
   /**
    * The annotation sets to search within. The caller must have READ access to
    * these annotation sets. Required. All queried annotation sets must have the
    * same type.
    */
   core.List<core.String> annotationSetIds;
 
   /**
    * Specifies number of results to return in a single page. If unspecified, it
    * will default to 256. The maximum value is 2048.
    */
   core.int pageSize;
 
   /**
    * The continuation token, which is used to page through large result sets. To
    * get the next page of results, set this parameter to the value of
    * nextPageToken from the previous response.
    */
   core.String pageToken;
 
   /**
-   * If specified, this query matches only annotations which overlap this range.
+   * If specified, this query matches only annotations that overlap this range.
    */
   QueryRange range;
 
 
   SearchAnnotationsRequest();
 
   SearchAnnotationsRequest.fromJson(core.Map _json) {
     if (_json.containsKey("annotationSetIds")) {
       annotationSetIds = _json["annotationSetIds"];
     }
@@ skipping 20 matching lines @@
       _json["pageToken"] = pageToken;
     }
     if (range != null) {
       _json["range"] = (range).toJson();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class SearchAnnotationsResponse {
   /** The matching annotations. */
   core.List<Annotation> annotations;
 
   /**
    * The continuation token, which is used to page through large result sets.
    * Provide this value in a subsequent request to return the next page of
    * results. This field will be empty if there aren't any additional results.
    */
   core.String nextPageToken;
@@ skipping 252 matching lines @@
   core.List<core.String> datasetIds;
 
   /**
    * Only return read group sets for which a substring of the name matches this
    * string.
    */
   core.String name;
 
   /**
    * Specifies number of results to return in a single page. If unspecified, it
-   * will default to 128. The maximum value is 1024.
+   * will default to 256. The maximum value is 1024.
    */
   core.int pageSize;
 
   /**
    * The continuation token, which is used to page through large result sets. To
    * get the next page of results, set this parameter to the value of
    * nextPageToken from the previous response.
    */
   core.String pageToken;
 
@@ skipping 209 matching lines @@
       _json["alignments"] = alignments.map((value) => (value).toJson()).toList();
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class SearchReferenceSetsRequest {
   /**
    * If present, return references for which the accession matches any of these
    * strings. Best to give a version number, for example GCF_000001405.26. If
    * only the main accession number is given then all records with that main
    * accession will be returned, whichever version. Note that different versions
    * will have different sequences.
    */
   core.List<core.String> accessions;
 
@@ skipping 55 matching lines @@
       _json["pageSize"] = pageSize;
     }
     if (pageToken != null) {
       _json["pageToken"] = pageToken;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class SearchReferenceSetsResponse {
   /**
    * The continuation token, which is used to page through large result sets.
    * Provide this value in a subsequent request to return the next page of
    * results. This field will be empty if there aren't any additional results.
    */
   core.String nextPageToken;
 
   /** The matching references sets. */
   core.List<ReferenceSet> referenceSets;
@@ skipping 16 matching lines @@
       _json["nextPageToken"] = nextPageToken;
     }
     if (referenceSets != null) {
       _json["referenceSets"] = referenceSets.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class SearchReferencesRequest {
   /**
    * If present, return references for which the accession matches this string.
    * Best to give a version number, for example GCF_000001405.26. If only the
    * main accession number is given then all records with that main accession
    * will be returned, whichever version. Note that different versions will have
    * different sequences.
    */
   core.List<core.String> accessions;
 
@@ skipping 52 matching lines @@
       _json["pageToken"] = pageToken;
     }
     if (referenceSetId != null) {
       _json["referenceSetId"] = referenceSetId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class SearchReferencesResponse {
   /**
    * The continuation token, which is used to page through large result sets.
    * Provide this value in a subsequent request to return the next page of
    * results. This field will be empty if there aren't any additional results.
    */
   core.String nextPageToken;
 
   /** The matching references. */
   core.List<Reference> references;
@@ skipping 256 matching lines @@
       _json["nextPageToken"] = nextPageToken;
     }
     if (variants != null) {
       _json["variants"] = variants.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 
+/** The stream variants request. */
+class StreamVariantsRequest {
+  /**
+   * Only return variant calls which belong to call sets with these ids. Leaving
+   * this blank returns all variant calls.
+   */
+  core.List<core.String> callSetIds;
+
+  /**
+   * The end of the window (0-based, exclusive) for which overlapping variants
+   * should be returned.
+   */
+  core.String end;
+
+  /** Required. Only return variants in this reference sequence. */
+  core.String referenceName;
+
+  /**
+   * The beginning of the window (0-based, inclusive) for which overlapping
+   * variants should be returned.
+   */
+  core.String start;
+
+  /**
+   * Exactly one variant set ID must be provided. Only variants from this
+   * variant set will be returned.
+   */
+  core.List<core.String> variantSetIds;
+
+
+  StreamVariantsRequest();
+
+  StreamVariantsRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("callSetIds")) {
+      callSetIds = _json["callSetIds"];
+    }
+    if (_json.containsKey("end")) {
+      end = _json["end"];
+    }
+    if (_json.containsKey("referenceName")) {
+      referenceName = _json["referenceName"];
+    }
+    if (_json.containsKey("start")) {
+      start = _json["start"];
+    }
+    if (_json.containsKey("variantSetIds")) {
+      variantSetIds = _json["variantSetIds"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (callSetIds != null) {
+      _json["callSetIds"] = callSetIds;
+    }
+    if (end != null) {
+      _json["end"] = end;
+    }
+    if (referenceName != null) {
+      _json["referenceName"] = referenceName;
+    }
+    if (start != null) {
+      _json["start"] = start;
+    }
+    if (variantSetIds != null) {
+      _json["variantSetIds"] = variantSetIds;
+    }
+    return _json;
+  }
+}
+
+
 /**
  * A transcript represents the assertion that a particular region of the
  * reference genome may be transcribed as RNA.
  */
 class Transcript {
   /**
    * The range of the coding sequence for this transcript, if any. To determine
    * the exact ranges of coding sequence, intersect this range with those of the
    * exons, if any. If there are any exons, the codingSequence must start and
    * end within them.
    *
    * Note that in some cases, the reference genome will not exactly match the
    * observed mRNA transcript e.g. due to variance in the source genome from
    * reference. In these cases, exon.frame will not necessarily match the
    * expected reference reading frame and coding exon reference bases cannot
    * necessarily be concatenated to produce the original transcript mRNA.
    */
   TranscriptCodingSequence codingSequence;
 
   /**
-   * The exons which compose this transcript. Exons are the pieces of the
-   * transcript which are spliced together, may be exported from a cell's
-   * nucleus, and may then be translated to protein. This field should be unset
-   * for genomes where transcript splicing does not occur, for example
-   * prokaryotes.
+   * The exons that compose this transcript. This field should be unset for
+   * genomes where transcript splicing does not occur, for example prokaryotes.
    *
    *
-   * Introns are regions of the transcript which are not included in the spliced
+   * Introns are regions of the transcript that are not included in the spliced
    * RNA product. Though not explicitly modeled here, intron ranges can be
-   * deduced; all regions of this transcript which are not exons are introns.
+   * deduced; all regions of this transcript that are not exons are introns.
    *
    *
    * Exonic sequences do not necessarily code for a translational product (amino
    * acids). Only the regions of exons bounded by the codingSequence correspond
    * to coding DNA sequence.
    *
    *
    * Exons are ordered by start position and may not overlap.
    */
   core.List<TranscriptExon> exons;
@@ skipping 27 matching lines @@
       _json["exons"] = exons.map((value) => (value).toJson()).toList();
     }
     if (geneId != null) {
       _json["geneId"] = geneId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TranscriptCodingSequence {
   /**
    * The end of the coding sequence on this annotation's reference sequence,
    * 0-based exclusive. Note that this position is relative to the reference
    * start, and not the containing annotation start.
    */
   core.String end;
 
   /**
    * The start of the coding sequence on this annotation's reference sequence,
@@ skipping 20 matching lines @@
       _json["end"] = end;
     }
     if (start != null) {
       _json["start"] = start;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TranscriptExon {
   /**
    * The end position of the exon on this annotation's reference sequence,
    * 0-based exclusive. Note that this is relative to the reference start, and
    * not the containing annotation start.
    */
   core.String end;
 
   /**
-   * The frame of this exon. Contains a value of 0, 1, or 2 which indicates the
+   * The frame of this exon. Contains a value of 0, 1, or 2, which indicates the
    * offset of the first coding base of the exon within the reading frame of the
    * coding DNA sequence, if any. This field is dependent on the strandedness of
    * this annotation (see Annotation.position.reverseStrand). For forward
    * stranded annotations, this offset is relative to the exon.start. For
    * reverse strand annotations, this offset is relative to the exon.end-1.
    *
    * Unset if this exon does not intersect the coding sequence. Upon creation of
    * a transcript, the frame must be populated for all or none of the coding
    * exons.
    */
@@ skipping 248 matching lines @@
    */
   core.String effect;
 
   /**
    * Google annotation ID of the gene affected by this variant. This should be
    * provided when the variant is created.
    */
   core.String geneId;
 
   /**
-   * Google annotation ID of the transcripts affected by this variant. These
+   * Google annotation IDs of the transcripts affected by this variant. These
    * should be provided when the variant is created.
    */
   core.List<core.String> transcriptIds;
 
   /**
    * Type has been adapted from ClinVar's list of variant types.
    * Possible string values are:
    * - "CNV"
    * - "DELETION"
    * - "INSERTION"
@@ skipping 53 matching lines @@
       _json["transcriptIds"] = transcriptIds;
     }
     if (type != null) {
       _json["type"] = type;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class VariantAnnotationCondition {
   /**
    * The MedGen concept id associated with this gene. Search for these IDs at
    * http://www.ncbi.nlm.nih.gov/medgen/
    */
   core.String conceptId;
 
-  /** The set of external ids for this condition. */
+  /** The set of external IDs for this condition. */
   core.List<ExternalId> externalIds;
 
   /** A set of names for the condition. */
   core.List<core.String> names;
 
   /**
    * The OMIM id for this condition. Search for these IDs at http://omim.org/
    */
   core.String omimId;
 
@@ skipping 82 matching lines @@
     }
     if (metadata != null) {
       _json["metadata"] = metadata.map((value) => (value).toJson()).toList();
     }
     if (referenceBounds != null) {
       _json["referenceBounds"] = referenceBounds.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
-
-